#include <Fuzzy.h>

// Membuat objek Fuzzy
Fuzzy *fuzzy = new Fuzzy();

// Pin potentiometer dan LED
int lightPotPin = A0;
int distancePotPin = A1;
int ledPin = 9;

// Fungsi untuk membaca nilai potentiometer cahaya
int readLightPot() {
    return analogRead(lightPotPin);
}

// Fungsi untuk membaca nilai potentiometer jarak
int readDistancePot() {
    int value = analogRead(distancePotPin);
    // Asumsikan bahwa nilai potensio sudah dalam rentang yang diinginkan
    return value;
}

void setup() {
    Serial.begin(9600);
    pinMode(ledPin, OUTPUT);

    // Mendefinisikan himpunan fuzzy untuk potentiometer cahaya
    FuzzySet *lightDark = new FuzzySet(0, 100, 200, 300);
    FuzzySet *lightMedium = new FuzzySet(200, 400, 600, 800);
    FuzzySet *lightBright = new FuzzySet(500, 700, 1023, 1023);
    FuzzyInput *light = new FuzzyInput(1);
    light->addFuzzySet(lightDark);
    light->addFuzzySet(lightMedium);
    light->addFuzzySet(lightBright);
    fuzzy->addFuzzyInput(light);

    // Mendefinisikan himpunan fuzzy untuk potentiometer jarak
    FuzzySet *distanceNear = new FuzzySet(0, 25, 30, 50);
    FuzzySet *distanceMedium = new FuzzySet(30, 60, 80, 100);
    FuzzySet *distanceFar = new FuzzySet(80, 120, 150, 150);
    FuzzyInput *distance = new FuzzyInput(2);
    distance->addFuzzySet(distanceNear);
    distance->addFuzzySet(distanceMedium);
    distance->addFuzzySet(distanceFar);
    fuzzy->addFuzzyInput(distance);

    // Mendefinisikan himpunan fuzzy untuk intensitas LED
    FuzzySet *ledLow = new FuzzySet(0, 40, 50, 100);
    FuzzySet *ledMedium = new FuzzySet(50, 100, 150, 200);
    FuzzySet *ledHigh = new FuzzySet(150, 200, 255, 255);
    FuzzyOutput *ledIntensity = new FuzzyOutput(1);
    ledIntensity->addFuzzySet(ledLow);
    ledIntensity->addFuzzySet(ledMedium);
    ledIntensity->addFuzzySet(ledHigh);
    fuzzy->addFuzzyOutput(ledIntensity);

    // Menyusun aturan fuzzy
    FuzzyRuleAntecedent *ifLightDarkAndDistanceNear = new FuzzyRuleAntecedent();
    ifLightDarkAndDistanceNear->joinWithAND(lightDark, distanceNear);
    FuzzyRuleConsequent *thenLedHigh1 = new FuzzyRuleConsequent();
    thenLedHigh1->addOutput(ledHigh);
    FuzzyRule *fuzzyRule1 = new FuzzyRule(1, ifLightDarkAndDistanceNear, thenLedHigh1);
    fuzzy->addFuzzyRule(fuzzyRule1);

    FuzzyRuleAntecedent *ifLightDarkAndDistanceMedium = new FuzzyRuleAntecedent();
    ifLightDarkAndDistanceMedium->joinWithAND(lightDark, distanceMedium);
    FuzzyRuleConsequent *thenLedHigh2 = new FuzzyRuleConsequent();
    thenLedHigh2->addOutput(ledHigh);
    FuzzyRule *fuzzyRule2 = new FuzzyRule(2, ifLightDarkAndDistanceMedium, thenLedHigh2);
    fuzzy->addFuzzyRule(fuzzyRule2);

    FuzzyRuleAntecedent *ifLightDarkAndDistanceFar = new FuzzyRuleAntecedent();
    ifLightDarkAndDistanceFar->joinWithAND(lightDark, distanceFar);
    FuzzyRuleConsequent *thenLedMedium1 = new FuzzyRuleConsequent();
    thenLedMedium1->addOutput(ledMedium);
    FuzzyRule *fuzzyRule3 = new FuzzyRule(3, ifLightDarkAndDistanceFar, thenLedMedium1);
    fuzzy->addFuzzyRule(fuzzyRule3);

    FuzzyRuleAntecedent *ifLightMediumAndDistanceNear = new FuzzyRuleAntecedent();
    ifLightMediumAndDistanceNear->joinWithAND(lightMedium, distanceNear);
    FuzzyRuleConsequent *thenLedMedium2 = new FuzzyRuleConsequent();
    thenLedMedium2->addOutput(ledMedium);
    FuzzyRule *fuzzyRule4 = new FuzzyRule(4, ifLightMediumAndDistanceNear, thenLedMedium2);
    fuzzy->addFuzzyRule(fuzzyRule4);

    FuzzyRuleAntecedent *ifLightMediumAndDistanceMedium = new FuzzyRuleAntecedent();
    ifLightMediumAndDistanceMedium->joinWithAND(lightMedium, distanceMedium);
    FuzzyRuleConsequent *thenLedMedium3 = new FuzzyRuleConsequent();
    thenLedMedium3->addOutput(ledMedium);
    FuzzyRule *fuzzyRule5 = new FuzzyRule(5, ifLightMediumAndDistanceMedium, thenLedMedium3);
    fuzzy->addFuzzyRule(fuzzyRule5);

    FuzzyRuleAntecedent *ifLightMediumAndDistanceFar = new FuzzyRuleAntecedent();
    ifLightMediumAndDistanceFar->joinWithAND(lightMedium, distanceFar);
    FuzzyRuleConsequent *thenLedLow1 = new FuzzyRuleConsequent();
    thenLedLow1->addOutput(ledLow);
    FuzzyRule *fuzzyRule6 = new FuzzyRule(6, ifLightMediumAndDistanceFar, thenLedLow1);
    fuzzy->addFuzzyRule(fuzzyRule6);

    FuzzyRuleAntecedent *ifLightBrightAndDistanceNear = new FuzzyRuleAntecedent();
    ifLightBrightAndDistanceNear->joinWithAND(lightBright, distanceNear);
    FuzzyRuleConsequent *thenLedLow2 = new FuzzyRuleConsequent();
    thenLedLow2->addOutput(ledLow);
    FuzzyRule *fuzzyRule7 = new FuzzyRule(7, ifLightBrightAndDistanceNear, thenLedLow2);
    fuzzy->addFuzzyRule(fuzzyRule7);

    FuzzyRuleAntecedent *ifLightBrightAndDistanceMedium = new FuzzyRuleAntecedent();
    ifLightBrightAndDistanceMedium->joinWithAND(lightBright, distanceMedium);
    FuzzyRuleConsequent *thenLedLow3 = new FuzzyRuleConsequent();
    thenLedLow3->addOutput(ledLow);
    FuzzyRule *fuzzyRule8 = new FuzzyRule(8, ifLightBrightAndDistanceMedium, thenLedLow3);
    fuzzy->addFuzzyRule(fuzzyRule8);

    FuzzyRuleAntecedent *ifLightBrightAndDistanceFar = new FuzzyRuleAntecedent();
    ifLightBrightAndDistanceFar->joinWithAND(lightBright, distanceFar);
    FuzzyRuleConsequent *thenLedLow4 = new FuzzyRuleConsequent();
    thenLedLow4->addOutput(ledLow);
    FuzzyRule *fuzzyRule9 = new FuzzyRule(9, ifLightBrightAndDistanceFar, thenLedLow4);
    fuzzy->addFuzzyRule(fuzzyRule9);
}

void loop() {
    int light = readLightPot();
    int distance = readDistancePot();

    Serial.print(" , Light: ");
    Serial.print(light);
    Serial.print(" , Distance: ");
    Serial.print(distance);
    Serial.println(" cm");

    // Memasukkan nilai input ke sistem fuzzy
    fuzzy->setInput(1, light);
    fuzzy->setInput(2, distance);

    // Menjalankan inferensi fuzzy
    fuzzy->fuzzify();

    // Mendapatkan nilai output dari sistem fuzzy
    float ledValue = fuzzy->defuzzify(1);

    // Menyetel intensitas LED
    analogWrite(ledPin, ledValue);

    // Menampilkan nilai intensitas LED di Serial Monitor
    Serial.print("LED Intensity: ");
    Serial.print(ledValue);
}