from machine import Pin
import time
import os
import math

# Definición de pines para LEDs y botones
led = Pin("LED", Pin.OUT)
ledred = Pin(6, Pin.OUT)
ledgreen = Pin(7, Pin.OUT)
ledblue = Pin(8, Pin.OUT)
boton1 = Pin(18, Pin.IN, Pin.PULL_UP)
boton2 = Pin(19, Pin.IN, Pin.PULL_UP)
boton3 = Pin(20, Pin.IN, Pin.PULL_UP)
boton4 = Pin(21, Pin.IN, Pin.PULL_UP)

# Variables globales
nombre_archivo_abierto = None
tipoonda = 1  # Tipo de onda por defecto
elementos = 10  # Número de elementos en la serie de Taylor por defecto

print("Operaciones ABM en archivos")

# Funciones ABM y utilitarias
def crear_archivo():
    global nombre_archivo_abierto
    nombre_archivo = input("Ingrese el nombre del archivo .dat a crear: ")
    nombre_archivo += ".dat"
    with open(nombre_archivo, 'w') as archivo:
            nombre_archivo_abierto = nombre_archivo
            print("Archivo", nombre_archivo, "creado exitosamente.")

def mostrar_archivos():
    archivos_dat = [archivo for archivo in os.listdir() if archivo.endswith(".dat")]

    if archivos_dat:
        print("Archivos .dat existentes:")
        for archivo in archivos_dat:
            print(f"- {archivo}")
    else:
        print("No hay archivos .dat en el directorio.")
        
def abrir_archivo():
    global nombre_archivo_abierto
    nombre_archivo = input("Ingrese el nombre del archivo .dat existente: ")
    nombre_archivo += ".dat"
    lista_archivos = os.listdir()
    if nombre_archivo in lista_archivos:
        nombre_archivo_abierto = nombre_archivo
        print(nombre_archivo_abierto, "abierto correctamente.")
    else:
        print(nombre_archivo, "no existe.")

def borrar_archivo():
    archivo_borrar = input("Ingrese el nombre del archivo .dat a borrar: ")
    archivo_borrar += ".dat"
    lista_archivos = os.listdir()
    if archivo_borrar in lista_archivos:
        os.remove(archivo_borrar)
        print(archivo_borrar, "Se elimino correctamente.")
    else:
        print(archivo_borrar, "no existe.")
        
def cambiar_nombre_archivo():
    nombre_actual = input("Ingrese el nombre del archivo .dat existente: ")
    nombre_actual += ".dat"
    if nombre_actual in os.listdir():
        nuevo_nombre = input("Ingrese el nuevo nombre para el archivo .dat: ")
        nuevo_nombre += ".dat"
        os.rename(nombre_actual, nuevo_nombre)
        print(nombre_actual, "ha sido renombrado como", nuevo_nombre, "correctamente.")
    else:
        print(nombre_actual, "no existe.")

def obtener_fecha_hora():
    ahora = time.localtime()
    dia = ahora[2]
    mes = ahora[1]
    hora = ahora[3]
    minuto = ahora[4]
    segundo = ahora[5]
    
    info_tiempo = "{:02}/{:02} {:02}:{:02}:{:02}".format(dia, mes , hora, minuto, segundo)
    return info_tiempo

# Funciones de cálculo modificadas para incluir señal Taylor, señal math y error
def calculo_sen_taylor(x, n):
    sen_x_taylor = sum((-1)**i * x**(2 * i + 1) / math.factorial(2 * i + 1) for i in range(n))
    sen_x_math = math.sin(x)
    error = abs(sen_x_taylor - sen_x_math)
    return sen_x_taylor, sen_x_math, error

def calculo_cos_taylor(x, n):
    cos_x_taylor = sum((-1)**i * x**(2 * i) / math.factorial(2 * i) for i in range(n))
    cos_x_math = math.cos(x)
    error = abs(cos_x_taylor - cos_x_math)
    return cos_x_taylor, cos_x_math, error

def calculo_e(x, n):
    e_x_taylor = sum(x**i / math.factorial(i) for i in range(n))
    e_x_math = math.exp(x)
    error = abs(e_x_taylor - e_x_math)
    return e_x_taylor, e_x_math, error

def generar_dato():
    global nombre_archivo_abierto, tipoonda, elementos
    if nombre_archivo_abierto:
        try:
            with open(nombre_archivo_abierto, 'a') as archivo:
                num_registro = sum(1 for _ in open(nombre_archivo_abierto)) + 1
                fecha_obte = obtener_fecha_hora()
                signal_taylor, signal_math, error = 0, 0, 0

                # Determina el cálculo basado en el tipo de onda seleccionado
                if tipoonda == 1:  # Seno
                    signal_taylor, signal_math, error = calculo_sen_taylor(math.pi/4, elementos)
                elif tipoonda == 2:  # Coseno
                    signal_taylor, signal_math, error = calculo_cos_taylor(math.pi/4, elementos)
                elif tipoonda == 3:  # Exponencial
                    signal_taylor, signal_math, error = calculo_e(1, elementos)  # Ajusta el valor de x según lo que sea necesario

                # Formato de registro ajustado para incluir todos los datos requeridos
                registro = f"No {num_registro} | Fecha {fecha_obte} | Señal Taylor {signal_taylor:.5f} | Señal con Función de math {signal_math:.5f} | error {error:.5f} | n elementos de la serie {elementos} | tipo onda {tipoonda}"
                
                archivo.write(registro + '\n')
                print("Registro añadido correctamente:", registro)
        except Exception as e:
            print(f"No se pudo añadir el registro. Error: {e}")
    else:
        print("No se ha abierto ningún archivo. Utiliza la función abrir_archivo antes de añadir registros.")


# Funciones para manejar las interrupciones de los botones
def tipoonda1(pin):
    global tipoonda
    tipoonda = 1
    # Encender LED rojo
    ledred.value(1)
    ledgreen.value(0)
    ledblue.value(0)
    generar_dato()

def tipoonda2(pin):
    global tipoonda
    tipoonda = 2
    # Encender LED verde
    ledred.value(0)
    ledgreen.value(1)
    ledblue.value(0)
    generar_dato()

def tipoonda3(pin):
    global tipoonda
    tipoonda = 3
    # Encender LED azul
    ledred.value(0)
    ledgreen.value(0)
    ledblue.value(1)
    generar_dato()


def set_elementos(pin):
    global elementos
    elementos += 10
    print("Número de elementos de la serie ajustado a:", elementos)

# Configuración de interrupciones para los botones
boton1.irq(trigger=Pin.IRQ_FALLING, handler=tipoonda1)
boton2.irq(trigger=Pin.IRQ_FALLING, handler=tipoonda2)
boton3.irq(trigger=Pin.IRQ_FALLING, handler=tipoonda3)
boton4.irq(trigger=Pin.IRQ_FALLING, handler=set_elementos)

# Menú principal y función main
def menu():
    while True:
        print("\nMenu ABM con archivos")
        print("1. Crear Archivo")
        print("2. Mostrar Archivos .dat")
        print("3. Abrir un archivo existente")
        print("4. Borrar un archivo .dat")
        print("5. Cambiar nombre de un archivo .dat")
        print("6. Primera serie")
        print("7. Segunda serie")
        print("8. Tercera serie")
        print("9. Numero de elementos")
        print("10. Fin de Programa")
        opcion = int(input("Elija una opción: "))
        if 1 <= opcion <= 10:
            return opcion
        else:
            print("Opción no válida. Por favor, elija una opción del 1 al 10.")

def main():
    global tipoonda
    global elementos
    elementos=10
    while True:
        opcion = menu()
        if opcion == 1:
            crear_archivo()
        elif opcion == 2:
            mostrar_archivos()
        elif opcion == 3:
            abrir_archivo()
        elif opcion == 4:
            borrar_archivo()
        elif opcion == 5:
            cambiar_nombre_archivo()
        elif opcion == 6:
            tipoonda=1
            generar_dato()
        elif opcion == 7:
            tipoonda=2
            generar_dato()
        elif opcion == 8:
            tipoonda=3
            generar_dato()
        elif opcion == 9:
            elementos=int(input("Elementos: "))
        elif opcion == 10:
            print("Fin del programa.")
            break


if __name__ == '__main__':
    main()