# PythonJS Low Level Runtime
# by Amirouche Boubekki and Brett Hartshorn - copyright 2013
# License: "New BSD"


__NULL_OBJECT__ = Object.create( null )
if 'window' in this and 'document' in this:
	__NODEJS__ = False
	pythonjs = {}
else:
	## note, we can not test for: '"process" in this' or '"process" in global'
	## make sure we are really inside NodeJS by letting this fail, and halting the program.
	__NODEJS__ = True
	print process.title
	print process.version


def jsrange(num):
	"""Emulates Python's range function"""
	var(i, r)
	i = 0
	r = []
	while i < num:
		r.push(i)
		i = i + 1
	return r


def create_array():
	"""Used to fix a bug/feature of Javascript where new Array(number)
	created a array with number of undefined elements which is not
	what we want"""
	var(array)
	array = []
	for i in jsrange(arguments.length):
		array.push(arguments[i])
	return array

def adapt_arguments(handler):
	"""Useful to transform Javascript arguments to Python arguments"""
	def func():
		handler(Array.prototype.slice.call(arguments))
	return func



def get_attribute(object, attribute):
	"""Retrieve an attribute, method, property, or wrapper function.

	method are actually functions which are converted to methods by
	prepending their arguments with the current object. Properties are
	not functions!

	DOM support:
		http://stackoverflow.com/questions/14202699/document-createelement-not-working
		https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof

	Direct JavaScript Calls:
		if an external javascript function is found, and it was not a wrapper that was generated here,
		check the function for a 'cached_wrapper' attribute, if none is found then generate a new
		wrapper, cache it on the function, and return the wrapper.
	"""
	if attribute == '__call__':
		if JS("{}.toString.call(object) === '[object Function]'"):
			if JS("object.pythonscript_function === true"):
				return object
			elif JS("object.is_wrapper !== undefined"):
				return object
			else:
				JS("var cached = object.cached_wrapper")
				if cached:
					return cached
				else:
					def wrapper(args,kwargs): return object.apply(None, args)
					wrapper.is_wrapper = True
					object.cached_wrapper = wrapper
					return wrapper

	var(attr)
	attr = object[attribute]  ## this could be a javascript object with cached method

	if __NODEJS__ is False:
		if JS("object instanceof HTMLDocument"):
			#print 'DYNAMIC wrapping HTMLDocument'
			if JS("typeof(attr) === 'function'"):
				def wrapper(args,kwargs): return attr.apply(object, args)
				wrapper.is_wrapper = True
				return wrapper
			else:
				return attr
		elif JS("object instanceof HTMLElement"):
			#print 'DYNAMIC wrapping HTMLElement'
			if JS("typeof(attr) === 'function'"):
				def wrapper(args,kwargs): return attr.apply(object, args)
				wrapper.is_wrapper = True
				return wrapper
			else:
				return attr
		
	#if attribute in object:  ## in test not allowed with javascript-string
	if attr is not None:  ## what about cases where attr is None?
		if JS("typeof(attr) === 'function' && attr.pythonscript_function === undefined && attr.is_wrapper === undefined"):
			## to avoid problems with other generated wrapper funcs not marked with:
			## F.pythonscript_function or F.is_wrapper, we could check if object has these props:
			## bases, __name__, __dict__, __call__
			#print 'wrapping something external', object, attribute

			def wrapper(args,kwargs): return attr.apply(object, args)
			wrapper.is_wrapper = True
			return wrapper
		else:
			return attr

	var(__class__, __dict__, bases)

	# next check object.__dict__ for attr, note that object could be a class, and classes have a __dict__
	__dict__ = object.__dict__
	if __dict__:
		attr = __dict__[attribute]
		if attr != None:
			return attr


	# next check for object.__class__
	__class__ = object.__class__
	if __class__:  ## at this point we can assume we are dealing with a pythonjs class instance

		if attribute in __class__.__properties__:  ## @property decorators
			return __class__.__properties__[ attribute ]['get']( [object], JSObject() )

		__dict__ = __class__.__dict__
		attr = __dict__[attribute]

		if attribute in __dict__:
			if JS("{}.toString.call(attr) === '[object Function]'"):
				def method():
					var(args)
					args =  Array.prototype.slice.call(arguments)
					if (JS('args[0] instanceof Array') and JS("{}.toString.call(args[1]) === '[object Object]'") and args.length == 2):
						pass
					else:
						# in the case where the method was submitted to javascript code
						# put the arguments in order to be processed by PythonJS
						args = [args, JSObject()]
					args[0].splice(0, 0, object)
					return attr.apply(None, args)  ## should we bind `this` here so callback can use this?
				method.is_wrapper = True

				object[attribute] = method  ## cache method - we assume that methods do not change

				return method
			else:
				return attr

		bases = __class__.__bases__

		for base in bases:
			attr = _get_upstream_attribute(base, attribute)
			if attr:
				if JS("{}.toString.call(attr) === '[object Function]'"):
					def method():
						var(args)
						args =  Array.prototype.slice.call(arguments)
						if (JS('args[0] instanceof Array') and JS("{}.toString.call(args[1]) === '[object Object]'") and args.length == 2):
							pass
						else:
							# in the case where the method was submitted to javascript code
							# put the arguments in order to be processed by PythonJS
							args = [args, JSObject()]

						args[0].splice(0, 0, object)
						return attr.apply(None, args)
					method.is_wrapper = True

					object[attribute] = method  ## cache method - we assume that methods do not change

					return method
				else:
					return attr

		for base in bases:  ## upstream property getters come before __getattr__
			var( prop )
			prop = _get_upstream_property(base, attribute)
			if prop:
				return prop['get']( [object], JSObject() )

		if '__getattr__' in __dict__:
			return __dict__['__getattr__']( [object, attribute], JSObject() )

		for base in bases:
			var( f )
			f = _get_upstream_attribute(base, '__getattr__')
			if f:
				return f( [object, attribute], JSObject() )


	if JS('object instanceof Array'):
		if attribute == '__getitem__':
			def wrapper(args,kwargs): return object[ args[0] ]
			wrapper.is_wrapper = True
			return wrapper
		elif attribute == '__setitem__':
			def wrapper(args,kwargs): object[ args[0] ] = args[1]
			wrapper.is_wrapper = True
			return wrapper

	elif attribute == '__getitem__':  ## this should be a JSObject - or anything else - is this always safe?
		def wrapper(args,kwargs): return object[ args[0] ]
		wrapper.is_wrapper = True
		return wrapper
	elif attribute == '__setitem__':
		def wrapper(args,kwargs): object[ args[0] ] = args[1]
		wrapper.is_wrapper = True
		return wrapper

	# raise AttributeError instead? or should we allow this? maybe we should be javascript style here and return undefined
	return None

def _get_upstream_attribute(base, attr):
	if attr in base.__dict__:
		return base.__dict__[ attr ]
	for parent in base.__bases__:
		return _get_upstream_attribute(parent, attr)

def _get_upstream_property(base, attr):
	if attr in base.__properties__:
		return base.__properties__[ attr ]
	for parent in base.__bases__:
		return _get_upstream_property(parent, attr)

def set_attribute(object, attribute, value):
	"""Set an attribute on an object by updating its __dict__ property"""
	var(__dict__, __class__)
	__class__ = object.__class__
	#if __class__:  ## TODO property setter
	__dict__ = object.__dict__
	if __dict__:
		__dict__[attribute] = value
	else:
		object[attribute] = value



def get_arguments(signature, args, kwargs):
	"""Based on ``signature`` and ``args``, ``kwargs`` parameters retrieve
	the actual parameters.

	This will set default keyword arguments and retrieve positional arguments
	in kwargs if their called as such"""

	if args is None:
		args = []
	if kwargs is None:
		kwargs = JSObject()
	out = JSObject()

	# if the caller did not specify supplemental positional arguments e.g. *args in the signature
	# raise an error
	if args.length > signature.args.length:
		if signature.vararg:
			pass
		else:
			print 'ERROR args:', args, 'kwargs:', kwargs, 'sig:', signature
			raise TypeError("Supplemental positional arguments provided but signature doesn't accept them")

	j = 0
	while j < signature.args.length:
		name = signature.args[j]
		if name in kwargs:
			# value is provided as a keyword argument
			out[name] = kwargs[name]
		elif j < args.length:
			# value is positional and within the signature length
			out[name] = args[j]
		elif name in signature.kwargs:
			# value is not found before and is in signature.length
			out[name] = signature.kwargs[name]
		j += 1

	args = args.slice(j)  ## note that if this fails because args is not an array, then a pythonjs function was called from javascript in a bad way.

	if signature.vararg:
		out[signature.vararg] = args
	if signature.varkwarg:
		out[signature.varkwarg] = kwargs
	return out