import verse as v
from versoodefines import *

def MakeStrList(dictionary):
	txt = ""
	if len(dictionary) > 0:
		txt += "{"
		i = 0
		for key in dictionary:
			if i != 0:
				txt += ", "
			txt += str(key) + ": " + dictionary[key].name
			i += 1
		txt += "} "
	return txt

def MakeNodeStr(id, node_id, node_name):
	txt = "[" + id + "] " + str(node_id) + ": " + node_name
	return txt

class IdDict:
	def __init__(self, name, session):
		self.name = name
		self.session = session
		self.items = {}

	def __getitem__(self, id):
		if id in self.items:
			return self.items[id]
		if isinstance(id, str):
			for i in self.items.itervalues():
				if i.name == id:
					return i
		raise IndexError
	
	def __len__(self):
		return len(self.items)

	def __iter__(self):
		return self.items.iterkeys()
	
	def __contains__(self, id):
		if id in self.items:
			return True
		if isinstance(id, str):
			for i in self.items.itervalues():
				if i.name == id:
					return True
		return False
	
	def __getattr__(self, name):
		if isinstance(name, str):
			for i in self.items.itervalues():
				if i.name == name:
					return i
		raise AttributeError

	def __str__(self):
		return self.name + " = " + MakeStrList(self.items)
	
	def __repr__(self):
		return self.__str__()
	
	def _add(self, id, node):
		self.items[id] = node
		try:
			if self.expected_item_name == node.name:
				self.expected_item_name = False
		except AttributeError:
			return

	def _del(self, id):
		if id in self.items:
			del self.items[id]

	def _wait_for_item(self, name):
		self.expected_item_name = name
		reset_timeout()
		while self.expected_item_name and not timeout():
			self.session.update()
		del self.expected_item_name

class Tag:
	def __init__(self, node_id, group_id, tag_id, name, type, tag):
		self.node_id = node_id
		self.group_id = group_id
		self.tag_id = tag_id
		self.name = name
		self.type = type
		self.tag = tag
	
	def get_node_id(self):
		return self.node_id

	def get_group_id(self):
		return self.group_id

	def get_tag_id(self):
		return self.tag_id

	def get_name(self):
		return self.name

	def get_type(self):
		return self.type

	def get_tag(self):
		return self.tag
	
	def get_value(self):
		return self.tag

	def destroy(self):
		v.send_tag_destroy(self.node_id, self.group_id, self.tag_id)
	
	def __repr__(self):
		return self.__str__()
	
	def _tag_set(self, value):
		node_id = self.node_id
		group_id = self.group_id
		tag_id = self.tag_id
		name = self.name
		type = self.type
		v.send_tag_create(node_id, group_id, tag_id, name, type, value)

	def __str__(self):
		global TTYPES
		txt = "[Tag] " + str(self.tag_id) + ": " + TTYPES[self.type]
		txt += " " + self.name + " = " + str(self.tag)
		return txt

class TagDict(IdDict):
	def __init__(self, name, session):
		IdDict.__init__(self, name, session)
	
	def __setitem__(self, id, value):
		if id in self.items:
			self.items[id]._tag_set(value)
			return
		if isinstance(id, str):
			for i in self.items.itervalues():
				if i.name == id:
					i._tag_set(value)
					return
		raise IndexError

class TagGroup:
	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.tags = TagDict("Tags", session)

		v.send_tag_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_tag_group_destroy(self.node_id, self.group_id)

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

	def _cb_tag_create(self, tag_id, name, type, tag):
		tag = Tag(self.node_id, self.group_id, tag_id, name, type, tag)
		self.tags._add(tag_id, tag)
	
	def _cb_tag_destroy(self, tag_id):
		self.tags._del(tag_id)
	
	def __setattr__(self, name, value):
		known_attribs = ["node_id", "group_id", "session", "name", "tags"]
		if name in known_attribs:
			self.__dict__[name] = value
			return

		if name in self.__dict__["tags"]:
			self.__dict__["tags"][name]._tag_set(value)
			return

		raise AttributeError
	
	def tag_create(self, name, type, tag):
		if name in self.tags:
			return
		v.send_tag_create(self.node_id, self.group_id, ~0, name, type, tag)
		self.tags._wait_for_item(name)
		return self.tags[name]

class Node:
	def __init__(self, node_id, session):
		self.node_id = node_id
		self.session = session
		self.taggroups = IdDict("Tag Groups", session)
		self.name = ""
		self.typename = "Node"
		v.send_node_subscribe(node_id)
	
	def get_node_id(self):
		return self.node_id

	def get_name(self):
		return self.name

	def destroy(self):
		v.send_node_destroy(self.node_id)
	
	def name_set(self, name):
		if name == self.name:
			return
		v.send_node_name_set(self.node_id, name)
		self.expected_name = name
		reset_timeout()
		while self.expected_name and not timeout():
			self.session.update()
		del self.expected_name

	def tag_group_create(self, name):
		if name in self.taggroups:
			return
		v.send_tag_group_create(self.node_id, ~0, name)
		self.taggroups._wait_for_item(name)
		return self.taggroups[name]
	
	def _cb_node_name_set(self, name):
		self.name = name
		try:
			if self.expected_name == name:
				self.expected_name = False
		except AttributeError:
			return
	
	def __getattr__(self, id):
		return self.taggroups.__getattr__(id)
	
	def __repr__(self):
		return self.__str__()
	
	def __str__(self):
		txt = MakeNodeStr(self.typename, self.node_id, self.name)
		if len(self.taggroups) > 0:
			txt += "\n" + str(self.taggroups)
		return txt

	def _cb_tag_gp_create(self, group_id, name):
		taggroup = TagGroup(self.node_id, group_id, name, self.session)
		self.taggroups._add(group_id, taggroup)
	
	def _cb_tag_gp_destroy(self, group_id):
		self.taggroups._del(group_id)
	
	def _cb_tag_create(self, group_id, tag_id, name, type, tag):
		if group_id in self.taggroups:
			self.taggroups[group_id]._cb_tag_create(tag_id, name, type, tag)
	
	def _cb_tag_destroy(self, group_id, tag_id):
		if group_id in self.taggroups:
			 self.taggroups[group_id]._cb_tag_destroy(tag_id)