import verse as v
import weakref
import threading
import pdb

from versoodefines import *
from versoonode import *
from versooobject import *
from versootext import *
from versoobitmap import *

# Callback Update Thread

def _TimeCallback():
	v.callback_update(10000)

class _TimeCallbackThread(threading.Thread):
	def __init__(self, function, delay):
		threading.Thread.__init__(self)
		self.the_lock = threading.Lock()
		self.function = function
		self.delay = delay

	def run(self):
		self.alive = 1
		while self.alive:
			self.the_lock.acquire()
			self.function()
			self.the_lock.release()
			time.sleep(self.delay)

	def kill(self):
		self.alive = 0

def StartCallbackThread():
	t = _TimeCallbackThread(_TimeCallback, 0.2)
	# don't keep app alive for me, make ctrl-c, or ctr-d work
	t.setDaemon(True)
	t.start()

# Session

class Session:
	def __init__(self):
		self.is_connected = False
		self.session = None
		# also in connect_terminate
		self.nodes = IdDict("Nodes", self)
		self.new_object_created = False
		self.new_object_type = None
		self.address = ""

		cbl = [(None, None)] * v.CALLBACK_FUNCTIONS
		cbl[v.SEND_CONNECT_ACCEPT] = (self._cb_connect_accept, None)
		cbl[v.SEND_CONNECT_TERMINATE] = (self._cb_connect_terminate, None)
		cbl[v.SEND_NODE_CREATE] = (self._cb_node_create, None)
		cbl[v.SEND_NODE_NAME_SET] = (self._cb_node_name_set, None)
		cbl[v.SEND_NODE_DESTROY] = (self._cb_node_destroy, None)
		cbl[v.SEND_TAG_GROUP_CREATE] = (self._cb_tag_gp_create, None)
		cbl[v.SEND_TAG_GROUP_DESTROY] = (self._cb_tag_gp_destroy, None)
		cbl[v.SEND_TAG_CREATE] = (self._cb_tag_create, None)
		cbl[v.SEND_TAG_DESTROY] = (self._cb_tag_destroy, None)
		cbl[v.SEND_O_METHOD_GROUP_CREATE] = (self._cb_method_gp_create, None)
		cbl[v.SEND_O_METHOD_GROUP_DESTROY] = (self._cb_method_gp_destroy, None)
		cbl[v.SEND_O_METHOD_CREATE] = (self._cb_method_create, None)
		cbl[v.SEND_O_METHOD_DESTROY] = (self._cb_method_destroy, None)
		cbl[v.SEND_O_METHOD_CALL] = (self._cb_method_call, None)
		cbl[v.SEND_O_LINK_SET] = (self._cb_link_set, None)
		cbl[v.SEND_O_LINK_DESTROY] = (self._cb_link_destroy, None)
		cbl[v.SEND_T_SET_LANGUAGE] = (self._cb_set_language, None)
		cbl[v.SEND_T_BUFFER_CREATE] = (self._cb_buffer_create, None)
		cbl[v.SEND_T_BUFFER_DESTROY] = (self._cb_buffer_destroy, None)
		cbl[v.SEND_T_TEXT_SET] = (self._cb_text_set, None)
		cbl[v.SEND_B_DIMENSIONS_SET] = (self._cb_dimensions_set, None)
		cbl[v.SEND_B_LAYER_CREATE] = (self._cb_layer_create, None)
		cbl[v.SEND_B_LAYER_DESTROY] = (self._cb_layer_destroy, None)
		self.cbl = cbl

		for i in range(0, len(cbl)):
			cb = cbl[i]
			if cb[0]:
				v.callback_set(i, cb[0])
			elif cb[1]:
				v.callback_set(i, cb[1])
	
	def callback_set(self, const, func):
		cb = self.cbl[const]
		if cb[0]:
			self.cbl[const] = (cb[0], func)
		else:
			v.callback_set(const, func)
	
	def update(self):
		v.callback_update(10000)

	def _update5(self):
		for i in range(5):
			self.update()
	
	def _cb_connect_accept(self, avatar, address, host_id):
		self.is_connected = True
		v.send_node_list(~0)

		func = self.cbl[v.SEND_CONNECT_ACCEPT][1]
		if func: func(avatar, address, host_id)
	
	def _cb_connect_terminate(self, address, msg):
		self._destroy_connection()
	
	def _cb_node_create(self, node_id, type, owner):
		node = None
		if type == v.OBJECT:
			node = Object(node_id, self)
		elif type == v.TEXT:
			node = Text(node_id, self)
		elif type == v.BITMAP:
			node = Bitmap(node_id, self)
		else:
			node = Node(node_id, self)

		self.nodes._add(node_id, node)
		if owner == v.OWNER_MINE:
			if type == self.new_object_type:
				if not self.new_object_created:
					self.new_object_created = node

		func = self.cbl[v.SEND_NODE_CREATE][1]
		if func: func(node_id, type, owner)
	
	def _cb_node_name_set(self, node_id, name):
		if node_id in self.nodes:
			self.nodes[node_id]._cb_node_name_set(name)

		func = self.cbl[v.SEND_NODE_NAME_SET][1]
		if func: func(node_id, name)

	def _cb_node_destroy(self, node_id):
		self.nodes._del(node_id)
	
		func = self.cbl[v.SEND_NODE_DESTROY][1]
		if func: func(node_id)

	def _cb_tag_gp_create(self, node_id, group_id, name):
		if node_id in self.nodes:
			self.nodes[node_id]._cb_tag_gp_create(group_id, name)
		
		func = self.cbl[v.SEND_TAG_GROUP_CREATE][1]
		if func: func(node_id, group_id, name)

	def _cb_tag_gp_destroy(self, node_id, group_id):
		if node_id in self.nodes:
			self.nodes[node_id]._cb_tag_gp_destroy(group_id)
			
		func = self.cbl[v.SEND_TAG_GROUP_DESTROY][1]
		if func: func(node_id, group_id)

	def _cb_tag_create(self, node_id, group_id, tag_id, name, type, tag):
		if node_id in self.nodes:
			node = self.nodes[node_id]
			node._cb_tag_create(group_id, tag_id, name, type, tag)
				
		func = self.cbl[v.SEND_TAG_CREATE][1]
		if func: func(node_id, group_id, tag_id, name, type, tag)

	def _cb_tag_destroy(self, node_id, group_id, tag_id):
		if node_id in self.nodes:
			self.nodes[node_id]._cb_tag_destroy(group_id, tag_id)
					
		func = self.cbl[v.SEND_TAG_DESTROY][1]
		if func: func(node_id, group_id, tag_id)

	def _cb_method_gp_create(self, node_id, group_id, name):
		if node_id in self.nodes:
			if isinstance(self.nodes[node_id], Object):
				self.nodes[node_id]._cb_method_gp_create(group_id, name)
					
		func = self.cbl[v.SEND_O_METHOD_GROUP_CREATE][1]
		if func: func(node_id, group_id, name)

	def _cb_method_gp_destroy(self, node_id, group_id):
		if node_id in self.nodes:
			if isinstance(self.nodes[node_id], Object):
				self.nodes[node_id]._cb_method_gp_destroy(group_id)
					
		func = self.cbl[v.SEND_O_METHOD_GROUP_DESTROY][1]
		if func: func(node_id, group_id)

	def _cb_method_create(self, node_id, group_id, method_id, name, params):
		if node_id in self.nodes:
			node = self.nodes[node_id]
			if isinstance(node, Object):
				node._cb_method_create(group_id, method_id, name, params)
						
		func = self.cbl[v.SEND_O_METHOD_CREATE][1]
		if func: func(node_id, group_id, method_id, name, params)

	def _cb_method_destroy(self, node_id, group_id, method_id):
		if node_id in self.nodes:
			if isinstance(self.nodes[node_id], Object):
				self.nodes[node_id]._cb_method_destroy(group_id, method_id)
						
		func = self.cbl[v.SEND_O_METHOD_DESTROY][1]
		if func: func(node_id, group_id, method_id)

	def _cb_method_call(self, node_id, group_id, method_id, sender, params):
		if node_id in self.nodes:
			if isinstance(self.nodes[node_id], Object):
				object = self.nodes[node_id]
				object._cb_method_call(group_id, method_id, sender, params)
						
		func = self.cbl[v.SEND_O_METHOD_CALL][1]
		if func: func(node_id, group_id, method_id, sender, params)

	def _cb_link_set(self, node_id, link_id, link, label, target_id):
		if node_id in self.nodes:
			if isinstance(self.nodes[node_id], Object):
				object = self.nodes[node_id]
				object._cb_link_set(link_id, link, label, target_id)
						
		func = self.cbl[v.SEND_O_LINK_SET][1]
		if func: func(node_id, link_id, link, label, target_id)

	def _cb_link_destroy(self, node_id, link_id):
		if node_id in self.nodes:
			if isinstance(self.nodes[node_id], Object):
				object = self.nodes[node_id]
				object._cb_link_destroy(link_id)
						
		func = self.cbl[v.SEND_O_LINK_DESTROY][1]
		if func: func(node_id, link_id)

	def _cb_set_language(self, node_id, language):
		if node_id in self.nodes:
			if isinstance(self.nodes[node_id], Text):
				self.nodes[node_id]._cb_set_language(language)
						
		func = self.cbl[v.SEND_T_SET_LANGUAGE][1]
		if func: func(node_id, language)

	def _cb_buffer_create(self, node_id, buffer_id, index, name):
		# FIXME: wtf is index?
		if node_id in self.nodes:
			if isinstance(self.nodes[node_id], Text):
				self.nodes[node_id]._cb_buffer_create(buffer_id, name)
						
		func = self.cbl[v.SEND_T_BUFFER_CREATE][1]
		if func: func(node_id, buffer_id, index, name)

	def _cb_buffer_destroy(self, node_id, buffer_id):
		if node_id in self.nodes:
			if isinstance(self.nodes[node_id], Text):
				self.nodes[node_id]._cb_buffer_destroy(buffer_id)
							
		func = self.cbl[v.SEND_T_BUFFER_DESTROY][1]
		if func: func(node_id, buffer_id)

	def _cb_text_set(self, node_id, buffer_id, pos, length, text):
		if node_id in self.nodes:
			if isinstance(self.nodes[node_id], Text):
				self.nodes[node_id]._cb_text_set(buffer_id, pos, length, text)
							
		func = self.cbl[v.SEND_T_TEXT_SET][1]
		if func: func(node_id, buffer_id, pos, length, text)

	def _cb_dimensions_set(self, node_id, width, height, depth):
		if node_id in self.nodes:
			if isinstance(self.nodes[node_id], Bitmap):
				bmp = self.nodes[node_id]
				bmp._cb_dimensions_set(width, height, depth)
							
		func = self.cbl[v.SEND_B_DIMENSIONS_SET][1]
		if func: func(node_id, width, height, depth)

	def _cb_layer_create(self, node_id, layer_id, name, type):
		if node_id in self.nodes:
			if isinstance(self.nodes[node_id], Bitmap):
				self.nodes[node_id]._cb_layer_create(layer_id, name, type)
							
		func = self.cbl[v.SEND_B_LAYER_CREATE][1]
		if func: func(node_id, layer_id, name, type)

	def _cb_layer_destroy(self, node_id, layer_id):
		if node_id in self.nodes:
			if isinstance(self.nodes[node_id], Bitmap):
				self.nodes[node_id]._cb_layer_destroy(layer_id)
								
		func = self.cbl[v.SEND_B_LAYER_DESTROY][1]
		if func: func(node_id, layer_id)

	def connected(self):
		return self.is_connected
	
	def get_avatar(self):
		if self.is_connected:
			return v.session_get_avatar()
		else:
			return ~0

	def connect(self, user="user", passw="pass", address="localhost"):
		if self.session != None:
			self.connect_terminate()

		self.session = v.send_connect(user, passw, address, 0)
		self.address = address
		v.session_set(self.session)
		reset_timeout()
		while not self.is_connected and not timeout():
			self.update()
	
	def _destroy_connection(self):
		v.session_destroy(self.session)
		v.session = None
		self.nodes = IdDict("Nodes", self)
		self.new_object_created = False
		self.new_object_type = None
		self.is_connected = False
	
	def connect_terminate(self):
		if self.is_connected:
			v.send_connect_terminate(self.address, "bye")
			self._update5()
			self._destroy_connection()
			
	def node_create(self, type, name):
		self.new_object_created = False
		self.new_object_type = type
		v.send_node_create(~0, type, v.OWNER_MINE)
		reset_timeout()
		while not self.new_object_created and not timeout():
			self.update()
		ob = self.new_object_created
		ob.name_set(name)
		return ob

	def object_create(self, name):
		return self.node_create(v.OBJECT, name)

	def text_create(self, name, language):
		node = self.node_create(v.TEXT, name)
		node.set_language(language)
		return node

	def geometry_create(self, name):
		return self.node_create(v.GEOMETRY, name)

	def audio_create(self, name):
		return self.node_create(v.AUDIO, name)

	def bitmap_create(self, name, width, height, depth):
		node = self.node_create(v.BITMAP, name)
		node.dimensions_set(width, height, depth)
		return node

	def material_create(self, name):
		return self.node_create(v.MATERIAL, name)

	def curve_create(self, name):
		return self.node_create(v.CURVE, name)

	def __getattr__(self, id):
		if id in self.nodes:
			return self.nodes[id]
		else:
			raise AttributeError
	
	def __repr__(self):
		return self.__str__()

	def __str__(self):
		txt = "Versoo Session"
		if len(self.nodes) > 0:
			txt += "\n" + str(self.nodes)
		return txt