#include <stdio.h>
#include <stdbool.h>
#include "pico/stdlib.h"
#include <stdint.h>

typedef struct {
    uint8_t a; // Pin para el segmento a
    uint8_t b; // Pin para el segmento b
    uint8_t c; // Pin para el segmento c
    uint8_t d; // Pin para el segmento d
    uint8_t e; // Pin para el segmento e
    uint8_t f; // Pin para el segmento f
    uint8_t g; // Pin para el segmento g
    uint8_t d1; // Pin para el dígito 1
    uint8_t d2; // Pin para el dígito 2
    uint8_t d3; // Pin para el dígito 3
    uint8_t d4; // Pin para el dígito 4
} Display4Digit7Seg;

const uint8_t Display_7Seg[] = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F};

void Write_Display4Digit7seg(Display4Digit7Seg *D4D, uint16_t val);
void Reset_Display4Digit7seg(Display4Digit7Seg *D4D);
Display4Digit7Seg Display = {0,1,2,3,4,5,6,7,8,9,10};

void GpioInit(void) {
    // Configuración de pines para segmentos
    gpio_init(Display.a); gpio_set_dir(Display.a, GPIO_OUT);
    gpio_init(Display.b); gpio_set_dir(Display.b, GPIO_OUT);
    gpio_init(Display.c); gpio_set_dir(Display.c, GPIO_OUT);
    gpio_init(Display.d); gpio_set_dir(Display.d, GPIO_OUT);
    gpio_init(Display.e); gpio_set_dir(Display.e, GPIO_OUT);
    gpio_init(Display.f); gpio_set_dir(Display.f, GPIO_OUT);
    gpio_init(Display.g); gpio_set_dir(Display.g, GPIO_OUT);

    // Configuración de pines para dígitos
    gpio_init(Display.d1); gpio_set_dir(Display.d1, GPIO_OUT);
    gpio_init(Display.d2); gpio_set_dir(Display.d2, GPIO_OUT);
    gpio_init(Display.d3); gpio_set_dir(Display.d3, GPIO_OUT);
    gpio_init(Display.d4); gpio_set_dir(Display.d4, GPIO_OUT);
}

void Write_Display4Digit7seg(Display4Digit7Seg *D4D, uint16_t val) {
    uint8_t digits[4];
    
    // Separar el valor en dígitos
    digits[0] = val % 10;
    digits[1] = (val / 10) % 10;
    digits[2] = (val / 100) % 10;
    digits[3] = (val / 1000) % 10;
    
    // Multiplexación de dígitos
    for(int i = 0; i < 4; i++) {
        // Apagar todos los dígitos
        Reset_Display4Digit7seg(D4D);
        
        // Seleccionar el dígito a mostrar
        if(i == 0) gpio_put(D4D->d1, 0); // Encender el dígito 1
        if(i == 1) gpio_put(D4D->d2, 0); // Encender el dígito 2
        if(i == 2) gpio_put(D4D->d3, 0); // Encender el dígito 3
        if(i == 3) gpio_put(D4D->d4, 0); // Encender el dígito 4
        
        // Encender los segmentos para el dígito actual
        uint8_t data = Display_7Seg[digits[i]];
        gpio_put(D4D->a, (data & (1 << 0)) == 0);
        gpio_put(D4D->b, (data & (1 << 1)) == 0);
        gpio_put(D4D->c, (data & (1 << 2)) == 0);
        gpio_put(D4D->d, (data & (1 << 3)) == 0);
        gpio_put(D4D->e, (data & (1 << 4)) == 0);
        gpio_put(D4D->f, (data & (1 << 5)) == 0);
        gpio_put(D4D->g, (data & (1 << 6)) == 0);
        
        sleep_ms(50); // Tiempo para mostrar el dígito (ajustar según sea necesario)
    }
}

void Reset_Display4Digit7seg(Display4Digit7Seg *D4D) {
    gpio_put(D4D->d1, 1);
    gpio_put(D4D->d2, 1);
    gpio_put(D4D->d3, 1);
    gpio_put(D4D->d4, 1);
    gpio_put(D4D->a, 1);
    gpio_put(D4D->b, 1);
    gpio_put(D4D->c, 1);
    gpio_put(D4D->d, 1);
    gpio_put(D4D->e, 1);
    gpio_put(D4D->f, 1);
    gpio_put(D4D->g, 1);
}

int main(void) {
    GpioInit();
    
    for(;;) {
        for(int i = 0; i <= 9999; i++) {
            Write_Display4Digit7seg(&Display, i);
            sleep_ms(1); // Tiempo de refresco (ajustar según sea necesario)
        }
    }
}