#include <EEPROM.h>
#include <DallasTemperature.h>
#include <OneWire.h>
#include <Thread.h>

#define SMOKE_PIN  2
#define FLAME_PIN  3
#define TEMPERATURE_PIN  4
#define BUTTON_PIN  5
#define LIGHT_PIN  11
#define RELAY_PIN  12

#define NO_DATA "-"
#define LONG_PRESS_BUTTON 2000
#define BLINK_DELAY 500

#define FLAME_ENABLED_POINTER   0
#define SMOKE_ENABLED_POINTER   1
#define TEMPERATURE_ENABLED_POINTER   2
#define TEMPERATURE_POINTER   3
#define DELAY_TIME_POINTER   5
#define ALARM_LEVEL_POINTER   7

#define MAX_DELAY   10000
#define MIN_ALARM_LEVEL 3
OneWire oneWire(TEMPERATURE_PIN);
DallasTemperature sensors(&oneWire);

bool flameEnabled;
bool smokeEnabled;
bool temperatureEnabled;
int maxTemperature;
int delayTime;
byte alarmLevel;

bool debuging;
bool alarm;
bool flame;
bool fire;
bool smoke;
bool temperatureHigh;
int currentAlarmLevel;
float currentTemperature;


void setup(void) {
  readConfig();
  setPinsMode();
  relayOff();
  sensors.begin();
}

void readConfig(void) {
  flameEnabled = EEPROM.read(FLAME_ENABLED_POINTER);
  smokeEnabled = EEPROM.read(SMOKE_ENABLED_POINTER);
  temperatureEnabled = EEPROM.read(TEMPERATURE_ENABLED_POINTER);
  maxTemperature = readInt(TEMPERATURE_POINTER);
  delayTime = readInt(DELAY_TIME_POINTER);
  if (delayTime > MAX_DELAY || delayTime < 0) {
    delayTime = MAX_DELAY;
    writeInt(DELAY_TIME_POINTER, delayTime);
  }
  alarmLevel = readInt(ALARM_LEVEL_POINTER);
  if (alarmLevel > MIN_ALARM_LEVEL || alarmLevel <= 0) {
    alarmLevel = 1;
    writeInt(ALARM_LEVEL_POINTER, alarmLevel);
  }
}

void setPinsMode(void) {
  pinMode(FLAME_PIN, INPUT );
  pinMode(SMOKE_PIN, INPUT );
  pinMode(RELAY_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT );
  pinMode(LIGHT_PIN, OUTPUT);
}

void loop(void) {

  isFire();
  if (fire) {
    alarmOn();
  }
  if (alarm) {
    if (digitalRead(BUTTON_PIN)) {
      alarmOff();
    }
  }
  if (digitalRead(BUTTON_PIN)) {
    unsigned long startPressing = millis();
    while (digitalRead(BUTTON_PIN)) {
      if ( millis() - startPressing >= LONG_PRESS_BUTTON) {
        debuging ? debugOff() : debugOn();
        lightBlink();
        break;
      }
    }
  }
  if (debuging) {
    debug();
  }
  delay (delayTime);
}

void lightBlink(void) {
  digitalToggle(LIGHT_PIN);
  delay (BLINK_DELAY);
  digitalToggle(LIGHT_PIN);

}
inline void digitalToggle(byte pin) {
  digitalWrite(pin, !digitalRead(pin));
}
void isFire(void) {
  isFlame();
  isSmoke();
  isTemperatureHigh();
  currentAlarmLevel = 0;
  if (flame) {
    currentAlarmLevel++;
  }
  if (smoke) {
    currentAlarmLevel++;
  }
  if (temperatureHigh) {
    currentAlarmLevel++;
  }
  fire = currentAlarmLevel >= alarmLevel;
}

void isFlame(void) {
  if (flameEnabled) {
    flame = digitalRead(FLAME_PIN) == LOW;
    return;
  }
  flame = true;
}

void isSmoke(void) {
  if (smokeEnabled) {
    smoke = digitalRead(SMOKE_PIN) == LOW;
    return;
  }
  smoke = true;
}

void isTemperatureHigh(void) {
  if (temperatureEnabled) {
    sensors.requestTemperatures();
    currentTemperature = sensors.getTempCByIndex(0);
    temperatureHigh = currentTemperature > maxTemperature;
    return;
  }
  temperatureHigh = true;
}

void relayOff() {
  digitalWrite(RELAY_PIN, HIGH);
}

void relayOn() {
  digitalWrite(RELAY_PIN, LOW);
}

void lightOn() {
  digitalWrite(LIGHT_PIN, HIGH);
}

void lightOff() {
  digitalWrite(LIGHT_PIN, LOW);
}

void alarmOn(void) {
  alarm = true;
  relayOn();
  lightOn();
}

void alarmOff(void) {
  alarm = false;
  relayOff();
  lightOff();
}

void debugOn(void) {
  debuging = true;
  Serial.begin(9600);
}

void debugOff(void) {
  debuging = false;
  Serial.end();
}

void debug(void) {
  writeData();
}

void writeData() {
  Serial.println("Config                 | State");

  Serial.print("(A)larm level:       ");
  Serial.print(alarmLevel);
  Serial.print(" | ");
  Serial.println(currentAlarmLevel);

  Serial.print("(F)lame alarm:       ");
  Serial.print(flameEnabled);
  Serial.print(" | ");
  if (flameEnabled) {
    Serial.println(flame);
  } else {
    Serial.println(NO_DATA);
  }

  Serial.print("(S)moke alarm:       ");
  Serial.print(smokeEnabled);
  Serial.print(" | ");
  if (smokeEnabled) {
    Serial.println(smoke);
  } else {
    Serial.println(NO_DATA);
  }

  Serial.print("(T)emperature alarm: ");
  Serial.print(temperatureEnabled);
  Serial.print(" | ");
  if (temperatureEnabled) {
    Serial.println(temperatureHigh);
  } else {
    Serial.println(NO_DATA);
  }

  Serial.print("(M)ax temperature:   ");
  Serial.print(maxTemperature);
  Serial.print(" | ");
  if (temperatureEnabled) {
    Serial.println(currentTemperature);
  } else {
    Serial.println(NO_DATA);
  }

  Serial.print("(D)elay time:        ");
  Serial.print(delayTime);
  Serial.print(" | ");
  Serial.println(NO_DATA);

  Serial.print("Fire alarm:          ");
  Serial.print(NO_DATA);
  Serial.print(" | ");
  Serial.println(alarm);

  Serial.println();
}

void serialEvent() {
  while (Serial.available() >= 3) {
    char key = Serial.read();
    int value = Serial.parseInt();
    switch (key) {
      case 'F':
        flameEnabled = value;
        EEPROM.write(FLAME_ENABLED_POINTER, flameEnabled);
        break;
      case 'S':
        smokeEnabled = value;
        EEPROM.write(SMOKE_ENABLED_POINTER, smokeEnabled);
        break;
      case 'T':
        temperatureEnabled = value;
        EEPROM.write(TEMPERATURE_ENABLED_POINTER, temperatureEnabled);
        break;
      case 'M':
        maxTemperature = value;
        writeInt(TEMPERATURE_POINTER, maxTemperature);
        break;
      case 'D':
        delayTime = value;
        writeInt(DELAY_TIME_POINTER, delayTime);
        break;
      case 'A':
        alarmLevel = value;
        writeInt(ALARM_LEVEL_POINTER, alarmLevel);
        break;
    }
  }
  Serial.readString();
}

int readInt(int addr) {
  byte raw[2];
  for (byte i = 0; i < 2; i++) raw[i] = EEPROM.read(addr + i);
  int &num = (int&)raw;
  return num;
}

void writeInt(int addr, int num) {
  byte raw[2];
  (int&)raw = num;
  for (byte i = 0; i < 2; i++) EEPROM.write(addr + i, raw[i]);
}