#include <main.hpp>
/************************************************
 *              Global Variables                *
 ************************************************/
ESPMegaPRO espmega = ESPMegaPRO();
ESPMegaDisplayOTA internalDisplayOTA = ESPMegaDisplayOTA();
Button rightOnButton(&espmega.inputs, RIGHT_ON_BUTTON_PIN);
Button rightOffButton(&espmega.inputs, RIGHT_OFF_BUTTON_PIN, true);
Button leftOnButton(&espmega.inputs, LEFT_ON_BUTTON_PIN);
Button leftOffButton(&espmega.inputs, LEFT_OFF_BUTTON_PIN, true);
SmartVariable toiletLightsLock;
SmartVariable gymLightsLock;

/************************************************
 *            End of Global Variables           *
 ************************************************/

void setup()
{
  // Initialize both displayports
  INTERNAL_DISPLAY_UART.begin(INTERNAL_DISPLAY_BAUDRATE);
  ESP_LOGI("CUD IoT OS", "Starting Initialization");
  send_stop_bytes(INTERNAL_DISPLAY_UART);
  INTERNAL_DISPLAY_UART.print("rest");
  send_stop_bytes(INTERNAL_DISPLAY_UART);
  // Wait for the display to reset
  vTaskDelay(1000 / portTICK_PERIOD_MS);
  // Initialize the ESPMegaPRO
  ESP_LOGV("CUD IoT OS", "Initializing ESPMegaPRO");
  espmega.begin();
  // Initialize Inputs
  espmega.inputs.preloadInputBuffer();
  espmega.inputs.setDebounceTime(RIGHT_STADIUM_LIGHT_SWITCH_PIN, SWITCH_DEBOUNCE_TIME_MS);
  espmega.inputs.setDebounceTime(LEFT_STADIUM_LIGHT_SWITCH_PIN, SWITCH_DEBOUNCE_TIME_MS);
  espmega.inputs.setDebounceTime(GIRLS_TOILET_LIGHT_SWITCH_PIN, SWITCH_DEBOUNCE_TIME_MS);
  espmega.inputs.setDebounceTime(BOYS_TOILET_LIGHT_SWITCH_PIN, SWITCH_DEBOUNCE_TIME_MS);
  // Initialize Outputs
  for (uint8_t i = 0; i < 16; i++)
  {
    // Digital Pin Mode
    espmega.outputs.setValue(i, 4095);
  }
  // Initialize IoT Modules
  ESP_LOGV("CUD IoT OS", "Initializing IoT Modules");
  espmega.setTimezone("ICT-7");
  espmega.enableIotModule();
  // Setup Ethernet
  ESP_LOGV("CUD IoT OS", "Initializing Ethernet");
  ETH.begin();
  ESP_LOGD("CUD IoT OS", "Binding Ethernet Interface");
  espmega.iot->bindEthernetInterface(&ETH);
  // Connect to Network
  ESP_LOGV("CUD IoT OS", "Connecting to Network");
  espmega.iot->loadNetworkConfig();
  espmega.iot->connectNetwork();
  // Connect to the MQTT Broker
  ESP_LOGV("CUD IoT OS", "Connecting to MQTT Broker");
  espmega.iot->loadMqttConfig();
  vTaskDelay(3000 / portTICK_PERIOD_MS); // Wait for the network to stabilize
  espmega.iot->connectToMqtt();
  // Enable Web Server
  ESP_LOGV("CUD IoT OS", "Enabling Web Server");
  espmega.enableWebServer(80);
  // Initialize Internal Display
  ESP_LOGV("CUD IoT OS", "Initializing Internal Display");
  espmega.enableInternalDisplay(&INTERNAL_DISPLAY_UART);
  // Register all cards with iot
  ESP_LOGV("CUD IoT OS", "Registering Cards with IoT");
  espmega.iot->registerCard(0);
  espmega.iot->registerCard(1);
  // Input callbacks
  // This pre-load the input buffers
  // We need to do this to prevent switches that are left on the "on" position from triggering the callback
  espmega.inputs.registerCallback(handle_input_change);
  espmega.iot->registerMqttCallback(handle_mqtt_message);
  internalDisplayOTA.begin("/intdisp", espmega.display, espmega.webServer);
  button_init();
  smartvar_init();
  ESP_LOGI("CUD IoT OS", "Initialization Complete");
}

void smartvar_init() {
  // Initialize Smart Variables
  ESP_LOGV("CUD IoT OS", "Initializing Smart Variables");
  toiletLightsLock.begin(5);
  toiletLightsLock.bindFRAM(&espmega.fram, 10000);
  toiletLightsLock.setValueAutoSave(true);
  // Construct the topic
  char* toilet_lock_topic = (char*)malloc(strlen(TOPIC_TOILET_LIGHT_LOCK) + strlen(espmega.iot->getMqttConfig()->base_topic) + 5);
  sprintf(toilet_lock_topic, "%s%s", espmega.iot->getMqttConfig()->base_topic, TOPIC_TOILET_LIGHT_LOCK);
  char* toilet_lock_set_topic = (char*)malloc(strlen(TOPIC_TOILET_LIGHT_LOCK) + strlen(espmega.iot->getMqttConfig()->base_topic) + 15);
  sprintf(toilet_lock_set_topic, "%s%s/set", espmega.iot->getMqttConfig()->base_topic, TOPIC_TOILET_LIGHT_LOCK);
  char* toilet_lock_request_topic = (char*)malloc(strlen(TOPIC_TOILET_LIGHT_LOCK) + strlen(espmega.iot->getMqttConfig()->base_topic) + 15);
  sprintf(toilet_lock_request_topic, "%s%s/request", espmega.iot->getMqttConfig()->base_topic, TOPIC_TOILET_LIGHT_LOCK);
  toiletLightsLock.enableIoT(espmega.iot, toilet_lock_topic);
  toiletLightsLock.enableSetValue(toilet_lock_set_topic);
  toiletLightsLock.enableValueRequest(toilet_lock_request_topic);

  gymLightsLock.begin(5);
  gymLightsLock.bindFRAM(&espmega.fram, 10010);
  gymLightsLock.setValueAutoSave(true);
  // Construct the topic
  char* gym_lock_topic = (char*)malloc(strlen(TOPIC_GYM_LIGHT_LOCK) + strlen(espmega.iot->getMqttConfig()->base_topic) + 5);
  sprintf(gym_lock_topic, "%s%s", espmega.iot->getMqttConfig()->base_topic, TOPIC_GYM_LIGHT_LOCK);
  char* gym_lock_set_topic = (char*)malloc(strlen(TOPIC_GYM_LIGHT_LOCK) + strlen(espmega.iot->getMqttConfig()->base_topic) + 15);
  sprintf(gym_lock_set_topic, "%s%s/set", espmega.iot->getMqttConfig()->base_topic, TOPIC_GYM_LIGHT_LOCK);
  char* gym_lock_request_topic = (char*)malloc(strlen(TOPIC_GYM_LIGHT_LOCK) + strlen(espmega.iot->getMqttConfig()->base_topic) + 15);
  sprintf(gym_lock_request_topic, "%s%s/request", espmega.iot->getMqttConfig()->base_topic, TOPIC_GYM_LIGHT_LOCK);
  gymLightsLock.enableIoT(espmega.iot, gym_lock_topic);
  gymLightsLock.enableSetValue(gym_lock_set_topic);
  gymLightsLock.enableValueRequest(gym_lock_request_topic);
}

void button_init()
{
  // Initialize buttons

  // Right On Button
  rightOnButton.setMinShortPressTime(BUTTON_SHORT_PRESS_TIME_MS);
  rightOnButton.setMinLongPressTime(BUTTON_LONG_PRESS_TIME_MS);
  rightOnButton.setShortPressCallback([]()
                                      { 
                                        if (get_gym_light_lock())
                                          return;
                                        // Turn on right light
                                        espmega.outputs.setState(RIGHT_LIGHT_RELAY_PIN, HIGH); });
  rightOnButton.setLongPressCallback([]()
                                     { 
                                      if (get_gym_light_lock())
                                        return;
                                        // Turn on both lights
                                        espmega.outputs.setState(RIGHT_LIGHT_RELAY_PIN, HIGH);
                                        espmega.outputs.setState(LEFT_LIGHT_RELAY_PIN, HIGH); });
  rightOnButton.begin();

  // Right Off Button
  rightOffButton.setMinShortPressTime(BUTTON_SHORT_PRESS_TIME_MS);
  rightOffButton.setMinLongPressTime(BUTTON_LONG_PRESS_TIME_MS);
  rightOffButton.setShortPressCallback([]()
                                       { 
                                        if (get_gym_light_lock())
                                          return;
                                        // Turn off right light
                                        espmega.outputs.setState(RIGHT_LIGHT_RELAY_PIN, LOW); });
  rightOffButton.setLongPressCallback([]()
                                      { 
                                        if (get_gym_light_lock())
                                          return;
                                        // Turn off both lights
                                        espmega.outputs.setState(RIGHT_LIGHT_RELAY_PIN, LOW);
                                        espmega.outputs.setState(LEFT_LIGHT_RELAY_PIN, LOW); });
  rightOffButton.begin();

  // Left On Button
  leftOnButton.setMinShortPressTime(BUTTON_SHORT_PRESS_TIME_MS);
  leftOnButton.setMinLongPressTime(BUTTON_LONG_PRESS_TIME_MS);
  leftOnButton.setShortPressCallback([]()
                                     { 
                                      if (get_gym_light_lock())
                                        return;
                                        // Turn on left light
                                        espmega.outputs.setState(LEFT_LIGHT_RELAY_PIN, HIGH); });
  leftOnButton.setLongPressCallback([]()
                                    { 
                                      if (get_gym_light_lock())
                                        return;
                                      // Turn on both lights
                                      espmega.outputs.setState(RIGHT_LIGHT_RELAY_PIN, HIGH);
                                      espmega.outputs.setState(LEFT_LIGHT_RELAY_PIN, HIGH); });
  leftOnButton.begin();

  // Left Off Button
  leftOffButton.setMinShortPressTime(BUTTON_SHORT_PRESS_TIME_MS);
  leftOffButton.setMinLongPressTime(BUTTON_LONG_PRESS_TIME_MS);
  leftOffButton.setShortPressCallback([]()
                                      { 
                                        // Turn off left light
                                        espmega.outputs.setState(LEFT_LIGHT_RELAY_PIN, LOW); });
  leftOffButton.setLongPressCallback([]()
                                     { 
                                      // Turn off both lights
                                      espmega.outputs.setState(RIGHT_LIGHT_RELAY_PIN, LOW);
                                      espmega.outputs.setState(LEFT_LIGHT_RELAY_PIN, LOW); });
  leftOffButton.begin();
}

void loop()
{
  leftOnButton.loop();
  leftOffButton.loop();
  rightOnButton.loop();
  rightOffButton.loop();
  espmega.loop();
}

void send_stop_bytes(HardwareSerial &uart)
{
  uart.write(0xFF);
  uart.write(0xFF);
  uart.write(0xFF);
}

void handle_input_change(uint8_t pin, bool state)
{
  switch (pin)
  {
  case RIGHT_STADIUM_LIGHT_SWITCH_PIN:
    if (get_gym_light_lock())
    {
      return;
    }
    espmega.outputs.setState(RIGHT_STADIUM_LIGHT_RELAY_PIN,
                                 !espmega.outputs.getState(RIGHT_STADIUM_LIGHT_RELAY_PIN));
    break;
  case LEFT_STADIUM_LIGHT_SWITCH_PIN:
    if (get_gym_light_lock())
    {
      return;
    }
    espmega.outputs.setState(LEFT_STADIUM_LIGHT_RELAY_PIN,
                                 !espmega.outputs.getState(LEFT_STADIUM_LIGHT_RELAY_PIN));
    break;
  case GIRLS_TOILET_LIGHT_SWITCH_PIN:
    if (get_toilet_light_lock())
    {
      return;
    }
    espmega.outputs.setState(GIRLS_TOILET_LIGHT_RELAY_PIN,
                                 !espmega.outputs.getState(GIRLS_TOILET_LIGHT_RELAY_PIN));
    break;
  case BOYS_TOILET_LIGHT_SWITCH_PIN:
    if (get_toilet_light_lock())
    {
      return;
    }
    espmega.outputs.setState(BOYS_TOILET_LIGHT_RELAY_PIN,
                                 !espmega.outputs.getState(BOYS_TOILET_LIGHT_RELAY_PIN));
    break;
  default:
    break;
  }
}

bool get_toilet_light_lock()
{
  return toiletLightsLock.getIntValue() == 1;
}

bool get_gym_light_lock()
{
  return gymLightsLock.getIntValue() == 1;
}

void handle_mqtt_message(char *topic, char *payload)
{
  // Do nothing
}