#include "main.h"
#include "stm32l0xx_hal.h"
#include <string.h>
#include <stdbool.h>
#include <stdio.h>

/* ************** 硬件配置 ************** */
// 4x4 键盘引脚
#define KEYPAD_GPIO_PORT       GPIOB
#define KEYPAD_ROW1_PIN        GPIO_PIN_0
#define KEYPAD_ROW2_PIN        GPIO_PIN_1
#define KEYPAD_ROW3_PIN        GPIO_PIN_2
#define KEYPAD_ROW4_PIN        GPIO_PIN_3
#define KEYPAD_COL1_PIN        GPIO_PIN_4
#define KEYPAD_COL2_PIN        GPIO_PIN_5
#define KEYPAD_COL3_PIN        GPIO_PIN_6
#define KEYPAD_COL4_PIN        GPIO_PIN_7

#define KEYPAD_ROWS_MASK       (KEYPAD_ROW1_PIN | KEYPAD_ROW2_PIN | KEYPAD_ROW3_PIN | KEYPAD_ROW4_PIN)
#define KEYPAD_COLS_MASK       (KEYPAD_COL1_PIN | KEYPAD_COL2_PIN | KEYPAD_COL3_PIN | KEYPAD_COL4_PIN)

// LED 指示灯
#define LED_RED_GPIO_PORT      GPIOA
#define LED_RED_PIN            GPIO_PIN_8
#define LED_GREEN_GPIO_PORT    GPIOA
#define LED_GREEN_PIN          GPIO_PIN_7

// I2C LCD (PA9 = SCL, PA10 = SDA)
#define I2C_SCL_PIN            GPIO_PIN_9
#define I2C_SDA_PIN            GPIO_PIN_10
#define LCD_I2C_ADDR           0x27

/* ************** 系统参数 ************** */
#define PASSWORD_LENGTH        6
#define PASSWORD               "123456"
#define MAX_WRONG_ATTEMPTS     3
#define LOCKOUT_TIME_MS        30000
#define KEYPAD_SCAN_PERIOD_MS  50
#define GREEN_FLASH_MS         100
#define GREEN_ACCESS_MS        2000
#define RED_SHORT_FLASH_MS     300
#define RED_ERROR_MS           1000
#define RED_BLINK_PERIOD_MS    500

#define KEY_CANCEL             0xF0
#define KEY_ENTER              0xF1

static const char keypad_layout[4][4] = 
{
    {'1', '2', '3', 'A'},
    {'4', '5', '6', 'B'},
    {'7', '8', '9', 'C'},
    {KEY_CANCEL, '0', KEY_ENTER, 'D'}
};

/* ************** 系统状态 ************** */
typedef struct 
{
    char input_buffer[PASSWORD_LENGTH + 1];
    uint8_t input_index;
    uint8_t wrong_attempts;

    bool locked;
    uint32_t lock_start_time;

    bool green_active;
    bool red_active;
    uint32_t green_off_time;
    uint32_t red_off_time;

    char last_key;
    uint32_t last_toggle;
} SystemState_t;

static SystemState_t sys;

/* ************** I2C 句柄（全局） ************** */
static I2C_HandleTypeDef hi2c1;

/* ************** I2C LCD 驱动（完全重写，参考成功示例） ************** */

// 向 LCD 发送字节（带背光）
static void LCD_Write(uint8_t data, uint8_t mode)
{
    uint8_t high_nibble = (data & 0xF0) | mode | 0x08;  // 0x08 = 背光打开
    uint8_t low_nibble = ((data << 4) & 0xF0) | mode | 0x08;
    
    uint8_t buf[4];
    
    // 发送高4位
    buf[0] = high_nibble;
    buf[1] = high_nibble | 0x04;  // EN = 1
    buf[2] = high_nibble & ~0x04; // EN = 0
    
    // 发送低4位
    buf[3] = low_nibble;
    buf[4] = low_nibble | 0x04;   // EN = 1
    buf[5] = low_nibble & ~0x04;  // EN = 0
    
    HAL_I2C_Master_Transmit(&hi2c1, LCD_I2C_ADDR << 1, buf, 6, 100);
    HAL_Delay(2);
}

static void LCD_Cmd(uint8_t cmd)
{
    LCD_Write(cmd, 0);
}

static void LCD_Data(uint8_t data)
{
    LCD_Write(data, 1);
}

// LCD 初始化 - 关键部分
static void LCD_InitDisplay(void)
{
    // 等待 LCD 上电
    HAL_Delay(50);
    
    // 初始化序列（4位模式）
    uint8_t init_buf[4];
    
    // 第一次: 0x30
    init_buf[0] = 0x30 | 0x08;
    init_buf[1] = 0x30 | 0x08 | 0x04;
    init_buf[2] = 0x30 | 0x08;
    HAL_I2C_Master_Transmit(&hi2c1, LCD_I2C_ADDR << 1, init_buf, 3, 100);
    HAL_Delay(5);
    
    // 第二次: 0x30
    HAL_I2C_Master_Transmit(&hi2c1, LCD_I2C_ADDR << 1, init_buf, 3, 100);
    HAL_Delay(1);
    
    // 第三次: 0x30
    HAL_I2C_Master_Transmit(&hi2c1, LCD_I2C_ADDR << 1, init_buf, 3, 100);
    HAL_Delay(1);
    
    // 设置为4位模式: 0x20
    init_buf[0] = 0x20 | 0x08;
    init_buf[1] = 0x20 | 0x08 | 0x04;
    init_buf[2] = 0x20 | 0x08;
    HAL_I2C_Master_Transmit(&hi2c1, LCD_I2C_ADDR << 1, init_buf, 3, 100);
    HAL_Delay(1);
    
    // 功能设置: 4位, 2行, 5x8点阵
    LCD_Cmd(0x28);
    HAL_Delay(1);
    
    // 显示开关: 显示开, 光标关, 闪烁关
    LCD_Cmd(0x0C);
    HAL_Delay(1);
    
    // 清屏
    LCD_Cmd(0x01);
    HAL_Delay(5);
    
    // 输入模式: 光标右移, 不移动显示
    LCD_Cmd(0x06);
    HAL_Delay(1);
}

static void LCD_Clear(void)
{
    LCD_Cmd(0x01);
    HAL_Delay(2);
}

static void LCD_SetCursor(uint8_t col, uint8_t row)
{
    uint8_t row_offsets[] = {0x00, 0x40, 0x14, 0x54};
    if (row >= 4) row = 0;
    LCD_Cmd(0x80 | (col + row_offsets[row]));
}

static void LCD_Print(const char* str)
{
    while(*str) {
        LCD_Data((uint8_t)*str++);
    }
}

static void LCD_PrintNum(uint8_t num)
{
    char buf[4];
    sprintf(buf, "%d", num);
    LCD_Print(buf);
}

// 测试显示函数 - 用于验证LCD是否工作
static void LCD_TestPattern(void)
{
    LCD_Clear();
    LCD_SetCursor(0, 0);
    LCD_Print("LCD Test OK!");
    LCD_SetCursor(0, 1);
    LCD_Print("Hello STM32!");
    HAL_Delay(2000);
    LCD_Clear();
}

/* ************** I2C 初始化 ************** */
static void I2C_Init(void)
{
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_I2C1_CLK_ENABLE();

    GPIO_InitTypeDef gpio = {0};
    gpio.Pin = I2C_SCL_PIN | I2C_SDA_PIN;
    gpio.Mode = GPIO_MODE_AF_OD;
    gpio.Pull = GPIO_PULLUP;
    gpio.Speed = GPIO_SPEED_FREQ_HIGH;
    gpio.Alternate = GPIO_AF4_I2C1;
    HAL_GPIO_Init(GPIOA, &gpio);

    hi2c1.Instance = I2C1;
    hi2c1.Init.Timing = 0x00201D2B;
    hi2c1.Init.OwnAddress1 = 0;
    hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
    hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
    hi2c1.Init.OwnAddress2 = 0;
    hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
    hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
    
    if (HAL_I2C_Init(&hi2c1) != HAL_OK) {
        // I2C 初始化失败 - 可以在这里添加错误处理
        while(1);
    }
}

/* ************** 键盘扫描 ************** */
static char Keypad_Scan(void) 
{
    const uint16_t row_pins[4] = {KEYPAD_ROW1_PIN, KEYPAD_ROW2_PIN, KEYPAD_ROW3_PIN, KEYPAD_ROW4_PIN};
    const uint16_t col_pins[4] = {KEYPAD_COL1_PIN, KEYPAD_COL2_PIN, KEYPAD_COL3_PIN, KEYPAD_COL4_PIN};

    for (uint8_t i = 0; i < 4; i++) 
    {
        HAL_GPIO_WritePin(KEYPAD_GPIO_PORT, KEYPAD_ROWS_MASK, GPIO_PIN_SET);
        HAL_GPIO_WritePin(KEYPAD_GPIO_PORT, row_pins[i], GPIO_PIN_RESET);

        for (volatile uint8_t k = 0; k < 50; k++) __NOP();

        for (int j = 0; j < 4; j++) 
        {
            if (HAL_GPIO_ReadPin(KEYPAD_GPIO_PORT, col_pins[j]) == GPIO_PIN_RESET) 
            {
                HAL_GPIO_WritePin(KEYPAD_GPIO_PORT, row_pins[i], GPIO_PIN_SET);
                return keypad_layout[i][j];
            }
        }
        HAL_GPIO_WritePin(KEYPAD_GPIO_PORT, row_pins[i], GPIO_PIN_SET);
    }
    return 0;
}

static char Keypad_GetKey(void) 
{
    char cur = Keypad_Scan();
    if (cur != 0 && sys.last_key == 0) {
        sys.last_key = cur;
        return cur;
    }
    if (cur == 0) sys.last_key = 0;
    return 0;
}

/* ************** 显示更新 ************** */
static void Display_Update(void)
{
    LCD_SetCursor(0, 0);
    if(sys.locked)
    {
        LCD_Print("*** LOCKED ***  ");
        LCD_SetCursor(0, 1);
        LCD_Print("Wait 30s       ");
        return;
    }

    LCD_Print("PW:");
    for(uint8_t i=0; i<sys.input_index; i++)
        LCD_Data('*');
    for(uint8_t i=sys.input_index; i<PASSWORD_LENGTH; i++)
        LCD_Data('_');
    LCD_Print("        ");

    LCD_SetCursor(0, 1);
    if(sys.wrong_attempts > 0)
    {
        LCD_Print("Fail:");
        LCD_PrintNum(sys.wrong_attempts);
        LCD_Print("/3          ");
    }
    else
    {
        LCD_Print("Enter Code      ");
    }
}

static void Display_Success(void)
{
    LCD_Clear();
    LCD_SetCursor(4, 0);
    LCD_Print("ACCESS");
    LCD_SetCursor(5, 1);
    LCD_Print("GRANTED");
    HAL_Delay(2000);
    LCD_Clear();
    Display_Update();
}

static void Display_Fail(void)
{
    LCD_Clear();
    LCD_SetCursor(4, 0);
    LCD_Print("ACCESS");
    LCD_SetCursor(5, 1);
    LCD_Print("DENIED");
    HAL_Delay(1500);
    LCD_Clear();
    Display_Update();
}

/* ************** 按键处理 ************** */
static void ProcessKey(uint32_t now, char key) 
{
    if (sys.locked) return;

    if ((key >= '0' && key <= '9') || (key >= 'A' && key <= 'D')) 
    {
        if (sys.input_index < PASSWORD_LENGTH) 
        {
            sys.input_buffer[sys.input_index++] = key;
            sys.input_buffer[sys.input_index] = '\0';

            sys.green_active = true;
            sys.green_off_time = now + GREEN_FLASH_MS;
            Display_Update();
        }
    } 
    else if (key == KEY_CANCEL) 
    {
        if (sys.input_index > 0) 
        {
            sys.input_index = 0;
            sys.input_buffer[0] = '\0';
            sys.red_active = true;
            sys.red_off_time = now + RED_SHORT_FLASH_MS;
            Display_Update();
        }
    } 
    else if (key == KEY_ENTER) 
    {
        if (sys.input_index == PASSWORD_LENGTH) 
        {
            if (strncmp(sys.input_buffer, PASSWORD, PASSWORD_LENGTH) == 0) 
            {
                sys.wrong_attempts = 0;
                sys.green_active = true;
                sys.green_off_time = now + GREEN_ACCESS_MS;
                Display_Success();
            } 
            else 
            {
                sys.wrong_attempts++;
                sys.red_active = true;
                sys.red_off_time = now + RED_ERROR_MS;
                Display_Fail();

                if (sys.wrong_attempts >= MAX_WRONG_ATTEMPTS) 
                {
                    sys.locked = true;
                    sys.lock_start_time = now;
                    sys.wrong_attempts = 0;
                    Display_Update();
                }
            }
        } 
        else 
        {
            sys.red_active = true;
            sys.red_off_time = now + RED_SHORT_FLASH_MS;
        }

        sys.input_index = 0;
        sys.input_buffer[0] = '\0';
        
        if (!sys.locked && sys.wrong_attempts < MAX_WRONG_ATTEMPTS)
        {
            Display_Update();
        }
    }
}

/* ************** 硬件初始化 ************** */
void SystemClock_Config(void);
void MX_GPIO_Init(void);

/* ************** MAIN ************** */
int main(void) 
{
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    I2C_Init();
    
    // LCD 初始化并测试
    LCD_InitDisplay();
    LCD_TestPattern();  // 显示测试信息，确认LCD工作
    
    memset(&sys, 0, sizeof(sys));
    Display_Update();

    uint32_t last_scan = 0;

    while (1) 
    {
        uint32_t now = HAL_GetTick();

        if ((now - last_scan) >= KEYPAD_SCAN_PERIOD_MS) 
        {
            last_scan = now;

            if (!sys.locked) 
            {
                char key = Keypad_GetKey();
                if (key != 0)
                    ProcessKey(now, key);
            } 
            else 
            {
                if ((now - sys.lock_start_time) >= LOCKOUT_TIME_MS) 
                {
                    sys.locked = false;
                    sys.wrong_attempts = 0;
                    sys.input_index = 0;
                    sys.input_buffer[0] = '\0';
                    HAL_GPIO_WritePin(LED_RED_GPIO_PORT, LED_RED_PIN, GPIO_PIN_RESET);
                    LCD_Clear();
                    Display_Update();
                }
            }
        }

        // LED 控制
        if (sys.locked) 
        {
            if ((now - sys.last_toggle) >= RED_BLINK_PERIOD_MS) {
                sys.last_toggle = now;
                HAL_GPIO_TogglePin(LED_RED_GPIO_PORT, LED_RED_PIN);
            }
            HAL_GPIO_WritePin(LED_GREEN_GPIO_PORT, LED_GREEN_PIN, GPIO_PIN_RESET);
        } 
        else 
        {
            if (sys.green_active && (now < sys.green_off_time))
                HAL_GPIO_WritePin(LED_GREEN_GPIO_PORT, LED_GREEN_PIN, GPIO_PIN_SET);
            else {
                HAL_GPIO_WritePin(LED_GREEN_GPIO_PORT, LED_GREEN_PIN, GPIO_PIN_RESET);
                sys.green_active = false;
            }

            if (sys.red_active && (now < sys.red_off_time))
                HAL_GPIO_WritePin(LED_RED_GPIO_PORT, LED_RED_PIN, GPIO_PIN_SET);
            else {
                HAL_GPIO_WritePin(LED_RED_GPIO_PORT, LED_RED_PIN, GPIO_PIN_RESET);
                sys.red_active = false;
            }
        }
    }
}

/* ************** 系统时钟配置 ************** */
void SystemClock_Config(void) 
{
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
    RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
    HAL_RCC_OscConfig(&RCC_OscInitStruct);

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
    HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);

    HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq() / 1000);
    HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
}

/* ************** GPIO 初始化 ************** */
void MX_GPIO_Init(void) 
{
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();

    GPIO_InitTypeDef gpio = {0};

    gpio.Pin = LED_RED_PIN;
    gpio.Mode = GPIO_MODE_OUTPUT_PP;
    gpio.Pull = GPIO_NOPULL;
    gpio.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(LED_RED_GPIO_PORT, &gpio);

    gpio.Pin = LED_GREEN_PIN;
    HAL_GPIO_Init(LED_GREEN_GPIO_PORT, &gpio);

    gpio.Pin = KEYPAD_ROWS_MASK;
    gpio.Mode = GPIO_MODE_OUTPUT_PP;
    HAL_GPIO_Init(KEYPAD_GPIO_PORT, &gpio);
    HAL_GPIO_WritePin(KEYPAD_GPIO_PORT, KEYPAD_ROWS_MASK, GPIO_PIN_SET);

    gpio.Pin = KEYPAD_COLS_MASK;
    gpio.Mode = GPIO_MODE_INPUT;
    gpio.Pull = GPIO_PULLUP;
    HAL_GPIO_Init(KEYPAD_GPIO_PORT, &gpio);
}