import datetime
import io
import os
import serial
import time
from random import *


def respuesta_sensor(L):
    # VAMOS A VER LOS IA QUE SON DE N2
    n2_list_c1 = list([0, 1, 2, 3, 9])
    # si n2_list_c1 es 9, n2_list_c2 puede ser de 1 a 9 y siempre es final hasta 30 digitos
    n2_list_c2 = list([0, 1, 2, 3, 5, 7, 9, 4, 6, 8])


"""    
    ## Realizamos una lectura entre 1 y 500.
	lectura = randint(0,500)
	if(lectura < 30):
		print("INCIDENCIA-01")
		sensor.close()
		return "INCIDENCIA-01"
	if(lectura > 470):
		print("INCIDENCIA-02")
		sensor.close()
		return "INCIDENCIA-02"
	if(lectura>210 and lectura < 290):
		sensor.close()
		return ""
	sensor.close()
	return lectura
"""


def procesar_lecturas(lectura_uno, lectura_dos):
    ## VAMOS A PROCESAR LA LECTURA SOLO PARA LOS IA MÁS COMUNES, Y SIEMPRE DEJANDO LOS IA10 E IA37 AL FINAL
    ## PARA EVITAR EL USO DEL SEPARADOR
    tamano_uno = len(lectura_uno)
    tamano_uno_porprocesar = tamano_uno
    tamano_dos = len(lectura_dos)
    tamano_dos_porprocesar = tamano_dos
    diccionario_lectura = dict({"00": "", "01": "", "02": "", "37": "", "10": "", "11": "", "13": "",
                                "15": "", "17": "", "310X": "", "330X": ""})  # aquí meteríamos todos los IA del GS1 128
    # PROCESAMOS LECTURA_UNO
    while(len(tamano_uno_porprocesar != 0)):
        if(lectura_uno[0:2] == "00"):
            diccionario_lectura["00"] = lectura_uno[2:20]
            lectura_uno = lectura_uno[20:]
            tamano_uno_porprocesar = tamano_uno_porprocesar - 20
        if(lectura_uno[0:2] == "01"):
            diccionario_lectura["01"] = lectura_uno[2:16]
            lectura_uno = lectura_uno[16:]
            tamano_uno_porprocesar = tamano_uno_porprocesar - 16
        if(lectura_uno[0:2] == "02"):
            diccionario_lectura["02"] = lectura_uno[2:16]
            lectura_uno = lectura_uno[16:]
            tamano_uno_porprocesar = tamano_uno_porprocesar - 16
        if(lectura_uno[0:2] == "11"):
            diccionario_lectura["11"] = lectura_uno[2:8]
            lectura_uno = lectura_uno[8:]
            tamano_uno_porprocesar = tamano_uno_porprocesar - 8
        if(lectura_uno[0:2] == "13"):
            diccionario_lectura["13"] = lectura_uno[2:8]
            lectura_uno = lectura_uno[8:]
            tamano_uno_porprocesar = tamano_uno_porprocesar - 8
        if(lectura_uno[0:2] == "15"):
            diccionario_lectura["15"] = lectura_uno[2:8]
            lectura_uno = lectura_uno[8:]
            tamano_uno_porprocesar = tamano_uno_porprocesar - 8
        if(lectura_uno[0:4] == "310X"):
            diccionario_lectura["310X"] = lectura_uno[4:10]
            lectura_uno = lectura_uno[10:]
            tamano_uno_porprocesar = tamano_uno_porprocesar - 10
        if(lectura_uno[0:4] == "330X"):
            diccionario_lectura["330X"] = lectura_uno[4:10]
            lectura_uno = lectura_uno[10:]
            tamano_uno_porprocesar = tamano_uno_porprocesar - 10
        if(lectura_uno[0:2] == "10"):
            diccionario_lectura["10"] = lectura_uno[2:]
            tamano_uno_porprocesar = 0
        if(lectura_uno[0:2] == "37"):
            diccionario_lectura["37"] = lectura_uno[2:]
            tamano_uno_porprocesar = 0
    # PROCESAMOS LECTURA_DOS
    while(len(tamano_dos_porprocesar != 0)):
        if(lectura_dos[0:2] == "00"):
            diccionario_lectura["00"] = lectura_dos[2:20]
            lectura_dos = lectura_dos[20:]
            tamano_dos_porprocesar = tamano_dos_porprocesar - 20
        if(lectura_dos[0:2] == "01"):
            diccionario_lectura["01"] = lectura_dos[2:16]
            lectura_dos = lectura_dos[16:]
            tamano_dos_porprocesar = tamano_dos_porprocesar - 16
        if(lectura_dos[0:2] == "02"):
            diccionario_lectura["02"] = lectura_dos[2:16]
            lectura_dos = lectura_dos[16:]
            tamano_dos_porprocesar = tamano_dos_porprocesar - 16
        if(lectura_dos[0:2] == "11"):
            diccionario_lectura["11"] = lectura_dos[2:8]
            lectura_dos = lectura_dos[8:]
            tamano_dos_porprocesar = tamano_dos_porprocesar - 8
        if(lectura_dos[0:2] == "13"):
            diccionario_lectura["13"] = lectura_dos[2:8]
            lectura_dos = lectura_dos[8:]
            tamano_dos_porprocesar = tamano_dos_porprocesar - 8
        if(lectura_dos[0:2] == "15"):
            diccionario_lectura["15"] = lectura_dos[2:8]
            lectura_dos = lectura_dos[8:]
            tamano_dos_porprocesar = tamano_dos_porprocesar - 8
        if(lectura_dos[0:4] == "310X"):
            diccionario_lectura["310X"] = lectura_dos[4:10]
            lectura_dos = lectura_dos[10:]
            tamano_dos_porprocesar = tamano_dos_porprocesar - 10
        if(lectura_dos[0:4] == "330X"):
            diccionario_lectura["330X"] = lectura_dos[4:10]
            lectura_dos = lectura_dos[10:]
            tamano_dos_porprocesar = tamano_dos_porprocesar - 10
        if(lectura_dos[0:2] == "10"):
            diccionario_lectura["10"] = lectura_dos[2:]
            tamano_dos_porprocesar = 0
        if(lectura_dos[0:2] == "37"):
            diccionario_lectura["37"] = lectura_dos[2:]
            tamano_dos_porprocesar = 0
    # AHORA TENEMOS QUE TRANSFORMAR LA INFORMACIÓN DEL DICCIONARIO EN UNA CADENA PARA PASARLA AL RETURN
    ###################
    #############
    ######



def lectura_gs1128(tiempolectura):
    # GS1 128 ESTA COMPUESTO POR DOS CÓDIGOS DE BARRAS, LUEGO POR POSICIÓN TENDREMOS QUE HACER DOS LECTURAS
    # DIFERENTES PARA DAR POR CONCLUIDA LA LECTURA.
    lectura_uno = str("")
    lectura_dos = str("")
    lecturas_hechas = int(0)
    L = 48
    if 'sensor' in locals():
        sensor.close()
    if 'sensor' in globals():
        sensor.close()
    TIEMPO_INICIO_LECTURA = datetime.datetime.now()
    TIEMPO_TRANSCURRIDO_LECTURA = 0
    TIEMPO_DIFERENCIA_LECTURA = 0
    sensor = serial.Serial('/dev/ttyACM0', timeout=0)
    # HASTA QUE NO HAGAMOS LAS DOS LECTURAS REQUERIDAS NO PODREMOS AVANZAR
    # SE CREARÁ UN ESCAPE TEMPORAL EN CASO DE QUE NO SE PUEDA LEER UNA ETIQUETA
    while(lecturas_hechas != 2):
        sensor.flushInput()
        sensor.write("\x16T\r")
        #
        lectura = respuesta_sensor(L)
        if(lectura != ""):
            if(lecturas_hechas == 0):
                lectura_uno = lectura
                lecturas_hechas = 1
            if(lecturas_hechas == 1 and lectura != lectura_uno):
                lectura_dos = lectura
                lecturas_hechas = 2
        TIEMPO_TRANSCURRIDO_LECTURA = datetime.datetime.now()
        TIEMPO_DIFERENCIA_LECTURA = TIEMPO_TRANSCURRIDO_LECTURA - TIEMPO_INICIO_LECTURA
        if(TIEMPO_DIFERENCIA_LECTURA >= tiempolectura):
            # si en el tiempo indicado no realizamos las dos lecturas marcamos la respuesta de error
            # si enviamos "" se procesará un error
            return("")
    # REALIZADAS LAS DOS LECTURAS AHORA TENDREMOS QUE PROCESARLAS PARA TRANSFORMARLA EN UNA SOLA CADENA
    lectura_procesada = procesar_lecturas(lectura_uno, lectura_dos)
    return lectura_procesada


def n568xug_GS1128(tiempolectura):
    # GS1
        # IA PALET COMPLETO: (01)123456789abcde(--)...
        # IA PALET EMPEZADO: (02)123456789abcde(37)... HASTA 8 BYTES
        # IA MATRÍCULA ÚNICA SSCC (00)123456789abcdefghi(--)... SSCC = (00) + 18 bytes A VECES NO APARECE
        # LOS () NO APARECEN EN EL CODIGO DE BARRAS, PERO TIENEN QUE APARECER COMO HUMANAMENTE LEGIBLE
        # EL NÚMERO MÁXIMO DE BYTES POR CÓDIGO GS1-128 ES DE 48 BYTES (NÚMEROS O LETRAS)
    IA01 = False
    IA02 = False
    IA00 = False
    lectura_IA00 = "-"
    lectura_IA01 = "-"
    lectura_IA02 = "-"
    LECTURA = str()
    L = 48
    # AL ENTRAR EN LA FUNCIÓN SE APAGA EL LED1G VERDE, POR LO QUE VOLVEMOS A ENCENDERLO
    global LED1G
    gpio.output(LED1G, gpio.HIGH)
    # ENTRAMOS EN EL CÓDIGO PARA EL SENSOR
    if 'sensor' in locals():
        sensor.close()
    if 'sensor' in globals():
        sensor.close()
    # ESTA VARIABLE VA A MARCAR EL TIEMPO MÁXIMO PARA REALIZAR UNA LECTURA CORRECTA, Y PEDIR ALGUNA
    # ACCIÓN AL PILOTO.
    TIEMPO_INICIO_LECTURA = datetime.datetime.now()
    TIEMPO_TRANSCURRIDO_LECTURA = 0
    TIEMPO_DIFERENCIA_LECTURA = 0
    ###
    # ACTIVAMOS EL SENSOR Y ESTABLECEMOS UN TIEMPO DE LECTURA (  ligado 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', timeout=0)
    # LEÉMOS CÓDIGOS HASTA DAR CON EL DESEADO
    # while((IA01 == False and IA02 == False) or (IA00 == False) or ()):
    while(True):
        # BORRAMOS CUALQUIER INFORMACIÓN ACUMULADA EN EL BUFFER DE ENTRADA.
        sensor.flushInput()
        # CODIGO DE ACCIÓN EN EL BUFFER DE SALIDA (esto lo lee el sensor para realizar la lectura)
        sensor.write("\x16T\r")
        # REALIZAMOS UNA LECTURA
        lectura = sensor.read(L)
        # AHORA VAMOS A PROCESAR LA LECTURA
        if(IA00 == False and lectura[0:2] == "00"):
            lectura_IA00 = lectura[2:20]
            gpio.output(LED1B, gpio.HIGH)
            IA00 = True
        if(IA01 == False and lectura[0:2] == "01"):
            lectura_IA01 = lectura[2:16]
            gpio.output(LED2B, gpio.HIGH)
            IA01 = True
        if(IA02 == False and lectura[0:2] == "02"):
            lectura_IA02 = lectura[2:16]
            gpio.output(LED2B, gpio.HIGH)
            IA02 = True
        TIEMPO_TRANSCURRIDO_LECTURA = datetime.datetime.now()
        TIEMPO_DIFERENCIA_LECTURA = TIEMPO_TRANSCURRIDO_LECTURA - TIEMPO_INICIO_LECTURA
        if(IA00 == True and (IA01 == True or IA02 == True)):
            LECTURA = lectura_IA00 + "|" + lectura_IA01 + "|" + lectura_IA02
            time.sleep(1)
            break  # Nos salimos del while en cuanto tenemos lectura válida + 1 segundo
        if(TIEMPO_DIFERENCIA_LECTURA.seconds >= tiempolectura):
            LECTURA = lectura_IA00 + "|" + lectura_IA01 + "|" + lectura_IA02
            time.sleep(1)
            break  # Nos salimos del while a los 4+1 segundos
    gpio.output(LED1B, gpio.LOW)
    gpio.output(LED2B, gpio.LOW)
    if(LECTURA == "-|-|-"):
        # DAREMOS POR VÁLIDA LA LECTURA CON SOLO TENER UN IA LEÍDO
        return ""
    return LECTURA
