py_object = object
import pixie.vm.object as object
from pixie.vm.primitives import nil, true, false
import pixie.vm.persistent_hash_map as persistent_hash_map
import pixie.vm.stdlib as proto
from  pixie.vm.code import extend, as_var, intern_var
import pixie.vm.rt as rt


VAR_KEY = intern_var(u"pixie.stdlib", u"key")

class PersistentHashSet(object.Object):
    _type = object.Type(u"pixie.stdlib.PersistentHashSet")

    def type(self):
        return PersistentHashSet._type

    def __init__(self, meta, m):
        self._meta = meta
        self._map = m

    def conj(self, v):
        return PersistentHashSet(self._meta, self._map.assoc(v, v))

    def disj(self, k):
        return PersistentHashSet(self._meta, self._map.without(k))

    def meta(self):
        return self._meta

    def with_meta(self, meta):
        return PersistentHashSet(meta, self._map)

EMPTY = PersistentHashSet(nil, persistent_hash_map.EMPTY)

@as_var("set")
def _create(coll):
    ret = EMPTY
    coll = rt._seq(coll)
    while coll is not nil:
        ret = ret.conj(rt._first(coll))
        coll = rt._seq(rt._next(coll))
    return ret

@extend(proto._count, PersistentHashSet)
def _count(self):
    assert isinstance(self, PersistentHashSet)
    return rt._count(self._map)

@extend(proto._val_at, PersistentHashSet)
def _val_at(self, key, not_found):
    assert isinstance(self, PersistentHashSet)
    return rt._val_at(self._map, key, not_found)

@extend(proto._contains_key, PersistentHashSet)
def _contains_key(self, key):
    assert isinstance(self, PersistentHashSet)
    return rt._contains_key(self._map, key)

@extend(proto._eq, PersistentHashSet)
def _eq(self, obj):
    assert isinstance(self, PersistentHashSet)
    if self is obj:
        return true
    if not isinstance(obj, PersistentHashSet):
        return false
    if self._map._cnt != obj._map._cnt:
        return false

    seq = rt.seq(obj)
    while seq is not nil:
        if rt._contains_key(self, rt.first(seq)) is false:
            return false
        seq = rt.next(seq)
    return true

@extend(proto._conj, PersistentHashSet)
def _conj(self, v):
    assert isinstance(self, PersistentHashSet)
    return self.conj(v)

@extend(proto._disj, PersistentHashSet)
def _disj(self, v):
    assert isinstance(self, PersistentHashSet)
    return self.disj(v)

@extend(proto._reduce, PersistentHashSet)
def _reduce(self, f, init):
    assert isinstance(self, PersistentHashSet)
    return rt._reduce(rt.keys(self._map), f, init)

@extend(proto._meta, PersistentHashSet)
def _meta(self):
    assert isinstance(self, PersistentHashSet)
    return self.meta()

@extend(proto._with_meta, PersistentHashSet)
def _with_meta(self, meta):
    assert isinstance(self, PersistentHashSet)
    return self.with_meta(meta)