const int hot_min = 1;
const int hot_max = 40;
const int warm_min = 30;
const int warm_max = 70;
const int cold_min = 60;
const int cold_max = 100;

// Define the fuzzy sets
struct FuzzySet {
  char* name;
  float a1, b1, c1; // Membership function parameters for input 1
  float a2, b2, c2; // Membership function parameters for input 2
};

FuzzySet cold_cold = {"Cold-Cold", -20, -10, 0, -20, -10, 0};
FuzzySet cold_warm = {"Cold-Warm", -20, -10, 0, -10, 0, 10};
FuzzySet cold_hot = {"Cold-Hot", -20, -10, 0, 0, 10, 20};
FuzzySet warm_cold = {"Warm-Cold", -10, 0, 10, -20, -10, 0};
FuzzySet warm_warm = {"Warm-Warm", -10, 0, 10, -10, 0, 10};
FuzzySet warm_hot = {"Warm-Hot", -10, 0, 10, 0, 10, 20};
FuzzySet hot_cold = {"Hot-Cold", 0, 10, 20, -20, -10, 0};
FuzzySet hot_warm = {"Hot-Warm", 0, 10, 20, -10, 0, 10};
FuzzySet hot_hot = {"Hot-Hot", 0, 10, 20, 0, 10, 20};

// Define the membership function
float membership(FuzzySet set, float x, float y) {
  float membership_x = 0.0;
  if (x <= set.a1 || x >= set.c1) {
    membership_x = 0.0;
  } else if (x <= set.b1) {
    membership_x = (x - set.a1) / (set.b1 - set.a1);
  } else {
    membership_x = (set.c1 - x) / (set.c1 - set.b1);
  }
  
  float membership_y = 0.0;
  if (y <= set.a2 || y >= set.c2) {
    membership_y = 0.0;
  } else if (y <= set.b2) {
    membership_y = (y - set.a2) / (set.b2 - set.a2);
  } else {
    membership_y = (set.c2 - y) / (set.c2 - set.b2);
  }
  
  // Use the min operator for AND operation
  return fmin(membership_x, membership_y); 
}

// Perform rules of fuzzy logic operations
void fuzzy_logic(float temp1, float temp2) {
  float cold_cold_membership = membership(cold_cold, temp1, temp2);   //low
  float cold_warm_membership = membership(cold_warm, temp1, temp2);   //low
  float cold_hot_membership = membership(cold_hot, temp1, temp2);     //mid
  float warm_cold_membership = membership(warm_cold, temp1, temp2);   //low
  float warm_warm_membership = membership(warm_warm, temp1, temp2);   //mid
  float warm_hot_membership = membership(warm_hot, temp1, temp2);     //high
  float hot_cold_membership = membership(hot_cold, temp1, temp2);     //mid
  float hot_warm_membership = membership(hot_warm, temp1, temp2);     //high
  float hot_hot_membership = membership(hot_hot, temp1, temp2);       //high

  float output = defuzzification(cold_cold_membership, cold_warm_membership, cold_hot_membership, 
                                      hot_cold_membership, hot_warm_membership, hot_hot_membership, 
                                      warm_cold_membership, warm_warm_membership, warm_hot_membership,
                                      cold_min, cold_max, hot_min, hot_max, warm_min, warm_max );

  // Print the crisp output
  Serial.print("temp1: ");
  Serial.println(temp1);
  Serial.print("temp2: ");
  Serial.println(temp2);
  Serial.print("output: ");
  Serial.println(output); 
}  
  /*
  Serial.println(cold_cold_membership);
  Serial.println(cold_warm_membership);
  Serial.println(cold_hot_membership);
  Serial.println(warm_cold_membership);
  Serial.println(warm_warm_membership);
  Serial.println( warm_hot_membership);
  Serial.println(hot_cold_membership);
  Serial.println(hot_warm_membership);
  Serial.println(hot_hot_membership);
  */
                      
float defuzzification(float cold_cold_membership, float cold_warm_membership, float cold_hot_membership,
                      float hot_cold_membership, float hot_warm_membership, float hot_hot_membership,
                      float warm_cold_membership, float warm_warm_membership, float warm_hot_membership,
                      int cold_min, int cold_max, int hot_min, int hot_max, int warm_min, int warm_max)
                      {
                        float low_membership = fmax(fmax(cold_cold_membership ,cold_warm_membership ),warm_cold_membership);
                        float mid_membership = fmax(fmax(warm_warm_membership ,cold_hot_membership ),hot_cold_membership);
                        float high_membership = fmax(fmax(hot_hot_membership ,warm_hot_membership ),hot_warm_membership);
                        
                        float low_midpoint = (cold_min + cold_max) / 2.0;
                        float mid_midpoint = (warm_min + warm_max) / 2.0;
                        float high_midpoint = (hot_min + hot_max) / 2.0;

                        float output = (low_midpoint * low_membership + mid_midpoint * mid_membership + high_midpoint * high_membership ) 
                                        / (low_membership + mid_membership + high_membership);
                         
                        return output ;

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

}
void loop() {

 // float temp1 = analogRead(A2) ;  // Convert analog reading to temperature in Celsius
 // float temp2 = analogRead(A3) ;

  float sensor1Value = analogRead(A2); // read analog input on pin A2
  float temp1 = map(sensor1Value, 0, 1023, -20, 20); // map value to range -20 to 20
  float sensor2Value = analogRead(A3); // read analog input on pin A3
  float temp2 = map(sensor2Value, 0, 1023, -20, 20); // map value to range -20 to 20

  fuzzy_logic(temp1,temp2);
  delay(3000);



}