#include <Arduino.h>
#include <Keypad.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Servo.h>

// ============================================================
// ANTI-THEFT LOCKER SYSTEM
// Arduino Uno
// ============================================================

// ============================================================
// LED CONFIGURATION
// ============================================================

#define GREEN_LED_PIN A0
#define RED_LED_PIN   A1

// ============================================================
// PIN CONFIGURATION
// ============================================================

#define BUZZER_PIN 10
#define SERVO_PIN  11

// ============================================================
// LCD
// ============================================================

LiquidCrystal_I2C lcd(0x27, 16, 2);

// ============================================================
// SERVO
// ============================================================

Servo lockServo;

// Servo positions
const int LOCK_POSITION   = 0;
const int UNLOCK_POSITION = 90;

// ============================================================
// KEYPAD CONFIGURATION
// ============================================================

const byte ROWS = 4;
const byte COLS = 4;

char keys[ROWS][COLS] =
{
    {'1', '2', '3', 'A'},
    {'4', '5', '6', 'B'},
    {'7', '8', '9', 'C'},
    {'*', '0', '#', 'D'}
};

byte rowPins[ROWS] = {9, 8, 7, 6};
byte colPins[COLS] = {5, 4, 3, 2};

Keypad keypad = Keypad(
    makeKeymap(keys),
    rowPins,
    colPins,
    ROWS,
    COLS
);

// ============================================================
// SECURITY CONFIGURATION
// ============================================================

const char CORRECT_PASSWORD[] = "2580";

const byte PASSWORD_LENGTH = 4;
const byte MAX_ATTEMPTS = 3;

const unsigned long UNLOCK_TIME = 5000UL;
const unsigned long LOCKOUT_TIME = 30000UL;

// ============================================================
// RUNTIME VARIABLES
// ============================================================

char enteredPassword[PASSWORD_LENGTH + 1];

byte passwordIndex = 0;
byte failedAttempts = 0;

bool lockerUnlocked = false;
bool systemLockedOut = false;

unsigned long unlockStartTime = 0;
unsigned long lockoutStartTime = 0;

// ============================================================
// FUNCTION DECLARATIONS
// ============================================================

void showWelcome();
void showPasswordScreen();
void clearPassword();
void processKey(char key);
void verifyPassword();

void unlockLocker();
void lockLocker();

void activateAlarm();
void startLockout();

void handleUnlockTimer();
void handleLockoutTimer();

void setLockedLED();
void setUnlockedLED();
void setAlarmLED();

void printSerialStatus();

// ============================================================
// SETUP
// ============================================================

void setup()
{
    Serial.begin(9600);

    // -------------------------
    // Pin configuration
    // -------------------------

    pinMode(BUZZER_PIN, OUTPUT);

    pinMode(GREEN_LED_PIN, OUTPUT);
    pinMode(RED_LED_PIN, OUTPUT);

    // -------------------------
    // Initial LED state
    // Locker starts locked
    // -------------------------

    setLockedLED();

    // -------------------------
    // Servo initialization
    // -------------------------

    lockServo.attach(SERVO_PIN);

    // Start in locked position
    lockServo.write(LOCK_POSITION);

    // -------------------------
    // LCD initialization
    // -------------------------

    lcd.init();
    lcd.backlight();

    // -------------------------
    // Password initialization
    // -------------------------

    clearPassword();

    // -------------------------
    // Welcome screen
    // -------------------------

    showWelcome();

    Serial.println(F("================================"));
    Serial.println(F(" ANTI-THEFT LOCKER SYSTEM"));
    Serial.println(F(" System initialized"));
    Serial.println(F("================================"));

    delay(2000);

    showPasswordScreen();
}

// ============================================================
// LOOP
// ============================================================

void loop()
{
    // Handle automatic relocking
    handleUnlockTimer();

    // Handle temporary security lockout
    handleLockoutTimer();

    // Ignore keypad input during lockout
    if (systemLockedOut)
    {
        return;
    }

    // Read keypad
    char key = keypad.getKey();

    if (key != NO_KEY)
    {
        processKey(key);
    }
}

// ============================================================
// LED CONTROL
// ============================================================

// ------------------------------------------------------------
// LOCKED STATE
// Red LED ON
// Green LED OFF
// ------------------------------------------------------------

void setLockedLED()
{
    digitalWrite(RED_LED_PIN, HIGH);
    digitalWrite(GREEN_LED_PIN, LOW);
}

// ------------------------------------------------------------
// UNLOCKED STATE
// Green LED ON
// Red LED OFF
// ------------------------------------------------------------

void setUnlockedLED()
{
    digitalWrite(RED_LED_PIN, LOW);
    digitalWrite(GREEN_LED_PIN, HIGH);
}

// ------------------------------------------------------------
// ALARM / SECURITY STATE
// Red LED ON
// Green LED OFF
// ------------------------------------------------------------

void setAlarmLED()
{
    digitalWrite(RED_LED_PIN, HIGH);
    digitalWrite(GREEN_LED_PIN, LOW);
}

// ============================================================
// WELCOME SCREEN
// ============================================================

void showWelcome()
{
    lcd.clear();

    lcd.setCursor(0, 0);
    lcd.print("ANTI-THEFT");

    lcd.setCursor(0, 1);
    lcd.print("LOCKER SYSTEM");

    delay(1500);
}

// ============================================================
// PASSWORD SCREEN
// ============================================================

void showPasswordScreen()
{
    lcd.clear();

    lcd.setCursor(0, 0);
    lcd.print("ENTER PASSWORD");

    lcd.setCursor(0, 1);

    for (byte i = 0; i < passwordIndex; i++)
    {
        lcd.print('*');
    }
}

// ============================================================
// CLEAR PASSWORD
// ============================================================

void clearPassword()
{
    memset(
        enteredPassword,
        0,
        sizeof(enteredPassword)
    );

    passwordIndex = 0;
}

// ============================================================
// PROCESS KEYPAD INPUT
// ============================================================

void processKey(char key)
{
    Serial.print(F("Key pressed: "));
    Serial.println(key);

    // ========================================================
    // CLEAR PASSWORD
    // ========================================================

    if (key == '*')
    {
        clearPassword();

        lcd.clear();

        lcd.setCursor(0, 0);
        lcd.print("PASSWORD CLEARED");

        delay(700);

        showPasswordScreen();

        return;
    }

    // ========================================================
    // SUBMIT PASSWORD
    // ========================================================

    if (key == '#')
    {
        if (passwordIndex == PASSWORD_LENGTH)
        {
            verifyPassword();
        }
        else
        {
            lcd.clear();

            lcd.setCursor(0, 0);
            lcd.print("4 DIGITS");

            lcd.setCursor(0, 1);
            lcd.print("REQUIRED");

            tone(BUZZER_PIN, 800, 200);

            delay(1000);

            showPasswordScreen();
        }

        return;
    }

    // ========================================================
    // ACCEPT NUMERIC DIGITS
    // ========================================================

    if (key >= '0' && key <= '9')
    {
        if (passwordIndex < PASSWORD_LENGTH)
        {
            enteredPassword[passwordIndex] = key;

            passwordIndex++;

            enteredPassword[passwordIndex] = '\0';

            lcd.setCursor(passwordIndex - 1, 1);
            lcd.print('*');

            // Short confirmation beep
            tone(BUZZER_PIN, 1200, 40);
        }

        return;
    }
}

// ============================================================
// PASSWORD VERIFICATION
// ============================================================

void verifyPassword()
{
    bool passwordCorrect = true;

    // Compare entered password
    for (byte i = 0; i < PASSWORD_LENGTH; i++)
    {
        if (enteredPassword[i] != CORRECT_PASSWORD[i])
        {
            passwordCorrect = false;
            break;
        }
    }

    // ========================================================
    // CORRECT PASSWORD
    // ========================================================

    if (passwordCorrect)
    {
        Serial.println(F("ACCESS GRANTED"));

        // Reset failed attempts
        failedAttempts = 0;

        lcd.clear();

        lcd.setCursor(0, 0);
        lcd.print("ACCESS GRANTED");

        lcd.setCursor(0, 1);
        lcd.print("UNLOCKING...");

        // Success beep
        tone(BUZZER_PIN, 1800, 150);

        // Unlock locker
        unlockLocker();

        // Clear password
        clearPassword();
    }

    // ========================================================
    // WRONG PASSWORD
    // ========================================================

    else
    {
        failedAttempts++;

        Serial.print(F("ACCESS DENIED - Attempt "));
        Serial.println(failedAttempts);

        lcd.clear();

        lcd.setCursor(0, 0);
        lcd.print("ACCESS DENIED");

        lcd.setCursor(0, 1);
        lcd.print("ATTEMPT ");

        lcd.print(failedAttempts);

        // Wrong password beep
        tone(BUZZER_PIN, 500, 500);

        delay(1200);

        clearPassword();

        // Check maximum attempts
        if (failedAttempts >= MAX_ATTEMPTS)
        {
            startLockout();
        }
        else
        {
            showPasswordScreen();
        }
    }
}

// ============================================================
// UNLOCK LOCKER
// ============================================================

void unlockLocker()
{
    // Move servo to unlock position
    lockServo.write(UNLOCK_POSITION);

    lockerUnlocked = true;

    unlockStartTime = millis();

    // Green LED ON
    setUnlockedLED();

    Serial.println(F("LOCKER STATUS: UNLOCKED"));

    lcd.clear();

    lcd.setCursor(0, 0);
    lcd.print("LOCKER UNLOCKED");

    lcd.setCursor(0, 1);
    lcd.print("AUTO LOCK: 5 SEC");
}

// ============================================================
// LOCK LOCKER
// ============================================================

void lockLocker()
{
    // Move servo to locked position
    lockServo.write(LOCK_POSITION);

    lockerUnlocked = false;

    // Red LED ON
    setLockedLED();

    Serial.println(F("LOCKER STATUS: LOCKED"));

    lcd.clear();

    lcd.setCursor(0, 0);
    lcd.print("LOCKER LOCKED");

    lcd.setCursor(0, 1);
    lcd.print("SECURE");

    delay(1000);

    showPasswordScreen();
}

// ============================================================
// AUTOMATIC UNLOCK TIMER
// ============================================================

void handleUnlockTimer()
{
    if (!lockerUnlocked)
    {
        return;
    }

    if (millis() - unlockStartTime >= UNLOCK_TIME)
    {
        lockLocker();
    }
}

// ============================================================
// START SECURITY LOCKOUT
// ============================================================

void startLockout()
{
    systemLockedOut = true;

    lockoutStartTime = millis();

    // Red LED remains ON
    setAlarmLED();

    Serial.println(F("!!! SECURITY LOCKOUT !!!"));

    // Activate alarm
    activateAlarm();

    lcd.clear();

    lcd.setCursor(0, 0);
    lcd.print("SECURITY ALERT");

    lcd.setCursor(0, 1);
    lcd.print("LOCKED 30 SEC");
}

// ============================================================
// ALARM
// ============================================================

void activateAlarm()
{
    for (byte i = 0; i < 5; i++)
    {
        // Buzzer ON
        tone(BUZZER_PIN, 1500);

        delay(200);

        // Buzzer OFF
        noTone(BUZZER_PIN);

        delay(150);
    }
}

// ============================================================
// LOCKOUT TIMER
// ============================================================

void handleLockoutTimer()
{
    if (!systemLockedOut)
    {
        return;
    }

    unsigned long elapsed =
        millis() - lockoutStartTime;

    if (elapsed >= LOCKOUT_TIME)
    {
        // End lockout
        systemLockedOut = false;

        // Reset failed attempts
        failedAttempts = 0;

        // Ensure locker remains locked
        lockServo.write(LOCK_POSITION);

        lockerUnlocked = false;

        // Red LED ON
        setLockedLED();

        Serial.println(F("Lockout expired"));

        lcd.clear();

        lcd.setCursor(0, 0);
        lcd.print("SYSTEM READY");

        lcd.setCursor(0, 1);
        lcd.print("TRY AGAIN");

        delay(1000);

        clearPassword();

        showPasswordScreen();
    }
}

// ============================================================
// SERIAL STATUS
// ============================================================

void printSerialStatus()
{
    Serial.print(F("Attempts: "));
    Serial.println(failedAttempts);

    Serial.print(F("Unlocked: "));
    Serial.println(
        lockerUnlocked ? "YES" : "NO"
    );

    Serial.print(F("Lockout: "));
    Serial.println(
        systemLockedOut ? "YES" : "NO"
    );
}