// Подключаем необходимые библиотеки:
// 1. Работа со временем
#include <TimeLib.h>
#include <TimeAlarms.h>
#include <DS3232RTC.h>
#include <Wire.h> // DS3232 работают по I2C/TWI протоколу (pins 20(SDA), 21(SCL))

// 2. Датчик влжности и температуры (DHT11) (pin 22)
#include <Wire.h>
#include "DHT.h"
#define DHTPIN 22
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

// 3. Датчики температоры по протоколу 1wire (pin 23)
#include <OneWire.h>
#include <DallasTemperature.h>
OneWire oneWire(23);
// !!! Хочу обратить внимание, что DallasTemperature конфликтует с DS3232RTC.h. Читай:
//https://github.com/JChristensen/DS3232RTC/pull/38
DallasTemperature dsSensors(&oneWire); // Класс для работы с датчиками температуры

// 4. Коммуникация с компьютером
#include <CmdMessenger.h>
CmdMessenger cmdMessenger = CmdMessenger(Serial);

// Экстренный режим (когда температура светильника выше чем заданое значение)
#define MaxLightTempepature 55
boolean EmergencyMode = false;
#define CriticalLightTempepature 50
boolean CriticalMode = false;

// ### Интервалы внутри дня
struct DayInterval {
  time_t schedule;
  OnTick_t callback;
};
DayInterval dayIntervals[10]; // Максимально может быть установлено 20 дневных интервалов (можно увеличить, но не больше 255!)
byte dayIntervalsLength = 0;

// ### История датчиков
// # Сохранить измерения каждые 6 мин. в массив размером 240 = 24 час истории
#define historyInterval AlarmHMS(0, 6, 0) // Каждые 6 мин
#define maxHistoryLength 240 // !!! Не устанавливать больше чем 255
struct Sensors {
  byte dayIntervalIndex;
  float boardTemperature;
  float lightTemperature;
  float boxTemperature;
  float boxHumidity;
  boolean emergencyMode;
  boolean criticalMode;
};
Sensors SensorsHistory[maxHistoryLength];
time_t lastSaveHistoryTime;
byte currentSensorsHistorySize = 0;

// ### Функции для работы с датчиками и историей
// # Считывает значения с датчиков и возвращает Sensors
Sensors readSensors() {
  Sensors info;

  info.dayIntervalIndex = currentDayIntervalIndex();
  info.boardTemperature = RTC.temperature() / 4.;
  info.lightTemperature = readLightTemp();
  info.boxTemperature = dht.readTemperature();
  info.boxHumidity = dht.readHumidity();
  info.emergencyMode = EmergencyMode;
  info.criticalMode = CriticalMode;

  return info;
}

#define MinTemp 0
float readLightTemp() {
  // Адреса датчиков температуры на радиаторе
  uint8_t lightSensorAddress1[8] = { 0x28, 0xFF, 0x78, 0x6D, 0xB4, 0x16, 0x03, 0x90 };
  uint8_t lightSensorAddress2[8] = { 0x28, 0xFF, 0xD6, 0x2B, 0x01, 0x17, 0x04, 0x26 };
 
  dsSensors.requestTemperatures();
 
  float temp1 = dsSensors.getTempC(lightSensorAddress1);
  float temp2 = dsSensors.getTempC(lightSensorAddress2);

  if (temp1 > MinTemp && temp2 > MinTemp) {
    return (temp1 + temp2) / 2.0;
  } else if (temp1 > MinTemp && temp2 < MinTemp) {
    return temp1;
  } else if (temp1 < MinTemp && temp2 > MinTemp) {
    return temp2;
  }else{
    return -127;
  }
}

// # Сохраняет измерение в первый елемент массива SensorsHistory
void saveSensorsMeasure() {
  byte lastIndex = currentSensorsHistorySize;
  if (currentSensorsHistorySize == maxHistoryLength) {
    lastIndex--;
  }

  // Сдвинуть все элементы на один вправо
  for(byte i = lastIndex; i > 0; i--) {
    SensorsHistory[i] = SensorsHistory[i-1];
  }
  // Вставляемые элемент идёт вначало
  SensorsHistory[0] = readSensors();
  lastSaveHistoryTime = now();
 
  if (currentSensorsHistorySize != maxHistoryLength) {
    currentSensorsHistorySize++;
  }
}
// # Выводит показания датчиков
void printSensorInfo(Sensors item) {
  Serial.print(" dayIntervalIndex: ");
  Serial.print(item.dayIntervalIndex);
  Serial.print(" boardTemperature: ");
  Serial.print(item.boardTemperature);
  Serial.print(" lightTemperature: ");
  Serial.print(item.lightTemperature);
  Serial.print(" boxTemperature: ");
  Serial.print(item.boxTemperature);
  Serial.print(" boxHumidity: ");
  Serial.print(item.boxHumidity);
  Serial.print(" emergencyMode: ");
  Serial.print(item.emergencyMode);
  Serial.print(" criticalMode: ");
  Serial.print(item.criticalMode);
}


// ### Функции для работы с времинем
// # Разница между двумя переменными времени (внутри дня!)
time_t timeDiffToday(time_t fromTime, time_t toTime) {
  time_t fromTimeInSecs = elapsedSecsToday(fromTime);
  time_t toTimeInSecs = elapsedSecsToday(toTime);

  // Если сравниваемое время меньше чем исходное, то это уже следующие сутки (+24часа)
  if (toTimeInSecs < fromTimeInSecs) {
    return SECS_PER_DAY + toTimeInSecs - fromTimeInSecs;
  } else {
    return toTimeInSecs - fromTimeInSecs;
  }
}
// # Вывести время на экран
void printDigits(int digits) {
  Serial.print(":");
  if (digits < 10)
    Serial.print('0');
  Serial.print(digits);
}
void printDateTime(time_t value) {
  Serial.print(day(value));
  Serial.print('.');
  Serial.print(month(value));
  Serial.print('.');
  Serial.print(year(value));
  Serial.print(' ');
 
  Serial.print(hour(value));
  printDigits(minute(value));
  printDigits(second(value));
}
void printlnDateTime(time_t value) {
  printDateTime(value);
  Serial.println();
}

// ### Функции для работы с дневными интервалами
// # Определение текущего интервала внутри дня
byte currentDayIntervalIndex() {
  time_t minTimeDiff = SECS_PER_DAY; // максимально возможное значение
  byte currentIndex;

  for(byte i = 0; i < dayIntervalsLength; i++) {
    time_t diff = timeDiffToday(now(), dayIntervals[i].schedule);

    // Поиск ближайшего дневного интервала
    if (diff < minTimeDiff) {
      minTimeDiff = diff;
      currentIndex = i;
    }
  }

  // В итоге нас интересует предыдущий интервал от найденного
  if (currentIndex == 0) {
    return dayIntervalsLength - 1;
  } else {
    return currentIndex - 1;
  }
}

void setupDayCallbacks() {
  for(byte i = 0; i < dayIntervalsLength; i++) {
    Alarm.alarmRepeat(dayIntervals[i].schedule, dayIntervals[i].callback);
  }
  // Запустить текуший дневной интервал
  startCurrentDayInterval();
}
void startCurrentDayInterval(){
  DayInterval interval = dayIntervals[currentDayIntervalIndex()];
  (*interval.callback)();
}

#define LIGHT_PIN 26
#define LIGHT_PWM 5

#define VENT_INPUT 6
#define LIGHT_FAN 7
#define VENT_OUTPUT 8
boolean showStatus = false;

void setup () {
  // Реле для света
  pinMode(LIGHT_PIN, OUTPUT);
  digitalWrite(LIGHT_PIN, HIGH);

  // ШИМ
  pinMode(VENT_INPUT, OUTPUT);
  pinMode(LIGHT_FAN, OUTPUT);
  pinMode(VENT_OUTPUT, OUTPUT);
  //timer 4 (controls pin 8, 7, 6)
  TCCR4B = TCCR4B & B11111000 | 0x01;

 
  Serial.begin(9600);
  cmdMessenger.printLfCr();   
  attachCommandCallbacks();

  dht.begin();
  dsSensors.begin();

  // Синхронизировать внутреннее время с часами DS3232
  setSyncProvider(RTC.get);

  if(timeStatus() != timeSet) {
    // В этом случае время будет установлено в 1.1.1970 00:00:00
    Serial.println("ОШИБКА! Не могу синхронизировать часы (может быть проблема с питанием или подключением)");
  } else {
    Serial.println("Время синхронизировано успешно!");     
  }

  // # Установить таймер
  // 1. Таймер для сохранения истории датчиков
  Alarm.timerRepeat(historyInterval, saveSensorsMeasure);

  // 2. Таймер для дневных интервалов
  dayIntervalsLength = 5;
  dayIntervals[0] = { AlarmHMS(17,0,0), modeEarlySunrise };
  dayIntervals[1] = { AlarmHMS(19,0,0), modeLateSunrise };
  dayIntervals[2] = { AlarmHMS(21,0,0), modeMorning };
  dayIntervals[3] = { AlarmHMS(7,0,0), modeBeforeNight };
  dayIntervals[4] = { AlarmHMS(9,0,0), modeNight };

  setupDayCallbacks();

  Alarm.timerRepeat(AlarmHMS(0,0,10), handleLightTemperature);
}

void loop () {
  cmdMessenger.feedinSerialData();

  if (showStatus) {
    printDateTime(now());
    Serial.print(" - ");
    printSensorInfo(readSensors());
    Serial.println();
  }

  Alarm.delay(1000); // wait one second between clock display
}

void handleLightTemperature() {
  float temp = readLightTemp();

  boolean newEmergencyMode = (temp <= 0 || temp >= MaxLightTempepature);
  boolean newCriticalMode = (temp >= CriticalLightTempepature);
  boolean needRestart = false;

  if (newEmergencyMode != EmergencyMode) {
    EmergencyMode = newEmergencyMode;
    needRestart = true;
  }

  if (newCriticalMode != CriticalMode) {
    CriticalMode = newCriticalMode;
    needRestart = true;
  }

  if (needRestart) startCurrentDayInterval();
}

// ### CmdMessenger комманды
enum {
  kHelp,
  kSetDateTime,
  kStatus,
  kLightPower,
  kFanSpeed,
  kPrintHistory,
};

void attachCommandCallbacks() {
  cmdMessenger.attach(OnUnknownCommand);
  cmdMessenger.attach(kHelp, OnHelp);
  cmdMessenger.attach(kSetDateTime, OnSetDateTime);
  cmdMessenger.attach(kStatus, OnStatus);
  cmdMessenger.attach(kLightPower, OnLightPower);
  cmdMessenger.attach(kFanSpeed, OnFanSpeed);
  cmdMessenger.attach(kPrintHistory, OnPrintHistory);

  ShowCommands();
}

void OnUnknownCommand() {
  Serial.println("Неизвестная комманда!");
  ShowCommands();
}

void OnHelp() {
  ShowCommands();
}

void ShowCommands() {
  Serial.println("Доступные комманды:");
  Serial.println(" 0;                                               - Выводит список доступных комманд");
  Serial.println(" 1,<год>,<месяц>,<день>,<час>,<минута>,<секунда>; - Установить системное дату и время");
  Serial.println(" 2;                                               - Выводит текущие показания датчиков");
  Serial.println(" 3,<яркость>;                                     - Установить яркость светильника (0 - 255)");
  Serial.println(" 4,<вентилятор>,<скорость>;                       - Установить скорость вентилятора (1 - вход, 2 - радиатор, 3 - выход) (0 - 255)");
  Serial.println(" 5;                                               - Экспортировать историю");
  Serial.println();
}

void OnSetDateTime() {
  time_t t;
  tmElements_t tm;

  tm.Year = CalendarYrToTm(cmdMessenger.readInt16Arg());
  tm.Month = cmdMessenger.readInt16Arg();
  tm.Day = cmdMessenger.readInt16Arg();
  tm.Hour = cmdMessenger.readInt16Arg();
  tm.Minute = cmdMessenger.readInt16Arg();
  tm.Second = cmdMessenger.readInt16Arg();
  t = makeTime(tm);

  // Перезаписать и пересинхронизировать внутреннее время с часами DS3232
  RTC.set(t);
  setTime(t);       

  Serial.print("Время успешно установлено в:");
  printlnDateTime(t);
}

void OnStatus() {
  showStatus = !showStatus;
}

void SetLightPower(int power) {
  if (CriticalMode) power = power / 2;
  if (EmergencyMode) power = 0;

  if (power > 0 && power < 256) {
    digitalWrite(LIGHT_PIN, LOW);
    analogWrite(LIGHT_PWM, power);
  } else {
    digitalWrite(LIGHT_PIN, HIGH);
    analogWrite(LIGHT_PWM, 0);
  }
  Serial.print("Яркость света установлена в:");
  Serial.println(power);
}
void OnLightPower() {
  SetLightPower(cmdMessenger.readInt16Arg());
}

void SetLightFanSpeed(byte fanSpeed) {
  analogWrite(LIGHT_FAN, fanSpeed);
  Serial.print("Скорость вертилятора света установлена в:");
  Serial.println(fanSpeed);
}
void SetFanSpeed(int fanIndex, int fanSpeed) {
  switch (fanIndex) {
    case 1: analogWrite(VENT_INPUT, fanSpeed); break;
    case 2: SetLightFanSpeed(fanSpeed); break;
    case 3: analogWrite(VENT_OUTPUT, fanSpeed); break;
    default: Serial.println("Неизвестный индекс вентилятора!");
  }
}
void OnFanSpeed() {
  int fanIndex = cmdMessenger.readInt16Arg();
  int fanSpeed = cmdMessenger.readInt16Arg();
 
  SetFanSpeed(fanIndex, fanSpeed);
}
void OnPrintHistory() {
  showStatus = false;

  Serial.println();
  Serial.println("\"Date time\", \"Mode index\", \"Board temperature\", \"Light temperature\", \"Box temperature\", \"Box humidity\", \"Emergency Mode\", \"Critical Mode\"");
  for (byte i = 0; i < currentSensorsHistorySize; i++) {
    time_t t = lastSaveHistoryTime - historyInterval * i;
    Sensors info =  SensorsHistory[i];

    printDateTime(t);
    Serial.print(",");
    Serial.print(info.dayIntervalIndex);
    Serial.print(",");
    Serial.print(info.boardTemperature);
    Serial.print(",");
    Serial.print(info.lightTemperature);
    Serial.print(",");
    Serial.print(info.boxTemperature);
    Serial.print(",");
    Serial.print(info.boxHumidity);
    Serial.print(",");
    Serial.print(info.emergencyMode);
    Serial.print(",");
    Serial.print(info.criticalMode);
    Serial.println();
  }
  Serial.println();
}

void modeEarlySunrise() {
  Serial.println("Режим: - Early Sunrise");
  SetLightPower(96);
  SetFanSpeed(1, 150);
  SetFanSpeed(2, 150);
  SetFanSpeed(3, 150);
}
void modeLateSunrise() {
  Serial.println("Режим: - Late Sunrise");
  SetLightPower(150);
  SetFanSpeed(1, 180);
  SetFanSpeed(2, 200);
  SetFanSpeed(3, 180);
}
void modeMorning() {
  Serial.println("Режим: - Morning");
  SetLightPower(255);
  SetFanSpeed(1, 255);
  SetFanSpeed(2, 255);
  SetFanSpeed(3, 255);
}
void modeBeforeNight() {
  Serial.println("Режим: - Before Night");
  SetLightPower(192);
  SetFanSpeed(1, 230);
  SetFanSpeed(2, 220);
  SetFanSpeed(3, 230);
}
void modeNight() {
  Serial.println("Режим: - Night");
  SetLightPower(0);
  SetFanSpeed(1, 100);
  SetFanSpeed(2, 0);
  SetFanSpeed(3, 100);
}