#include <LiquidCrystal.h>
#include <EEPROM.h>
 
// --- Hardware Definitions ---
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
const int BUZZER_PIN = 13; // Active buzzer connected here
 
// --- Constants ---
const int NUM_TIMERS = 4;
const int MASTER_CHANNEL = 0; 
const unsigned long UPDATE_INTERVAL = 150; 
const unsigned long ONE_HOUR_SECONDS = 3600;
const unsigned long LONG_PRESS_TIME = 2500; 
const unsigned long ALARM_INCREMENT = 900; 
const unsigned long INACTIVITY_RESET_TIME = 7000; 
const unsigned long ALARM_DURATION = 60; 
const unsigned long BLINKING_TIME = 1000; 
const unsigned long SETUP_TEXT_TIME = 1000; 
 
// --- Button Pins ---
const int buttonPins[NUM_TIMERS] = {6, 7, 8, 9}; 
const int ALARM_BUTTON = 10; 
 
// --- EEPROM Addresses ---
const int EEPROM_START_ADDRESS = 0;
const int ALARM_TIME_SIZE = sizeof(unsigned long);
 
// --- Data Structures ---
struct TimerData {
  unsigned long startTime;
  unsigned long elapsedTime; 
  bool isRunning;
  bool longFormat; 
  unsigned long alarmTime; 
  unsigned long lastAlarmUpdateTime; 
  bool alarmTriggered; 
  unsigned long alarmEndTime; 
  unsigned long lastAlarmSoundTime; // Track last sound time
};
 
TimerData timers[NUM_TIMERS];
bool blinkColon = false;
unsigned long lastSecond = 0; 
bool alarmSetupMode = false; 
bool setupButtonHeld = false;
unsigned long lastActivityTime = 0; 
bool muteMode = false; 
unsigned long lastMutePressTime = 0;
 
// --- Button Debouncing Variables ---
unsigned long lastDebounceTime[NUM_TIMERS + 1] = {0, 0, 0, 0, 0}; 
const int debounceDelay = 50; 
unsigned long lastAlarmButtonDebounceTime = 0;
 
// --- Long Press Variables ---
unsigned long buttonPressTime[NUM_TIMERS] = {0, 0, 0, 0};
bool buttonHeld[NUM_TIMERS] = {false, false, false, false};
 
// --- Last Displayed Values ---
unsigned long lastDisplayedTime[NUM_TIMERS]; 
unsigned long lastDisplayedAlarmTime[NUM_TIMERS]; 
 
// --- Blinking Variables ---
bool alarmBlinking[NUM_TIMERS] = {false, false, false, false}; 
unsigned long alarmBlinkTime = 0; 
 
// --- Setup Text Variable ---
unsigned long setupTextEndTime = 0;
 
// --- Sound Parameters ---
const int ALARM_TONE_DURATION = 150; // Duration of each beep
const int ALARM_TONE_INCREMENT = 150; // Frequency increment between beeps
const int ALARM_TONE_BASE = 150; // Starting frequency
const int ALARM_TONE_COUNT = 2; // Number of ascending tones
 
// --- Function Declarations ---
void updateTimers();
void displayTimers();
void printTime(int timerIndex, unsigned long totalSeconds);
void checkButtons();
void displayAlarmSetup(); 
unsigned long readAlarmTimeFromEEPROM(int timerIndex);
void writeAlarmTimeToEEPROM(int timerIndex, unsigned long alarmTime);
void printAlarmTime(int timerIndex);
void incrementAlarmTime(int timerIndex);
void resetAlarmTime(int timerIndex);
void copyMasterAlarmToOthers();
void resetAllAlarmTimes();
void checkAlarms();
 
void setup() {
  lcd.begin(16, 2);
 
  // Welcome text at startup
  lcd.setCursor(1, 0);
  lcd.print("**Timer One**");
  lcd.setCursor(0, 1);
  lcd.print("Tel.0755.500.500");
  delay(2500); 
  lcd.setCursor(1, 0);
  lcd.print("Fire Intinse!!");
  delay(1200);
 
  pinMode(BUZZER_PIN, OUTPUT);
 
  unsigned long currentTime = millis();
  for (int i = 0; i < NUM_TIMERS; i++) {
    timers[i].startTime = currentTime;
    timers[i].elapsedTime = 0;
    timers[i].isRunning = true; 
    timers[i].longFormat = false;
    timers[i].alarmTime = readAlarmTimeFromEEPROM(i); 
    timers[i].lastAlarmUpdateTime = 0; 
    timers[i].alarmTriggered = false; 
    timers[i].alarmEndTime = 0; 
    timers[i].lastAlarmSoundTime = 0; // Initialize sound tracking
 
    if (timers[i].alarmTime == 0xFFFFFFFF) { 
      timers[i].alarmTime = 0;
      writeAlarmTimeToEEPROM(i, timers[i].alarmTime); 
    }
 
    pinMode(buttonPins[i], INPUT_PULLUP);
    buttonPressTime[i] = 0;
    buttonHeld[i] = false;
    lastDisplayedTime[i] = 0xFFFFFFFF; 
    lastDisplayedAlarmTime[i] = 0xFFFFFFFF; 
  }
 
  pinMode(ALARM_BUTTON, INPUT_PULLUP);
  lastSecond = millis() / 1000; 
}
 
void loop() {
  checkButtons();
  updateTimers();
 
  if (!alarmSetupMode) {
    displayTimers();
  } else {
    displayAlarmSetup();
  }
 
  delay(UPDATE_INTERVAL);
}
 
void updateTimers() {
  unsigned long currentTime = millis();
  unsigned long currentSecond = currentTime / 1000;
 
  if (currentSecond != lastSecond) {
    blinkColon = !blinkColon;
    lastSecond = currentSecond;
 
    for (int i = 0; i < NUM_TIMERS; i++) {
      if (timers[i].isRunning) {
        timers[i].elapsedTime = (currentTime - timers[i].startTime) / 1000;
 
        if (timers[i].elapsedTime >= ONE_HOUR_SECONDS && !timers[i].longFormat) {
          timers[i].longFormat = true;
        }
 
        if (timers[i].elapsedTime >= (99 * ONE_HOUR_SECONDS + (59 * 60))) { 
          timers[i].isRunning = false;
          timers[i].elapsedTime = (99 * ONE_HOUR_SECONDS + (59 * 60));
        }
      }
    }
  }
 
  if (!alarmSetupMode) {
    checkAlarms(); 
  }
}
 
void displayTimers() {
  unsigned long currentTime = millis();
 
  if (setupTextEndTime > 0 && currentTime < setupTextEndTime) {
    return; 
  }
 
  for (int i = 0; i < NUM_TIMERS; i++) {
    int row = i / 2;
    int col = (i % 2) * 8;
 
    lcd.setCursor(col, row);
    lcd.print(i + 1);
    lcd.print("-");
 
    if (alarmBlinking[i]) {
      if ((currentTime - alarmBlinkTime) % (BLINKING_TIME * 2) < BLINKING_TIME) {
        printTime(i, timers[i].elapsedTime);
      } else {
        lcd.setCursor(col + 2, row); 
        lcd.print("      ");
      }
    } else {
      printTime(i, timers[i].elapsedTime);
    }
 
    lcd.setCursor(col + 7, row);
    if (muteMode) {
      lcd.print("*");
    } else {
      lcd.print(" "); 
    }
  }
}
 
void printTime(int timerIndex, unsigned long totalSeconds) {
  int hours = totalSeconds / ONE_HOUR_SECONDS;
  int minutes = (totalSeconds % ONE_HOUR_SECONDS) / 60;
  int seconds = totalSeconds % 60;
  lcd.setCursor((timerIndex % 2) * 8 + 2, timerIndex / 2); 
 
  if (timers[timerIndex].longFormat) {
    if (hours < 10) lcd.print("0");
    lcd.print(hours);
    lcd.print(blinkColon ? ":" : " ");
    if (minutes < 10) lcd.print("0");
    lcd.print(minutes);
  } else {
    if (minutes < 10) lcd.print("0");
    lcd.print(minutes);
    lcd.print(blinkColon ? ":" : " ");
    if (seconds < 10) lcd.print("0");
    lcd.print(seconds);
  }
}
 
void checkButtons() {
  int alarmButtonState = digitalRead(ALARM_BUTTON);
  unsigned long currentTime = millis();
 
  // Alarm setup button handling
  if (alarmButtonState == LOW) {
    if (millis() - lastAlarmButtonDebounceTime > debounceDelay) {
      if (!setupButtonHeld) {
        alarmSetupMode = true; 
        lastAlarmButtonDebounceTime = millis();
        setupButtonHeld = true;
        lastActivityTime = currentTime; 
 
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("SETARE ALARME");
        setupTextEndTime = currentTime + SETUP_TEXT_TIME;
 
        digitalWrite(BUZZER_PIN, LOW);
        for (int i = 0; i < NUM_TIMERS; i++) {
          timers[i].alarmTriggered = false;
          timers[i].alarmEndTime = 0;
        }
      }
    }
  } else {
    if (millis() - lastAlarmButtonDebounceTime > debounceDelay) {
      if (setupButtonHeld) {
        setupButtonHeld = false;
        if ((millis() - buttonPressTime[0]) >= LONG_PRESS_TIME) {
          alarmSetupMode = true; 
          lastAlarmButtonDebounceTime = millis();
          lastActivityTime = currentTime; 
 
          lcd.clear();
          lcd.setCursor(0, 0);
          lcd.print("ALARME SETATE");
          setupTextEndTime = currentTime + SETUP_TEXT_TIME;
        }
      }
    }
  }
 
  // Exit setup mode when button released
  if (alarmSetupMode && alarmButtonState == HIGH) {
    alarmSetupMode = false;
    for (int i = 0; i < NUM_TIMERS; i++) {
      writeAlarmTimeToEEPROM(i, timers[i].alarmTime);
    }
  }
 
  if (alarmSetupMode && (currentTime - lastActivityTime > INACTIVITY_RESET_TIME)) {
    resetAllAlarmTimes();
    lastActivityTime = currentTime + 100000; 
  }
 
  // Mute handling (buttons 1 and 4 pressed together)
  bool button1Pressed = digitalRead(buttonPins[0]) == LOW;
  bool button4Pressed = digitalRead(buttonPins[3]) == LOW;
 
  if (button1Pressed && button4Pressed) {
    if (millis() - lastMutePressTime > debounceDelay) {
      lastMutePressTime = millis();
      muteMode = !muteMode;
    }
  }
 
  // --- Swap elapsed time between channels when both buttons are pressed ---
  static unsigned long lastSwapTime = 600;
  const unsigned long swapDebounce = 600; // ms
 
  for (int i = 0; i < NUM_TIMERS - 1; i++) {
    for (int j = i + 1; j < NUM_TIMERS; j++) {
      bool buttonIPressed = digitalRead(buttonPins[i]) == LOW;
      bool buttonJPressed = digitalRead(buttonPins[j]) == LOW;
 
      if (buttonIPressed && buttonJPressed) {
        if (millis() - lastSwapTime > swapDebounce) {
          // Swap elapsedTime and startTime
          unsigned long tempElapsed = timers[i].elapsedTime;
          timers[i].elapsedTime = timers[j].elapsedTime;
          timers[j].elapsedTime = tempElapsed;
 
          unsigned long tempStart = timers[i].startTime;
          timers[i].startTime = timers[j].startTime;
          timers[j].startTime = tempStart;
 
          // Double beep for active buzzer
          digitalWrite(BUZZER_PIN, HIGH);
          delay(120);
          digitalWrite(BUZZER_PIN, LOW);
          delay(80);
          digitalWrite(BUZZER_PIN, HIGH);
          delay(120);
          digitalWrite(BUZZER_PIN, LOW);
 
          lastSwapTime = millis();
        }
      }
    }
  }
 
  // Channel button handling
  for (int i = 0; i < NUM_TIMERS; i++) {
    int buttonState = digitalRead(buttonPins[i]);
 
    if (alarmSetupMode && buttonState == LOW) {
      if (millis() - lastDebounceTime[i] > debounceDelay) {
        lastDebounceTime[i] = millis();
 
        if (!buttonHeld[i]) {
          buttonHeld[i] = true;
          buttonPressTime[i] = millis();
          incrementAlarmTime(i); 
          if (i == MASTER_CHANNEL) {
            copyMasterAlarmToOthers();
          }
          lastActivityTime = currentTime; 
          timers[i].alarmTriggered = false; 
        }
      }
 
      // Only reset ONCE per long press
      if (buttonHeld[i] && (millis() - buttonPressTime[i]) >= LONG_PRESS_TIME) {
        resetAlarmTime(i);
        if (i == MASTER_CHANNEL) {
          copyMasterAlarmToOthers();
        }
        // Single beep for active buzzer on alarm reset
        digitalWrite(BUZZER_PIN, HIGH);
        delay(100);
        digitalWrite(BUZZER_PIN, LOW);
        delay(1020);
 
        buttonHeld[i] = false;  // Prevent both reset and increment until release
        lastActivityTime = currentTime;
        timers[i].alarmTriggered = false;
      }
    } else {
      if (buttonState == LOW) {
        if (millis() - lastDebounceTime[i] > debounceDelay) {
          lastDebounceTime[i] = millis();
 
          if (!buttonHeld[i]) {
            buttonHeld[i] = true;
            buttonPressTime[i] = millis();
          }
        }
 
        // Only reset ONCE per long press
        if (!timers[i].alarmTriggered && buttonHeld[i] && (millis() - buttonPressTime[i]) >= LONG_PRESS_TIME) {
          timers[i].elapsedTime = 0;
          timers[i].startTime = millis();
          displayTimers();
          timers[i].alarmTriggered = false;
          alarmBlinking[i] = false;
 
          // Single beep for active buzzer
          digitalWrite(BUZZER_PIN, HIGH);
          delay(120);
          digitalWrite(BUZZER_PIN, LOW);
 
          // Prevent further resets until button is released
          buttonHeld[i] = false;
        }
      } else {
        // Button released
        if (buttonHeld[i]) {
          buttonHeld[i] = false;
          if (timers[i].alarmEndTime > 0) {
            timers[i].alarmEndTime = 0;
            timers[i].alarmTriggered = false;
          }
        }
      }
    }
  }
}
 
void displayAlarmSetup() {
  unsigned long currentTime = millis();
 
  if (setupTextEndTime > 0 && currentTime < setupTextEndTime) {
    return; 
  }
 
  lcd.setCursor(0, 0);
  lcd.print("A>");
  printAlarmTime(0);
  lcd.print(" A>");
  printAlarmTime(1);
  lcd.setCursor(0, 1);
  lcd.print("A>");
  printAlarmTime(2);
  lcd.print(" A>");
  printAlarmTime(3);
}
 
void printAlarmTime(int timerIndex) {
  unsigned long alarmTime = timers[timerIndex].alarmTime;
  int alarmHours = (alarmTime / 3600) % 100;
  int alarmMinutes = (alarmTime % 3600) / 60;
 
  lcd.setCursor((timerIndex % 2) * 8 + 2, timerIndex / 2); 
 
  if (alarmHours < 10) {
    lcd.print("0");
  }
  lcd.print(alarmHours);
  lcd.print(":");
 
  if (alarmMinutes < 10) {
    lcd.print("0");
  }
  lcd.print(alarmMinutes);
}
 
unsigned long readAlarmTimeFromEEPROM(int timerIndex) {
  int address = EEPROM_START_ADDRESS + (timerIndex * ALARM_TIME_SIZE);
  unsigned long alarmTime;
  EEPROM.get(address, alarmTime);
  return alarmTime;
}
 
void writeAlarmTimeToEEPROM(int timerIndex, unsigned long alarmTime) {
  int address = EEPROM_START_ADDRESS + (timerIndex * ALARM_TIME_SIZE);
  EEPROM.put(address, alarmTime);
}
 
void incrementAlarmTime(int timerIndex) {
  timers[timerIndex].alarmTime += ALARM_INCREMENT;
 
  if (timers[timerIndex].alarmTime >= 360000) { 
    timers[timerIndex].alarmTime = 0; 
  }
 
  timers[timerIndex].alarmTriggered = false; 
  timers[timerIndex].alarmEndTime = 0; 
  timers[timerIndex].lastAlarmUpdateTime = millis(); 
 
  if (timerIndex == MASTER_CHANNEL) {
    copyMasterAlarmToOthers();
  }
 
  displayAlarmSetup(); 
}
 
void resetAlarmTime(int timerIndex) {
  timers[timerIndex].alarmTime = 0;
  timers[timerIndex].alarmTriggered = false; 
  timers[timerIndex].alarmEndTime = 0; 
  displayAlarmSetup();
}
 
void copyMasterAlarmToOthers() {
  unsigned long masterAlarmTime = timers[MASTER_CHANNEL].alarmTime;
  for (int i = 0; i < NUM_TIMERS; i++) {
    if (i != MASTER_CHANNEL) {
      timers[i].alarmTime = masterAlarmTime;
      timers[i].lastAlarmUpdateTime = millis(); 
      timers[i].alarmTriggered = false; 
    }
  }
}
 
void resetAllAlarmTimes() {
  for (int i = 0; i < NUM_TIMERS; i++) {
    timers[i].alarmTime = 0;
  }
  displayAlarmSetup();
}
 
void resetTimer(int timerIndex) {
  timers[timerIndex].elapsedTime = 0;
  timers[timerIndex].startTime = millis();
  timers[timerIndex].alarmTriggered = false; 
  timers[timerIndex].alarmEndTime = 0; 
  alarmBlinking[timerIndex] = false; 
  displayTimers();
}
 
void checkAlarms() {
  unsigned long currentTime = millis() / 1000;
  for (int i = 0; i < NUM_TIMERS; i++) {
    if (timers[i].alarmTime > 0 && 
        timers[i].alarmTime <= timers[i].elapsedTime && 
        timers[i].alarmTime > timers[i].elapsedTime - 1 && 
        !timers[i].alarmTriggered) {
      timers[i].alarmEndTime = currentTime + ALARM_DURATION;
      timers[i].alarmTriggered = true;
      alarmBlinking[i] = true;
      alarmBlinkTime = millis();
      timers[i].lastAlarmSoundTime = millis(); // Reset sound timer
    }
 
    if (timers[i].alarmEndTime > 0 && currentTime < timers[i].alarmEndTime) {
      // Generate ascending tones
      if (!muteMode && 
          (millis() - timers[i].lastAlarmSoundTime) >= ALARM_TONE_DURATION) {
        int currentToneIndex = ((millis() - timers[i].lastAlarmSoundTime) / ALARM_TONE_DURATION) % ALARM_TONE_COUNT;
        int frequency = ALARM_TONE_BASE + (currentToneIndex * ALARM_TONE_INCREMENT);
        tone(BUZZER_PIN, frequency, ALARM_TONE_DURATION); // Generate tone
        delay(300); //
 
        timers[i].lastAlarmSoundTime = millis();
      }
    } else {
      noTone(BUZZER_PIN); // Stop tone when alarm ends
      if (timers[i].alarmEndTime > 0 && currentTime >= timers[i].alarmEndTime) {
        timers[i].alarmEndTime = 0;
        timers[i].alarmTriggered = false;
      }
    }
  }
}