from jstypes.code import run_js
set_x = run_js("(x) => { globalThis.x = x; }")
get_x = run_js("(x) => globalThis.x")

set_x({})
get_x()

from jstypes.ffi import JSDoubleProxy
from jstypes.code import run_js

setXJs = run_js("(x) => { globalThis.x = x; }")
def set_x(x):
    orig_x = get_x()
    if isinstance(orig_x, JSDoubleProxy):
        orig_x.destroy()
    xpx = create_proxy(x)
    setXJs(xpx)

@create_proxy
def main_loop():
    update()
    buf = render()
    drawImageToCanvas(buffer)
    requestAnimationFrame(main_loop)

def create_jsproxy(jsobj, jsthis=Js_undefined):
    # For the definition of ``compute_type_flags``, see "Determining which flags to set".
    return create_jsproxy_with_flags(compute_type_flags(jsobj), jsobj, jsthis)

def create_jsproxy_with_flags(type_flags, jsobj, jsthis):
    cls = get_jsproxy_class(type_flags)
    return cls.__new__(jsobj, jsthis)

@functools.cache
def get_jsproxy_class(type_flags):
    flag_mixin_pairs = [
        (HAS_GET, JSProxyHasGetMixin),
        (HAS_HAS, JSProxyHasHasMixin),
        # ...
        (IS_PY_JSON_DICT, JSPyJsonDictMixin)
    ]
    bases = [mixin for flag, mixin in flag_mixin_pairs if flag & type_flags]
    bases.insert(0, JSProxy)
    if type_flags & IS_ERROR:
        # We want JSException to be pickleable so it needs a distinct name
        name = "jstypes.ffi.JSException"
        bases.append(Exception)
    else:
        name = "jstypes.ffi.JSProxy"
    ns = {"_js_type_flags": type_flags}
    # Note: The actual way that we build the class does not result in the
    # mixins appearing as entries on the mro.
    return JSProxyMeta.__new__(JSProxyMeta, name, tuple(bases), ns)

class _JSProxyMetaClass(type):
    def __instancecheck__(cls, instance):
        return cls.__subclasscheck__(type(instance))

    def __subclasscheck__(cls, subcls):
        if type.__subclasscheck__(cls, subcls):
            return True
        if not hasattr(subclass, "_js_type_flags"):
            return False

        subcls_flags = subcls._js_type_flags
        # Check whether the flags on subcls are a subset of the flags on cls
        return cls._js_type_flags & subcls_flags == subcls_flags

d = {}
d.update(run_js("[['a', 'b'], [1, 2]]"))
assert d == {"a" : "b", 1 : 2}
# The result if we didn't filter out Array.keys would be as follows:
assert d != {1 : ['a', 'b'], 2: [1, 2]}

def normalize_python_keywords(attr):
    stripped = attr.strip("_")
    if not keyword.iskeyword(stripped):
        return attr
    if stripped != attr:
        return attr[:-1]
    return attr

class JSProxy:
    def __getattribute__(self, attr):
        try:
            return object.__getattribute__(self, attr)
        except AttributeError:
            pass
        if attr == "keys" and Array.isArray(self):
            raise AttributeError(attr)

        attr = normalize_python_keywords(attr)
        js_getattr = run_js(
            """
            (jsobj, attr) => jsobj[attr]
            """
        )
        js_hasattr = run_js(
            """
            (jsobj, attr) => attr in jsobj
            """
        )
        result = js_getattr(self, attr)
        if isjsfunction(result):
            result = result.__get__(self)
        if result is None and not js_hasattr(self, attr):
            raise AttributeError(attr)
        return result

    def __setattr__(self, attr, value):
        if attr in ["__loader__", "__name__", "__package__", "__path__", "__spec__"]:
            return object.__setattr__(self, attr, value)
        attr = normalize_python_keywords(attr)
        js_setattr = run_js(
            """
            (jsobj, attr) => {
                jsobj[attr] = value;
            }
            """
        )
        js_setattr(self, attr, value)

    def __delattr__(self, attr):
        if attr in ["__loader__", "__name__", "__package__", "__path__", "__spec__"]:
            return object.__delattr__(self, attr)
        attr = normalize_python_keywords(attr)
        js_delattr = run_js(
            """
            (jsobj, attr) => {
                delete jsobj[attr];
            }
            """
        )
        js_delattr(self, attr)

    def __dir__(self):
        return object.__dir__(self) + js_dir(self)

    def __eq__(self, other):
        if not isinstance(other, JSProxy):
            return False
        js_eq = run_js("(x, y) => x === y")
        return js_eq(self, other)

    def __ne__(self, other):
        if not isinstance(other, JSProxy):
            return True
        js_neq = run_js("(x, y) => x !== y")
        return js_neq(self, other)

    def __repr__(self):
        js_repr = run_js("x => x.toString()")
        return js_repr(self)

    def __bool__(self):
        return js_bool(self)

    @property
    def js_id(self):
        """
        This returns an integer with the property that jsproxy1 == jsproxy2
        if and only if jsproxy1.js_id == jsproxy2.js_id. There is no way to
        express the implementation in pseudocode.
        """
        raise NotImplementedError

    def as_py_json(self):
        """
        This is actually a mixin method. We leave it out if any of the flags
        IS_CALLABLE, IS_DOUBLE_PROXY, IS_ERROR, or IS_ITERATOR
        is set.
        """
        flags = self._js_type_flags
        if (flags & (IS_ARRAY | IS_ARRAY_LIKE)):
            flags |= IS_PY_JSON_SEQUENCE
        else:
            flags |= IS_PY_JSON_DICT
        return create_jsproxy_with_flags(flags, self, self.jsthis)

    def to_py(self, *, depth=-1, default_converter=None):
        """
        See section on deep conversions.
        """
        ...

    def object_entries(self):
        js_object_entries = run_js("x => Object.entries(x)")
        return js_object_entries(self)

    def object_keys(self):
        js_object_keys = run_js("x => Object.keys(x)")
        return js_object_keys(self)

    def object_values(self):
        js_object_values = run_js("x => Object.values(x)")
        return js_object_values(self)

    def to_weakref(self):
        js_weakref = run_js("x => new WeakRef(x)")
        return js_weakref(self)

def maybe_as_py_json(value):
    if (
        isinstance(value, JSProxy)
        and hasattr(value, as_py_json)
    ):
        return value.as_py_json()
    return value

class JSProxyHasGetMixin:
    def __getitem__(self, item):
        result = js_get(self, item)
        if self._js_type_flags & IS_PY_JSON_DICT:
            result = maybe_as_py_json(result)
        return result

class JSProxyHasSetMixin:
    def __setitem__(self, item, value):
        js_set = run_js(
            """
            (jsobj, item, value) => {
                jsobj.set(item, value);
            }
            """
        )
        js_set(self, item, value)

    def __delitem__(self, item, value):
        js_delete = run_js(
            """
            (jsobj, item) => {
                jsobj.delete(item);
            }
            """
        )
        js_delete(self, item)

class JSProxyHasHasMixin:
    def __contains__(self, item):
        js_has = run_js(
            """
            (jsobj, item) => jsobj.has(item);
            """
        )
        return js_has(self, item)

class JSProxyHasIncludesMixin:
    def __contains__(self, item):
        js_includes = run_js(
            """
            (jsobj, item) => jsobj.includes(item);
            """
        )
        return js_includes(self, item)

class JSProxyHasLengthMixin:
    def __len__(self, item):
        js_len = run_js(
            """
            (jsobj) => {
                const size = val.size;
                if (typeof size === "number") {
                    return size;
                }
                return val.length
            }
            """
        )
        result = js_len(self)
        if not isinstance(result, int):
            raise TypeError("object does not have a valid length")
        if result < 0:
            raise ValueError("length of object is negative")
        return result

class JSProxyContextManagerMixin:
    def __enter__(self):
        return self

    def __exit__(self, type, value, traceback):
        js_symbol_dispose = run_js(
            """
            (jsobj) => jsobj[Symbol.dispose]()
            """
        )
        js_symbol_dispose(self)

class JSArrayMixin(MutableSequence, JSProxyHasLengthMixin):
    def __getitem__(self, index):
        if not isinstance(index, (int, slice)):
            raise TypeError("Expected index to be an int or a slice")
        length = len(self)
        js_array_get = run_js(
            """
            (jsobj, index) => jsobj[index]
            """
        )
        if isinstance(index, int):
            if index >= length:
                raise IndexError(index)
            if index < -length:
                raise IndexError(index)
            if index < 0:
                index += length
            result = js_array_get(self, index)
            if self._js_type_flags & IS_PY_JSON_SEQUENCE:
                result = maybe_as_py_json(result)
            return result
        start = index.start
        stop = index.stop
        step = index.step
        slicelength = PySlice_AdjustIndices(length, &start, &stop, &step)
        if (slicelength <= 0) {
            return _PyJsvArray_New();
        }
        result = js_array_slice(self, slicelength, start, stop, step)
        if self._js_type_flags & IS_PY_JSON_SEQUENCE:
            result = result.as_py_json()
        return result


    def __setitem__(self, index, value):
        if not isinstance(index, (int, slice)):
            raise TypeError("Expected index to be an int or a slice")
        length = len(self)
        js_array_set = run_js(
            """
            (jsobj, index, value) => { jsobj[index] = value; }
            """
        )
        if isinstance(index, int):
            if index >= length:
                raise IndexError(index)
            if index < -length:
                raise IndexError(index)
            if index < 0:
                index += length
            result = js_array_set(self, index, value)
            return
        if not isinstance(value, Iterable):
            raise TypeError("must assign iterable to extended slice")
        seq = list(value)
        start = index.start
        stop = index.stop
        step = index.step
        slicelength = PySlice_AdjustIndices(length, &start, &stop, &step)
        if step != 1 and len(seq) != slicelength:
            raise TypeError(
                f"attempted to assign sequence of length {len(seq)} to"
                f"extended slice of length {slicelength}"
            )
        if step != 1 and slicelength == 0:
            return
        js_array_slice_assign(self, slicelength, start, stop, step, seq)

    def __delitem__(self, index):
        if not isinstance(index, (int, slice)):
            raise TypeError("Expected index to be an int or a slice")
        length = len(self)
        js_array_delete = run_js(
            """
            (jsobj, index) => { jsobj.splice(index, 1); }
            """
        )
        if isinstance(index, int):
            if index >= length:
                raise IndexError(index)
            if index < -length:
                raise IndexError(index)
            if index < 0:
                index += length
            result = js_array_delete(self, index)
            return
        start = index.start
        stop = index.stop
        step = index.step
        slicelength = PySlice_AdjustIndices(length, &start, &stop, &step)
        if step != 1 and slicelength == 0:
            return
        js_array_slice_assign(self, slicelength, start, stop, step, None)

    def insert(self, pos, value):
        if not isinstance(pos, int):
            raise TypeError("Expected an integer")
        js_insert = run_js(
            """
            (jsarr, pos, value) => { jsarr.splice(pos, value); }
            """
        )
        js_insert(self, pos, value)

class JSArrayLikeMixin(MutableSequence, JSProxyHasLengthMixin):
    def __getitem__(self, index):
        if not isinstance(index, int):
            raise TypeError("Expected index to be an int")
        JSArrayMixin.__getitem__(self, index)

    def __setitem__(self, index, value):
        if not isinstance(index, int):
            raise TypeError("Expected index to be an int")
        JSArrayMixin.__setitem__(self, index, value)

    def __delitem__(self, index):
        if not isinstance(index, int):
            raise TypeError("Expected index to be an int")
        JSArrayMixin.__delitem__(self, index, value)

class JSCallableMixin:
    def __get__(self, obj):
        """Return a new jsproxy bound to jsthis with the same JS object"""
        return create_jsproxy(self, jsthis=obj)

    def __call__(self, *args, **kwargs):
        """See the description of JSMethod_Vectorcall"""

    def new(self, *args, **kwargs):
        pyproxies = []
        jsargs = JSMethod_ConvertArgs(args, kwargs, pyproxies)

        do_construct = run_js(
            """
            (jsfunc, jsargs) =>
                Reflect.construct(jsfunc, jsargs)
            """
        )
        result = do_construct(self, jsargs)
        msg = (
            "This borrowed proxy was automatically destroyed "
            "at the end of a function call."
        )
        for px in pyproxies:
            px.destroy(msg)
        return result

def wrap_with_maybe_as_py_json(it):
    try:
        while val := it.next()
            yield maybe_as_py_json(val)
    except StopIteration(result):
        return maybe_as_py_json(result)


class JSIterableMixin:
    def __iter__(self):
        pyjson = self._js_type_flags & (IS_PY_JSON_SEQUENCE | IS_PY_JSON_DICT)
        pyjson_dict = self._js_type_flags & IS_PY_JSON_DICT
        js_get_iter = run_js(
            """
            (obj) => obj[Symbol.iterator]()
            """
        )

        if pyjson_dict:
            result = iter(self.object_keys())
        else:
            result = js_get_iter(self)

        if pyjson:
            result = wrap_with_maybe_as_py_json(result)
        return result

class JSIteratorMixin:
    def __iter__(self):
        return self

    def send(self, arg):
        js_next = run_js(
            """
            (obj, arg) => obj.next(arg)
            """
        )
        it_result = js_next(self, arg)
        value = it_result.value
        if it_result.done:
            raise StopIteration(value)
        return value

    def __next__(self):
        return self.send(None)

class JSGeneratorMixin(JSIteratorMixin):
    def throw(self, exc):
        if isinstance(exc, GeneratorExit):
            js_throw = run_js(
                """
                (obj, exc) => obj.return()
                """
            )
        else:
            js_throw = run_js(
                """
                (obj, exc) => obj.throw(exc)
                """
            )
        it_result = js_throw(self, exc)
        # if the error wasn't caught it will get raised back out.
        # now handle the case where the error got caught.
        value = it_result.value
        if self._js_type_flags & IS_PY_JSON_SEQUENCE:
            value = maybe_as_py_json(value)
        if it_result.done:
            raise StopIteration(value)
        return value

    def close(self):
        self.throw(GeneratorExit)

class JSPyJsonDictMixin(MutableMapping):
    def __getitem__(self, key):
        if not isinstance(key, str):
            raise KeyError(key)
        js_get = run_js(
            """
            (jsobj, key) => jsobj[key]
            """
        )
        result = js_get(self, key)
        if result is None and not key in self:
            raise KeyError(key)
        return maybe_as_py_json(result)

    def __setitem__(self, key, value):
        if not isinstance(key, str):
            raise TypeError("only keys of type string are supported")
        js_set = run_js(
            """
            (jsobj, key, value) => {
                jsobj[key] = value;
            }
            """
        )
        js_set(self, key, value)

    def __delitem__(self, key):
        if not isinstance(key, str):
            raise TypeError("only keys of type string are supported")
        if not key in self:
            raise KeyError(key)
        js_delete = run_js(
            """
            (jsobj, key) => {
                delete jsobj[key];
            }
            """
        )
        js_delete(self, key)

    def __contains__(self, key):
        if not isinstance(key, str):
            return False
        js_contains = run_js(
            """
            (jsobj, key) => key in jsobj
            """
        )
        return js_contains(self, key)

    def __len__(self):
        return sum(1 for _ in self)

    def __iter__(self):
        # defined by IS_ITERABLE mixin, see implementation there.

def get_type_flags(ty):
    from collections.abc import Generator, MutableSequence, Sequence

    flags = 0
    if hasattr(ty, "__len__"):
        flags |= HAS_LENGTH
    if hasattr(ty, "__getitem__"):
        flags |= HAS_GET
    if hasattr(ty, "__setitem__"):
        flags |= HAS_SET
    if hasattr(ty, "__contains__"):
        flags |= HAS_CONTAINS
    if ty is dict:
        # Currently we don't set this on subclasses.
        flags |= IS_DICT
    if hasattr(ty, "__call__"):
        flags |= IS_CALLABLE
    if hasattr(ty, "__iter__"):
        flags |= IS_ITERABLE
    if hasattr(ty, "__next__"):
        flags |= IS_ITERATOR
    if issubclass(ty, Generator):
        flags |= IS_GENERATOR
    if issubclass(ty, Sequence):
        flags |= IS_SEQUENCE
    if issubclass(ty, MutableSequence):
        flags |= IS_MUTABLE_SEQUENCE
    return flags

def get_pyproxy_flags(obj, is_js_json):
    flags = get_type_flags(type(obj))
    if not is_js_json:
        return flags
    if flags & IS_SEQUENCE:
        flags |= IS_JS_JSON_SEQUENCE
    elif flags & HAS_GET:
        flags |= IS_JS_JSON_DICT
    return flags