from versoonode import *
from versoodefines import *
import verse as v

class Method:
	def __init__(self, node_id, group_id, method_id, name, params):
		self.node_id = node_id
		self.group_id = group_id
		self.method_id = method_id
		self.name = name
		self.params = params
		self.callback = None
	
	def get_node_id(self):
		return self.node_id
	
	def get_group_id(self):
		return self.group_id
	
	def get_method_id(self):
		return self.method_id
	
	def get_name(self):
		return self.name
	
	def get_params(self):
		return self.params
	
	def destroy(self):
		node_id = self.node_id
		group_id = self.group_id
		method_id = self.method_id
		v.send_o_method_destroy(node_id, group_id, method_id)
	
	def __call__(self, *args):
		node_id = self.node_id
		group_id = self.group_id
		method_id = self.method_id
		avatar = v.session_get_avatar()
		v.send_o_method_call(node_id, group_id, method_id, avatar, args)
	
	def __repr__(self):
		return self.__str__()

	def __str__(self):
		return "[Method] " + str(self.method_id) + ": " + self.definition()

	def definition(self):
		global PTYPES

		str = self.name + "("
		i = 0
		for param in self.params:
			if i != 0: str += ", "
			str += PTYPES[param[1]] + " " + param[0]
			i += 1
		str += ")"
		return str
	
	def set_callback(self, callback):
		self.callback = callback
	
	def _cb_method_call(self, sender, params):
		if self.callback:
			self.callback(sender, params)

class MethodGroup:
	def __init__(self, node_id, group_id, name, session):
		self.node_id = node_id
		self.group_id = group_id
		self.name = name
		self.session = session
		self.methods = IdDict("Methods", session)

		v.send_o_method_group_subscribe(node_id, group_id)
	
	def get_node_id(self):
		return self.node_id
	
	def get_group_id(self):
		return self.group_id
	
	def get_name(self):
		return self.name
	
	def destroy(self):
		v.send_o_method_group_destroy(self.node_id, self.group_id)

	def __getattr__(self, id):
		return self.methods.__getattr__(id)
	
	def __repr__(self):
		return self.__str__()
	
	def __str__(self):
		txt = MakeNodeStr("Method Group", self.group_id, self.name)
		if len(self.methods) > 0:
			txt += "\n" + str(self.methods)
		return txt

	def _cb_method_create(self, method_id, name, params):
		method = Method(self.node_id, self.group_id, method_id, name, params)
		self.methods._add(method_id, method)
	
	def _cb_method_destroy(self, method_id):
		self.methods._del(method_id)
	
	def _cb_method_call(self, method_id, sender, params):
		if method_id in self.methods:
			self.methods[method_id]._cb_method_call(sender, params)

	def method_create(self, name, params, callback=None):
		if name in self.methods:
			return
		node_id = self.node_id
		group_id = self.group_id
		v.send_o_method_create(node_id, group_id, ~0, name, params)
		self.methods._wait_for_item(name)
		if callback and name in self.methods:
			self.methods[name].set_callback(callback)
		return self.methods[name]

class Link:
	def __init__(self, node_id, link_id, link, label, target_id, session):
		self.node_id = node_id
		self.link_id = link_id
		self.link = link
		self.label = label
		self.name = label
		self.target_id = target_id
		self.session = session

	def get_node_id(self):
		return self.node_id
	
	def get_link_id(self):
		return self.group_id
	
	def get_name(self):
		return self.name
	
	def get_label(self):
		return self.label
	
	def get_link(self):
		return self.link
	
	def get_target_id(self):
		return self.target_id
	
	def destroy():
		v.send_o_link_destroy(self.node_id, self.link_id)
		
	def __repr__(self):
		return self.__str__()

	def __str__(self):
		txt = "[Link] " + str(self.link_id) + ": "
		txt += str(self.label) + " ("
		txt += "link: " + str(self.link) + ", "
		txt += "target_id: " + str(self.target_id) + ")"
		return txt

class Object(Node):
	def __init__(self, node_id, session):
		Node.__init__(self, node_id, session)
		self.methodgroups = IdDict("Method Groups", session)
		self.links = IdDict("Links", session)
		self.typename = "Object"
	
	def method_group_create(self, name):
		if name in self.methodgroups:
			return
		v.send_o_method_group_create(self.node_id, ~0, name)
		self.methodgroups._wait_for_item(name)
		return self.methodgroups[name]

	def link_set(self, link, label, target_id):
		if label in self.links:
			return
		v.send_o_link_set(self.node_id, ~0, link, label, target_id)
		self.links._wait_for_item(label)

	def __getattr__(self, id):
		if id in self.methodgroups:
			return self.methodgroups.__getattr__(id)
		elif id in self.links:
			return self.links.__getattr__(id)
		elif id in self.taggroups:
			return self.taggroups.__getattr__(id)
		else:
			raise AttributeError
	
	def __str__(self):
		txt = Node.__str__(self)
		if len(self.methodgroups) > 0:
			txt += "\n" + str(self.methodgroups)
		if len(self.links) > 0:
			txt += "\n" + str(self.links)
		return txt

	def _cb_method_gp_create(self, group_id, name):
		methodgroup = MethodGroup(self.node_id, group_id, name, self.session)
		self.methodgroups._add(group_id, methodgroup)

	def _cb_method_gp_destroy(self, group_id):
		self.methodgroups._del(group_id)

	def _cb_method_create(self, group_id, method_id, name, params):
		if group_id in self.methodgroups:
			methodgroup = self.methodgroups[group_id]
			methodgroup._cb_method_create(method_id, name, params)

	def _cb_method_destroy(self, group_id, method_id):
		if group_id in self.methodgroups:
			methodgroup = self.methodgroups[group_id]
			methodgroup._cb_method_destroy(method_id)
	
	def _cb_method_call(self, group_id, method_id, sender, params):
		if group_id in self.methodgroups:
			methodgroup = self.methodgroups[group_id]
			methodgroup._cb_method_call(method_id, sender, params)
	
	def _cb_link_set(self, link_id, vlink, label, target_id):
		node_id = self.node_id
		session = self.session
		link = Link(node_id, link_id, vlink, label, target_id, session)
		self.links._add(link_id, link)

	def _cb_link_destroy(self, link_id):
		self.links._del(link_id)