#include <LiquidCrystal_I2C.h>
#include <SimpleRotary.h>
#include <EEPROM.h>
#include <FastLED.h>
#include <msToString.h>
#include <RH_ASK.h>
#include <RHEncryptedDriver.h>
#include <Speck.h>
#include <AES.h>
#include <TcBUTTON.h>
#include <PZEM004T.h>

#include <ItemBool.h>
#include <ItemList.h>
#include <ItemRange.h>
#include <ItemCommand.h>
#include <ItemSubMenu.h>
#include <LcdMenu.h>
#include <MenuScreen.h>
#include <display/LiquidCrystal_I2CAdapter.h>
#include <input/KeyboardAdapter.h>
#include <renderer/CharacterDisplayRenderer.h>

CRGB wsled[1];

#define PIN_SEND 2
#define PIN_RECEIVE 3
#define SENSORID 103
#define PIN_LED 7
#define PIN_RELAY 8
#define PIN_SWITCH 6
#define PIN_ENCODER_A 9
#define PIN_ENCODER_B 10
#define PIN_ENCODER_SW 11

const uint8_t encryptKey[16] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10 };

Speck cipher;
//AES128 cipher;

RH_ASK radio(2000, PIN_RECEIVE, PIN_SEND, -1, false);

RHEncryptedDriver driver (radio, cipher);

LiquidCrystal_I2C lcd(0x27,20,4);  // set the LCD address to 0x27 for a 16 chars and 2 line display
CharacterDisplayRenderer renderer(new LiquidCrystal_I2CAdapter(&lcd), 20, 4, 0x7E, 0x7F);
LcdMenu menu(renderer);
KeyboardAdapter keyboard(&menu, &Serial);

TcBUTTON button(PIN_SWITCH);
TcBUTTON encbutton(PIN_ENCODER_SW);

SimpleRotary encoder(PIN_ENCODER_A, PIN_ENCODER_B, PIN_ENCODER_SW);

//#define PZEM_004T
PZEM004T pzem(Serial1);

uint32_t lastrefreshdisp;
uint32_t lasttransmit;

char S[10];

struct config_t {
  uint8_t initok;
  bool state;
  bool pstate;
  uint16_t lcdsleep;
  bool transmit_enabled;
  uint16_t transmitinterval;
  uint16_t tempm;
  uint16_t tempp;
  bool wattm_enabled;
  bool wattp_enabled;
  uint16_t wattm;
  uint16_t wattp;
  uint32_t counter_all;
  uint32_t counter_used;
};

struct mmss_t {
  uint16_t minute;
  uint16_t second;
};
struct hhmm_t {
  uint16_t hour;
  uint16_t minute;
};

struct conftemp_t {
  bool tempm_enabled;
  bool tempp_enabled;
  uint32_t tempm;
  uint32_t tempp;
};

struct measure_t {
  uint16_t count;
  uint16_t voltage;
  uint32_t current;
  uint32_t power;
  uint32_t energy;
  uint16_t pf;
};

uint8_t rh_payload[17];

struct mmss_t lcdsleep;
struct mmss_t transmitinterval;

struct hhmm_t tempm;
struct hhmm_t tempp;

uint32_t counter;

struct conftemp_t conftemp;

struct measure_t measure_lcd;
struct measure_t measure_t433;

bool measure_lcd_reset;
bool measure_t433_reset;
bool measure_kwh_reset;

struct config_t config;
bool ledblinkstate;

bool menu_state;
bool lcdsleep_state;
uint32_t lastbuttonactivity;
 
void load_config();
void init_config(bool firststart);
void save_config();
void reset_time();
void reset_watt();
void reset_all();
void exit_menu();
void PowerOff();
void PowerOn();
void refresh_display();
void refresh_values();
void refresh_counters();
void refresh_confdisplay();

MENU_SCREEN(actionsScreen, actionsItems,
    ITEM_BOOL_REF("Etat persist", config.pstate, "Oui", "Non", [](const Ref<bool> value) { config.pstate = value; save_config(); }, "%s"),
    ITEM_BOOL_REF("T433", config.transmit_enabled, "Oui", "Non", [](const Ref<bool> value) { config.transmit_enabled = value; save_config(); }, "%s"),
    ITEM_BOOL_REF("Watt-", config.wattm_enabled, "Oui", "Non", [](const Ref<bool> value) { config.wattm_enabled = value; save_config(); }, "%s"),
    ITEM_BOOL_REF("Watt+", config.wattp_enabled, "Oui", "Non", [](const Ref<bool> value) { config.wattp_enabled = value; save_config(); }, "%s"),
    ITEM_BOOL_REF("Tempo avant(-)", conftemp.tempm_enabled, "Oui", "Non", [](const Ref<bool> value) { conftemp.tempm_enabled = value; conftemp.tempm = config.tempm*60; if(value) { PowerOff(); } }, "%s"),
    ITEM_BOOL_REF("Tempo apres(+)", conftemp.tempp_enabled, "Oui", "Non", [](const Ref<bool> value) { conftemp.tempp_enabled = value; conftemp.tempp = config.tempp*60; }, "%s"));
MENU_SCREEN(settingsScreen, settingsItems,
    ITEM_RANGE_REF<uint16_t>("Watt-", config.wattm, 1, 10, 3670, [](const Ref<uint16_t> value) { config.wattm = value; save_config(); }, "%04dW"),
    ITEM_RANGE_REF<uint16_t>("Watt+", config.wattp, 1, 20, 3680, [](const Ref<uint16_t> value) { config.wattp = value; save_config(); }, "%04dW"),
    ITEM_WIDGET(
    "Ecran(mm:ss)",
    [](const Ref<uint16_t> minute, const Ref<uint16_t> second) { config.lcdsleep = minute*60+second; save_config(); },
    WIDGET_RANGE_REF<uint16_t>(lcdsleep.minute, 1, 0, 59, "%02d", 0, false),
    WIDGET_RANGE_REF<uint16_t>(lcdsleep.second, 1, 0, 59, ":%02d", 0, false)),
    ITEM_WIDGET(
    "T433(mm:ss)",
    [](const Ref<uint16_t> minute, const Ref<uint16_t> second) { config.transmitinterval = minute*60+second; save_config(); },
    WIDGET_RANGE_REF<uint16_t>(transmitinterval.minute, 1, 0, 4, "%02d", 0, false),
    WIDGET_RANGE_REF<uint16_t>(transmitinterval.second, 1, 0, 59, ":%02d", 0, false)),
    ITEM_WIDGET(
    "Temp-(hh:mm)",
    [](const Ref<uint16_t> hour, const Ref<uint16_t> minute) { config.tempm = hour*60+minute; save_config(); },
    WIDGET_RANGE_REF<uint16_t>(tempm.hour, 1, 0, 23, "%02d", 0, false),
    WIDGET_RANGE_REF<uint16_t>(tempm.minute, 1, 0, 59, ":%02d", 0, false)),
    ITEM_WIDGET(
    "Temp+(hh:mm)",
    [](const Ref<uint16_t> hour, const Ref<uint16_t> minute) { config.tempp = hour*60+minute; save_config(); },
    WIDGET_RANGE_REF<uint16_t>(tempp.hour, 1, 0, 23, "%02d", 0, false),
    WIDGET_RANGE_REF<uint16_t>(tempp.minute, 1, 0, 59, ":%02d", 0, false)));
MENU_SCREEN(resetScreen, resetItems,
    ITEM_COMMAND("Reset temps+kWh", []() { reset_all(); }),
    ITEM_COMMAND("Reset temps", []() { reset_time(); }),
    ITEM_COMMAND("Reset kWh", []() { reset_watt(); }),
    ITEM_COMMAND("Reset conf. usine", []() { init_config(false); })
    );
MENU_SCREEN(mainScreen, mainItems,
    ITEM_SUBMENU("Actions", actionsScreen),
    ITEM_SUBMENU("Reglages", settingsScreen),
    ITEM_SUBMENU("Reset", resetScreen),
    ITEM_COMMAND("Sortir du menu", []() { exit_menu(); }));

void exit_menu() {
  lastbuttonactivity=millis();
  menu_state=false;
  save_config();
  menu.hide();
  refresh_display();
  refresh_counters();
  refresh_confdisplay();
}

void save_config() {
  EEPROM.put(0, config);
  EEPROM.commit();
}

void init_config(bool firststart) {
  config.initok = 42;
  config.state = false;
  config.pstate = false;
  config.lcdsleep = 60;
  config.transmit_enabled = true;
  config.transmitinterval = 15;
  config.wattm_enabled = false;
  config.wattp_enabled = false;
  config.wattm = 100;
  config.wattp = 2000;
  config.tempm = 60;
  config.tempp = 720;
  if(firststart) {
    config.counter_all = 0;
    config.counter_used = 0;
  }
  save_config();
  load_config();
}

void load_config() {
  EEPROM.get(0, config);
  lcdsleep.minute = config.lcdsleep / 60;
  lcdsleep.second = config.lcdsleep % 60;
  transmitinterval.minute = config.transmitinterval / 60;
  transmitinterval.second = config.transmitinterval % 60;
  tempm.hour = config.tempm / 60;
  tempm.minute = config.tempm % 60;
  tempp.hour = config.tempp / 60;
  tempp.minute = config.tempp % 60;
}

void reset_time() {
  config.counter_all=0;
  config.counter_used=0;
}
void reset_watt() {
  measure_kwh_reset = true;
}
void reset_all() {
  reset_time();
  reset_watt();
}

void clear_lcd_temp() {
  if(menu_state == false) {
    lcd.setCursor(3, 3);
    lcd.print("         ");
  }
}

void PowerOn() {
  config.state=true;
  conftemp.tempm_enabled = false;
  clear_lcd_temp();
  refresh_confdisplay();
  save_config();
  digitalWrite(PIN_LED, HIGH);
  digitalWrite(PIN_RELAY, HIGH);
}

void PowerOff() {
  config.state=false;
  conftemp.tempp_enabled = false;
  clear_lcd_temp();
  refresh_confdisplay();
  measure_lcd_reset = true;
  measure_t433_reset = true;
  save_config();
  digitalWrite(PIN_LED, LOW);
  digitalWrite(PIN_RELAY, LOW);
}

char* create_value(uint32_t value, char *ret, String unit, uint8_t factor, uint8_t factor2, uint8_t maxchar) {
  char valuestr[10];
  ret[0]='\0';
  dtostrf(value/pow(10,factor2), maxchar, factor, valuestr);
  if(strlen(valuestr) < maxchar) {
    for(int i=0;i<maxchar-strlen(valuestr);i++) {
      ret[i]=' ';
    }
  }
  ret[maxchar-strlen(valuestr)]='\0';
  strcat(ret, valuestr);
  strcat(ret, unit.c_str());
  return ret;
}

void refresh_values() {
 char retval[15];
 //Serial.println(create_value(measure_lcd.voltage, retval, "V", 1, 5));
 create_value(measure_lcd.voltage+counter*10, retval, "V", 1, 1, 5);
 lcd.setCursor(2, 0);
 lcd.print(retval);
 create_value(measure_lcd.current, retval, "A", 2, 2, 5);
 lcd.setCursor(11, 0);
 lcd.print(retval);
 create_value(measure_lcd.power, retval, "W", 0, 1, 4);
 lcd.setCursor(0, 1);
 lcd.print(retval);
 create_value(measure_lcd.pf, retval, "%", 0, 0, 3);
 lcd.setCursor(7, 1);
 lcd.print(retval);
 create_value(measure_lcd.energy, retval, "kWh", 1, 3, 5);
 lcd.setCursor(12, 1);
 lcd.print(retval);
 measure_lcd_reset = true;
}

void refresh_temp()
{
  if(conftemp.tempp_enabled == true && config.state == true) {
    lcd.setCursor(3, 3);
    lcd.print('+');
    lcd.setCursor(4, 3);
    lcd.print(msToString(conftemp.tempp*1000, S, sizeof(S), true, true, true, 2));
  }
  if(conftemp.tempm_enabled == true && config.state == false) {
    lcd.setCursor(3, 3);
    lcd.print('-');
    lcd.setCursor(4, 3);
    lcd.print(msToString(conftemp.tempm*1000, S, sizeof(S), true, true, true, 2));
  }
}

void refresh_counters()
{
  if(config.state) {
    config.counter_all++;
  }
  lcd.setCursor(1, 2);
  lcd.print(msToString(config.counter_all*1000, S, sizeof(S), true, true, true, 2));
  lcd.setCursor(11, 2);
  lcd.print(msToString(config.counter_used*1000, S, sizeof(S), true, true, true, 2));
}

void refresh_display()
{
  //Serial.print("Hello World!!! ");
  //Serial.print(msToString(counter*1000, S, sizeof(S), true, true, true, 2));
  counter++;
  //Serial.print(" ");
  //Serial.println(millis());
  //lcd.setCursor(3,0);
  //lcd.print("Hello, world!");
  if(conftemp.tempm_enabled == true && config.state == false) {
    if(conftemp.tempm > 0) {
      conftemp.tempm--;
    } else {
      conftemp.tempm = config.tempm*60;
      PowerOn();
    }
  }
  if(conftemp.tempp_enabled == true && config.state == true) {
    if(conftemp.tempp > 0) {
      conftemp.tempp--;
    } else {
      conftemp.tempp = config.tempp*60;
      PowerOff();
    }
  }
  if(menu_state == false) {
    refresh_values();
    refresh_temp();
    if(config.state) { refresh_counters(); }
  }
}

char confdisplay_char(char c, bool b) {
  return b?c:'-';
}

void refresh_confdisplay() {
  if(menu_state == false) {
    char confdisplay[5];
    sprintf(confdisplay, "%c%c%c%c%c", confdisplay_char('w', config.wattm_enabled), confdisplay_char('W', config.wattp_enabled), confdisplay_char('t', conftemp.tempm_enabled), confdisplay_char('T', conftemp.tempp_enabled), confdisplay_char('X', config.transmit_enabled));
    lcd.setCursor(15, 3);
    lcd.print(confdisplay);
  }
}

void blink() {
  wsled[0] = CRGB::Red; FastLED.show();
  delay(100);
  wsled[0] = CRGB::Black; FastLED.show();
}

void setSensorType(uint8_t stype)
{
  uint8_t payload0; 
  payload0 = stype << 4;
  rh_payload[0] &= 0b00001111;
  rh_payload[0] += payload0;
}

void printHex(uint8_t num) {
  char hexCar[2];

  sprintf(hexCar, "%02X", num);
  Serial.print(hexCar);
}

void transmit() {
  Serial.println("Transmit");
  //blink();

  if(config.state == true) {
    rh_payload[0] |= 0b00000001;
  } else {
    rh_payload[0] &= 0b11111110;
  }
  rh_payload[1] = measure_t433.voltage >> 8;
  rh_payload[2] = measure_t433.voltage;
  rh_payload[3] = measure_t433.current >> 24;
  rh_payload[4] = measure_t433.current >> 16;
  rh_payload[5] = measure_t433.current >> 8;
  rh_payload[6] = measure_t433.current;
  rh_payload[7] = measure_t433.power >> 24;
  rh_payload[8] = measure_t433.power >> 16;
  rh_payload[9] = measure_t433.power >> 8;
  rh_payload[10] = measure_t433.power;
  rh_payload[11] = measure_t433.energy >> 24;
  rh_payload[12] = measure_t433.energy >> 16;
  rh_payload[13] = measure_t433.energy >> 8;
  rh_payload[14] = measure_t433.energy;
  rh_payload[15] = measure_t433.pf >> 8;
  rh_payload[16] = measure_t433.pf;

  measure_t433_reset = true;

  Serial.print("Hex RH Payload: ");
  for(int i=0;i<17;i++) {
    printHex(rh_payload[i]);
  }
  Serial.println();

  driver.send(rh_payload, 17);
  driver.waitPacketSent();
}

void onHoldButton() {
  Serial.println("Button Held for 2 seconds!");
  if(lcdsleep_state == false) {
    lastbuttonactivity=millis();
  } else {
    reset_all();
  }
}

void onPressButton() {
  lastbuttonactivity=millis();
  if(lcdsleep_state) {
    lcd.backlight();
    lcd.display();
  } else {
    //Power
  }
}

void onPressEncButton() {
  lastbuttonactivity=millis();
  if(lcdsleep_state) {
    lcd.backlight();
    lcd.display();
  } else {
    menu_state = true;
    menu.show();
  }
}

void setup()
{
  pinMode(PIN_LED, OUTPUT_12MA);
  digitalWrite(PIN_LED, LOW);
  pinMode(PIN_RELAY, OUTPUT_12MA);
  digitalWrite(PIN_RELAY, LOW);
  Serial.begin();
  FastLED.addLeds<WS2812, 16, GRB>(wsled, 1);
  EEPROM.begin(256);
  delay(500);
  if (!driver.init()) { Serial.println("RH init failed"); }
  driver.setHeaderId(SENSORID);
  cipher.setKey(encryptKey, sizeof(encryptKey));
  setSensorType(3);
  load_config();
  conftemp.tempm_enabled = false;
  conftemp.tempp_enabled = false;
  conftemp.tempm = config.tempm*60;
  conftemp.tempp = config.tempp*60;
  measure_lcd.count=0;
  measure_lcd.voltage=2305;
  measure_lcd.current=1023;
  measure_lcd.power=14567;
  measure_lcd.energy=19876;
  measure_lcd.pf=5;
  measure_t433.count=0;
  measure_t433.voltage=2305;
  measure_t433.current=1023;
  measure_t433.power=14567;
  measure_t433.energy=19876;
  measure_t433.pf=5;
  if(config.initok != 42) { init_config(true); }
  //init_config(true);
  lcd.init();                      // initialize the lcd 

  button.setOnHold(onHoldButton, 2000);
  button.setOnPress(onPressButton);
  encbutton.setOnPress(onPressEncButton);

  config.state=true;

  renderer.begin();
  menu.setScreen(mainScreen);
  menu_state = true;
  //menu.hide();

  //init_config();
  //save_config();
  load_config();
  if(config.pstate == true && config.state == true) {
    PowerOn();
  } else if(config.pstate == false) {
    config.state=false;
    save_config();
  }
  refresh_confdisplay();

  lastrefreshdisp = millis();
  if(menu_state == false) {
    refresh_display();
    refresh_counters();
  }
  lcd.backlight();

  transmit();

}

void setup1() {
  pzem.begin();
}

bool timer_ok(uint32_t lastmillis, uint16_t seconds)
{
  if(millis() < lastmillis)
  {
    return UINT16_MAX-lastmillis+millis() > seconds*1000;
    Serial.println("millis reset");
  } else {
    return millis() > lastmillis+seconds*1000;
  }
}

void loop() {
 if(timer_ok(lastrefreshdisp, 1)) {
  lastrefreshdisp = millis();
  //blink();
  refresh_display();
 }
 if(conftemp.tempm_enabled) {
   if(millis() % 1000 > 500) {
    if(ledblinkstate == false) { ledblinkstate = true; wsled[0] = CRGB::Red; FastLED.show(); }
    //Serial.println("On");
   } else {
    if(ledblinkstate) { ledblinkstate = false; wsled[0] = CRGB::Black; FastLED.show(); }
    //Serial.println("Off");
   }
 }
 if(menu_state == true)
 { 
   menu.poll(1000);
   keyboard.observe();
 } else {
   button.update();
   encbutton.update();
   if(lcdsleep_state == false && timer_ok(lastbuttonactivity, config.lcdsleep)) {
     lcdsleep_state = true;
     lcd.noBacklight();
     lcd.noDisplay();
   }
 }
 if(((config.transmit_enabled == false || config.state == false) && timer_ok(lasttransmit, 30)) || (config.state == true && config.transmit_enabled == true && timer_ok(lasttransmit, config.transmitinterval))) {
   lasttransmit = millis();
   transmit();
 }
}

void add_value_measure_16(uint16_t value, uint16_t count, uint16_t *average) {
  *average = *average + ((value + *average) / count);
}

void add_value_measure_32(uint32_t value, uint16_t count, uint32_t *average) {
  *average = *average + ((value + *average) / count);
}

void loop1() {
/*
  uint16_t voltage, frequency, powerFactor;
  uint32_t current, power, energy;

  if(measure_kwh_reset == true) {
    pzem.resetEnergy();
    measure_kwh_reset = false;
  }

  if(pzem.readAllRaw(&voltage, &current, &power, &energy, &frequency, &powerFactor))
  {

    if(measure_t433_reset == true) {
      measure_t433.count = 0;
      measure_t433.voltage = 0;
      measure_t433.current = 0;
      measure_t433.power = 0;
      measure_t433.energy = 0;
      measure_t433.pf = 0;
      measure_t433_reset = false;
    }

    if(measure_lcd_reset == true) {
      measure_lcd.count = 0;
      measure_lcd.voltage = 0;
      measure_lcd.current = 0;
      measure_lcd.power = 0;
      measure_lcd.energy = 0;
      measure_lcd.pf = 0;
      measure_lcd_reset = false;
    }
  

    measure_t433.count++;
    add_value_measure_16(voltage, measure_t433.count, &(measure_t433.voltage));
    add_value_measure_32(current, measure_t433.count, &(measure_t433.current));
    add_value_measure_32(power, measure_t433.count, &(measure_t433.power));
    measure_t433.energy = energy;
    add_value_measure_16(powerFactor, measure_t433.count, &(measure_t433.pf));

    measure_lcd.count++;
    add_value_measure_16(voltage, measure_lcd.count, &(measure_lcd.voltage));
    add_value_measure_32(current, measure_lcd.count, &(measure_lcd.current));
    add_value_measure_32(power, measure_lcd.count, &(measure_lcd.power));
    measure_lcd.energy = energy;
    add_value_measure_16(powerFactor, measure_lcd.count, &(measure_lcd.pf));
  }
*/
  delay(1000);
}