import datetime
import appuifw, graphics, e32,key_codes, socket
from key_codes import *
import os.path

class Planilla:

	def __init__(self):
		self.dias = []
		self.mes = 0
		self.year = 0
		self.primerdia = 0
		self.num_dias = 0
		#ahora son cosas particulares a los caracteres metidos
		self.mananas = 0
		self.tardes = 0
		self.noches = 0
		self.suma = 0
		self.libres = 0
		self.salidas = 0

	def load(self,mes,year):
		self.mes = mes
		self.year = year
		self.primerdia = datetime.daysInMonth.weekday(year,mes,1)
		self.num_dias = datetime.daysInMonth.calculate(year,mes)
		
		for i in range(self.num_dias):
			self.dias.append(u"?")

	def _noches(self):
		self.noches = self.noches + 1
	def _salidas(self):
		self.salidas = self.salidas + 1
	def _tardes(self):
		self.tardes = self.tardes + 1
	def _mananas(self):
		self.mananas = self.mananas + 1
	def _suma(self):
		self.suma = self.suma + 1
	def _libres(self):
		self.libres = self.libres + 1
	def resumir(self):
		self.mananas = 0
		self.tardes = 0
		self.noches = 0
		self.suma = 0
		self.libres = 0
		self.salidas = 0
		tabla = {u"M": self._mananas,
				u"T": self._tardes,
				u"L": self._libres,
				u"-": self._salidas,
				u"N": self._noches,
				u"S": self._suma,
				u"?": lambda: 1}
		for dia in self.dias:
			fun = tabla[dia]
			fun()
		
		return [self.mananas, self.tardes, self.libres, self.noches, self.salidas, self.suma]
	
	def reset(self):
		self.dias = []
		self.mes = 0
		self.year = 0
		self.primerdia = 0
		self.num_dias = 0
		
	def cambio(self,dia, tipo):
		self.dias[dia]=tipo

	def __str__(self):
		result = ""
		for i in range(self.primerdia):
			result = result + u"  "
		
		for dia in self.dias:
			result = result + dia + u" "
			i = i + 1
			result = result + "\n"
			i = -1
		return result


	def save(self,path):
		res = ""
		file = open(path,"w")
		res = res + str(self.mes) + "\n"
		res = res + str(self.year) + "\n"
		res = res + str(self.num_dias) + "\n"
		res = res + str(self.primerdia) + "\n"
		for i in self.dias:
			res = res + i + "\n"
		file.write(res)
		file.close()

	def load_file(self,path):
		file = open(path,"r")
		self.mes = int(file.readline())
		self.year = int(file.readline())
		self.num_dias = int(file.readline())
		self.primerdia = int(file.readline())
		for i in range(self.num_dias):
			self.dias.append(unicode(file.readline().strip()))
"""
now = datetime.datetime.now()
planilla = Planilla()
planilla.load(now.month,now.year)
planilla.cambio(1,'L')
planilla.cambio(23,'-')
print planilla

planilla.save("test")

planilla2 = Planilla()
planilla2.load_file("test")

print planilla2
"""

class Keyboard(object):
	def __init__(self,onevent=lambda:None):
		self._keyboard_state={}
		self._downs={}
		self._onevent=onevent
	def handle_event(self,event):
		if event['type'] == appuifw.EEventKeyDown:
			code=event['scancode']
			if not self.is_down(code):
				self._downs[code]=self._downs.get(code,0)+1
			self._keyboard_state[code]=1
		elif event['type'] == appuifw.EEventKeyUp:
			self._keyboard_state[event['scancode']]=0
		self._onevent()
	def is_down(self,scancode):
		return self._keyboard_state.get(scancode,0)
	def pressed(self,scancode):
		if self._downs.get(scancode,0):
			self._downs[scancode]-=1
			return True
		return False

class CalendarWidget:
	def __init__(self,x,y,w_celda,h_celda):
		self._w_celda = w_celda
		self._h_celda = h_celda
		self._width = w_celda*7
		self._height = h_celda*7 #se incluyen dias semana, faltaria titulo
		self._x = x
		self._y = y
		self._rec_x = x #por ahora, coor del rectangulo
		self._rec_y = y + 8
		self._rec_X = self._rec_x + (w_celda * 7)
		self._rec_Y = self._rec_y + (h_celda * 7)
		self._selected = 7
		self._titulo = ""
		self._primerdia = 7
		self._dias = 31
	def titulo(self,title):
		self._titulo = title
	
	def planilla(self,plan):
		self._planilla = plan
		self._primerdia = plan.primerdia+7
		self._selected = self._primerdia
		self._dias = plan.num_dias + self._primerdia
	def seleccionado(self):
		return self._selected
	def seleccionar(self,dia):
		self._selected = self._primerdia + dia -1
		
	def _pintacuadro(self,pos,letra,numero):
		"""
		Pinta dentro de un cuadrito de la posicion pos la letra 
		y si cabe el numero
		"""
		x = pos % 7
		y = pos / 7
		x = self._rec_x + (x * self._w_celda) + (self._w_celda/2 -2)
		y = self._rec_y + (y * self._h_celda) + (self._h_celda - 3)
		canvas.text((x,y),letra,font=u'LatinBold12')
		if pos >6:
			canvas.text((x-7,y-7),unicode(numero),font=u'Acp5')
		
	def sube(self):
		if self._selected -7 >= self._primerdia:
			self.restaurar(self._selected)
			self._selected = self._selected - 7
			self._select(self._selected)
	
	def baja(self):
		if self._selected + 7 < self._dias: 
			self.restaurar(self._selected)
			self._selected = self._selected + 7
			self._select(self._selected)
	
	def izquierda(self):
		if self._selected > self._primerdia:
			self.restaurar(self._selected)
			self._selected = self._selected - 1
			self._select(self._selected)
	def derecha(self):
		if self._selected + 1 < self._dias:
			self.restaurar(self._selected)
			self._selected = self._selected + 1
			self._select(self._selected)
	def _select(self,pos):
		i = pos % 7
		j = pos / 7
		x = self._rec_x + (i * self._w_celda) 
		y = self._rec_y + (j * self._h_celda)
		X = x + self._w_celda
		Y = y + self._h_celda
		dia = pos - self._primerdia +1
		canvas.rectangle((x,y,X,Y),fill=(111,111,255))
		self._pintacuadro(pos,self._planilla.dias[dia-1],dia)
	def restaurar(self,pos):
		i = pos % 7
		j = pos / 7
		x = self._rec_x + (i * self._w_celda) 
		y = self._rec_y + (j * self._h_celda)
		X = x + self._w_celda
		Y = y + self._h_celda
		dia = pos - self._primerdia +1
		canvas.rectangle((x,y,X+1,Y+1),0x000000,fill=(255,255,255),width=1)
		self._pintacuadro(pos,self._planilla.dias[dia-1],dia)
		
	def redraw(self):
		canvas.clear(0xffffff)
		if self._titulo != "":
			canvas.text((self._x,self._y),self._titulo)
		canvas.rectangle((self._rec_x,self._rec_y,self._rec_X+1,self._rec_Y+1),0x000000) #rectangulo marco
		i = self._rec_x
		j = self._rec_y
		for x in range(6):
			j = j + self._h_celda
			i = i + self._w_celda
			canvas.line((i,self._rec_y,i,self._rec_Y),0x000000) #verticale
			canvas.line((self._rec_x,j,self._rec_X,j),0x000000) #horizontales
		self._pintacuadro(0,u'L',1)
		self._pintacuadro(1,u'M',2)
		self._pintacuadro(2,u'X',3)
		self._pintacuadro(3,u'J',4)
		self._pintacuadro(4,u'V',5)
		self._pintacuadro(5,u'S',6)
		self._pintacuadro(6,u'D',7)
		# acedemos de manera directa a la planilla, no es lo mejor pero...es rapido
		
		if self._selected >6:
			self._select(self._selected)
		primer= self._planilla.primerdia+7
		i = 1
		for dia in self._planilla.dias:
			self._pintacuadro(primer,dia,i)
			i = i +1
			primer = primer + 1
		

class Planillas:
	def __init__(self,widget):
		"""Constructor"""
		self._now = datetime.datetime.now()
		self._root = u'e:\\planillas\\'
		self._actual = Planilla()
		self._mes = self._now.month
		self._anno = self._now.year
		self._widget = widget
		self._modificado = 0
		
	def load(self):
		file = self._root + unicode(self._mes) + unicode(self._anno)
		if not os.path.exists(self._root):
			os.mkdir(self._root)
		if os.path.exists(file):
			self._actual.load_file(file)
		else:
			appuifw.note(u"No hay planilla de este mes. Creando una", "info")
			self._actual.load(self._mes,self._anno)
			self._actual.save(file)
		self._widget.titulo(self.mes(self._mes) + u' ' + unicode(self._anno))
		self._widget.planilla(self._actual)
		self._widget.seleccionar(self._now.day)
		self._modificado =0
	def anterior(self):
		self.save()	
		if self._mes >1:
			#seguiremos en el mismo año
			self._mes = self._mes - 1
		else:
			self._mes = 12
			self._anno = self._anno - 1
		self._actual.reset() #borramos lo que haya
		self.load()
	def siguiente(self):
		self.save()	
		if self._mes >11:
			self._mes = 1
			self._anno = self._anno + 1
		else:
			self._mes = self._mes + 1
		self._actual.reset() #borramos lo que haya
		self.load()
		
	def save(self):
		if self._modificado == 1:
			guardar = appuifw.query(u"Ha habido cambios en la planilla. Quieres guardarlos?","query")
			if guardar == 1:
				file = self._root + unicode(self._mes) + unicode(self._anno)
				self._actual.save(file)
	
	def cambio(self):
		change = appuifw.popup_menu([u"Mañana",u"Tarde",u"Libre",u"Noche",u"------",U"Summa"])
		if change != None:
			change = [u'M',u'T',u'L',u'N',u'-',u'S'][change]
			pos = calendarWidget.seleccionado()- 7 - self._actual.primerdia #Calculamos el dia real a partir de la pos(nos saltamos la ocultacion :P)
			self._actual.cambio(pos,change)
			self._modificado = 1
	
	def resumir(self):
		res = self._actual.resumir()
		appuifw.note(u"Dias:     " + unicode(res[0]+res[1])
					+ u"\nNoches: " + unicode(res[3])
					+ u"\nSalidas: " + unicode(res[4])
					+ u"\nLibres:  " + unicode(res[2])
					+ u"\nSumma:   " + unicode(res[5])
					)
		
	def bluetooth(self):
		file = self._root + unicode(self._mes) + unicode(self._anno)
		device=socket.bt_obex_discover()
		address=device[0]
		channel=device[1][u'OBEX Object Push']
		socket.bt_obex_send_file(address,channel,file)
		appuifw.note(u"Planilla enviada","info")

	def mes(self,numero):
		return [u'Enero',u'Febrero',u'Marzo',u'Abril',u'Mayo',u'Junio',
				u'Julio',u'Agosto',u'Septiempre',u'Octubre',u'Noviembre',u'Diciembre'][numero-1]


cerrando = 0

def handle_redraw(rect):
	if cerrando != 1:   #así no da error al repintar al salir
		calendarWidget.redraw()

				
lock = e32.Ao_lock()
keyboard=Keyboard()
cerrando=1 #Nos evitamos el error de pintado inicial
canvas=appuifw.Canvas(event_callback=keyboard.handle_event, redraw_callback=handle_redraw)
appuifw.app.body=canvas
appuifw.app.screen='normal'
calendarWidget = CalendarWidget(9,14,22,17)
cerrando=0	# Ya podemos pintar
planillas =  Planillas(calendarWidget)
planillas.load()
def quit():
	global cerrando,canvas
	cerrando=1
	planillas.save()
	canvas = None
	appuifw.app.set_exit()
	lock.signal()
	
canvas.bind(key_codes.EKeyLeftArrow, lambda: calendarWidget.izquierda())
canvas.bind(key_codes.EKeyRightArrow, lambda: calendarWidget.derecha())
canvas.bind(key_codes.EKeyUpArrow, lambda: calendarWidget.sube())
canvas.bind(key_codes.EKeyDownArrow, lambda: calendarWidget.baja())
canvas.bind(key_codes.EKeySelect, lambda: planillas.cambio())
#w,h = canvas.size
#img=graphics.Image.new((w,h))

def item1():
	appuifw.note(u"Foo", "info")

def item2():
	appuifw.note(u"Outch", "info")

appuifw.app.title = u"Planillas"
appuifw.app.menu = [(u"Mes Anterior", planillas.anterior),
                    (u"Mes Siguiente", planillas.siguiente),
					(u"Resumen Mes", planillas.resumir),
					(u"Enviar Bluetooth", planillas.bluetooth),
					(u"Salir", quit)]
appuifw.app.exit_key_handler=quit

calendarWidget.redraw()
lock.wait()