#include <Fuzzy.h>
#include "DHTesp.h"
#include <ESP32Servo.h>

#define PhotoR  33
#define Relay   23

const int DHT_PIN = 32;
const int servoPin = 19;

DHTesp dhtSensor;
Servo servo;

Fuzzy *fuzzy = new Fuzzy();

// FuzzyInput DHT22 Temp
FuzzySet *dingin    = new FuzzySet(0, 0, 10, 20);
FuzzySet *sedang    = new FuzzySet(10, 20, 20, 30);
FuzzySet *panas     = new FuzzySet(20, 30, 100, 100);

// FuzzyInput Photoresistor
FuzzySet *gelap     = new FuzzySet(0, 0, 1000, 1500);
FuzzySet *sgelap    = new FuzzySet(1000, 1500, 1500, 2000);
FuzzySet *sterang   = new FuzzySet(1500, 2000, 2000, 2500);
FuzzySet *terang    = new FuzzySet(2000, 2500, 4095, 4095);

// FuzzyOutput kipas
FuzzySet *rendah    = new FuzzySet(0, 0, 0, 5);
FuzzySet *medium    = new FuzzySet(0, 5, 5, 10);
FuzzySet *tinggi    = new FuzzySet(5, 10, 10, 10);

// FuzzyOutput Lampu
FuzzySet *mati      = new FuzzySet(0, 0, 0, 5);
FuzzySet *nyala     = new FuzzySet(5, 10, 10, 10);

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

  pinMode(PhotoR, INPUT);
  pinMode(Relay, OUTPUT);

  servo.attach(servoPin, 500, 2400);
  dhtSensor.setup(DHT_PIN, DHTesp::DHT22);

  // FuzzyInput
  FuzzyInput *temp = new FuzzyInput(1);

  temp->addFuzzySet(dingin);
  temp->addFuzzySet(sedang);
  temp->addFuzzySet(panas);
  fuzzy->addFuzzyInput(temp);

  // FuzzyInput
  FuzzyInput *photor = new FuzzyInput(2);

  photor->addFuzzySet(gelap);
  photor->addFuzzySet(sgelap);
  photor->addFuzzySet(sterang);
  photor->addFuzzySet(terang);
  fuzzy->addFuzzyInput(photor);

  // FuzzyOutput
  FuzzyOutput *kipas = new FuzzyOutput(1);

  kipas->addFuzzySet(rendah);
  kipas->addFuzzySet(medium);
  kipas->addFuzzySet(tinggi);
  fuzzy->addFuzzyOutput(kipas);

  // FuzzyOutput
  FuzzyOutput *lampu = new FuzzyOutput(2);

  lampu->addFuzzySet(mati);
  lampu->addFuzzySet(nyala);
  fuzzy->addFuzzyOutput(lampu);

  // Building FuzzyRule 1
  FuzzyRuleAntecedent *dingingelap = new FuzzyRuleAntecedent();
  dingingelap->joinWithAND(dingin, gelap);

  FuzzyRuleConsequent *rendahnyala1 = new FuzzyRuleConsequent();
  rendahnyala1->addOutput(rendah);
  rendahnyala1->addOutput(nyala);

  FuzzyRule *fuzzyRule1 = new FuzzyRule(1, dingingelap, rendahnyala1);
  fuzzy->addFuzzyRule(fuzzyRule1);

  // Building FuzzyRule 2
  FuzzyRuleAntecedent *dinginsgelap = new FuzzyRuleAntecedent();
  dinginsgelap->joinWithAND(dingin, sgelap);

  FuzzyRuleConsequent *rendahnyala2 = new FuzzyRuleConsequent();
  rendahnyala2->addOutput(rendah);
  rendahnyala2->addOutput(nyala);

  FuzzyRule *fuzzyRule2 = new FuzzyRule(2, dinginsgelap, rendahnyala2);
  fuzzy->addFuzzyRule(fuzzyRule2);

  // Building FuzzyRule 3
  FuzzyRuleAntecedent *dinginsterang = new FuzzyRuleAntecedent();
  dinginsterang->joinWithAND(dingin, sterang);

  FuzzyRuleConsequent *rendahnyala3 = new FuzzyRuleConsequent();
  rendahnyala3->addOutput(rendah);
  rendahnyala3->addOutput(nyala);

  FuzzyRule *fuzzyRule3 = new FuzzyRule(3, dinginsterang, rendahnyala3);
  fuzzy->addFuzzyRule(fuzzyRule3);

  // Building FuzzyRule 4
  FuzzyRuleAntecedent *dinginterang = new FuzzyRuleAntecedent();
  dinginterang->joinWithAND(dingin, terang);

  FuzzyRuleConsequent *rendahnyala4 = new FuzzyRuleConsequent();
  rendahnyala4->addOutput(rendah);
  rendahnyala4->addOutput(nyala);

  FuzzyRule *fuzzyRule4 = new FuzzyRule(4, dinginterang, rendahnyala4);
  fuzzy->addFuzzyRule(fuzzyRule4);

  // Building FuzzyRule 5
  FuzzyRuleAntecedent *sedanggelap = new FuzzyRuleAntecedent();
  sedanggelap->joinWithAND(sedang, gelap);

  FuzzyRuleConsequent *mediumnyala1 = new FuzzyRuleConsequent();
  mediumnyala1->addOutput(medium);
  mediumnyala1->addOutput(nyala);

  FuzzyRule *fuzzyRule5 = new FuzzyRule(5, sedanggelap, mediumnyala1);
  fuzzy->addFuzzyRule(fuzzyRule5);

  // Building FuzzyRule 6
  FuzzyRuleAntecedent *sedangsgelap = new FuzzyRuleAntecedent();
  sedangsgelap->joinWithAND(sedang, sgelap);

  FuzzyRuleConsequent *mediumnyala2 = new FuzzyRuleConsequent();
  mediumnyala2->addOutput(medium);
  mediumnyala2->addOutput(nyala);

  FuzzyRule *fuzzyRule6 = new FuzzyRule(6, sedangsgelap, mediumnyala2);
  fuzzy->addFuzzyRule(fuzzyRule6);

  // Building FuzzyRule 7
  FuzzyRuleAntecedent *sedangsterang = new FuzzyRuleAntecedent();
  sedangsterang->joinWithAND(sedang, sterang);

  FuzzyRuleConsequent *mediummati1 = new FuzzyRuleConsequent();
  mediummati1->addOutput(medium);
  mediummati1->addOutput(mati);

  FuzzyRule *fuzzyRule7 = new FuzzyRule(7, sedangsterang, mediummati1);
  fuzzy->addFuzzyRule(fuzzyRule7);

  // Building FuzzyRule 8
  FuzzyRuleAntecedent *sedangterang = new FuzzyRuleAntecedent();
  sedangterang->joinWithAND(sedang, terang);

  FuzzyRuleConsequent *mediummati2 = new FuzzyRuleConsequent();
  mediummati2->addOutput(medium);
  mediummati2->addOutput(mati);

  FuzzyRule *fuzzyRule8 = new FuzzyRule(8, sedangterang, mediummati2);
  fuzzy->addFuzzyRule(fuzzyRule8);

  // Building FuzzyRule 9
  FuzzyRuleAntecedent *panasgelap = new FuzzyRuleAntecedent();
  panasgelap->joinWithAND(panas, gelap);

  FuzzyRuleConsequent *tinggimati1 = new FuzzyRuleConsequent();
  tinggimati1->addOutput(tinggi);
  tinggimati1->addOutput(mati);

  FuzzyRule *fuzzyRule9 = new FuzzyRule(9, panasgelap, tinggimati1);
  fuzzy->addFuzzyRule(fuzzyRule9);

  // Building FuzzyRule 10
  FuzzyRuleAntecedent *panassgelap = new FuzzyRuleAntecedent();
  panassgelap->joinWithAND(panas, sgelap);

  FuzzyRuleConsequent *tinggimati2 = new FuzzyRuleConsequent();
  tinggimati2->addOutput(tinggi);
  tinggimati2->addOutput(mati);

  FuzzyRule *fuzzyRule10 = new FuzzyRule(10, panassgelap, tinggimati2);
  fuzzy->addFuzzyRule(fuzzyRule10);

  // Building FuzzyRule 11
  FuzzyRuleAntecedent *panassterang = new FuzzyRuleAntecedent();
  panassterang->joinWithAND(panas, sterang);

  FuzzyRuleConsequent *tinggimati3 = new FuzzyRuleConsequent();
  tinggimati3->addOutput(tinggi);
  tinggimati3->addOutput(mati);

  FuzzyRule *fuzzyRule11 = new FuzzyRule(11, panassterang, tinggimati3);
  fuzzy->addFuzzyRule(fuzzyRule11);

  // Building FuzzyRule 12
  FuzzyRuleAntecedent *panasterang = new FuzzyRuleAntecedent();
  panasterang->joinWithAND(panas, terang);

  FuzzyRuleConsequent *tinggimati4 = new FuzzyRuleConsequent();
  tinggimati4->addOutput(tinggi);
  tinggimati4->addOutput(mati);

  FuzzyRule *fuzzyRule12 = new FuzzyRule(12, panasterang, tinggimati4);
  fuzzy->addFuzzyRule(fuzzyRule12);
}

void loop()
{
  TempAndHumidity  data = dhtSensor.getTempAndHumidity();

  int input1 = data.temperature;
  int input2 = analogRead(PhotoR);

  Serial.println("\n\n\nEntrance: ");
  Serial.print("\t\t\tTemperatur: ");
  Serial.print(input1);
  Serial.print(", Photoresistor: ");
  Serial.println(input2);

  fuzzy->setInput(1, input1);
  fuzzy->setInput(2, input2);

  fuzzy->fuzzify();

  float output1 = fuzzy->defuzzify(1);
  float output2 = fuzzy->defuzzify(2);

  Serial.println("Result: ");
  Serial.print("\t\t\tFan: ");
  Serial.print(output1);
  Serial.print(", and Lamp: ");
  Serial.println(output2);

  float pos = map(output1, 1.7, 8.3, 0, 180);
  Serial.println(pos);
  servo.write(pos);

  if(output2 < 5) digitalWrite(Relay, HIGH);
  else digitalWrite(Relay, LOW);

  // wait 12 seconds
  delay(1000);
}