__object = {__bases__: [], __name__: 'object'}
__object.__mro__ = [__object]

__type = {__bases__: [__object], __mro__: [__object], __name__: 'type'}

__object.__metaclass__ = __type


def __isnot__(self, other):
    return not (self is other)

__object.__isnot__ = __isnot__


def issubclass(klass, other):  
    if klass is other:
        return True
    if not klass.__bases__:
        return False
    for base in klass.__bases__:
        if issubclass(base, other):
            return True
    return False


def pythonium_is_true(v):
    if v is __FALSE or v is False:
        return False
    if v is __TRUE or (JS('v !== undefined') and v != __NONE):
        return True
    if isinstance(v, int):
        if pythonium_get_attribute(v, 'jsobject') == 0:
            return False
        return True
    return False


def isinstance(object, klass):
    if object.__class__:
        return issubclass(object.__class__, klass)
    return False

def pythonium_obj_to_js_exception(obj):
    def exception():
        this.exception = obj
    return exception


def pythonium_is_exception(obj, exc):
    if obj is exc:
        return True
    return isinstance(obj, exc)


def pythonium_call(object):
    args = Array.prototype.slice.call(arguments, 1)
    if object.__metaclass__:
        instance = {__class__: object}
        init = lookup(instance, '__init__')
        if init:
            init.apply(instance, args)
        return instance
    else:
        return object.apply(object, args)



def pythonium_mro(bases):
    """Calculate the Method Resolution Order of bases using the C3 algorithm.

    Suppose you intended creating a class K with the given base classes. This
    function returns the MRO which K would have, *excluding* K itself (since
    it doesn't yet exist), as if you had actually created the class.

    Another way of looking at this, if you pass a single class K, this will
    return the linearization of K (the MRO of K, *including* itself).
    """
    # based on http://code.activestate.com/recipes/577748-calculate-the-mro-of-a-class/
    seqs = [C.__mro__ for C in bases]
    seqs.push(bases.slice())
    res = []
    while True:
        # non_empty = list(filter(None, seqs))
        non_empty = []
        for seq in seqs:
            empty = True
            for item in seq:
                if item:
                    empty = False
                    break
            if not empty:
                non_empty.push(seq)
        if non_empty.length == 0:
            # Nothing left to process, we're done.
            return res
        for seq in non_empty:  # Find merge candidates among seq heads.
            candidate = seq[0]
            not_head = [s for s in non_empty if candidate in s.splice(1)]
            if not_head.length != 0:
                # Reject the candidate.
                candidate = None
            else:
                break
        if not candidate:
            raise TypeError("Inconsistent hierarchy, no C3 MRO is possible")
        res.push(candidate)
        for seq in seqs:
            # Remove candidate.
            index = seq.indexOf(candidate)
            if index >= 0:
                del seq[index]


def pythonium_create_class(name, bases, attrs):
    attrs.__name__ = name
    attrs.__metaclass__ = __type
    attrs.__bases__ = bases
    mro = pythonium_mro(bases)
    mro.splice(0, 0, attrs)
    attrs.__mro__ = mro
    return attrs


def lookup(object, attr):
    object_attr = object[attr]
    if object_attr != None:
        if object_attr and {}.toString.call(object_attr) == '[object Function]':
            def method_wrapper():
                args = Array.prototype.slice.call(arguments)
                args.splice(0, 0, object)
                return object_attr.apply(None, args)
            return method_wrapper
        return object_attr
    else:
        for base in object.__class__.__mro__:
            class_attr = base[attr]
            if class_attr != None:
                if {}.toString.call(class_attr) == '[object Function]':
                    def method_wrapper():
                        args = Array.prototype.slice.call(arguments)
                        args.splice(0, 0, object)
                        return class_attr.apply(None, args)
                    return method_wrapper
                return class_attr


def pythonium_object_get_attribute(object, attr):
    r = lookup(object, attr)
    if r != None:
        return r
    else:
        getattr = lookup(object, '__getattr__')
        if getattr:
            return getattr(attr)
        else:
            console.log('__get_attribute__', object, attr)
            console.trace()
            raise AttributeError

__object.__getattribute__ = pythonium_object_get_attribute


def pythonium_get_attribute(object, attr):
    if object.__class__:
        getattribute = lookup(object, '__getattribute__')
        return getattribute(attr)
    attr = object[attr]
    if attr:
        if {}.toString.call(attr) == '[object Function]':
            def method_wrapper():
                return attr.apply(object, arguments)
            return method_wrapper
        else:
            return attr


def pythonium_set_attribute(object, attr, value):
    object[attr] = value