#!/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 *

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

## Designamos las variables relacionadas con el hardware
gpio.setmode(gpio.BCM)
gpio.setwarnings(False)
gpio.setup(23, gpio.OUT)
gpio.setup(24, gpio.IN)

## 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 iniciar_trabajo():
	## Registramos la hora en la que el piloto comienza el trabajo en el pasillo.
	piloto_empieza = datetime.datetime.now()
	# PARA DESPUES DAR DATOS DE TIEMPO, ANALISIS DEL ARCHIVO DE TRABAJO PARA VER ERRORES, ETC (SE PUEDE
	# DAR INCLUSO AL TERMINAR EL TRABAJO SIN MÁS COMPLICACIONES)
	
	## 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 = 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(pasillo_.get())
	pasillo = str("{:03d}".format(pasillo))
	alturamax = int(alturamax_.get())
	longitud = int(longitudcodigo_.get())

	## Ponemos el valor del pulsometro de apagado en False
	inputValue = False
	ultima_lectura = ''
	#items = list([])

	## Nos vamos a mover por columnas y alturas para una correcta medición
	columna = 1
	altura = 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)
	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
		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
		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()
	
	"""
		if(Airvant.existe_trabajo(direccion) == False):
			archivo_trabajo = open(direccion, 'w')
		else:
			# SI EL ARCHIVO EXISTE ES QUE SE HA DADO UN ERROR DE LECTURA, TENEMOS QUE GUARDAR LECTURAS
			# POR DONDE LO DEJAMOS ANTES DEL ERROR.
			archivo_trabajo = open(direccion, 'r') # abrimos en modo lectura
			items = fichero.readlines() # extraemos todas las lecturas en una lista
			archivo_trabajo.close() # cerramos el archivo
			ultima_lectura = items[-1].split("|") # columna | altura | lectura item
			# tenemos que repetir la lectura previa al error
			columna = int(ultima_lectura[0])
			altura = int(ultima_lectura[1])
			ultima_lectura = str(ultima_lectura[2])
			# Volvemos a crear el archivo donde volveremos a meter datos
			archivo_trabajo = open(direccion, 'w') # borramos todo el archivo anterior
			archivo_trabajo.close()
			archivo_trabajo = open(direccion, 'a')
			archivo_trabajo.writelines(items)
			archivo_trabajo.close()


				#fichero.close()
	"""
	## Mostramos por pantalla el inicio de la operación de trabajo	
	print("Empresa: {0} Nº de pasillo: {1} Longitud de código: {2}".format(empresa, pasillo, longitud)) #print(pasillo, longitud, num)
	
	while(True):
		# encendemos led rojo inicio operacion
		gpio.output(23, True)
		# ESTO TENDRÁ QUE SER UN LED VERDE ENCENDIDO 1/7 central
		# mostramos por pantalla las lecturas para los clientes
		print("Columna {1} | Altura {2} | Lectura: {3} " .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))
		###
		# cuando se hace la lectura se apaga el led rojo
		gpio.output(23, False)
		time.sleep(0.2)
						
		if (lectura != ultima_lectura and lectura != 'INCIDENCIA-01' and lectura != 'INCIDENCIA-02' and lectura != ''):
			item = item + 1
			ultima_lectura = lectura
			# ANTES DE ENTRAR A UNA MULTICAPA NOS ALEJAMOS PARA PODER ENVIAR UNA SEÑAL BLUETOOTH (forzamos if '')
			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
			lecturas_correctas = lecturas_correctas + 1
			#items.append(dato_item)
			# POR SER BUENA LECTURA ENCENDEREMOS EN MARQUEE VERDE 7/7 DESDE 1/7 CENTRAL 1 SEGUNDO
			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
			lecturas_incidencias = lecturas_incidencias + 1
			#items.append(dato_item)
			# POR SER UNA INCIDENCIA ENCENDEREMOS EN MARQUEE ROJO 7/7 DESDE 1/7 CENTRAL 2 SEGUNDOS
			for parpadeo in range(5):
				gpio.output(23, True)
				time.sleep(0.2)
				gpio.output(23, False)
				time.sleep(0.2)
		
		if(lectura == ''):
			## 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
			# - MULTICAPA DE X TAMAÑO 
			# - 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
            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(24)
            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 = piloto_.get()
	empresa = 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(pasillo_.get())
	pasillo = str("{:03d}".format(pasillo))
	archivo = empresa + " " + pasillo + ".txt"
	email = email_.get()
	direccion_trabajo = "trabajos/" + str(empresa) + "/" + str(archivo)
	direccion_excel = "trabajos/" + str(empresa) + "/" + 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


######################################################################################################	
 #	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")
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()