'''Most important file in Js2Py implementation: PyJs class - father of all PyJs objects'''
from copy import copy
import re
#from translators import translator

from .translators.friendly_nodes import REGEXP_CONVERTER
from .utils.injector import fix_js_args
from types import FunctionType, ModuleType, GeneratorType, BuiltinFunctionType, MethodType, BuiltinMethodType
import traceback



# python 3 support
import six
if six.PY3:
    basestring = str
    long = int
    xrange = range
    unicode = str


def str_repr(s):
    if six.PY2:
        return repr(s.encode('utf-8'))
    else:
        return repr(s)

def MakeError(name, message):
    """Returns PyJsException with PyJsError inside"""
    return JsToPyException(ERRORS[name](Js(message)))




def to_python(val):
    if not isinstance(val, PyJs):
        return val
    if isinstance(val, PyJsUndefined) or isinstance(val, PyJsNull):
        return None
    elif isinstance(val, PyJsNumber):
        # this can be either float or long/int better to assume its int/long when a whole number...
        v = val.value
        try:
            i = int(v) if v==v else v # nan...
            return v if i!=v else i
        except:
            return v
    elif isinstance(val, (PyJsString, PyJsBoolean)):
        return val.value
    elif isinstance(val, PyObjectWrapper):
        return val.__dict__['obj']
    return JsObjectWrapper(val)

def to_dict(js_obj, known=None): # fixed recursion error in self referencing objects
    res = {}
    if known is None:
        known = {}
    if js_obj in known:
        return known[js_obj]
    known[js_obj] = res
    for k in js_obj:
        name = k.value
        input = js_obj.get(name)
        output = to_python(input)
        if isinstance(output, JsObjectWrapper):
            if output._obj.Class=='Object':
                output = to_dict(output._obj, known)
                known[input] = output
            elif output._obj.Class=='Array':
                output = to_list(output._obj)
                known[input] = output
        res[name] = output
    return res


def to_list(js_obj, known=None):
    res = len(js_obj)*[None]
    if known is None:
        known = {}
    if js_obj in known:
        return known[js_obj]
    known[js_obj] = res
    for k in js_obj:
        try:
            name = int(k.value)
        except:
            continue
        input = js_obj.get(str(name))
        output = to_python(input)
        if isinstance(output, JsObjectWrapper):
            if output._obj.Class in ['Array', 'Arguments']:
                output = to_list(output._obj, known)
                known[input] = output
            elif output._obj.Class in ['Object']:
                output = to_dict(output._obj)
                known[input] = output
        res[name] = output
    return res


def HJs(val):
    if hasattr(val, '__call__'): #
        @Js
        def PyWrapper(this, arguments, var=None):
            args = tuple(to_python(e) for e in arguments.to_list())
            try:
                py_res = val.__call__(*args)
            except Exception as e:
                message = 'your Python function failed!  '
                try:
                    message += e.message
                except:
                    pass
                raise MakeError('Error', message)
            return py_wrap(py_res)

        try:
            PyWrapper.func_name = val.__name__
        except:
            pass
        return PyWrapper
    if isinstance(val, tuple):
        val = list(val)
    return Js(val)

def Js(val):
    '''Converts Py type to PyJs type'''
    if isinstance(val, PyJs):
        return val
    elif val is None:
        return undefined
    elif isinstance(val, basestring):
        return PyJsString(val, StringPrototype)
    elif isinstance(val, bool):
        return true if val else false
    elif isinstance(val, float) or isinstance(val, int) or isinstance(val, long):
        # This is supposed to speed things up. may not be the case
        if val in NUM_BANK:
            return NUM_BANK[val]
        return PyJsNumber(float(val), NumberPrototype)
    elif isinstance(val, FunctionType):
        return PyJsFunction(val, FunctionPrototype)
    #elif isinstance(val, ModuleType):
    #    mod = {}
    #    for name in dir(val):
    #        value = getattr(val, name)
    #        if isinstance(value, ModuleType):
    #            continue  # prevent recursive module conversion
    #        try:
    #            jsval = HJs(value)
    #        except RuntimeError:
    #            print 'Could not convert %s to PyJs object!' % name
    #            continue
    #        mod[name] = jsval
    #    return Js(mod)
    #elif isintance(val, ClassType):

    elif isinstance(val, dict): # convert to object
         temp = PyJsObject({}, ObjectPrototype)
         for k, v in six.iteritems(val):
             temp.put(Js(k), Js(v))
         return temp
    elif isinstance(val, (list, tuple)): #Convert to array
        return PyJsArray(val, ArrayPrototype)
    elif isinstance(val, JsObjectWrapper):
        return val.__dict__['_obj']
    else: # try to convert to js object
        return py_wrap(val)
        #raise RuntimeError('Cant convert python type to js (%s)' % repr(val))
        #try:
        #    obj = {}
        #    for name in dir(val):
        #        if name.startswith('_'):  #dont wrap attrs that start with _
        #            continue
        #        value = getattr(val, name)
        #        import types
        #        if not isinstance(value, (FunctionType, BuiltinFunctionType, MethodType, BuiltinMethodType,
        #                                  dict, int, basestring, bool, float, long, list, tuple)):
        #            continue
        #        obj[name] = HJs(value)
        #    return Js(obj)
        #except:
        #    raise RuntimeError('Cant convert python type to js (%s)' % repr(val))

def Type(val):
    try:
        return val.TYPE
    except:
        raise RuntimeError('Invalid type: '+str(val))

def is_data_descriptor(desc):
    return desc and ('value' in desc or 'writable' in desc)
    
def is_accessor_descriptor(desc):
    return desc and ('get' in desc or 'set' in desc)
    
def is_generic_descriptor(desc):
    return desc and not (is_data_descriptor(desc) or is_accessor_descriptor(desc))



##############################################################################

class PyJs(object):
    PRIMITIVES =  {'String', 'Number', 'Boolean', 'Undefined', 'Null'}
    TYPE = 'Object'
    Class = None
    extensible = True
    prototype = None
    own = {}
    GlobalObject = None
    IS_CHILD_SCOPE = False
    value = None
    
    def __init__(self, value=None, prototype=None, extensible=False):
        '''Constructor for Number String and Boolean'''
        # I dont think this is needed anymore
        # if self.Class=='String' and not isinstance(value, basestring):
        #     raise TypeError
        # if self.Class=='Number':
        #     if not isinstance(value, float):
        #         if not (isinstance(value, int) or isinstance(value, long)):
        #             raise TypeError
        #         value = float(value)
        # if self.Class=='Boolean' and not isinstance(value, bool):
        #     raise TypeError
        self.value = value
        self.extensible = extensible
        self.prototype = prototype
        self.own = {}
        
    def is_undefined(self):
        return self.Class=='Undefined'
    
    def is_null(self):
        return self.Class=='Null'
        
    def is_primitive(self):
        return self.TYPE in self.PRIMITIVES
    
    def is_object(self):
        return not self.is_primitive()

    def _type(self):
        return Type(self)
    
    def is_callable(self):
        return hasattr(self, 'call')
    
    def get_own_property(self, prop):
        return self.own.get(prop)
    
    def get_property(self, prop):
        cand = self.get_own_property(prop)
        if cand:
            return cand
        if self.prototype is not None:
            return self.prototype.get_property(prop)
    
    def get(self, prop): #external use!
         #prop = prop.value
         if self.Class=='Undefined' or self.Class=='Null':
             raise MakeError('TypeError', 'Undefiend and null dont have properties!')
         if not isinstance(prop, basestring):
             prop = prop.to_string().value
         if not isinstance(prop, basestring): raise RuntimeError('Bug')
         cand = self.get_property(prop)
         if cand is None:
             return Js(None)
         if is_data_descriptor(cand): 
             return cand['value']
         if cand['get'].is_undefined():
             return cand['get']
         return cand['get'].call(self)
    
    def can_put(self, prop):  #to check
        desc = self.get_own_property(prop)
        if desc: #if we have this property
            if is_accessor_descriptor(desc):
                return desc['set'].is_callable() # Check if setter method is defined           
            else:  #data desc 
                return desc['writable']
        if self.prototype is not None:
            return self.extensible
        inherited = self.get_property(prop)
        if inherited is None:
            return self.extensible
        if is_accessor_descriptor(inherited):
            return not inherited['set'].is_undefined()
        elif self.extensible:
            return inherited['writable']
        return False
            
    
    def put(self, prop, val, op=None):  #external use!
        '''Just like in js: self.prop op= val
           for example when op is '+' it will be self.prop+=val
           op can be either None for simple assignment or one of:
           * / % + - << >> & ^ |'''
        if self.Class=='Undefined' or self.Class=='Null':
             raise MakeError('TypeError', 'Undefiend and null dont have properties!')
        if not isinstance(prop, basestring):
             prop = prop.to_string().value
        #we need to set the value to the incremented one
        if op is not None:
            val = getattr(self.get(prop), OP_METHODS[op])(val)
        if not self.can_put(prop):
            return val
        own_desc = self.get_own_property(prop)
        if is_data_descriptor(own_desc):
            if self.Class=='Array': #only array has different define_own_prop
                self.define_own_property(prop, {'value':val})
            else:
                self.own[prop]['value'] = val
            return val
        desc = self.get_property(prop)
        if is_accessor_descriptor(desc):
            desc['set'].call(self, (val,))
        else:
            new = {'value' : val,
                   'writable' : True,
                   'configurable' : True,
                   'enumerable' : True}
            if self.Class=='Array':
                self.define_own_property(prop, new)
            else:
                self.own[prop] = new
        return val
                
    def has_property(self, prop):
        return self.get_property(prop) is not None
    
    def delete(self, prop):
        if not isinstance(prop, basestring):
            prop = prop.to_string().value
        desc = self.get_own_property(prop)
        if desc is None: 
            return Js(True)
        if desc['configurable']:
            del self.own[prop]
            return Js(True)
        return Js(False)
    
    def default_value(self, hint=None):  # made a mistake at the very early stage and made it to prefer string... caused lots! of problems
        order = ('valueOf', 'toString')
        if hint=='String' or (hint is None and self.Class=='Date'):
            order = ('toString', 'valueOf')
        for meth_name in order:
            method = self.get(meth_name)
            if method is not None and method.is_callable():
                cand = method.call(self)
                if cand.is_primitive():
                    return cand
        raise MakeError('TypeError', 'Cannot convert object to primitive value')
        

    def define_own_property(self, prop, desc): #Internal use only. External through Object
        # prop must be a Py string. Desc is either a descriptor or accessor.
        #Messy method -  raw translation from Ecma spec to prevent any bugs. # todo check this
        current = self.get_own_property(prop)

        extensible = self.extensible
        if not current: #We are creating a new property
            if not extensible:
                return False
            if is_data_descriptor(desc) or is_generic_descriptor(desc):
                DEFAULT_DATA_DESC = {'value': undefined, #undefined
                             'writable': False,
                             'enumerable': False,
                             'configurable': False}
                DEFAULT_DATA_DESC.update(desc)
                self.own[prop] = DEFAULT_DATA_DESC
            else:
                DEFAULT_ACCESSOR_DESC = {'get': undefined, #undefined
                                 'set': undefined, #undefined
                                 'enumerable': False,
                                 'configurable': False}
                DEFAULT_ACCESSOR_DESC.update(desc)
                self.own[prop] = DEFAULT_ACCESSOR_DESC
            return True
        if not desc or desc==current: #We dont need to change anything.
            return True
        configurable = current['configurable']  
        if not configurable:  #Prevent changing configurable or enumerable
            if desc.get('configurable'):
                return False
            if 'enumerable' in desc and desc['enumerable']!=current['enumerable']:
                return False
        if is_generic_descriptor(desc):
            pass
        elif is_data_descriptor(current)!=is_data_descriptor(desc):
            if not configurable:
                return False
            if is_data_descriptor(current):
                del current['value']
                del current['writable']
                current['set'] = undefined #undefined
                current['get'] = undefined #undefined
            else:
                del current['set']
                del current['get']
                current['value'] = undefined #undefined
                current['writable'] = False 
        elif is_data_descriptor(current) and is_data_descriptor(desc):
            if not configurable:
                if not current['writable'] and desc.get('writable'):
                    return False
            if not current['writable'] and 'value' in desc and current['value']!=desc['value']:
                return False
        elif is_accessor_descriptor(current) and is_accessor_descriptor(desc):
            if not configurable:
                if 'set' in desc and desc['set'] is not current['set']:
                    return False
                if 'get' in desc and desc['get'] is not current['get']:
                    return False
        current.update(desc)
        return True

    #these methods will work only for Number class
    def is_infinity(self):
        assert self.Class=='Number'
        return self.value==float('inf') or self.value==-float('inf')

    def is_nan(self):
        assert self.Class=='Number'
        return self.value!=self.value #nan!=nan evaluates to true

    def is_finite(self):
        return not (self.is_nan() or self.is_infinity())
    #Type Conversions. to_type. All must return pyjs subclass instance
    
    def to_primitive(self, hint=None):
        if self.is_primitive():
            return self
        if hint is None and (self.Class=='Number' or self.Class=='Boolean'):  # favour number for Class== Number or Boolean default = String
            hint = 'Number'
        return self.default_value(hint)
            
    def to_boolean(self):
        typ = Type(self)
        if typ=='Boolean': #no need to convert
            return self
        elif typ=='Null' or typ=='Undefined': #they are both always false
            return false
        elif typ=='Number' or typ=='String': #false only for 0, '' and NaN
            return Js(bool(self.value and self.value==self.value)) # test for nan (nan -> flase)
        else: #object -  always true
            return true

    def to_number(self):
        typ = Type(self)
        if typ=='Null':  #null is 0
            return Js(0)
        elif typ=='Undefined':  # undefined is NaN
            return NaN
        elif typ=='Boolean':    # 1 for true 0 for false
            return Js(int(self.value))
        elif typ=='Number':# or self.Class=='Number':   # no need to convert
            return self
        elif typ=='String':
            s = self.value.strip() #Strip white space
            if not s: # '' is simply 0
                return Js(0)
            if 'x' in s or 'X' in s[:3]: #hex (positive only)
                try: # try to convert
                    num = int(s, 16)
                except ValueError: # could not convert > NaN
                    return NaN
                return Js(num)
            sign = 1 #get sign
            if s[0] in '+-':
                if s[0]=='-': 
                    sign = -1
                s = s[1:]
            if s=='Infinity': #Check for infinity keyword. 'NaN' will be NaN anyway.
                return Js(sign*float('inf'))
            try: #decimal try
                num = sign*float(s) # Converted
            except ValueError:
                return NaN # could not convert to decimal  > return NaN
            return Js(num) 
        else: #object -  most likely it will be NaN.
            return self.to_primitive('Number').to_number()
            
    def to_string(self):
        typ = Type(self)
        if typ=='Null':
            return Js('null')
        elif typ=='Undefined':
            return Js('undefined')
        elif typ=='Boolean':
            return Js('true') if self.value else Js('false')
        elif typ=='Number': #or self.Class=='Number':
            if self.is_nan():
                return Js('NaN')
            elif self.is_infinity():
                sign = '-' if self.value<0 else ''
                return Js(sign+'Infinity')
            elif isinstance(self.value, long) or self.value.is_integer():  # dont print .0
                return Js(unicode(int(self.value)))
            return Js(unicode(self.value)) # accurate enough
        elif typ=='String':
            return self
        else: #object
            return self.to_primitive('String').to_string()
            
            
    def to_object(self):
        typ = self.TYPE
        if typ=='Null' or typ=='Undefined':
            raise MakeError('TypeError', 'undefined or null can\'t be converted to object')
        elif typ=='Boolean': # Unsure here... todo repair here
            return Boolean.create(self)
        elif typ=='Number': #?
            return Number.create(self)
        elif typ=='String': #? 
            return String.create(self)
        else: #object
            return self

    def to_int32(self):
        num = self.to_number()
        if num.is_nan() or num.is_infinity():
            return 0
        int32 = int(num.value) % 2**32
        return int(int32 - 2**32 if int32 >= 2**31 else int32)

    def strict_equality_comparison(self, other):
        return PyJsStrictEq(self, other)

    def cok(self):
        """Check object coercible"""
        if self.Class in {'Undefined', 'Null'}:
            raise MakeError('TypeError', 'undefined or null can\'t be converted to object')

    def to_int(self):
        num = self.to_number()
        if num.is_nan():
            return 0
        elif num.is_infinity():
            return 10**20 if num.value>0 else -10**20
        return int(num.value)

    def to_uint32(self):
        num = self.to_number()
        if num.is_nan() or num.is_infinity():
            return 0
        return int(num.value) % 2**32

    def to_uint16(self):
        num = self.to_number()
        if num.is_nan() or num.is_infinity():
            return 0
        return int(num.value) % 2**16

    def to_int16(self):
        num = self.to_number()
        if num.is_nan() or num.is_infinity():
            return 0
        int16 = int(num.value) % 2**16
        return int(int16 - 2**16 if int16 >= 2**15 else int16)



    def same_as(self, other):
        typ = Type(self)
        if typ!=other.Class:
            return False
        if typ=='Undefined' or typ=='Null':
            return True
        if typ=='Boolean' or typ=='Number' or typ=='String':
            return self.value==other.value
        else: #object
            return self is other #Id compare.

    #Not to be used by translation (only internal use)
    def __getitem__(self, item):
        return self.get(str(item) if not isinstance(item, PyJs) else item.to_string().value)

    def __setitem__(self, item, value):
        self.put(str(item) if not isinstance(item, PyJs) else item.to_string().value,  Js(value))

    def __len__(self):
        try:
            return self.get('length').to_uint32()
        except:
            raise TypeError('This object (%s) does not have length property'%self.Class)
    #Oprators-------------
    #Unary, other will be implemented as functions. Increments and decrements 
    # will be methods of Number class
    def __neg__(self): #-u
        return Js(-self.to_number().value)
    
    def __pos__(self): #+u
        return self.to_number()
    
    def __invert__(self): #~u
        return Js(Js(~self.to_int32()).to_int32())
    
    def neg(self): # !u  cant do 'not u' :(
        return Js(not self.to_boolean().value)
    
    def __nonzero__(self): 
        return self.to_boolean().value

    def __bool__(self):
        return self.to_boolean().value
        
    def typeof(self): 
        if self.is_callable():
            return Js('function')
        typ = Type(self).lower()
        if typ=='null':
            typ = 'object'
        return Js(typ)
        
    #Bitwise operators
    #  <<, >>,  &, ^, |
    
    # << 
    def __lshift__(self, other):
        lnum = self.to_int32()
        rnum = other.to_uint32()
        shiftCount = rnum & 0x1F
        return Js(Js(lnum << shiftCount).to_int32())
    
    # >>
    def __rshift__(self, other):
        lnum = self.to_int32()
        rnum = other.to_uint32()
        shiftCount = rnum & 0x1F
        return Js(Js(lnum >> shiftCount).to_int32())


    # >>>
    def pyjs_bshift(self, other):
        lnum = self.to_uint32()
        rnum = other.to_uint32()
        shiftCount = rnum & 0x1F
        return Js(Js(lnum >> shiftCount).to_uint32())
     
    # & 
    def __and__(self, other):
        lnum = self.to_int32()
        rnum = other.to_int32()
        return Js(Js(lnum & rnum).to_int32())
    
    # ^
    def __xor__(self, other):
        lnum = self.to_int32()
        rnum = other.to_int32()
        return Js(Js(lnum ^ rnum).to_int32())

    # |
    def __or__(self, other):
        lnum = self.to_int32()
        rnum = other.to_int32()
        return Js(Js(lnum | rnum).to_int32())

    # Additive operators
    # + and - are implemented here
        
    # +
    def __add__(self, other):
        a = self.to_primitive()
        b = other.to_primitive()
        if a.TYPE=='String' or b.TYPE=='String':
            return Js(a.to_string().value+b.to_string().value)
        a = a.to_number()
        b = b.to_number()
        return Js(a.value+b.value)
    
    # -
    def __sub__(self, other):
        return Js(self.to_number().value-other.to_number().value)
    
    #Multiplicative operators
    # *, / and % are implemented here
    
    # *
    def __mul__(self, other):
        return Js(self.to_number().value*other.to_number().value)
        
    # /
    def __div__(self, other):
        a = self.to_number().value
        b = other.to_number().value
        if b:
            return Js(a/b)
        if not a or a!=a:
            return NaN
        return Infinity if a>0 else -Infinity
    
    # %
    def __mod__(self, other):
        a = self.to_number().value
        b = other.to_number().value
        if abs(a)==float('inf') or not b:
            return NaN
        if abs(b)==float('inf'):
            return Js(a)
        pyres = Js(a%b) #different signs in python and javascript
                        #python has the same sign as b and js has the same 
                        #sign as a.
        if a<0 and pyres.value>0:
            pyres.value -= abs(b)
        elif a>0 and pyres.value<0:
            pyres.value += abs(b)
        return Js(pyres)
        
    #Comparisons (I dont implement === and !== here, these
    # will be implemented as external functions later)
    # <, <=, !=, ==, >=, > are implemented here.
    
    def abstract_relational_comparison(self, other, self_first=True):
        ''' self<other if self_first else other<self.
           Returns the result of the question: is self smaller than other?
           in case self_first is false it returns the answer of:
                                               is other smaller than self.
           result is PyJs type: bool or undefined'''
        px = self.to_primitive('Number')
        py = other.to_primitive('Number')
        if not self_first: #reverse order
            px, py = py, px
        if not (px.Class=='String' and py.Class=='String'):
            px, py = px.to_number(), py.to_number()
            if px.is_nan() or py.is_nan():
                return undefined
            return Js(px.value<py.value) # same cmp algorithm
        else:
            # I am pretty sure that python has the same
            # string cmp algorithm but I have to confirm it
            return Js(px.value<py.value) 
        
    #<
    def __lt__(self, other): 
        res = self.abstract_relational_comparison(other, True)
        if res.is_undefined():
            return false
        return res
    
    #<=
    def __le__(self, other): 
        res = self.abstract_relational_comparison(other, False)
        if res.is_undefined():
            return false
        return res.neg() 
    
    #>=
    def __ge__(self, other): 
        res = self.abstract_relational_comparison(other, True)
        if res.is_undefined():
            return false
        return res.neg() 
    
    #>
    def __gt__(self, other): 
        res = self.abstract_relational_comparison(other, False)
        if res.is_undefined():
            return false
        return res
        
    def abstract_equality_comparison(self, other):
        ''' returns the result of JS == compare.
           result is PyJs type: bool'''
        tx, ty = self.TYPE, other.TYPE
        if tx==ty:
            if tx=='Undefined' or tx=='Null':
                return true
            if tx=='Number' or tx=='String' or tx=='Boolean':
                return Js(self.value==other.value)
            return Js(self is other) # Object
        elif (tx=='Undefined' and ty=='Null') or (ty=='Undefined' and tx=='Null'):
            return true
        elif tx=='Number' and ty=='String':
            return self.abstract_equality_comparison(other.to_number())
        elif tx=='String' and ty=='Number':
            return self.to_number().abstract_equality_comparison(other)
        elif tx=='Boolean':
            return self.to_number().abstract_equality_comparison(other)
        elif ty=='Boolean':
            return self.abstract_equality_comparison(other.to_number())
        elif (tx=='String' or tx=='Number') and other.is_object():
            return self.abstract_equality_comparison(other.to_primitive())
        elif (ty=='String' or ty=='Number') and self.is_object():
            return self.to_primitive().abstract_equality_comparison(other)
        else:
           return false
                
    #==
    def __eq__(self, other): 
        return self.abstract_equality_comparison(other)
           
    #!=
    def __ne__(self, other): 
        return self.abstract_equality_comparison(other).neg()
    
    #Other methods (instanceof)
    
    def instanceof(self, other):
        '''checks if self is instance of other'''
        if not hasattr(other, 'has_instance'):
            return false
        return other.has_instance(self)
        
    #iteration
    def __iter__(self):
        #Returns a generator of all own enumerable properties
        # since the size od self.own can change we need to use different method of iteration.
        # SLOW! New items will NOT show up.
        returned = {}
        if not self.IS_CHILD_SCOPE:
            cands = sorted(name for name in self.own if self.own[name]['enumerable'])
        else:
            cands = sorted(name for name in self.own)
        for cand in cands:
            check = self.own.get(cand)
            if check and check['enumerable']:
                yield Js(cand)

    
    def contains(self, other):
        if not self.is_object():
            raise MakeError('TypeError',"You can\'t use 'in' operator to search in non-objects")
        return Js(self.has_property(other.to_string().value))
        
    #Other Special methods
    def __call__(self, *args):
        '''Call a property prop as a function (this will be global object).
        
        NOTE: dont pass this and arguments here, these will be added
        automatically!'''
        if not self.is_callable():
            raise  MakeError('TypeError', '%s is not a function'%self.typeof())
        return self.call(self.GlobalObject, args)


    def create(self, *args):
        '''Generally not a constructor, raise an error'''
        raise  MakeError('TypeError', '%s is not a constructor'%self.Class)

    def __unicode__(self):
        return self.to_string().value

    def __repr__(self):
        if self.Class=='Object':
            res = []
            for e in self:
                res.append(str_repr(e.value)+': '+str_repr(self.get(e)))
            return '{%s}'%', '.join(res)
        elif self.Class=='String':
            return str_repr(self.value)
        elif self.Class=='Array':
            res = []
            for e in self:
                res.append(repr(self.get(e)))
            return '[%s]'%', '.join(res)
        else:
            val = str_repr(self.to_string().value)
            return val

    def _fuck_python3(self): # hack to make object hashable in python 3 (__eq__ causes problems)
        return object.__hash__(self)

    def callprop(self, prop, *args):
        '''Call a property prop as a method (this will be self).
        
        NOTE: dont pass this and arguments here, these will be added
        automatically!'''
        if not isinstance(prop, basestring):
            prop = prop.to_string().value
        cand = self.get(prop)
        if not cand.is_callable():
            raise  MakeError('TypeError','%s is not a function'%cand.typeof())
        return cand.call(self, args)

    def to_python(self):
        """returns equivalent python object.
         for example if this object is javascript array then this method will return equivalent python array"""
        return to_python(self)

    def to_py(self):
        """returns equivalent python object.
         for example if this object is javascript array then this method will return equivalent python array"""
        return self.to_python()


if six.PY3:
    PyJs.__hash__ = PyJs._fuck_python3
    PyJs.__truediv__ = PyJs.__div__
#Define some more classes representing operators:

def PyJsStrictEq(a, b):
    '''a===b'''
    tx, ty = Type(a), Type(b)
    if tx!=ty:
        return false
    if tx=='Undefined' or tx=='Null':
        return true
    if a.is_primitive(): #string bool and number case
        return Js(a.value==b.value)
    return Js(a is b) # object comparison
    
  
def PyJsStrictNeq(a, b):
    ''' a!==b'''
    return PyJsStrictEq(a, b).neg()
    
def PyJsBshift(a, b):
    """a>>>b"""
    return a.pyjs_bshift(b)


def PyJsComma(a, b):
    return b

class PyJsException(Exception):
    def __str__(self):
        if self.mes.Class=='Error':
            return self.mes.callprop('toString').value
        else:
            return unicode(self.mes)

class PyJsSwitchException(Exception): pass


PyJs.MakeError = staticmethod(MakeError)

def JsToPyException(js):
    temp = PyJsException()
    temp.mes = js
    return temp

def PyExceptionToJs(py):
    return py.mes

#Scope class it will hold all the variables accessible to user
class Scope(PyJs):
    Class = 'global'
    extensible = True
    IS_CHILD_SCOPE = True
    # todo speed up
    # in order to speed up this very important class the top scope should behave differently than
    # child scopes, child scope should not have this property descriptor thing because they cant be changed anyway
    # they are all confugurable= False

    def __init__(self, scope, closure=None):
        """Doc"""
        self.prototype = closure
        if closure is None:
            # global, top level scope
            self.own = {}
            for k, v in six.iteritems(scope):
                # set all the global items
                self.define_own_property(k, {'value': v, 'configurable': False,
                                                'writable': False, 'enumerable': False})
        else:
            # not global, less powerful but faster closure.
            self.own = scope # simple dictionary which maps name directly to js object.

    def register(self, lval):
        # registered keeps only global registered variables
        if self.prototype is None:
            # define in global scope
            if lval in self.own:
                self.own[lval]['configurable'] = False
            else:
                self.define_own_property(lval, {'value': undefined, 'configurable': False,
                                                'writable': True, 'enumerable': True})
        elif lval not in self.own:
            # define in local scope since it has not been defined yet
            self.own[lval] = undefined # default value

    def registers(self, lvals):
        """register multiple variables"""
        for lval in lvals:
            self.register(lval)

    def put(self, lval, val, op=None):
        if self.prototype is None:
            # global scope put, simple
            return PyJs.put(self, lval, val, op)
        else:
            # trying to put in local scope
            # we dont know yet in which scope we should place this var
            if lval in self.own:
                if op: # increment operation
                     val = getattr(self.own[lval], OP_METHODS[op])(val)
                self.own[lval] = val
                return val
            else:
                #try to put in the lower scope since we cant put in this one (var wasn't registered)
                return self.prototype.put(lval, val, op)

    def force_own_put(self, prop, val, configurable=False):
        if self.prototype is None: # global scope
            self.own[prop] = {'value': val, 'writable': True, 'enumerable':True, 'configurable':configurable}
        else:
            self.own[prop] = val

    def get(self, prop, throw=True):
        #note prop is always a Py String
        if not isinstance(prop, basestring):
            prop = prop.to_string().value
        if self.prototype is not None:
            # fast local scope
            cand = self.own.get(prop)
            if cand is None:
                return self.prototype.get(prop, throw)
            return cand
        # slow, global scope
        if prop not in self.own:
            if throw:
                raise MakeError('ReferenceError', '%s is not defined' % prop)
            return undefined
        return PyJs.get(self, prop)

    def delete(self, lval):
        if self.prototype is not None:
            if lval in self.own:
                return false
            return self.prototype.delete(lval)
        # we are in global scope here. Must exist and be configurable to delete
        if lval not in self.own:
            # this lval does not exist, why do you want to delete it???
            return true
        if self.own[lval]['configurable']:
            del self.own[lval]
            return true
        # not configurable, cant delete
        return false

    def pyimport(self, name, module):
        self.register(name)
        self.put(name, py_wrap(module))

    def __repr__(self):
        return u'[Object Global]'

    def to_python(self):
        return to_python(self)

class This(Scope):
    IS_CHILD_SCOPE = False
    def get(self, prop, throw=False):
        return Scope.get(self, prop, throw)

class JsObjectWrapper(object):
    def __init__(self, obj):
        self.__dict__['_obj'] = obj

    def __call__(self, *args):
        args = tuple(Js(e) for e in args)
        if '_prop_of' in self.__dict__:
            parent, meth =  self.__dict__['_prop_of']
            return to_python(parent._obj.callprop(meth, *args))
        return to_python(self._obj(*args))

    def __getattr__(self, item):
        if item == 'new' and self._obj.is_callable():
            # return instance initializer
            def PyJsInstanceInit(*args):
                args = tuple(Js(e) for e in args)
                return self._obj.create(*args).to_python()
            return PyJsInstanceInit
        cand = to_python(self._obj.get(str(item)))
        # handling method calling... obj.meth(). Value of this in meth should be self
        if isinstance(cand, self.__class__):
            cand.__dict__['_prop_of'] = self, str(item)
        return cand

    def __setattr__(self, item, value):
        self._obj.put(str(item), Js(value))

    def __getitem__(self, item):
        cand = to_python(self._obj.get(str(item)))
        if isinstance(cand, self.__class__):
            cand.__dict__['_prop_of'] = self, str(item)
        return cand

    def __setitem__(self, item, value):
        self._obj.put(str(item), Js(value))

    def __iter__(self):
        if self._obj.Class=='Array':
            return iter(self.to_list())
        elif self._obj.Class=='Object':
            return iter(self.to_dict())
        else:
            raise MakeError('TypeError', '%s is not iterable in Python' % self._obj.Class)

    def __repr__(self):
        if self._obj.is_primitive() or self._obj.is_callable():
            return repr(self._obj)
        elif self._obj.Class in {'Array', 'Arguments'}:
            return repr(self.to_list())
        return repr(self.to_dict())

    def __len__(self):
        return len(self._obj)

    def __nonzero__(self):
        return bool(self._obj)

    def __bool__(self):
        return bool(self._obj)

    def to_dict(self):
        return to_dict(self.__dict__['_obj'])

    def to_list(self):
        return to_list(self.__dict__['_obj'])



class PyObjectWrapper(PyJs):
    Class = 'PyObjectWrapper'
    def __init__(self, obj):
        self.obj = obj

    def get(self, prop):
        if not isinstance(prop, basestring):
            prop = prop.to_string().value
        try:
            if prop.isdigit():
                return py_wrap(self.obj[int(prop)])
            return py_wrap(getattr(self.obj, prop))
        except:
            return undefined

    def put(self, prop, val, throw=False):
        if not isinstance(prop, basestring):
            prop = prop.to_string().value
        try:
            setattr(self.obj, prop, to_python(val))
        except AttributeError:
            raise MakeError('TypeError', 'Read only object probably...')
        return val

    def __call__(self, *args):
        py_args = tuple(to_python(e) for e in args)
        try:
            py_res = self.obj.__call__(*py_args)
        except Exception as e:
            message = 'your Python function failed!  '
            try:
                message += e.message
            except:
                pass
            raise MakeError('Error', message)
        return py_wrap(py_res)


    def callprop(self, prop, *args):
        py_args = tuple(to_python(e) for e in args)
        if not isinstance(prop, basestring):
            prop = prop.to_string().value
        return self.get(prop)(*py_args)

    def delete(self, prop):
        if not isinstance(prop, basestring):
            prop = prop.to_string().value
        try:
            if prop.isdigit():
                del self.obj[int(prop)]
            else:
                delattr(self.obj, prop)
            return true
        except:
            return false

    def __repr__(self):
        return 'PyObjectWrapper(%s)' % str(self.obj)

    def to_python(self):
        return self.obj

    def to_py(self):
        return self.obj


def py_wrap(py):
    if isinstance(py, (FunctionType, BuiltinFunctionType, MethodType, BuiltinMethodType,
                       dict, int, str, bool, float, list, tuple, long, basestring)) or py is None :
        return HJs(py)
    return PyObjectWrapper(py)



  
##############################################################################
#Define types
    
#Object
class PyJsObject(PyJs):
    Class = 'Object'
    def __init__(self, prop_descs={}, prototype=None, extensible=True):
        self.prototype = prototype
        self.extensible = extensible
        self.own = {}
        for prop, desc in six.iteritems(prop_descs):
            self.define_own_property(prop, desc)

    def __repr__(self):
        return repr(self.to_python().to_dict())

    
    
ObjectPrototype = PyJsObject()


#Function
class PyJsFunction(PyJs):
    Class = 'Function'
    def __init__(self, func, prototype=None, extensible=True, source=None):
        cand = fix_js_args(func)
        has_scope = cand is func
        func = cand
        self.argcount = six.get_function_code(func).co_argcount - 2 - has_scope
        self.code = func
        self.source = source if source else '{ [python code] }'
        self.func_name = func.__name__ if not func.__name__.startswith('PyJs_anonymous') else ''
        self.extensible = extensible
        self.prototype = prototype
        self.own = {}
        #set own property length to the number of arguments
        self.define_own_property('length', {'value': Js(self.argcount), 'writable': False,
                                            'enumerable': False, 'configurable': False})

        if self.func_name:
            self.define_own_property('name', {'value': Js(self.func_name), 'writable': False,
                                            'enumerable': False, 'configurable': True})

        # set own prototype
        proto = Js({})
        # constructor points to this function
        proto.define_own_property('constructor',{'value': self, 'writable': True,
                                                 'enumerable': False, 'configurable': True})
        self.define_own_property('prototype', {'value': proto, 'writable': True,
                                                 'enumerable': False, 'configurable': False})

    def _set_name(self, name):
        '''name is py type'''
        if self.own.get('name'):
            self.func_name = name
            self.own['name']['value'] = Js(name)

    def construct(self, *args):
        proto = self.get('prototype')
        if not proto.is_object(): # set to standard prototype
            proto = ObjectPrototype
        obj = PyJsObject(prototype=proto)
        cand = self.call(obj, *args)
        return cand if cand.is_object() else obj
    
    def call(self, this, args=()):
        '''Calls this function and returns a result 
        (converted to PyJs type so func can return python types)
        
        this must be a PyJs object and args must be a python tuple of PyJs objects.
        
        arguments object is passed automatically and will be equal to Js(args) 
        (tuple converted to arguments object).You dont need to worry about number 
        of arguments you provide if you supply less then missing ones will be set 
        to undefined (but not present in arguments object).
        And if you supply too much then excess will not be passed 
        (but they will be present in arguments object).
        '''
        if not hasattr(args, '__iter__'):  #get rid of it later
            args = (args,)
        args = tuple(Js(e) for e in args) # this wont be needed later

        arguments = PyJsArguments(args, self) # tuple will be converted to arguments object.
        arglen = self.argcount #function expects this number of args.
        if len(args)>arglen:
            args = args[0:arglen]
        elif len(args)<arglen:
            args += (undefined,)*(arglen-len(args))
        args += this, arguments  #append extra params to the arg list
        try:
            return Js(self.code(*args))
        except NotImplementedError:
            raise
        except RuntimeError as e: # maximum recursion
            raise MakeError('RangeError', e.message if not isinstance(e, NotImplementedError) else 'Not implemented!')
        
    def has_instance(self, other):
        # I am not sure here so instanceof may not work lol.
        if not other.is_object():
            return false
        proto = self.get('prototype')
        if not proto.is_object():
            raise TypeError('Function has non-object prototype in instanceof check')
        while True:
            other = other.prototype
            if not other:  # todo make sure that the condition is not None or null
                return false
            if other is proto:
                return true

    def create(self, *args):
        proto = self.get('prototype')
        if not proto.is_object():
            proto = ObjectPrototype
        new = PyJsObject(prototype=proto)
        res = self.call(new, args)
        if res.is_object():
            return res
        return new

class PyJsBoundFunction(PyJsFunction):
    def __init__(self, target, bound_this, bound_args):
        self.target = target
        self.bound_this = bound_this
        self.bound_args = bound_args
        self.argcount = target.argcount
        self.code = target.code
        self.source = target.source
        self.func_name = target.func_name
        self.extensible = True
        self.prototype = FunctionPrototype
        self.own = {}
        # set own property length to the number of arguments
        self.define_own_property('length', {'value': target.get('length')-Js(len(self.bound_args)), 'writable': False,
                                            'enumerable': False, 'configurable': False})

        if self.func_name:
            self.define_own_property('name', {'value': Js(self.func_name), 'writable': False,
                                              'enumerable': False, 'configurable': True})

        # set own prototype
        proto = Js({})
        # constructor points to this function
        proto.define_own_property('constructor', {'value': self, 'writable': True,
                                                  'enumerable': False, 'configurable': True})
        self.define_own_property('prototype', {'value': proto, 'writable': True,
                                               'enumerable': False, 'configurable': False})


    def call(self, this, args=()):
        return self.target.call(self.bound_this, self.bound_args+args)

    def has_instance(self, other):
        return self.target.has_instance(other)

PyJs.PyJsBoundFunction = PyJsBoundFunction

OP_METHODS = {'*': '__mul__',
              '/': '__div__',
              '%': '__mod__',
              '+': '__add__',
              '-': '__sub__',
              '<<': '__lshift__',
              '>>': '__rshift__',
              '&': '__and__',
              '^': '__xor__',
              '|': '__or__',
              '>>>': 'pyjs_bshift'}

def Empty():
    return Js(None)

#Number
class PyJsNumber(PyJs):  #Note i dont implement +0 and -0. Just 0.
    TYPE = 'Number'
    Class = 'Number'



NumberPrototype = PyJsObject({}, ObjectPrototype)
NumberPrototype.Class = 'Number'
NumberPrototype.value = 0

Infinity = PyJsNumber(float('inf'), NumberPrototype)
NaN = PyJsNumber(float('nan'), NumberPrototype)
PyJs.NaN = NaN
PyJs.Infinity = Infinity

# This dict aims to increase speed of string creation by storing character instances
CHAR_BANK = {}
NUM_BANK = {}
PyJs.CHAR_BANK = CHAR_BANK
#String
# Different than implementation design in order to improve performance
#for example I dont create separate property for each character in string, it would take ages.
class PyJsString(PyJs):
    TYPE = 'String'
    Class = 'String'
    extensible = False
    def __init__(self, value=None, prototype=None):
        '''Constructor for Number String and Boolean'''
        if not isinstance(value, basestring):
            raise TypeError # this will be internal error
        self.value = value
        self.prototype = prototype
        self.own = {}
         # this should be optimized because its mych slower than python str creation (about 50 times!)
        # Dont create separate properties for every index. Just
        self.own['length'] = {'value': Js(len(value)), 'writable': False,
                             'enumerable': False, 'configurable': False}
        if len(value)==1:
            CHAR_BANK[value] = self #, 'writable': False,
                               # 'enumerable': True, 'configurable': False}

    def get(self, prop):
        if not isinstance(prop, basestring):
                prop = prop.to_string().value
        try:
            index = int(prop)
            if index<0:
                return undefined
            char = self.value[index]
            if char not in CHAR_BANK:
                Js(char) # this will add char to CHAR BANK
            return CHAR_BANK[char]
        except Exception:
            pass
        return PyJs.get(self, prop)

    def can_put(self, prop):
        return False

    def __iter__(self):
        for i in xrange(len(self.value)):
            yield Js(i)  # maybe create an int bank?


StringPrototype = PyJsObject({}, ObjectPrototype)
StringPrototype.Class = 'String'
StringPrototype.value = ''

CHAR_BANK[''] = Js('')

#Boolean
class PyJsBoolean(PyJs):
    TYPE = 'Boolean'
    Class = 'Boolean'

BooleanPrototype = PyJsObject({}, ObjectPrototype)
BooleanPrototype.Class = 'Boolean'
BooleanPrototype.value = False

true = PyJsBoolean(True, BooleanPrototype)
false = PyJsBoolean(False, BooleanPrototype)


#Undefined
class PyJsUndefined(PyJs):
    TYPE = 'Undefined'
    Class = 'Undefined'
    def __init__(self):
        pass

undefined = PyJsUndefined()

#Null
class PyJsNull(PyJs):
    TYPE = 'Null'
    Class = 'Null'
    def __init__(self):
        pass
null = PyJsNull()
PyJs.null = null

class PyJsArray(PyJs):
    Class = 'Array'
    def __init__(self, arr=[], prototype=None):
        self.extensible = True
        self.prototype = prototype
        self.own = {'length' : {'value': Js(0), 'writable': True,
                                            'enumerable': False, 'configurable': False}}
        for i, e in enumerate(arr):
            self.define_own_property(str(i), {'value': Js(e), 'writable': True,
                                              'enumerable': True, 'configurable': True})

    def define_own_property(self, prop, desc):
        old_len_desc = self.get_own_property('length')
        old_len = old_len_desc['value'].value  #  value is js type so convert to py.
        if prop=='length':
            if 'value' not in desc:
                return PyJs.define_own_property(self, prop, desc)
            new_len =  desc['value'].to_uint32()
            if new_len!=desc['value'].to_number().value:
                raise MakeError('RangeError', 'Invalid range!')
            new_desc = {k:v for k,v in six.iteritems(desc)}
            new_desc['value'] = Js(new_len)
            if new_len>=old_len:
                return PyJs.define_own_property(self, prop, new_desc)
            if not old_len_desc['writable']:
                return False
            if 'writable' not in new_desc or new_desc['writable']==True:
                new_writable = True
            else:
                new_writable = False
                new_desc['writable'] = True
            if not PyJs.define_own_property(self, prop, new_desc):
                return False
            if new_len<old_len:
                # not very efficient for sparse arrays, so using different method for sparse:
                if old_len>30*len(self.own):
                    for ele in self.own.keys():
                        if ele.isdigit() and int(ele)>=new_len:
                            if not self.delete(ele): # if failed to delete set len to current len and reject.
                                new_desc['value'] = Js(old_len+1)
                                if not new_writable:
                                    new_desc['writable'] = False
                                PyJs.define_own_property(self, prop, new_desc)
                                return False
                    old_len = new_len
                else: # standard method
                    while new_len<old_len:
                        old_len -= 1
                        if not self.delete(str(int(old_len))): # if failed to delete set len to current len and reject.
                            new_desc['value'] = Js(old_len+1)
                            if not new_writable:
                                new_desc['writable'] = False
                            PyJs.define_own_property(self, prop, new_desc)
                            return False
            if not new_writable:
                self.own['length']['writable'] = False
            return True
        elif prop.isdigit():
            index = int(int(prop) % 2**32)
            if index>=old_len and not old_len_desc['writable']:
                return False
            if not PyJs.define_own_property(self, prop, desc):
                return False
            if index>=old_len:
                old_len_desc['value'] = Js(index + 1)
            return True
        else:
            return PyJs.define_own_property(self, prop, desc)

    def to_list(self):
        return [self.get(str(e)) for e in xrange(self.get('length').to_uint32())]

    def __repr__(self):
        return repr(self.to_python().to_list())





ArrayPrototype = PyJsArray([], ObjectPrototype)

class PyJsArguments(PyJs):
    Class = 'Arguments'
    def __init__(self, args, callee):
        self.own = {}
        self.extensible = True
        self.prototype = ObjectPrototype
        self.define_own_property('length', {'value': Js(len(args)), 'writable': True,
                                            'enumerable': False, 'configurable': True})
        self.define_own_property('callee', {'value': callee, 'writable': True,
                                            'enumerable': False, 'configurable': True})
        for i, e in enumerate(args):
            self.put(str(i), Js(e))

    def to_list(self):
        return [self.get(str(e)) for e in xrange(self.get('length').to_uint32())]


#We can define function proto after number proto because func uses number in its init
FunctionPrototype = PyJsFunction(Empty, ObjectPrototype)
FunctionPrototype.own['name']['value'] = Js('')


# I will not rewrite RegExp engine from scratch. I will use re because its much faster.
# I have to only make sure that I am handling all the differences correctly.
REGEXP_DB = {}

class PyJsRegExp(PyJs):
    Class = 'RegExp'
    extensible = True

    def __init__(self, regexp, prototype=None):

        self.prototype = prototype
        self.glob = False
        self.ignore_case = 0
        self.multiline = 0
        # self._cache = {'str':'NoStringEmpty23093',
        #                'iterator': None,
        #                'lastpos': -1,
        #                'matches': {}}
        flags = ''
        if not regexp[-1]=='/':
            #contains some flags (allowed are i, g, m
            spl =  regexp.rfind('/')
            flags = set(regexp[spl+1:])
            self.value = regexp[1:spl]
            if 'g' in flags:
                self.glob = True
            if 'i' in flags:
                self.ignore_case = re.IGNORECASE
            if 'm' in flags:
                self.multiline = re.MULTILINE
        else:
            self.value = regexp[1:-1]

        try:
            if self.value in REGEXP_DB:
                self.pat = REGEXP_DB[regexp]
            else:
                comp =  'None'
                # we have to check whether pattern is valid.
                # also this will speed up matching later
                # todo critical fix patter conversion etc. ..!!!!!
                # ugly hacks porting js reg exp to py reg exp works in 99% of cases ;)
                possible_fixes = [
                    (u'[]', u'[\0]'),
                    (u'[^]', u'[^\0]'),
                    (u'nofix1791', u'nofix1791')
                ]
                reg = self.value
                for fix, rep in possible_fixes:
                    comp = REGEXP_CONVERTER._interpret_regexp(reg, flags)
                    #print 'reg -> comp', reg, '->', comp
                    try:
                        self.pat = re.compile(comp, self.ignore_case | self.multiline)
                        #print reg, '->', comp
                        break
                    except:
                        reg = reg.replace(fix, rep)
                       # print 'Fix', fix, '->', rep, '=', reg
                else:
                    raise
                REGEXP_DB[regexp] = self.pat
        except:
            #print 'Invalid pattern but fuck it', self.value, comp
            raise MakeError('SyntaxError', 'Invalid RegExp pattern: %s -> %s'% (repr(self.value), repr(comp)))
        # now set own properties:
        self.own = {'source' : {'value': Js(self.value), 'enumerable': False, 'writable': False, 'configurable': False},
                    'global' : {'value': Js(self.glob), 'enumerable': False, 'writable': False, 'configurable': False},
                    'ignoreCase' : {'value': Js(bool(self.ignore_case)), 'enumerable': False, 'writable': False, 'configurable': False},
                    'multiline' : {'value': Js(bool(self.multiline)), 'enumerable': False, 'writable': False, 'configurable': False},
                    'lastIndex' : {'value': Js(0), 'enumerable': False, 'writable': True, 'configurable': False}}

    def match(self, string, pos):
        '''string is of course py string'''
        return self.pat.match(string, pos)  # way easier :)
        # assert 0<=pos <= len(string)
        # if not pos:
        #     return re.match(self.pat, string)
        # else:
        #     if self._cache['str']==string:
        #         if pos>self._cache['lastpos']:
        #             for m in self._cache['iterator']:
        #                 start = m.start()
        #                 self._cache['lastpos'] = start
        #                 self._cache['matches'][start] = m
        #                 if start==pos:
        #                     return m
        #                 elif start>pos:
        #                     return None
        #             self._cache['lastpos'] = len(string)
        #             return None
        #         else:
        #             return self._cache['matches'].get(pos)
        #     else:
        #         self._cache['str'] = string
        #         self._cache['matches'] = {}
        #         self._cache['lastpos'] = -1
        #         self._cache['iterator'] = re.finditer(self.pat, string)
        #         return self.match(string, pos)



def JsRegExp(source):
    # Takes regexp literal!
    return PyJsRegExp(source, RegExpPrototype)

RegExpPrototype = PyJsRegExp('/(?:)/', ObjectPrototype)

####Exceptions:
default_attrs = {'writable':True, 'enumerable':False, 'configurable':True}


def fill_in_props(obj, props, default_desc):
    for prop, value in props.items():
        default_desc['value'] = Js(value)
        obj.define_own_property(prop, default_desc)



class PyJsError(PyJs):
    Class = 'Error'
    extensible = True
    def __init__(self, message=None, prototype=None):
        self.prototype = prototype
        self.own = {}
        if message is not None:
            self.put('message', Js(message).to_string())
            self.own['message']['enumerable'] = False

ErrorPrototype = PyJsError(Js(''), ObjectPrototype)
@Js
def Error(message):
    return PyJsError(None if message.is_undefined() else message, ErrorPrototype)
Error.create = Error
err = {'name': 'Error',
       'constructor': Error}
fill_in_props(ErrorPrototype, err, default_attrs)
Error.define_own_property('prototype', {'value': ErrorPrototype,
                                        'enumerable': False,
                                        'writable': False,
                                        'configurable': False})

def define_error_type(name):
    TypeErrorPrototype = PyJsError(None, ErrorPrototype)
    @Js
    def TypeError(message):
        return PyJsError(None if message.is_undefined() else message, TypeErrorPrototype)
    err = {'name': name,
           'constructor': TypeError}
    fill_in_props(TypeErrorPrototype, err, default_attrs)
    TypeError.define_own_property('prototype', {'value': TypeErrorPrototype,
                                                'enumerable': False,
                                                'writable': False,
                                                'configurable': False})
    ERRORS[name] = TypeError

ERRORS = {'Error': Error}
ERROR_NAMES = ['Eval', 'Type', 'Range', 'Reference', 'Syntax', 'URI']

for e in ERROR_NAMES:
    define_error_type(e+'Error')


##############################################################################
# Import and fill prototypes here.

#this works only for data properties
def fill_prototype(prototype, Class, attrs, constructor=False):
    for i in dir(Class):
        e = getattr(Class, i)
        if six.PY2:
            if hasattr(e, '__func__'):
                temp = PyJsFunction(e.__func__, FunctionPrototype)
                attrs = {k:v for k,v in attrs.iteritems()}
                attrs['value'] = temp
                prototype.define_own_property(i, attrs)
        else:
            if hasattr(e, '__call__') and not i.startswith('__'):
                temp = PyJsFunction(e, FunctionPrototype)
                attrs = {k:v for k,v in attrs.items()}
                attrs['value'] = temp
                prototype.define_own_property(i, attrs)
        if constructor:
            attrs['value'] = constructor
            prototype.define_own_property('constructor', attrs)
            



PyJs.undefined = undefined
PyJs.Js = staticmethod(Js)

from .prototypes import jsfunction, jsobject, jsnumber, jsstring, jsboolean, jsarray, jsregexp, jserror


#Object proto
fill_prototype(ObjectPrototype, jsobject.ObjectPrototype, default_attrs)
#Define __proto__ accessor (this cant be done by fill_prototype since)
@Js
def __proto__():
    return this.prototype if this.prototype is not None else null
getter = __proto__
@Js
def __proto__(val):
    if val.is_object():
        this.prototype = val
setter =  __proto__
ObjectPrototype.define_own_property('__proto__', {'set': setter,
                                                  'get': getter,
                                                  'enumerable': False,
                                                  'configurable':True})


#Function proto
fill_prototype(FunctionPrototype, jsfunction.FunctionPrototype, default_attrs)
#Number proto
fill_prototype(NumberPrototype, jsnumber.NumberPrototype, default_attrs)
#String proto
fill_prototype(StringPrototype, jsstring.StringPrototype, default_attrs)
#Boolean proto
fill_prototype(BooleanPrototype, jsboolean.BooleanPrototype, default_attrs)
#Array proto
fill_prototype(ArrayPrototype, jsarray.ArrayPrototype, default_attrs)
#Error proto
fill_prototype(ErrorPrototype, jserror.ErrorPrototype, default_attrs)
#RegExp proto
fill_prototype(RegExpPrototype, jsregexp.RegExpPrototype, default_attrs)
# add exec to regexpfunction (cant add it automatically because of its name :(
RegExpPrototype.own['exec'] = RegExpPrototype.own['exec2']
del RegExpPrototype.own['exec2']

#########################################################################
# Constructors

# String
@Js
def String(st):
    if not len(arguments):
        return Js('')
    return arguments[0].to_string()

@Js
def string_constructor():
    temp = PyJsObject(prototype=StringPrototype)
    temp.Class = 'String'
    #temp.TYPE = 'String'
    if not len(arguments):
        temp.value = ''
    else:
        temp.value = arguments[0].to_string().value
        for i, ch in enumerate(temp.value): # this will make things long...
            temp.own[str(i)] = {'value': Js(ch), 'writable': False,
                                'enumerable': True, 'configurable': True}
    temp.own['length'] = {'value': Js(len(temp.value)), 'writable': False,
                          'enumerable': False, 'configurable': False}
    return temp

String.create = string_constructor

# RegExp
REG_EXP_FLAGS = {'g', 'i', 'm'}
@Js
def RegExp(pattern, flags):
    if pattern.Class=='RegExp':
        if not flags.is_undefined():
            raise  MakeError('TypeError', 'Cannot supply flags when constructing one RegExp from another')
        # return unchanged
        return pattern
    #pattern is not a regexp
    if pattern.is_undefined():
        pattern = ''
    else:
        pattern = pattern.to_string().value
        # try:
        #     pattern = REGEXP_CONVERTER._unescape_string(pattern.to_string().value)
        # except:
        #     raise MakeError('SyntaxError', 'Invalid regexp')
    flags = flags.to_string().value if not flags.is_undefined() else ''
    for flag in flags:
        if flag not in REG_EXP_FLAGS:
            raise MakeError('SyntaxError', 'Invalid flags supplied to RegExp constructor "%s"' % flag)
    if len(set(flags))!=len(flags):
        raise MakeError('SyntaxError', 'Invalid flags supplied to RegExp constructor "%s"' % flags)
    pattern  = '/%s/'%(pattern if pattern else '(?:)') + flags
    return JsRegExp(pattern)

RegExp.create = RegExp
PyJs.RegExp = RegExp

# Number

@Js
def Number():
    if len(arguments):
        return arguments[0].to_number()
    else:
        return Js(0)

@Js
def number_constructor():
    temp = PyJsObject(prototype=NumberPrototype)
    temp.Class = 'Number'
    #temp.TYPE = 'Number'
    if len(arguments):
        temp.value = arguments[0].to_number().value
    else:
        temp.value = 0
    return temp

Number.create = number_constructor

# Boolean

@Js
def Boolean(value):
    return value.to_boolean()
@Js
def boolean_constructor(value):
    temp = PyJsObject(prototype=BooleanPrototype)
    temp.Class = 'Boolean'
    #temp.TYPE = 'Boolean'
    temp.value = value.to_boolean().value
    return temp

Boolean.create = boolean_constructor


##############################################################################

def appengine(code):
    try:
        return translator.translate_js(code.decode('utf-8'))
    except:
        return traceback.format_exc()
        
        
        
builtins = ('true','false','null','undefined','Infinity',
            'NaN')

scope = dict(zip(builtins, [eval(e) for e in builtins]))

JS_BUILTINS = {k:v for k,v in scope.items()}


# Fill in NUM_BANK
for e in xrange(-2**10,2**14):
    NUM_BANK[e] = Js(e)

if __name__=='__main__':
    print(ObjectPrototype.get('toString').callprop('call'))
    print(FunctionPrototype.own)
    a=  null-Js(49404)
    x = a.put('ser', Js('der'))
    print(Js(0) or Js('p') and Js(4.0000000000050000001))
    FunctionPrototype.put('Chuj', Js(409))
    for e in FunctionPrototype:
        print('Obk', e.get('__proto__').get('__proto__').get('__proto__'), e)
    import code
    s = Js(4)
    b = Js(6)

    s2 = Js(4)
    o =  ObjectPrototype
    o.put('x', Js(100))
    var = Scope(scope)
    e = code.InteractiveConsole(globals())
    #e.raw_input = interactor
    e.interact()


