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

import serial
import time


lecturas = list()


def procesar_gs1128_00(lectura):
	gs1 = {"00": "-", "01": "-", "02": "-", "37": "-", "10": "-", "11": "-", "13": "-", "15": "-",
		   "17": "-", "310X":"-", "330X":"-", "por-procesar":"-"}
	por_procesar = str()
	for indicador in range(len(gs1)):
		if(lectura[0:2] == "00"):
			gs1["00"] = lectura[2:20]
			lectura = lectura[20:]

		if(lectura[0:2] == "01"):
			gs1["01"] = lectura[2:16]
			lectura = lectura[16:]

		if(lectura[0:2] == "02"):
			gs1["02"] = lectura[2:16]
			lectura = lectura[16:]

		if(lectura[0:2] == "37"):
			aux = lectura.split("")  # CAMBIAR EN LINUX
			if(len(aux) == 2):
				gs1["37"] = aux[0][2:]
				lectura = aux[1]
			else:
				gs1["37"] = aux[0][2:0]
				lectura = ""

		if(lectura[0:2] == "10"):
			aux = lectura.split("")  # CAMBIAR EN LINUX
			if(len(aux) == 2):
				gs1["10"] = aux[0][2:]
				lectura = aux[1]
			else:
				gs1["10"] = aux[0][2:]
				lectura = ""

		if(lectura[0:2] == "11"):
			gs1["11"] = lectura[2:8]
			lectura = lectura[8:]

		if(lectura[0:2] == "13"):
			gs1["13"] = lectura[2:8]
			lectura = lectura[8:]

		if(lectura[0:2] == "15"):
			gs1["15"] = lectura[2:8]
			lectura = lectura[8:]

		if(lectura[0:2] == "17"):
			gs1["17"] = lectura[2:8]
			lectura = lectura[8:]

		if(lectura[0:3] == "310"):
			gs1["310X"] = lectura[3]+"-"+lectura[4:10]
			lectura = lectura[10:]

		if(lectura[0:3] == "330"):
			gs1["330X"] = lectura[3]+"-"+lectura[4:10]
			lectura = lectura[10:]
	# Preparamos el return con una cadena ordenada de los parámetros del diccionario gs1
	por_procesar = lectura
	respuesta = str(gs1["00"])+" "+str(gs1["01"])+" "+str(gs1["02"])+" "+str(gs1["37"])+" "+str(gs1["10"])+" "+str(gs1["11"])+" "+str(gs1["13"])+" "+str(gs1["15"])+" "+str(gs1["17"])+" "+str(gs1["310X"])+" "+str(gs1["330X"]+" "+str(por_procesar))
	return respuesta

def procesar_gs1128_00_0x(lectura1, lectura2):
	gs1 = {"00": "-", "01": "-", "02": "-", "37": "-", "10": "-", "11": "-", "13": "-", "15": "-",
		   "17": "-", "310X":"-", "330X":"-", "por-procesar":"-"}
	por_procesar1 = str()
	por_procesar2 = str()

	for indicador in range(len(gs1)):
		if(lectura1[0:2] == "00"):
			gs1["00"] = lectura1[2:20]
			lectura1 = lectura1[20:]

		if(lectura1[0:2] == "01"):
			gs1["01"] = lectura1[2:16]
			lectura1 = lectura1[16:]

		if(lectura1[0:2] == "02"):
			gs1["02"] = lectura1[2:16]
			lectura1 = lectura1[16:]

		if(lectura1[0:2] == "37"):
			aux = lectura1.split("")  # CAMBIAR EN LINUX
			if(len(aux) == 2):
				gs1["37"] = aux[0][2:]
				lectura1 = aux[1]
			else:
				gs1["37"] = aux[0][2:0]
				lectura1 = ""

		if(lectura1[0:2] == "10"):
			aux = lectura1.split("")  # CAMBIAR EN LINUX
			if(len(aux) == 2):
				gs1["10"] = aux[0][2:]
				lectura1 = aux[1]
			else:
				gs1["10"] = aux[0][2:]
				lectura1 = ""

		if(lectura1[0:2] == "11"):
			gs1["11"] = lectura1[2:8]
			lectura1 = lectura1[8:]

		if(lectura1[0:2] == "13"):
			gs1["13"] = lectura1[2:8]
			lectura1 = lectura1[8:]

		if(lectura1[0:2] == "15"):
			gs1["15"] = lectura1[2:8]
			lectura1 = lectura1[8:]

		if(lectura1[0:2] == "17"):
			gs1["17"] = lectura1[2:8]
			lectura1 = lectura1[8:]

		if(lectura1[0:3] == "310"):
			gs1["310X"] = lectura1[3]+"-"+lectura1[4:10]
			lectura1 = lectura1[10:]

		if(lectura1[0:3] == "330"):
			gs1["330X"] = lectura1[3]+"-"+lectura1[4:10]
			lectura1 = lectura1[10:]

	for indicador in range(len(gs1)):
		if(lectura2[0:2] == "00"):
			gs1["00"] = lectura2[2:20]
			lectura2 = lectura2[20:]

		if(lectura2[0:2] == "01"):
			gs1["01"] = lectura2[2:16]
			lectura2 = lectura2[16:]

		if(lectura2[0:2] == "02"):
			gs1["02"] = lectura2[2:16]
			lectura2 = lectura2[16:]

		if(lectura2[0:2] == "37"):
			aux = lectura2.split("")  # CAMBIAR EN LINUX
			if(len(aux) == 2):
				gs1["37"] = aux[0][2:]
				lectura2 = aux[1]
			else:
				gs1["37"] = aux[0][2:0]
				lectura2 = ""

		if(lectura2[0:2] == "10"):
			aux = lectura2.split("")  # CAMBIAR EN LINUX
			if(len(aux) == 2):
				gs1["10"] = aux[0][2:]
				lectura2 = aux[1]
			else:
				gs1["10"] = aux[0][2:]
				lectura2 = ""

		if(lectura2[0:2] == "11"):
			gs1["11"] = lectura2[2:8]
			lectura2 = lectura2[8:]

		if(lectura2[0:2] == "13"):
			gs1["13"] = lectura2[2:8]
			lectura2 = lectura2[8:]

		if(lectura2[0:2] == "15"):
			gs1["15"] = lectura2[2:8]
			lectura2 = lectura2[8:]

		if(lectura2[0:2] == "17"):
			gs1["17"] = lectura2[2:8]
			lectura2 = lectura2[8:]

		if(lectura2[0:3] == "310"):
			gs1["310X"] = lectura2[3]+"-"+lectura2[4:10]
			lectura2 = lectura2[10:]

		if(lectura2[0:3] == "330"):
			gs1["330X"] = lectura2[3]+"-"+lectura2[4:10]
			lectura2 = lectura2[10:]
	
    # Preparamos el return con una cadena ordenada de los parámetros del diccionario gs1
	por_procesar1 = lectura1
	por_procesar2 = lectura2
	por_procesar = str(por_procesar1)+"+"+str(por_procesar2)
	respuesta = str(gs1["00"])+" "+str(gs1["01"])+" "+str(gs1["02"])+" "+str(gs1["37"])+" "+str(gs1["10"])+" "+str(gs1["11"])+" "+str(gs1["13"])+" "+str(gs1["15"])+" "+str(gs1["17"])+" "+str(gs1["310X"])+" "+str(gs1["330X"]+" "+str(por_procesar))
	return respuesta

def sensor_modo_disparo(tiempo_para_lectura):
	global lecturas

	if 'sensor' in locals():
		sensor.close()
	if 'sensor' in globals():
		sensor.close()

	sensor = serial.Serial('/dev/ttyACM0', timeout = tiempo_para_lectura)
	sensor.flushInput()
	sensor.write("\x16T\r")
	lectura = sensor.read(48)

	if((lectura[:2] == "00") and (len(lectura) >= 20)):
		lectura = procesar_gs1128_00(lectura)
		if(lectura != lecturas[-1]):
			if((lectura in lecturas) == False):
				sensor.close()
				lecturas.append(lectura)
				return lectura
	else:
		sensor.close()
		return ""

def sensor_modo_video(tiempo_para_lectura):
	global lecturas
    ##################################################################################################
    # 1) Se borra cualquier operación anterior activa en el sensor.
	##################################################################################################
	if 'sensor' in locals():
		sensor.close()
	if 'sensor' in globals():
		sensor.close()
	###################################################################################################
	# 2) Se establecen la configuración para la lectura. Longitud del código buscado, tiempo
	#    establecido para encontrar dicha lectura y el puerto desde donde opera el sensor.
	###################################################################################################
	TIEMPO_INICIO_LECTURA = datetime.datetime.now()
	TIEMPO_TRANSCURRIDO_LECTURA = 0
	TIEMPO_DIFERENCIA_LECTURA = 0
	## Ponemos el puerto en escucha estableciendo ciertos términos ligados con read():
	## timeout = none -> espera por siempre hasta completar L (nº de bytes)
	## timeout = 0 -> modo de no bloqueo, va enviando todo lo que coge.
	## timeout = x -> envia lo que coge hasta que el tiempo x ha transcurrido.
	sensor = serial.Serial('/dev/ttyACM0', baudrate = 115200, timeout = 0)
	##################################################################################################
	# 3) Comenzamos el proceso de búsqueda del código.
	#    - Si se encuentra la lectura se envía la cadena de bytes interpretada por el sensor.
	#    - Si no se encuentra la lectura se envía una cadena vacía.
	##################################################################################################
	while(True):
		## Borramos instrucción de lectura anterior localizada en buffer de entrada.
		## Si no existe instrucción no borra nada.
		sensor.flushInput()
		## Enviamos instrucción de lectura al sensor por buffer de entrada.
		sensor.write("\x16T\r")
		## Configuramos un tope de 48 bytes, que es el máximo de un subcódigo GS1-128.
		lectura = sensor.read(48)
		## Como mínimo tenemos que localizar un subcódigo con indicador 00 segido de 18 bytes más.
		## En estos casos, la última lectura es una lectura GS1-128 ya procesada.
		if((lectura[:2] == "00") and (len(lectura) >= 20)):
			lectura = procesar_gs1128_00(lectura)
			if(lectura != lecturas[-1]):
				if((lectura in lecturas) == False):
					sensor.close()
					lecturas.append(lectura)
					return lectura
		TIEMPO_TRANSCURRIDO_LECTURA = datetime.datetime.now()
		TIEMPO_DIFERENCIA_LECTURA = TIEMPO_TRANSCURRIDO_LECTURA - TIEMPO_INICIO_LECTURA
		## Si se supera el tiempo_para_lectura y no hemos obtenido ninguna lectura, limpiamos los buffer
		## del sensor y enviamos una cadena vacía.
		if(TIEMPO_DIFERENCIA_LECTURA.seconds >= tiempo_para_lectura):
			### Tenemos que cerrar el proceso de lectura que estaba activo
			#sensor.flushInput()
			###
			sensor.flushOutput()
			sensor.close()
			return ""


tiempo_para_lectura = 5

while(True):
    lectura = sensor_modo_disparo(tiempo_para_lectura)
    if(lectura != ""):
        print("MODO DISPARO: {0}" .format(lectura))
        break
time.sleep(10)
while(True):
    lectura = sensor_modo_video(tiempo_para_lectura)
    if(lectura != ""):
        print("MODO VIDEO: {0}" .format(lectura))
        break
