#!/usr/bin/python
# -*- coding: utf-8 -*-

######################################################################################################
 # SOFTWARE PARA DISPOSITIVO SOBRE DRON RADIOCONTROLADO DE AIRVANT SOCIEDAD.
 # DESARROLLO DE SOFTWARE E IMPLEMENTACIÓN DE HARDWARE:
 #  Juan de Dios Yáñez Ávila, CEO Onwards, Director I+D+i en Airvant.
 # EMAIL DE CONTACTO:
 #  juandediosyanez@onw4rds.com | juandediosyanez@gmail.com
 # ARCHIVO: interfaz.py
 # VERSIÓN: 0.2.
 # ENTORNO DE USO: Python 2.7.9.
 # FECHA: 2017/__/__
 # DERECHOS:
 ## Los derechos de uso/explotación de este software son al 50% por Airvant sociedad, y el 
 ## desarrollador del mismo. El código y archivos asociados están protegidos por las leyes
 ## de propiedad intelectual e industrial. El uso fraudulento y no permitido de los mismos
 ## está penado por la ley.
######################################################################################################

from Airvant import *
from Tkinter import *

import bluetooth, datetime, io, os, serial, time 
import RPi.GPIO as gpio

## Designamos las variables relacionadas con el hardware
 ## LUCES DE CONTROL
LEDCONTROL1G = 4
LEDCONTROL1B = 17
LEDCONTROL2B = 27
 ## LUCES DE CONTROL LECTURA
LEDLECTURAG = 18
LEDLECTURAR1 = 23
LEDLECTURAR2 = 24

gpio.setmode(gpio.BCM)
gpio.setwarnings(False)

## Led de control configuración
gpio.setup(LEDCONTROL1G, gpio.OUT)
gpio.setup(LEDCONTROL1B, gpio.OUT)
gpio.setup(LEDCONTROL2B, gpio.OUT)
gpio.setup(LEDLECTURAG, gpio.OUT)
gpio.setup(LEDLECTURAR1, gpio.OUT)
gpio.setup(LEDLECTURAR2, gpio.OUT)


### TENGO QUE CREAR UN PATRON POR CADA INCIDENCIA CON EL RGB
### TENGO QUE USAR EL PANEL 7 SEGMENTOS PARA INDICAR AL PILOTO EL PASILLO
### - CUANDO EL PANEL INDIQUE EL PASILLO PODRÁ COMENZAR.
### - CUANDO ESTE APAGADO NO TIENE TAREA ASIGNADA
### SE PODRÍAN CREAR LOS PATRONES DE LUCES DENTRO DE EL MÓDULO DE FUNCIONES Airvant.

## Designamos las variables relacionadas con el análisis del trabajo en el pasillo
piloto_empieza = 0
piloto_termina = 0
lecturas_correctas = 0
lecturas_incidencias = 0

## Puede que queramos borrar un pasillo entero por el motivo que sea, en ese caso llamaremos al técnico
## y será el encargado de acceder via VNC o Putty al archivo del pasillo que queremos borrar.
## El piloto solo puede borrar una última lectura, en el tiempo indicado por los led amarillos.
	##	def borrar(pasillo):
	##		import os
	##		pasillo = str(pasillo)
	##		name_doc = 'lecturas/'+pasillo+'.txt'
	##		fichero = open(name_doc, 'r')
	##		a = []
	##		for linea in fichero.readlines():
	##			a.append(linea)
	##		fichero.close()
	##		a.pop(len(a)-1)
	##		os.remove(name_doc)
	##		fichero2 = open(name_doc, 'w')
	##		for i in range(len(a)):
	##			for j in range(len(a[i])):
	##				fichero2.write(a[i][j])
	##		fichero2.close()
	##		print("Borrado")
##
	##	def borrar_():
	##			empresa_b = empresa.get()
	##			pasillo_b = entrada_pasillo.get()
	##			pasar = empresa_b+pasillo_b
	##			pasar = str(pasar)
	##			borrar(pasar)
##
"""
def panel(pasillo):
	panel_pasillo = list([])
	for numero in pasillo:
		panel_pasillo.append()
	digitos = len(panel_pasillo)
"""


def iniciar_trabajo():
	## Indicamos al piloto que ya puede comenzar el trabajo LED1 VERDE
	## panel_trabajando()
	gpio.output(LEDCONTROL1G, True)
	SUBIENDO = True # ESTA VARIABLE ES ESENCIAL PARA EL CONTROL DE LA OPERATIVA DE VUELO
	## Registramos la hora en la que el piloto comienza el trabajo en el pasillo.
	piloto_empieza = datetime.datetime.now()
	## Tenemos que hacer un reajuste para evitar los errores de introducir un 0 o no en la designación de pasillos.
	## Estos serán siempre numéricos, y si poseen letras deberemos reajustar este hecho
	empresa = dato_empresa.get()
	# Reajustamos el número de pasillo para que siempre sea lo que queremos.
	# No tendremos 1000 pasillos en un mismo almacén, por tanto con una designación 001 es suficiente.
	pasillo = int(dato_pasillo.get())
	pasillo = str("{:03d}".format(pasillo))
	alturamax = int(dato_alturamax.get())
	longitud = int(dato_longitudcodigo.get())
	## Ponemos el valor del pulsometro de apagado en False
	inputValue = False
	ultima_lectura = ''
	## Nos vamos a mover por columnas y alturas para una correcta medición
	columna = 1
	altura = 1
	alturamin = 1
	item = 0
	## Creamos el archivo_trabajo y si ya existe seguimos leyendo desde el punto en el que nos quedamos.
	## Por cada empresa se crea una carpeta concreta, y dentro de esta un archivo con nombre de la empresa y pasillo.
	archivo = empresa + " " + pasillo + ".txt"
	#direccion = "trabajos/" + str(empresa) + "/" + str(archivo)
	direccion = "trabajos/" + str(archivo) # PARECE QUE NO PODEMOS CREAR UNA CARPETA
	if(os.path.exists(direccion) == False):
		archivo_trabajo = open(direccion, "w")
		archivo_trabajo.close()
	else:
		archivo_trabajo = open(direccion, "r") # si existe es que se tubo que parar el trabajo por lo que sea
		###
		# SE DEBERÍA AVISAR DE QUE EXISTE EL ARCHIVO_TRABAJO CON ALGUNA LUZ
		aviso_existetrabajo()
		###
		items = archivo_trabajo.readlines() # tenemos todos los items para ver la evolución
		# contabilizamos los item leídos
		item = len(items) # retomamos la cuenta de items
		archivo_trabajo.close()
		# volvemos al punto de trabajo en el que nos quedamos
		if(item != 0):
			ultima_lectura = items[-1].split("|")
			# columna | altura | lectura item
			altura = int(ultima_lectura[1])+1
			if(altura == alturamax):
				altura = 1
				columna = int(ultima_lectura[0])+1
			else:
				columna = int(ultima_lectura[0])
			ultima_lectura = str(ultima_lectura[2])
			archivo_trabajo.close()
		else:
			print("Error, trabajo creado sin registros. Borre archivo de trabajo")
			return
			### ESTO ES UNA SITUACIÓN QUE HAY QUE RESOLVER
	
	## Pantalla del técnico --> inicio del trabajo en pasillo	
	print("Empresa: {0} Nº de pasillo: {1} Longitud de código: {2}".format(empresa, pasillo, longitud)) #print(pasillo, longitud, num)
	
	while(True):
		###
		# ENCENDEMOS LED VERDE, AVISANDO INICIO TRABAJO. ESTO TENDRÁ QUE SER UN LED VERDE ENCENDIDO 1/7 central
		aviso_pilototrabaja()
		###
		# Pantalla del técnico --> lecturas
		print("Columna {0} | Altura {1} | Lectura: {2} " .format(columna, altura, item+1))
		# hacemos una lectura con el sensor del tamaño especificado para identificar posible incidencias
		###
		### PARA HACER TESTs RECURRIREMOS A UNA FUNCIÓN ESPECÍFICA
		### lectura = test_n568(int(longitud))
		###
		lectura = n568xug(int(longitud))
		###
		if (lectura != ultima_lectura and lectura != 'INCIDENCIA-01' and lectura != 'INCIDENCIA-02' and lectura != ''):
			item = item + 1
			ultima_lectura = lectura
			altura = altura +1
			if(altura > alturamax):
				altura = 1
				columna = columna + 1
			dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura)+"\n" 
			## Guardamos en el archivo_trabajo y en items la lectura
			archivo_trabajo = open(direccion, 'a')
			archivo_trabajo.write(dato_item)
			archivo_trabajo.close()
			## Mostramos la lectura
			print(dato_item)
			## Como es una lectura correcta, la contabilizamos como tal
			global lecturas_correctas = lecturas_correctas + 1
			###
			# POR SER UNA LECTURA CORRECTA ENCENDEREMOS EN MARQUEE VERDE 7/7 DESDE 1/7 CENTRAL 1 SEGUNDO
			aviso_lecturacorrecta()
			###
			time.sleep(1) #1.2 segundos
		
		if(lectura == "INCIDENCIA-01" or lectura == "INCIDENCIA-02"):
			## Guardamos la incidencia, pero no aumentamos los item, pues no se ha leído
			ultima_lectura = lectura
			altura = altura +1
			if(altura > alturamax):
				altura = 1
				columna = columna + 1
			dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura)+"\n"
			## Guardamos en el archivo_trabajo y en items la lectura
			archivo_trabajo = open(direccion, 'a')
			archivo_trabajo.write(dato_item)
			archivo_trabajo.close()
			## Mostramos la lectura
			print(dato_item)
			## Como es una incidencia, la contabilizamos como tal
			global lecturas_incidencias = lecturas_incidencias + 1
			###
			# POR SER UNA INCIDENCIA ENCENDEREMOS EN MARQUEE ROJO 7/7 DESDE 1/7 CENTRAL 2 SEGUNDOS
			aviso_lecturaincidencianormal()
			###
		
		if(lectura == ''):
			###
			# POR SER UNA INCIDENCIA DESCONOCIDA
			aviso_lecturaincidenciadesconocida()
			###
			
			## En caso de que no se lea nada en el timeout dado se encienden unas luces de aviso para actuar
			# EN ESTE CASO TENDREMOS QUE USAR EL MANDO BLUETOOTH, SEGÚN EL BOTÓN SE REGISTRARÁ:
			# - INCIDENCIA DESCONOCIDA --> tenemos que aumentar el numero de incidencias
			# - HUECO --> aumenta el conteo de columnas y alturas
			# - MULTICAPA DE X TAMAÑO --> detiene el conteo de columnas y alturas
			# - FINALIZAR EL TRABAJO Y TRANSFORMARLO EN UN EXCEL
			# ENCENDEMOS LA BANDA EN EL COLOR AZUL DE AIRVANT ESPERANDO UNA INDICACIÓN 1/7
			## Actualmente el led rojo parpadea esperando presionar el boton para finalizar el trabajo pero EL BOTÓN AHORA ES INNECESARIO, PUES DISPONEMOS DE UNA CONEXIÓN BLUETOOTH PARA DAR COMANDOS CONCRETOS
            ## Pedimos al piloto que indique lo que ocurre
			respuesta_piloto = peticion_piloto()
			## Analizamos la respuesta y actuamos en consecuencia
			## PUEDE SER t, h, e, o un numero que indica el tamaño de la multicapa --> fijo tenemos que ir a una funcion de lectura especial solo para la multicapa
			
			###
			 # PILOTO TERMINA EL TRABAJO
			###
			if(respuesta_piloto == "t"):
				piloto_termina = datetime.datetime.now()
				## Avisamos al técnico de que ha terminado el trabajo
				aviso_terminado()
				print("Piloto ha terminado el pasillo...")
				return
			######
			 # SI EL PILOTO DECIDE HUECO (respuesta_piloto = "h")
			######
			if(respuesta_piloto == "h"):
				lectura = "HUECO"
				altura = altura +1
				if(altura > alturamax):
					altura = 1
					columna = columna + 1
				dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura)+"\n"
				## Guardamos en el archivo_trabajo y en items la lectura
				archivo_trabajo = open(direccion, 'a')
				archivo_trabajo.write(dato_item)
				archivo_trabajo.close()
				## Mostramos la lectura
				print(dato_item)
				aviso_hueco()
			###
			 # SI EL PILOTO DECIDE ERROR DESCONOCIDO
			###
			if(respuesta_piloto == "e"):
				lectura = "INCIDENCIA¿?"
				altura = altura +1
				if(altura > alturamax):
					altura = 1
					columna = columna + 1
				dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura)+"\n"
				## Guardamos en el archivo_trabajo y en items la lectura
				archivo_trabajo = open(direccion, 'a')
				archivo_trabajo.write(dato_item)
				archivo_trabajo.close()
				## Mostramos la lectura
				print(dato_item)
				aviso_errordesconocido()

			if(respuesta_piloto != "t" and respuesta_piloto != "h" and respuesta_piloto != "e"):
				## En este caso la respuesta ha sido multicapa, con un tamaño de la misma en forma de numero
				aviso_multicapa()
				altura = altura +1
				if(altura > alturamax):
					altura = 1
					columna = columna + 1
				numero_item_multicapa = int(respuesta_piloto)
				item_multicapa = list([])
				ultima_multicapa = n568xug(int(longitud))
				item_multicapa.append(ultima_multicapa)
				numero_item_multicapa = numero_item_multicapa -1
				for lectura_en_multicapa in range(numero_item_multicapa):
					lectura_multicapa = n568xug(int(longitud))
					if(lectura_multicapa != ultima_multicapa and lectura_multicapa != ''):
						item_multicapa.append(lectura_multicapa)
						ultima_multicapa = lectura_multicapa
						aviso_lecturacorrecta()
						## SI SE DAN INCIDENCIAS NO SE MUESTRA, PERO SE REGISTRAN, CAMBIAR A FUTURO
						if(lectura_multicapa == INCIDENCIA01 or lectura_multicapa == INCIDENCIA02):
							lecturas_incidencias = lecturas_incidencias + 1
						else:
							lecturas_correctas = lecturas_correctas + 1

					if(lectura_multicapa == ''):
						aviso_lecturaincidenciadesconocida
						respuesta_piloto_multicapa = peticion_piloto_multicapa()
						if(respuesta_piloto_multicapa == "e"):
							aviso_errordesconocido()
							lectura_multicapa = "INCIDENCIA¿?"
							item_multicapa.append(lectura_multicapa)
						## SI EXISTE UN HUECO DENTRO DE LA MULTICAPA NO SE TIENE EN CUENTA, CAMBIAR A FUTURO
				## Ahora vamos a leer la lista de la multicapa y meterla en el archivo_trabajo
				for lectura_en_multicapa in item_multicapa:
					dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura_en_multicapa)+"\n" 
					## Guardamos en el archivo_trabajo y en items la lectura
					archivo_trabajo = open(direccion, 'a')
					archivo_trabajo.write(dato_item)
					archivo_trabajo.close()
					## Mostramos la lectura al técnico
					print(dato_item)
				aviso_multicapafin()
				
			"""
				gpio.output(23, False)
				time.sleep(0.2)
				gpio.output(23, True)
				time.sleep(0.2)
				gpio.output(23, False)
				time.sleep(0.2)
				gpio.output(23, True)
				time.sleep(0.2)
				gpio.output(23, False)
				time.sleep(0.2)
				gpio.output(23, True)
				time.sleep(2)
				inputValue = gpio.input(BOTON)
				if(inputValue == True):
					gpio.output(23, False)
					## En este punto hemos finalizado el trabajo, de modo que haremos el registro de datos de operación.
					piloto_termina = datetime.datetime.now()
					return #nos salimos de la funcion iniciar_trabajo()
			"""
                    

def envio():
	piloto = dato_piloto.get()
	empresa = dato_empresa.get()
	# Reajustamos el número de pasillo para que siempre sea lo que queremos.
	# No tendremos 1000 pasillos en un mismo almacén, por tanto con una designación 001 es suficiente.
	pasillo = int(dato_pasillo.get())
	pasillo = str("{:03d}".format(pasillo))
	archivo = empresa + " " + pasillo + ".txt"
	email = dato_email.get()
	#direccion_trabajo = "trabajos/" + str(empresa) + "/" + str(archivo)
	direccion_trabajo = "trabajos/" + str(archivo)
	#direccion_excel = "trabajos/" + str(empresa) + "/" + str(empresa) + str(pasillo) + ".xlsx"
	direccion_excel = "trabajos/" + str(empresa) + str(pasillo) + ".xlsx"
	## Queremos enviar el trabajo que se encuentra en la dirección
	envio_trabajo(direccion_trabajo, direccion_excel, email, empresa, pasillo)
	## Mostramos al técnico como ha sido la operación
	print("Trabajo del piloto {0} finalizado.\n" .format(piloto))
	tiempo_de_trabajo = piloto_termina - piloto_empieza
	print(" Análisis del trabajo:\n Nº de lecturas correctas: {0}\n Nº de incidencias: {1}\n Tiempo de trabajo: {2}" .format(lecturas_correctas, lecturas_incidencias, tiempo_de_trabajo))
	## Ponemos variable globales a cero, para no tener que cerrar el programa
	piloto_empieza = 0
	piloto_termina = 0
	lecturas_correctas = 0
	lecturas_incidencias = 0
	# ESTOS RESULTADOS TAMBIÉN SE PODRIAN ENVIAR A OTRO EMAIL PARA TENER UN REGISTRO DE COMO SE TRABAJA
	# ESTO QUIZAS SE PODRIA HACER MAS EFICIENTE MEDIANTE UNA LECTURA DEL ARCHIVO_TRABAJO.TXT

######################################################################################################
 # CUANDO EL TÉCNICO SE ENCUENTRA GESTIONANDO EL TRABAJO, EL PANEL MUESTRA UNA "A" DE AIRVANT
######################################################################################################

panel_tecnico()

######################################################################################################	
 #	CÓDIGO RELACIONADO CON EL DISEÑO DE LA INTERFAZ GRÁFICA DEL TÉCNICO
 #	- EL TÉCNICO TIENE QUE AUTORIZAR EL TRABAJO DEL PILOTO.
 # 	- EL TÉCNICO DEFINE EL NOMBRE DE LA EMPRESA, EL PASILLO A PROCEDER, LA LONGITUD DE CÓDIGO, ETC.
 #	- EL TÉCNICO VE EN TIEMPO REAL EL TRABAJO DE CADA PILOTO.
 #	- EL TÉCNICO VERIFICA QUE EL TRABAJO EN PASILLO HA CONCLUIDO.
 ######################################################################################################


root = Tk()
root.title("Airvant Inventario")
# root.iconbitmap('onwards.ico') # DA ERROR PONER EL ICONO
root.config(bg="lightblue")

menubar = Menu(root)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label="Salir", command=root.quit)
menubar.add_cascade(label="Archivo", menu=filemenu)
root.config(menu=menubar)
# ESTARÍA BIEN CREAR ALGO QUE PONGA EL DESARROLLADOR DE LA TECNOLOGÍA

img_airvant = PhotoImage(file="airvant_logo.png")

dato_piloto = StringVar()
dato_empresa = StringVar()
dato_pasillo = StringVar()
dato_alturamax = StringVar()
dato_longitudcodigo = StringVar()
dato_email = StringVar()


form_piloto = Label(root, text = "Nombre del piloto: ").grid(row=0, column=0, columnspan=2)
piloto = Entry(root, textvariable = dato_piloto).grid(row=1, column=0, columnspan=2)

form_empresa = Label(root, text = "Nombre de empresa: ").grid(row=2, column=0, columnspan=2)
empresa = Entry(root, textvariable = dato_empresa).grid(row=3, column=0, columnspan=2)

form_pasillo = Label(root, text = "Nº de pasillo: ").grid(row=4, column=0)
pasillo = Entry(root, textvariable = dato_pasillo, width = 8).grid(row=4, column=1)

form_altura = Label(root, text = "Altura de pasillo: ").grid(row=5, column=0)
alturamax = Entry(root, textvariable = dato_alturamax, width = 8).grid(row=5, column=1)

form_longitud = Label(root , text = "Longitud del codigo: ").grid(row=6, column=0)
longitudcodigo = Entry(root, textvariable = dato_longitudcodigo, width = 8).grid(row=6, column=1)

form_email = Label(root , text = "GMAIL de envío: ").grid(row=7, column=0)
email = Entry(root, textvariable = dato_email).grid(row=7, column=1)

boton = Button(root, text = "EMPEZAR/CONTINUAR", command = iniciar_trabajo ).grid(row=8, column=0, columnspan=2)
#boton_borrar = Button(root, text = "BORRAR ITEM", command = borrar_).grid(row=5, column=1)
boton_fin = Button(root, text = "ENVIAR TRABAJO", command = envio).grid(row=9, column=0, columnspan=2)

Label(root, text="Aplicacion para inventariado de almacen. Version 0.1.\nDesarrollada por Onwards.\n", justify="center").grid(row=10, column=0, columnspan=2)
Label(root, image=img_airvant).grid(row=0, rowspan=11, column=2)

root.mainloop()