#include <stdio.h> // Inclui a biblioteca padrão de entrada e saída para uso de funções como printf.
#include <ctype.h> // Inclui a biblioteca ctype.h
#include "pico/stdlib.h" // Inclui a biblioteca padrão para funcionalidades básicas como GPIO, temporização e comunicação serial.

char password_user[4] = {'0', '0', '0', '0'}; // Armazena a senha inserida pelo usuário na variável password_user
char password_atual[4] = {'0', '0', '0', '0'}; // Armazena a senha inserida pelo usuário na variável password_atual
int digSenha = 0; // Variável que armazena a quantidade de digitos da senha que foi inserido no teclado matricial
int contSenha = 0; // Variável que armazena a quantidade de digitos da senha inserida é igual a senha já cadastrada
uint8_t contador = 0; // Variável utiizada para armazenar o digito a ser exibido no display
int controle_1 = 0; // Variável de controle para inserir a senha de acesso para abrir a sala
int controle_2 = 0; // Variável de controle para inserir a senha de acesso para fechar a sala
int cont_1 = 0; // Variável para controle de tempo
int cont_2 = 0; // Variável para controle de tempo

// Definição dos pinos dos segmentos do display
const uint8_t display_pinos[] = {1, 2, 3, 4, 5, 6, 7};

// Definição dos pinos do teclado matricial
#define LINHAS 4
#define COLUNAS 4

// Definição do pino de acionamento do Buzzer
#define buzzer 10

// Definição dos pinos de acionamento dos LEDs de visualização
#define led_verde 11
#define led_amarelo 12
#define led_vermelho 13

// Definição dos pinos de acionamento dos Relés
#define rele_1 15
#define rele_2 14

// Mapeamento dos dígitos para os segmentos do display
const uint8_t digits[10][7] = {
    {1, 1, 1, 1, 1, 1, 0}, // 0
    {0, 1, 1, 0, 0, 0, 0}, // 1
    {1, 1, 0, 1, 1, 0, 1}, // 2
    {1, 1, 1, 1, 0, 0, 1}, // 3
    {0, 1, 1, 0, 0, 1, 1}, // 4
    {1, 0, 1, 1, 0, 1, 1}, // 5
    {1, 0, 1, 1, 1, 1, 1}, // 6
    {1, 1, 1, 0, 0, 0, 0}, // 7
    {1, 1, 1, 1, 1, 1, 1}, // 8
    {1, 1, 1, 0, 0, 1, 1}  // 9
};

// Função para exibir um dígito no display
void display_digit(uint8_t digit) {
    for (int i = 0; i < 7; i++) {
        gpio_put(display_pinos[i], digits[digit][i]);
    }
}

// Função para limpar o display
void display_clear() {
    for (int i = 0; i < 7; i++) {
        gpio_put(display_pinos[i], 0);
    }
}

// Atualização dos pinos de acordo com as novas conexões do teclado matricial
const uint8_t linha_pinos[LINHAS] = {28, 27, 26, 22}; // Pinos conectados às linhas R1, R2, R3, R4
const uint8_t coluna_pinos[COLUNAS] = {21, 20, 19, 18}; // Pinos conectados às colunas C1, C2, C3, C4

// Mapa de teclas do teclado matricial
const char key_map[LINHAS][COLUNAS] = {
    {'1', '2', '3', 'A'},
    {'4', '5', '6', 'B'},
    {'7', '8', '9', 'C'},
    {'*', '0', '#', 'D'}
};

// Função para inicializar os pinos do teclado matricial
void keypad_init() {
    for (int i = 0; i < LINHAS; i++) {
        gpio_init(linha_pinos[i]);
        gpio_set_dir(linha_pinos[i], GPIO_OUT);
        gpio_put(linha_pinos[i], 0); // Configura as linhas como saídas em nível baixo
    }
    for (int i = 0; i < COLUNAS; i++) {
        gpio_init(coluna_pinos[i]);
        gpio_set_dir(coluna_pinos[i], GPIO_IN);
        gpio_pull_down(coluna_pinos[i]); // Configura as colunas como entradas com pull-down
    }    
}

// Função para ler o teclado matricial
char read_keypad() {
    for (int linha = 0; linha < LINHAS; linha++) {
        gpio_put(linha_pinos[linha], 1); // Ativa a linha atual
        for (int coluna = 0; coluna < COLUNAS; coluna++) {
            if (gpio_get(coluna_pinos[coluna])) { // Verifica se a coluna atual está em nível alto
                gpio_put(linha_pinos[linha], 0); // Desativa a linha atual
                return key_map[linha][coluna]; // Retorna a tecla pressionada
            }
        }
        gpio_put(linha_pinos[linha], 0); // Desativa a linha atual
    }
    return '\0'; // Retorna nulo se nenhuma tecla for pressionada
}

// Função para fechar a sala
void fechar_sala() {
    for (int j = 0; j < 4; j++) {
        password_user[j] = '0'; // Limpa a senha do usuário
        password_atual[j] = '0'; // Limpa a senha do atual
    }
    digSenha = 0; // Zera a variável digSenha
    contSenha = 0; // Zera a variável contSenha

    display_clear(); // Limpa o display

    controle_1 = 0; // Altera o valor da variável de controle_1
    controle_2 = 0; // Altera o valor da variável de controle_2

    cont_1 = 0; // Zera a variável cont_1
    cont_2 = 0; // Zera a variável cont_2
    
    gpio_put(rele_1, false); // Aciona o Relé para abrir a porta
    gpio_put(rele_2, false); // Aciona o Relé da contatora

    gpio_put(buzzer, 1); // Liga o sinal sonoro
    
    // Faz o LED vermelho piscar durante 3 segundos
    for (int x = 0; x < 6; x++) {
        gpio_put(led_vermelho, true);
        sleep_ms(250);
        gpio_put(led_vermelho, false);
        sleep_ms(250);
    }

    gpio_put(buzzer, 0); // Desliga o sinal sonoro
}

int main() {
    stdio_init_all(); // Inicializa todos os pinos de stdio
    keypad_init(); // Inicializa o teclado matricial

    // Inicializa e configura os pinos do buzzer como saída
    gpio_init(buzzer);
    gpio_set_dir(buzzer, GPIO_OUT);

    // Inicializa e configura os pinos dos LEDs como saída
    gpio_init(led_verde);
    gpio_set_dir(led_verde, GPIO_OUT);
    gpio_init(led_amarelo);
    gpio_set_dir(led_amarelo, GPIO_OUT);
    gpio_init(led_vermelho);
    gpio_set_dir(led_vermelho, GPIO_OUT);

    // Inicializa e configura os pinos dos relés como saída
    gpio_init(rele_1);
    gpio_set_dir(rele_1, GPIO_OUT);
    gpio_init(rele_2);
    gpio_set_dir(rele_2, GPIO_OUT);
    
    // Inicializa e configura os pinos do display como saída
    for (int i = 0; i < 7; i++) {
        gpio_init(display_pinos[i]);
        gpio_set_dir(display_pinos[i], GPIO_OUT);
    }

    char password_user_1[4] = {'9', '5', '3', '8'}; // Armazena a senha já cadastrada do usuário 1
    char password_user_2[4] = {'8', '5', '4', '8'}; // Armazena a senha já cadastrada do usuário 2
    char password_user_3[4] = {'9', '8', '2', '8'}; // Armazena a senha já cadastrada do usuário 3
    char password_user_4[4] = {'1', '6', '3', '2'}; // Armazena a senha já cadastrada do usuário 4

    while (true) {
        //*************************************************************************
        // Fecha a sala de aula depois de 2 horas
        if (controle_1 == 1) {
            sleep_ms(10); // Espera 10 milisegundos
            cont_1++; // Incrementa 1 a variável cont_1 a cada 10 milisegundos
            if (cont_1 == 100) {
                cont_1 = 0; // Zera a variável cont_1
                cont_2++; // Incrementa 1 a variável cont_2 a cada 1 segundo
                printf("%d\n", cont_2);                
                if (cont_2 == 9000) {
                    fechar_sala(); // Fecha a sala depois de passado 2,5 horas
                }
            }
        }
        //*************************************************************************
        
        char key = read_keypad(); //Lê o teclado matricial e armazena o valor lido na variável key
        contador = key - '0'; // converte a variável key em inteiro para armazana o valor na variável contador

        if (controle_1 == 0) {
            if (key != '\0' && isdigit(key)) { // Verifica se uma tecla foi pressionada e se ela é um número
                password_user[digSenha] = key; // Armazena o valor inserido na senha do usuário
                display_digit(contador);  // Exibe o dígito inserido no display
                digSenha++; // Incrementa 1 na variável que armazena a quantidade de digitos da senha que foi inserido no teclado matricial
                
                //*************************************************************************
                // Acende o LED amarelo e emite um sinal sonoro toda vez que um digito da senha é inserido
                gpio_put(buzzer, 1);
                gpio_put(led_amarelo, true);
                sleep_ms(250);
                gpio_put(buzzer, 0);
                gpio_put(led_amarelo, false);
                //*************************************************************************
                
                // Verifica se foram digitados os 4 números da senha
                if (digSenha == 4) {
                    //*************************************************************************
                    // Incrementa 1 a variável contSenha se a senha inserida pelo usuário for igual a senha já cadastrada
                    if (contSenha < 4) {
                        contSenha = 0;
                        for (int i = 0; i < 4; i++) {
                            if (password_user[i] == password_user_1[i]) {
                                contSenha++;                        
                            }
                        }
                    }
                    if (contSenha < 4) {
                        contSenha = 0;
                        for (int i = 0; i < 4; i++) {
                            if (password_user[i] == password_user_2[i]) {
                                contSenha++;                        
                            }
                        }
                    }
                    if (contSenha < 4) {
                        contSenha = 0;
                        for (int i = 0; i < 4; i++) {
                            if (password_user[i] == password_user_3[i]) {
                                contSenha++;                        
                            }
                        }
                    }
                    if (contSenha < 4) {
                        contSenha = 0;
                        for (int i = 0; i < 4; i++) {
                            if (password_user[i] == password_user_4[i]) {
                                contSenha++;                        
                            }
                        }
                    }
                    //*************************************************************************
                    
                    // Verifica se a variável contSenha é igual a 4
                    if (contSenha == 4) {
                        for (int i = 0; i < 4; i++) {                            
                            password_atual[i] = password_user[i]; // Armazena a senha digitada na senha atual                   
                        }
                        // Limpa a senha do usuário
                        for (int j = 0; j < 4; j++) {
                            password_user[j] = '0';
                        }

                        display_clear(); // Limpa o display

                        digSenha = 0; // Limpa a variável digSenha
                        contSenha = 0; // Limpa a variável contSenha
                        
                        gpio_put(rele_1, true); // Aciona o Relé para abrir a porta
                        gpio_put(rele_2, true); // Aciona o Relé da contatora
                        controle_1 = 1; // Altera o valor da variável de controle_1

                        //*************************************************************************
                        // Faz o LED verde pisca por 3 segundos e emite um sinal sonoro
                        gpio_put(buzzer, 1);                        
                        for (int x = 0; x < 6; x++) {
                            gpio_put(led_verde, true);
                            sleep_ms(250);
                            gpio_put(led_verde, false);
                            sleep_ms(250);                        }

                        gpio_put(buzzer, 0);
                        //*************************************************************************
                    } else {
                        // Limpa a senha do usuário
                        for (int i = 0; i < 4; i++) {
                            password_user[i] = '0';
                        }
                        digSenha = 0; // Limpa a variável digSenha
                        contSenha = 0; // Limpa a variável contSenha
                        
                        display_clear(); // Limpa o display

                        gpio_put(rele_1, false); // Desliga o Relé para abrir a porta
                        gpio_put(rele_2, false); // Desliga o Relé da contatora

                        controle_1 = 0; // Altera o valor da variável de controle_1

                        //*************************************************************************
                        // Acende o LED vermelho por 2 segundos e emite um sinal sonoro
                        gpio_put(buzzer, 1);
                        gpio_put(led_vermelho, true);
                        sleep_ms(2000);
                        gpio_put(led_vermelho, false);
                        gpio_put(buzzer, 0);
                        //*************************************************************************
                    }
                }
                sleep_ms(250);  // Espera 250 milisegundo
            }
        } else {
            // Permite inserir a senha para desligar quando a tecla '#' for apertada
            if (key != '\0' && key == '#' && controle_2 == 0) {
                printf("teste");
                controle_2 = 1;
            }

            if (controle_2 == 1) {
                if (key != '\0' && isdigit(key)) { // Verifica se uma tecla foi pressionada e se ela é um número
                    password_user[digSenha] = key; // Armazena o valor inserido na senha do usuário
                    display_digit(contador);  // Exibe o dígito inserido no display
                    digSenha++; // Incrementa 1 na variável que armazena a quantidade de digitos da senha que foi inserido no teclado matricial
                    // Acende o LED amarelo e emite um sinal sonoro toda vez que um digito da senha é inserido
                    //*************************************************************************
                    gpio_put(buzzer, 1);
                    gpio_put(led_amarelo, true);
                    sleep_ms(250);
                    gpio_put(buzzer, 0);
                    gpio_put(led_amarelo, false);
                    //*************************************************************************
                    if (digSenha == 4) {
                        // Incrementa 1 a variável contSenha se a senha inserida pelo usuário for igual a senha atual
                        //*************************************************************************
                        if (contSenha < 4) {
                            contSenha = 0;
                            for (int i = 0; i < 4; i++) {
                                if (password_user[i] == password_atual[i]) {
                                    contSenha++;                        
                                }
                            }
                        }
                        //*************************************************************************
                        // Verifica se a variável contSenha é igual a 4
                        if (contSenha == 4) {
                            fechar_sala(); // Fecha a sala
                            
                            // Emite um sinal sonoro por 1 segundo
                            gpio_put(buzzer, 1);
                            sleep_ms(1000);
                            gpio_put(buzzer, 0);
                            
                        //*************************************************************************
                        } else {
                            for (int j = 0; j < 4; j++) {
                                password_user[j] = '0'; // Limpa a senha do usuário
                            }
                            digSenha = 0; // Zera a variável digSenha
                            contSenha = 0; // Zera a variável contSenha
                            
                            display_clear(); // Limpa o display
                       
                            //*************************************************************************
                            // Acende o LED vermelho por 2 segundos e emite um sinal sonoro
                            gpio_put(buzzer, 1);
                            gpio_put(led_vermelho, true);
                            sleep_ms(2000);
                            gpio_put(led_vermelho, false);
                            gpio_put(buzzer, 0);
                            //*************************************************************************
                        }
                    }
                    sleep_ms(250); // Espera 250 milisegundos
                }
            }
        }     
    }
    return 0;
}