#include <Wire.h>
#include <iarduino_RTC.h>
#include <LiquidCrystal_I2C.h>

iarduino_RTC rtc(RTC_DS1307);
LiquidCrystal_I2C lcd(0x27, 20, 4);

const int pin_button_stw = 2;
const int pin_button_clock = 4;
const int pin_button_timer_s = 13;
const int pin_button_timer_m = 12;
const int pin_button_timer_start = 8;
const int pin_buzzer = 7;

const int interval = 1000; 

unsigned long currentMillis = 0;
unsigned long prevTime = 0; 
unsigned long lastButtonPress = 0; 

const int debounceDelay = 200; 

int clock_state = 0;
int stopwatchState = 0;

int h = 0, m = 0, s = 0;
int h_t = 0, m_t = 0, s_t = 0;

bool flag_timer = false;
bool flag_buzzer = false;
int count_buzzer_sec = 4;

void setup() {

  Wire.begin();
  lcd.init();
  lcd.backlight();
  rtc.begin();

  pinMode(pin_button_stw, INPUT_PULLUP);
  pinMode(pin_button_clock, INPUT_PULLUP);
  pinMode(pin_button_timer_s, INPUT_PULLUP);
  pinMode(pin_button_timer_m, INPUT_PULLUP);
  pinMode(pin_button_timer_start, INPUT_PULLUP);
  pinMode(pin_buzzer, OUTPUT);

  printStopwatch();
  printTimer();
  printDate();
}

void loop() {
  checkButtonStpW();
  check_Button_Clock();
  checkButtonTimerSec();
  checkButtonTimerMin();
  checkButtonTimerStart();

  currentMillis = millis();
  if (currentMillis - prevTime >= interval) {
    prevTime = currentMillis;

    if (clock_state == 0)
      updateClock12();
    else 
      updateClock24();

    if (stopwatchState == 1)
      updateStopwatch();

    if (flag_timer == true)
      updateTimerStart();

    if (flag_buzzer == true)
      updateBuzzer();
  }
}

void check_Button_Clock() {
  if (digitalRead(pin_button_clock) == LOW) {
        if (millis() - lastButtonPress > debounceDelay) {
            lastButtonPress = millis();

            if (clock_state == 0) {
                clock_state = 1;
                lcd.setCursor(16,0);
                lcd.print(" ");
            }
            else 
              clock_state = 0;
        }
    }
}

void checkButtonTimerMin() {
  if (digitalRead(pin_button_timer_m) == LOW && flag_timer == false) {
        if (millis() - lastButtonPress > debounceDelay) {
            lastButtonPress = millis();
            updateTimer('m');
            printTimer();
        }
    }
}

void checkButtonStpW() {
    if (digitalRead(pin_button_stw) == LOW) {
        if (millis() - lastButtonPress > debounceDelay) {
            lastButtonPress = millis();
            switch (stopwatchState) {
              case 0:
                stopwatchState = 1;
              break;
              case 1:
                stopwatchState = 2;
              break;
              case 2:
                resetStopwatch(); 
                stopwatchState = 0;
              break;
            }
        }
    }
}

void checkButtonTimerSec() {
    if (digitalRead(pin_button_timer_s) == LOW && flag_timer == false) {
        if (millis() - lastButtonPress > debounceDelay) {
            lastButtonPress = millis();
            updateTimer('s');
            printTimer();
        }
    }
}

void checkButtonTimerStart() {
    if (digitalRead(pin_button_timer_start) == LOW && (s_t != 0 || m_t != 0 || h_t != 0)) {
        if (millis() - lastButtonPress > debounceDelay) {
            lastButtonPress = millis();
            flag_timer = true;
        }
    }
}

void updateBuzzer() {
  count_buzzer_sec--;
  tone(pin_buzzer,  90);
  if (count_buzzer_sec == 0) {
    noTone(pin_buzzer);
    flag_buzzer = false;
    count_buzzer_sec = 4;
  }
}

void updateTimerStart() {
  if (s_t > 0) 
    s_t--;
  else {
    if (m_t > 0) {
      m_t--;
      s_t = 59;  
    } else {
      if (h_t > 0) {
        h_t--;
        m_t = 59; 
        s_t = 59; 
      }
    }
  }

  printTimer();

  if (h_t == 0 && m_t == 0 && s_t == 0) {
    flag_timer = false;
    flag_buzzer = true;
  }
}


void updateTimer(char value) {
  switch (value) {

    case 's':
      if (s_t == 50) {
        m_t++;
        s_t = 0;
      } 
      else 
        s_t += 10;
    break;

    case 'm':
    if (m_t == 50) {
        h_t++;
        m_t = 0;
      } 
      else 
        m_t ++;
    break;
  }
}

void updateClock24() {
    rtc.gettime();
    int hours = rtc.Hours;
    char buffer[20];
    lcd.setCursor(0, 0);
    sprintf(buffer, "Clock: %02d:%02d:%02d", hours, rtc.minutes, rtc.seconds);
    lcd.print(buffer);
    printSunMoon(hours);
}

void updateClock12() {
    rtc.gettime();
    lcd.setCursor(0, 0);
    char buffer [20];
    sprintf(buffer, "Clock: %02d:%02d:%02d", rtc.hours, rtc.minutes, rtc.seconds);
    lcd.print(buffer);
    lcd.print(rtc.midday == 1 ? " PM" : " AM");
}

void updateStopwatch() {
    s++;
    if (s >= 60) {
        s = 0;
        m++;
        
        if (m >= 60) {
          m = 0;
          h++;
        }
    }
    printStopwatch();
}

void resetStopwatch() {
  h = m = s = 0;
  printStopwatch();
}

void printStopwatch() {
  lcd.setCursor(0, 1);
  char buffer[20];
  sprintf(buffer, "Stopwatch: %02d:%02d:%02d", h, m, s);
  lcd.print(buffer);
}

void printTimer() {
  lcd.setCursor(0, 2);
  char buffer[20];
  sprintf(buffer, "Timer: %02d:%02d:%02d", h_t, m_t, s_t);
  lcd.print(buffer);
}

void printSunMoon(int hours) {

  byte char_sun[8] = {
      0b00100,
      0b10101,
      0b01110,
      0b11111,
      0b01110,
      0b10101,
      0b00100,
      0b00000
    };

    byte char_moon[8] = {
      0b00000,
      0b00000,
      0b01110,
      0b11100,
      0b11000,
      0b11100,
      0b01110,
      0b00000
    };

    lcd.createChar(0, char_sun);
    lcd.createChar(1, char_moon);
    lcd.setCursor(16,0);
    lcd.write(hours >= 6 && hours < 18 ? byte(0) : byte(1));
    lcd.setCursor(17,0);
    lcd.print(" ");

}

void printDate() {
  rtc.gettime();
  lcd.setCursor(0,3);
  char buffer[20];
  sprintf(buffer, "Date: %02d.%02d.20%02d", rtc.day, rtc.month, rtc.year);
  lcd.print(buffer);
}