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

class TextBuffer:
	def __init__(self, node_id, buffer_id, name, session):
		self.node_id = node_id
		self.buffer_id = buffer_id
		self.name = name
		self.session = session
		self.buf = ""

		v.send_t_buffer_subscribe(node_id, buffer_id)
	
	def get_node_id(self):
		return self.node_id
	
	def get_name(self):
		return self.name

	def get_buffer_id(self):
		return self.buffer_id
	
	def destroy(self):
		v.send_t_buffer_destroy(self.node_id, self.buffer_id)

	def __repr__(self):
		return self.__str__()
	
	def __str__(self):
		txt = MakeNodeStr("TextBuffer", self.buffer_id, self.name)
		txt += " (length: " + str(len(self.buf))
		txt += ", print .text() to read it)"
		return txt
	
	def text(self):
		return self.buf
	
	def get_text(self):
		return self.buf

	def _cb_text_set(self, pos, length, text):
		buflen = len(self.buf)

		if pos > buflen:
			pos = buflen
		if pos + length > buflen:
			length = buflen - pos

		self.buf = self.buf[0:pos] + text + self.buf[pos+length:]
	
	def text_set(self, pos, length, text):
		v.send_t_text_set(self.node_id, self.buffer_id, pos, length, text)
	
	def all_text_set(self, text):
		#while len(text) > v.T_MAX_TEXT_CMD_SIZE:
		#	txt = text[:v.T_MAX_TEXT_CMD_SIZE]
		#	text = text[v.T_MAX_TEXT_CMD_SIZE:]
		#	v.send_t_text_set(self.node_id, self.buffer_id, 0, ~0, txt)
		v.send_t_text_set(self.node_id, self.buffer_id, 0, ~0, text)
	
	def append_text(self, text):
		self.text_set(~0, 0, text)

	def load_file(self, filename):
		f = file(filename, "rU")
		self.all_text_set(f.read())

class Text(Node):
	def __init__(self, node_id, session):
		Node.__init__(self, node_id, session)
		self.buffers = IdDict("TextBuffers", session)
		self.typename = "Text"
		self.language = ""
		self.language_set = False
	
	def buffer_create(self, name):
		if name in self.buffers:
			return
		# wtf is index?
		v.send_t_buffer_create(self.node_id, ~0, 0, name)
		self.buffers._wait_for_item(name)
		return self.buffers[name]

	def __getattr__(self, id):
		if id in self.buffers:
			return self.buffers.__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.language) > 0:
			txt += ", " + self.language
		if len(self.buffers) > 0:
			txt += "\n" + str(self.buffers)
		return txt

	def _cb_buffer_create(self, buffer_id, name):
		buffer = TextBuffer(self.node_id, buffer_id, name, self.session)
		self.buffers._add(buffer_id, buffer)

	def _cb_buffer_destroy(self, buffer_id):
		self.buffers._del(buffer_id)

	def _cb_text_set(self, buffer_id, pos, length, text):
		if buffer_id in self.buffers:
			self.buffers[buffer_id]._cb_text_set(pos, length, text)
	
	def set_language(self, language):
		if language == self.language:
			return
		self.language_set = False
		v.send_t_set_language(self.node_id, language)
		reset_timeout()
		while not self.language_set and not timeout():
			self.session.update()
	
	def get_language(self):
		return self.language

	def _cb_set_language(self, language):
		self.language = language
		self.language_set = True