// https://arduino.stackexchange.com/questions/92772/esp-based-smart-light-system-over-alexa-malfunctioning

#include <WiFi.h>
#include <Espalexa.h>
#include <AceButton.h>
using namespace ace_button;

Espalexa espalexa;

// define the GPIO connected with Relays and switches
byte RelayPin[]  = {23, 22, 21, 19, 18, 05, 25, 26};          // D23 D22 D21 D19 D18 D5 D25 D26
byte SwitchPin[] = {13, 12, 14, 27, 33, 32, 15, 04};          // D13 D12 D14 D27 D33 D32 D15 D4

#define wifiLed     2   // D2

// WiFi Credentials
const char* ssid = "Wokwi-GUEST";  // https://docs.wokwi.com/guides/esp32-wifi
const char* password = "";


// device names

String Device_Name[] = { "Study Lamp", "CFL", "Yellow light", "Night Lamp", "Studio Light", "Outdoor Light", "Kitchen Light", "Room Light" };

// String Device_0_Name = "Study Lamp";
// String Device_1_Name = "CFL";
// String Device_2_Name = "Yellow light";
// String Device_3_Name = "Night Lamp";
// String Device_4_Name = "Studio Light";
// String Device_5_Name = "Outdoor Light";
// String Device_6_Name = "Kitchen Light";
// String Device_7_Name = "Room Light";

// prototypes
boolean connectWifi();

//callback functions
void Light0Changed(uint8_t brightness);
void Light1Changed(uint8_t brightness);
void Light2Changed(uint8_t brightness);
void Light3Changed(uint8_t brightness);
void Light4Changed(uint8_t brightness);
void Light5Changed(uint8_t brightness);
void Light6Changed(uint8_t brightness);
void Light7Changed(uint8_t brightness);

ButtonConfig config0; AceButton button0(&config0);
ButtonConfig config1; AceButton button1(&config1);
ButtonConfig config2; AceButton button2(&config2);
ButtonConfig config3; AceButton button3(&config3);
ButtonConfig config4; AceButton button4(&config4);
ButtonConfig config5; AceButton button5(&config5);
ButtonConfig config6; AceButton button6(&config6);
ButtonConfig config7; AceButton button7(&config7);

void handleEvent0(AceButton*, uint8_t, uint8_t);
void handleEvent1(AceButton*, uint8_t, uint8_t);
void handleEvent2(AceButton*, uint8_t, uint8_t);
void handleEvent3(AceButton*, uint8_t, uint8_t);
void handleEvent4(AceButton*, uint8_t, uint8_t);
void handleEvent5(AceButton*, uint8_t, uint8_t);
void handleEvent6(AceButton*, uint8_t, uint8_t);
void handleEvent7(AceButton*, uint8_t, uint8_t);

boolean wifiConnected = false;

//our callback functions

void Light0Changed(uint8_t brightness) { lightChanged(0, brightness); }
void Light1Changed(uint8_t brightness) { lightChanged(1, brightness); }
void Light2Changed(uint8_t brightness) { lightChanged(2, brightness); }
void Light3Changed(uint8_t brightness) { lightChanged(3, brightness); }
void Light4Changed(uint8_t brightness) { lightChanged(4, brightness); }
void Light5Changed(uint8_t brightness) { lightChanged(5, brightness); }
void Light6Changed(uint8_t brightness) { lightChanged(6, brightness); }
void Light7Changed(uint8_t brightness) { lightChanged(7, brightness); }


void lightChanged(uint8_t dev, uint8_t brightness) {
	
  Serial.print(F("Device "));
  Serial.print(dev);

  if (brightness == 255) {                   // Control the device
    digitalWrite(RelayPin[dev], LOW);
    Serial.println(" ON");
  }

  else {
    digitalWrite(RelayPin[dev], HIGH);
    Serial.println(" OFF");
  }
}

// connect to wifi – returns true if successful or false if not
boolean connectWifi() {
  boolean state = true;
  int i = 0;

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.println("");
  Serial.println("Connecting to WiFi");

  // Wait for connection
  Serial.print("Connecting...");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    if (i > 20) {
      state = false; break;
    }
    i++;
  }
  Serial.println("");
  if (state) {
    Serial.print("Connected to ");
    Serial.println(ssid);
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());
  }
  else {
    Serial.println("Connection failed.");
  }
  return state;
}

void addDevices(){
  // Define your devices here.
  espalexa.addDevice(Device_Name[0], Light0Changed); // simplest definition, default state off
  espalexa.addDevice(Device_Name[1], Light1Changed);
  espalexa.addDevice(Device_Name[2], Light2Changed);
  espalexa.addDevice(Device_Name[3], Light3Changed);
  espalexa.addDevice(Device_Name[4], Light4Changed); 
  espalexa.addDevice(Device_Name[5], Light5Changed);
  espalexa.addDevice(Device_Name[6], Light6Changed);
  espalexa.addDevice(Device_Name[7], Light7Changed);

  espalexa.begin();
}

void setup() {
  Serial.begin(115200);

  pinMode(wifiLed, OUTPUT);
  
  for (int i=0; i<8; i++) {

    pinMode(RelayPin[i], OUTPUT);
    digitalWrite(RelayPin[i], HIGH);         // During Starting all Relays should TURN OFF
    pinMode(SwitchPin[i], INPUT_PULLUP);
  } 

  for (int i = 0; i < 8; i++) {
    Serial.print( Device_Name[i]);
    Serial.println(".");
  }


  config0.setEventHandler(button0Handler);
  config1.setEventHandler(button1Handler);
  config2.setEventHandler(button2Handler);
  config3.setEventHandler(button3Handler);
  config4.setEventHandler(button4Handler);
  config5.setEventHandler(button5Handler);
  config6.setEventHandler(button6Handler);
  config7.setEventHandler(button7Handler);

  button0.init(SwitchPin[0]);
  button1.init(SwitchPin[1]);
  button2.init(SwitchPin[2]);
  button3.init(SwitchPin[3]);
  button4.init(SwitchPin[4]);
  button5.init(SwitchPin[5]);
  button6.init(SwitchPin[6]);
  button7.init(SwitchPin[7]);


  // Initialise wifi connection
  wifiConnected = connectWifi();

  if (wifiConnected)
  {
    addDevices();
  }
  else
  {
    Serial.println("Cannot connect to WiFi. So in Manual Mode");
    delay(1000);
  }
}

void loop() {
   if (WiFi.status() != WL_CONNECTED)
  {
    //Serial.print("WiFi Not Connected ");
    digitalWrite(wifiLed, LOW); //Turn off WiFi LED
  }
  else
  {
    //Serial.print("WiFi Connected  ");
    digitalWrite(wifiLed, HIGH);
    //Manual Switch Control
    //WiFi Control
    if (wifiConnected){
      espalexa.loop();
      delay(1);
    }
    else {
      wifiConnected = connectWifi(); // Initialise wifi connection
      if(wifiConnected){
      addDevices();
      }
    }
  }
  button0.check();
  button1.check();
  button2.check();
  button3.check();
  button4.check();
  button5.check();
  button6.check();
  button7.check();
}

void button0Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) {
  Serial.println("EVENT0");
  EspalexaDevice* d0 = espalexa.getDevice(0); //this will get "first device", the index is zero-based
  switch (eventType) {
    case AceButton::kEventPressed:
      Serial.println("kEventPressed");
      d0->setPercent(100);
      digitalWrite(RelayPin[0], LOW);
      break;
    case AceButton::kEventReleased:
      Serial.println("kEventReleased");
      d0->setPercent(0);
      digitalWrite(RelayPin[0], HIGH);
      break;
  }
}

void button1Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) {
  Serial.println("EVENT1");
  EspalexaDevice* d1 = espalexa.getDevice(1);
  switch (eventType) {
    case AceButton::kEventPressed:
      Serial.println("kEventPressed");
      d1->setPercent(100); //set value "brightness" in percent
      digitalWrite(RelayPin[1], LOW);
      break;
    case AceButton::kEventReleased:
      Serial.println("kEventReleased");
      d1->setPercent(0); //set value "brightness" in percent
      digitalWrite(RelayPin[1], HIGH);
      break;
  }
}

void button2Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) {
  Serial.println("EVENT2");
  EspalexaDevice* d2 = espalexa.getDevice(2);
  switch (eventType) {
    case AceButton::kEventPressed:
      Serial.println("kEventPressed");
      d2->setPercent(100);
      digitalWrite(RelayPin[2], LOW);
      break;
    case AceButton::kEventReleased:
      Serial.println("kEventReleased");
      d2->setPercent(0);
      digitalWrite(RelayPin[2], HIGH);
      break;
  }
}

void button3Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) {
  Serial.println("EVENT3");
  EspalexaDevice* d3 = espalexa.getDevice(3);
  switch (eventType) {
    case AceButton::kEventPressed:
      Serial.println("kEventPressed");
      d3->setPercent(100);
      digitalWrite(RelayPin[3], LOW);
      break;
    case AceButton::kEventReleased:
      Serial.println("kEventReleased");
      d3->setPercent(0);
      digitalWrite(RelayPin[3], HIGH);
      break;
  }
}

void button4Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) {
  Serial.println("EVENT4");
  EspalexaDevice* d4 = espalexa.getDevice(4);
  switch (eventType) {
    case AceButton::kEventPressed:
      Serial.println("kEventPressed");
      d4->setPercent(100);
      digitalWrite(RelayPin[4], LOW);
      break;
    case AceButton::kEventReleased:
      Serial.println("kEventReleased");
      d4->setPercent(0);
      digitalWrite(RelayPin[4], HIGH);
      break;
  }
}

void button5Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) {
  Serial.println("EVENT5");
  EspalexaDevice* d5 = espalexa.getDevice(5);
  switch (eventType) {
    case AceButton::kEventPressed:
      Serial.println("kEventPressed");
      d5->setPercent(100);
      digitalWrite(RelayPin[5], LOW);
      break;
    case AceButton::kEventReleased:
      Serial.println("kEventReleased");
      d5->setPercent(0);
      digitalWrite(RelayPin[5], HIGH);
      break;
  }
}

void button6Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) {
  Serial.println("EVENT6");
  EspalexaDevice* d6 = espalexa.getDevice(6);
  switch (eventType) {
    case AceButton::kEventPressed:
      Serial.println("kEventPressed");
      d6->setPercent(100);
      digitalWrite(RelayPin[6], LOW);
      break;
    case AceButton::kEventReleased:
      Serial.println("kEventReleased");
      d6->setPercent(0);
      digitalWrite(RelayPin[6], HIGH);
      break;
  }
}

void button7Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) {
  Serial.println("EVENT7");
  EspalexaDevice* d7 = espalexa.getDevice(7);
  switch (eventType) {
    case AceButton::kEventPressed:
      Serial.println("kEventPressed");
      d7->setPercent(100);
      digitalWrite(RelayPin[7], LOW);
      break;
    case AceButton::kEventReleased:
      Serial.println("kEventReleased");
      d7->setPercent(0);
      digitalWrite(RelayPin[7], HIGH);
      break;
  }
}