#include 
#include 
#include 
#include 

#define MY_NAME "MY_SMARTSWITCH"
#define TS_KEY "TODO_THINGSPEAK_KEY"
#define MQTT_SERVER "TODO_MQTT_HOSTNAME_OR_IP"
#define MQTT_PORT TODO_MQTT_PORT
#define MQTT_USER "TODO_MQTT_USER"
#define MQTT_PASS "TODO_MQTT_PASS"
#define MQTT_ROOT_TOPIC "/homebot/switches"
#define ESP_PIN 13
#define RELAY_PIN 15
#define SSID "TODO_WIFI_SSID"
#define WIFIPW "TODO_WIFI_PASSWORD"

/*******************************************************
 * Wifi switch class
 *******************************************************/

#define ESP_REFRESH_THRESH 2
#define MAX_BUFSZ 300
char g_buf[MAX_BUFSZ];
int g_wifiStatus = 0; // 0=disconnected, 1=connecting, 2=OK

int g_switchCommand = 0;
unsigned long g_switchCommandTime = 0;
MQTT *g_mqtt = NULL;

void wifiCb(void* response)
{
  uint32_t status;
  RESPONSE res(response);

  if (res.getArgc() != 1)
    return;

  res.popArgs((uint8_t*)&status, 4);
  if (status != STATION_GOT_IP) 
  {
    g_mqtt->disconnect();
    return;
  }
  
  Serial.println("WIFI CONNECTED");
  g_wifiStatus = 2;

  g_mqtt->connect(MQTT_SERVER, MQTT_PORT);
}

void mqttConnected(void* response)
{
  Serial.println("MQTT connected");
  sprintf(g_buf, "%s/%s/cmd", MQTT_ROOT_TOPIC, MY_NAME);
  g_mqtt->subscribe(g_buf); 
}
void mqttDisconnected(void* response) { }
void mqttData(void* response)
{
  if (timeStatus() == timeNotSet)
    return; // because we use now() below

  Serial.println("ARDUINO: recvd MQTT command...");
  RESPONSE res(response);

  String data = res.popString(); // topic
  Serial.println(data);

  data = res.popString(); // data
  Serial.println(data);

  g_switchCommandTime = now();
  if (data == "1")
    g_switchCommand = 1;
  else
    g_switchCommand = 0; // default to 'off'
}
void mqttPublished(void* response) { }

class WifiSwitch {
public:
  WifiSwitch() 
  : m_esp(&Serial1, &Serial, ESP_PIN),
    m_mqtt(&m_esp),
    m_lastESPrefresh(0), m_lastClockSync(0), m_lastDataUpload(0),
    m_espWorkerIdx(0), m_needToRefreshESP(0)
  {
    g_mqtt = &m_mqtt; // for callbacks
  }

  void setup() {
    pinMode(RELAY_PIN, OUTPUT);
    digitalWrite(RELAY_PIN, LOW); // disable relay
  }
  void loop() {
    /*******************************************
     * Do offline work
     *******************************************/

    /*******************************************
     * Do offline work that depends on Time
     *******************************************/

    if (timeStatus() != timeNotSet)
    {
      doCommand();
    }

    /*******************************************
     * Do online work
     *******************************************/

    if (refreshESP())
      return;

    m_esp.process();

    if (g_wifiStatus != 2)
      return; // can't do anything without wifi these days...

    if (m_espWorkerIdx == 0)
      syncClock();
    else if (m_espWorkerIdx == 1)
      uploadData();

    m_espWorkerIdx = (m_espWorkerIdx+1) % 2;
  }

  bool refreshESP() {
    if (!ESPneedsRefresh())
      return false;

    m_lastESPrefresh = millis();
    m_needToRefreshESP = 0;

    Serial.println("Reset ESP");
    g_wifiStatus = 1; // connecting

    m_mqtt.disconnect();

    m_esp.disable();
    delay(1000);
    m_esp.enable();
    delay(1000);
    m_esp.reset();
    delay(1000);

    int waitIter = 0;
    while (!m_esp.ready())
    {
      if (waitIter++ > 10)
      {
        // ESP failed to come up
        // -- force hardware refresh
        m_needToRefreshESP = ESP_REFRESH_THRESH;
        return true;
      }
      Serial.println("Waiting for ESP...");
    }

    setupMQTT();

    setupWifi();

    Serial.println("ARDUINO: system online");

    return true;
  }

  bool restGet(char *host, char *path, char *buf, int sz) {
    REST rest(&m_esp);

    if (!rest.begin(host)) {
      m_needToRefreshESP++;
      return false;
    }

    rest.get(path);

    memset(buf, 0, sz);

    if (rest.getResponse(buf, sz) != HTTP_STATUS_OK) {
      m_needToRefreshESP++;
      return false;
    }

    m_needToRefreshESP = 0;
    return true;
  }

  void uploadData() {
    if (!dataNeedsUpload())
      return;

    Serial.println("ARDUINO: upload to thingspeak...");

    m_lastDataUpload = millis();

    unsigned long uptimeMinutes = millis() / 1000 / 60;
    int ret = snprintf(g_buf, MAX_BUFSZ,
      "/update?key=%s&field1=%d&field2=%02d:%02d:%02d&field3=%d&field4=%lu",
      TS_KEY, weekday(), hour(), minute(), second(),
      g_switchCommand, uptimeMinutes
      );
    if (!(ret > 0 && ret < MAX_BUFSZ))
      return; 

    //Serial.println(g_buf);

    if (restGet("api.thingspeak.com", g_buf, g_buf, MAX_BUFSZ-1))
    {
      Serial.println("RESPONSE: ");
      Serial.println(g_buf);
    }
  }

  void setupWifi() {
    Serial.println("ARDUINO: setup wifi");
    m_esp.wifiCb.attach(&wifiCb);
    m_esp.wifiConnect(SSID, WIFIPW);
  }

  void setupMQTT() {
    Serial.println("ARDUINO: setup MQTT");
    if (!m_mqtt.begin(MY_NAME, MQTT_USER, MQTT_PASS, 120, 1))
      return; // failed to set up MQTT

    m_mqtt.lwt("/lwt", "offline", 0, 0);

    m_mqtt.connectedCb.attach(&mqttConnected);
    m_mqtt.disconnectedCb.attach(&mqttDisconnected);
    m_mqtt.publishedCb.attach(&mqttPublished);
    m_mqtt.dataCb.attach(&mqttData);
  }

  void syncClock() {
    if (!clockNeedsSync())
      return;

    Serial.println("ARDUINO: sync clock...");

    sprintf(g_buf, "%s", "/pdt/now.json?format=\\H%20\\M%20\\S%20\\d%20\\m%20\\y");
    //Serial.println(g_buf);

    if (!restGet("www.timeapi.org", g_buf, g_buf, MAX_BUFSZ-1))
      return;

    char *dateStr = strchr(g_buf, ':');
    if (dateStr == NULL)
      return;
    dateStr += 2;
    char *end = strchr(dateStr, '"');
    if (end == NULL)
      return;
    *end = '\0';

    Serial.println(dateStr);

    int H, M, S, d, m, y;
    int numRead = sscanf(dateStr, "%d %d %d %d %d %d", 
      &H, &M, &S, &d, &m, &y);
    if (numRead != 6)
      return;

    setTime(H, M, S, d, m, y);
    m_lastClockSync = millis();

    Serial.println("ARDUINO: clock synced!");
  }

  void doCommand() {
    unsigned long epochSecs = now();

    if (g_switchCommand == 1) 
      digitalWrite(RELAY_PIN, HIGH);
    else
      digitalWrite(RELAY_PIN, LOW);
  }

private:
  boolean clockNeedsSync() {
    if (timeStatus() == timeNotSet)
      return true;

    if (m_lastClockSync == 0)
      return true;

    if (millis() - m_lastClockSync > 900000) // 15 mins
      return true;

    return false;
  }

  boolean dataNeedsUpload() {
    if (m_lastDataUpload == 0)
      return true;

    // thingspeak only lets 1 update through every 15 seconds
    if (millis() - m_lastDataUpload > 16000)
      return true;

    return false;
  }

  boolean ESPneedsRefresh() {
    if (m_lastESPrefresh == 0)
      return true;

    if (millis() - m_lastESPrefresh < 30000) // 1 min
    {
      // don't refresh too often 
      return false;
    }

    if (m_needToRefreshESP >= ESP_REFRESH_THRESH)
      return true; // exceeded error thresh for refresh 

    if (g_wifiStatus != 2)
      return true; // couldn't connect wifi, reboot+retry

    return false;
  }

  ESP m_esp;
  MQTT m_mqtt;
  unsigned long m_lastDataUpload; // uses millis()
  unsigned long m_lastESPrefresh; // uses millis()
  unsigned long m_lastClockSync; // uses millis()
  int m_espWorkerIdx;
  int m_needToRefreshESP;
};

/*******************************************************
 * "Main"
 *******************************************************/

WifiSwitch mySwitch;

void setup() {
  Serial1.begin(19200); // don't change baud or...
  Serial.begin(19200);  // ... you'll get stuck 'Waiting for ESP'
  delay(10); // safety brick preventer
  mySwitch.setup();
}

void loop() {
  mySwitch.loop();
}