#include <Arduino.h>
#include <math.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <RTClib.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <EEPROM.h>
#include <vector>
#include <algorithm>

using namespace std;

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
#define ONE_WIRE_BUS 4
#define SIZE_PER_RECORD 16
#define MAX_EEPROM_RECORD 30

struct DataStore
{
    int tempVal;
    String datetime;
};

Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire);

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature tempSensor(&oneWire);
double curTempVal = 0;

RTC_DS3231 rtc;

unsigned long previousMillis = 0;
const unsigned long interval = 10000;

bool needSendToPC = true;

void displayTitle()
{
    oled.setTextSize(1);
    oled.setTextColor(SSD1306_WHITE);
    oled.setCursor(0, 0);
    oled.print("Current Temperature:");
}

void displayTemp(double value)
{
    oled.setTextSize(2);
    oled.setCursor(0, 16);
    oled.print(String(value));
    oled.setTextSize(1);
    oled.print(" ");
    oled.print(char(167));
    oled.setTextSize(2);
    oled.print("C");
}

void displayDateTime(DateTime now)
{
    oled.setTextSize(1);
    oled.setCursor(0, 40);
    oled.print(now.year());
    oled.print("/");
    oled.print(now.month());
    oled.print("/");
    oled.print(now.day());
    oled.print(" ");
    oled.print(now.hour());
    oled.print(":");
    oled.print(now.minute());
    oled.print(":");
    oled.print(now.second());
    oled.display();
}

double getTemp()
{
    // tempSensor.requestTemperatures();
    // return tempSensor.getTempCByIndex(0);

    // random from 26-30
    return random(26.0, 30.0);
}

// Format: [t][t][Y][Y][Y][Y][M][M][D][D][h][h][m][m][s][s]
void makeDataForEEPRom(DateTime time, double tempValue)
{
    int existingRecords = EEPROM.read(511);
    if (existingRecords > MAX_EEPROM_RECORD)
    {
        existingRecords = 0;
    }

    int year = time.year();
    int month = time.month();
    int day = time.day();
    int hour = time.hour();
    int minute = time.minute();
    int second = time.second();

    int temp = (int)(tempValue);

    int address = existingRecords * SIZE_PER_RECORD;

    EEPROM.write(address + 0, temp / 10);
    temp %= 10;
    EEPROM.write(address + 1, temp);
    EEPROM.write(address + 2, year / 1000);
    year %= 1000;
    EEPROM.write(address + 3, year / 100);
    year %= 100;
    EEPROM.write(address + 4, year / 10);
    year %= 10;
    EEPROM.write(address + 5, year);
    EEPROM.write(address + 6, month / 10);
    month %= 10;
    EEPROM.write(address + 7, month);
    EEPROM.write(address + 8, day / 10);
    day %= 10;
    EEPROM.write(address + 9, day);
    EEPROM.write(address + 10, hour / 10);
    hour %= 10;
    EEPROM.write(address + 11, hour);
    EEPROM.write(address + 12, minute / 10);
    minute %= 10;
    EEPROM.write(address + 13, minute);
    EEPROM.write(address + 14, second / 10);
    second %= 10;
    EEPROM.write(address + 15, second);

    EEPROM.write(511, ++existingRecords);

    EEPROM.commit();
}

vector<DataStore> getDataFromEEPRom()
{
    vector<DataStore> data;

    for (int i = 0; i < MAX_EEPROM_RECORD; i++)
    {
        int address = i * SIZE_PER_RECORD;
        int temp = EEPROM.read(address + 0) * 10 + EEPROM.read(address + 1);
        int year = EEPROM.read(address + 2) * 1000 + EEPROM.read(address + 3) * 100 + EEPROM.read(address + 4) * 10 + EEPROM.read(address + 5);
        int month = EEPROM.read(address + 6) * 10 + EEPROM.read(address + 7);
        int day = EEPROM.read(address + 8) * 10 + EEPROM.read(address + 9);
        int hour = EEPROM.read(address + 10) * 10 + EEPROM.read(address + 11);
        int minute = EEPROM.read(address + 12) * 10 + EEPROM.read(address + 13);
        int second = EEPROM.read(address + 14) * 10 + EEPROM.read(address + 15);

        String datetime = String(year) + "/" + String(month) + "/" + String(day) + " " + String(hour) + ":" + String(minute) + ":" + String(second);
        data.push_back({temp, datetime});
    }

    return data;
}

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

    // Initialize the EEPROM
    EEPROM.begin(512);

    // Initial temperature sensor and get the initial value
    tempSensor.begin();
    curTempVal = getTemp();

    // Initialize rtc
    rtc.begin();
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

    // Initialize oled
    if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C))
    { // Address 0x3C for 128x64
        Serial.println(F("SSD1306 allocation failed"));
        for (;;)
            ; // Don't proceed, loop forever
    }
}

void sendToPC(int curTempVal, DateTime now)
{
    Serial.print("Temp:");
    Serial.print(curTempVal);
    Serial.print("|");
    Serial.print("Date:");
    Serial.print(now.year());
    Serial.print("/");
    Serial.print(now.month());
    Serial.print("/");
    Serial.print(now.day());
    Serial.print("|");
    Serial.print("Time:");
    Serial.print(now.hour());
    Serial.print(":");
    Serial.print(now.minute());
    Serial.print(":");
    Serial.print(now.second());
    Serial.println();
}

void loop()
{
    // Measure temperature every 5 seconds
    unsigned long currentMillis = millis();
    if (currentMillis - previousMillis >= interval)
    {
        previousMillis = currentMillis;
        curTempVal = getTemp();

        // Save data to EEPROM

        DateTime now = rtc.now();
        makeDataForEEPRom(now, curTempVal);

        if (needSendToPC)
        {
            sendToPC(curTempVal, now);
        }
    }

    // Get rtc time
    DateTime now = rtc.now();

    oled.clearDisplay();
    displayTitle();
    displayTemp(curTempVal);
    displayDateTime(now);

    // Read string from Serial
    while (Serial.available())
    {
        String command = Serial.readStringUntil('\n');
        if (command == "STOP")
        {
            needSendToPC = false;
        }
        else if (command == "RESUME")
        {
            needSendToPC = true;
        }
        else if (command == "MIN")
        {
            auto listData = getDataFromEEPRom();
            auto minData = min_element(listData.begin(), listData.end(), [](const DataStore &a, const DataStore &b)
                                       { return a.tempVal < b.tempVal && a.tempVal > 0 && b.tempVal > 0; });
            Serial.println("MIN: ");
            Serial.print(minData->datetime);
            Serial.print(" | ");
            Serial.println(minData->tempVal);
        }
        else if (command == "MAX")
        {
            auto listData = getDataFromEEPRom();
            auto maxData = max_element(listData.begin(), listData.end(), [](const DataStore &a, const DataStore &b)
                                       { return a.tempVal < b.tempVal; });
            Serial.println("MAX: ");
            Serial.print(maxData->datetime);
            Serial.print(" | ");
            Serial.println(maxData->tempVal);
        }
        else if (command = "RESET_ROM")
        {
            // clear eeprom
            for (int i = 0; i < 512; i++)
            {
                EEPROM.write(i, 0);
            }
            EEPROM.commit();
        }
    }
}