#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include "RTClib.h"
#include <math.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
RTC_DS1307 rtc;

int tempSensor = A5;

int second = 0;
int minute = 0;
int hour = 0;

int secondAlarm = 999;
int minuteAlarm = 999;
int hourAlarm = 999;

int setTime[4];
int i = 0;
DateTime now;
int button = 2;
unsigned long prevTimeClock = 0;
bool playAlarm = false;
bool showTemp = false;
bool setTimeMode = false;
bool setAlarmMode = false;

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

  pinMode(tempSensor, OUTPUT);
  pinMode(button, INPUT);
  attachInterrupt(digitalPinToInterrupt(button), configureSetting, RISING);

  if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    while (true);
    oled.clearDisplay();
  }
  oled.clearDisplay();

  if(!rtc.begin()){ 
    Serial.println("Couldn't find RTC");
    Serial.flush();
    abort();
  }
  Serial.println("To set your own time enter hour, minute, second, and mode in that order:"); 
  while (i < 4) {
    setTime[i] = Serial.parseInt();
    i++;
  }
  if (i == 4) {
    configureTime(setTime[3]);
    i = 0;
  }
}


char dispHour[4];
char dispMin[4];
char dispSec[4];

void loop() {
  if(setTimeMode) {
    oled.clearDisplay();
    oled.setTextColor(WHITE);
    oled.setTextSize(1);
    oled.setCursor(17, 20);
    oled.println("Setting Time");
    oled.display();
    Serial.flush();
    if (Serial.available() > 0 && i < 4) {
      setTime[i] = Serial.parseInt();
      i++;
    }
    else if (i = 4) {
      configureTime(setTime[3]);
      setTimeMode = false;
      i = 0;
    }
  }
  else {
    if (hour == hourAlarm && minute == minuteAlarm && second == secondAlarm) {
      playAlarm = true;
    }

    if (playAlarm) {
      alarmTune();
    }

    if (setAlarmMode) {
      oled.clearDisplay();
      oled.setTextColor(WHITE);
      oled.setTextSize(1);
      oled.setCursor(17, 20);
      oled.println("Setting Alarm");
      oled.display();
      Serial.flush();
      if (Serial.available() > 0 && i < 3) {
        setTime[i] = Serial.parseInt();
        i++;
      }
      else if (i = 3) {
        configureAlarm();
        setAlarmMode = false;
        i = 0;
      }
    }

    if (prevTimeClock + 500 == millis() || prevTimeClock + 1000 <= millis()) {
      if (setTime[3] == 0) {
        now = rtc.now();
        hour = now.hour();
        minute = now.minute();
        second = now.second(); 
      }
      else {
        if (prevTimeClock + 1000 <= millis()) {
          second++;
          if (second == 60) {
            if (minute < 60) {
              minute++;
              if (minute == 60) {
                if (hour < 24) {
                  hour++;
                  if(hour == 24) {
                    hour = 0;
                  }
                }
                minute = 0;
              }
            }
            second = 0;
          }
        }
      }
      if (prevTimeClock + 1000 <= millis()) {
        prevTimeClock = millis();
      }
      if (!setAlarmMode) {
        if (hour < 10) {
          sprintf(dispHour, "0%d", hour);
        }
        else {
          sprintf(dispHour, "%d", hour);
        }
        if (minute < 10) {
          sprintf(dispMin, "0%d", minute);
        }
        else {
          sprintf(dispMin, "%d", minute);
        }
        if (second < 10) {
          sprintf(dispSec, "0%d", second);
        }
        else {
          sprintf(dispSec, "%d", second);
        }
        
        char displayTime[30];
        strcpy(displayTime, "");
        strcat(displayTime, dispHour);
        strcat(displayTime, ":");
        strcat(displayTime, dispMin);
        strcat(displayTime, ":");
        strcat(displayTime, dispSec);
        oled.clearDisplay();
        oled.setTextColor(WHITE);
        if (showTemp) {
          const float BETA = 3950;
          float val = analogRead(tempSensor);
          const float celsius = 1 / (log(1 / (1023. / val - 1)) / BETA + 1.0 / 298.15) - 273.15;
          oled.setTextSize(1);
          oled.setCursor(10, 35);
          oled.print(celsius);
          oled.print(" *C");
        }
        oled.setTextSize(1);
        oled.setCursor(10, 10);
        oled.println(displayTime);
        //analog clock
        oled.drawCircle(90, 30, 25, WHITE);
        oled.setCursor(88, 7);
        oled.println("0");
        oled.setCursor(108, 27);
        oled.println("3");
        oled.setCursor(88, 47);
        oled.println("6");
        oled.setCursor(68, 27);
        oled.println("9");
        //second
        double xSec = sin(((double)second/60) * 2 * PI) * 25;
        double ySec = -cos(((double)second/60) * 2 * PI) * 25;
        oled.drawLine(90, 30, 90 + xSec, 30 + ySec, WHITE);
        //minute
        double xMin = sin(((double)minute/60) * 2 * PI) * 20;
        double yMin = -cos(((double)minute/60) * 2 * PI) * 20;
        oled.drawLine(90, 30, 90 + xMin, 30 + yMin, WHITE);
        //hour
        double xHour = sin(((double)hour/12) * 2 * PI) * 15;
        double yHour = -cos(((double)hour/12) * 2 * PI) * 15;
        oled.drawLine(90, 30, 90 + xHour, 30 + yHour, WHITE);
        oled.display();
      }
    }
  }
}


unsigned long timeSettingAlarm = 0;

void configureAlarm() {
  Serial.println("Alarm set");
  hourAlarm = setTime[0] % 24;
  Serial.print("hour: ");
  Serial.println(hourAlarm);
  minuteAlarm = setTime[1] % 60;
  Serial.print("minute: ");
  Serial.println(minuteAlarm);
  secondAlarm = setTime[2] % 60; 
  Serial.print("second: ");
  Serial.println(secondAlarm);
  //sync time to time spent while setting alarm
  second = second + ((millis() - timeSettingAlarm)/1000);
  if (second > 60) {
    second = second % 60;
    minute++;
    if (minute == 60) {
      minute = 0;
      hour = (hour + 1) % 60;
    }
  }
}

void configureTime(int useCustomTime) {
  if (useCustomTime == 1) {
    Serial.println("Time set");
    hour = setTime[0] % 24;
    Serial.print("hour: ");
    Serial.println(hour);
    minute = setTime[1] % 60;
    Serial.print("minute: ");
    Serial.println(minute);
    second = setTime[2] % 60; 
    Serial.print("second: ");
    Serial.println(second);
  }
  else {
    now = rtc.now();
    hour = now.hour();
    minute = now.minute();
    second = now.second(); 
    Serial.println("Using default time");
  }
}

int buttonCounter = 0;
unsigned long prevTimeButton = -1000;
unsigned long prevTimeMessage = 0;

void configureSetting() {
  if (prevTimeMessage + 200 < millis()) {
    if (prevTimeButton + 1500 <= millis() && buttonCounter == 0) {
      prevTimeButton = millis();
      buttonCounter++;
      Serial.println("Button pressed");
    }
    else if (prevTimeButton + 1500 <= millis()) {
      switch (buttonCounter) {
        case 1:
          setTimeMode = true;
          break;
        case 2:
          setAlarmMode = true;
          timeSettingAlarm = millis();
          break;
        case 3:
          showTemp = !showTemp;
          break;
      }
      buttonCounter = 100;
    }
    else {
      buttonCounter++;
    }

    if (buttonCounter == 1) {
      Serial.println("Set time");
    }
    else if (buttonCounter == 2) {
      Serial.println("Set alarm");
    }
    else if (buttonCounter == 3) {
      Serial.println("Show temperature");
    }
    else if (buttonCounter > 3 && buttonCounter < 100) {
      Serial.println("Cancel");
    }
    else if (buttonCounter == 100) {
      Serial.println("Finalised selection");
      buttonCounter = 0;
    }

    prevTimeMessage = millis();
  }
}

unsigned long prevTimeAlarm = 0;
int alarmCount = 0;
void alarmTune() {
  if (alarmCount < 3) {
    if (millis() >= prevTimeAlarm + 1200) {
      alarmCount++;
      prevTimeAlarm = millis();
    }
    else if (millis() >= prevTimeAlarm + 800) {
      tone(8, 50, 50);
    }
    else if (millis() >= prevTimeAlarm + 400) {
      tone(8, 100, 50);
    }
    else if (millis() >= prevTimeAlarm + 0) {
      tone(8, 300, 50);
    }
  }
  else {
    playAlarm = false;
    alarmCount = 0;
  }
}
//Alarm to remember second passed and add to time after alarm set, use millis().