namespace WaterLevel {
  const int MAX_ANALOG_SIGNAL = 20;

  class WaterSensor {
    private:
      const uint8_t inputPin;
      const uint8_t outputPin;
      unsigned int absoluteConductivity() {
        digitalWrite(outputPin, HIGH);
        unsigned int result = analogRead(inputPin);
        digitalWrite(outputPin, LOW);
        return result;
      };
    public:
      int conductivityPercentage() {
        return absoluteConductivity() * 100 / MAX_ANALOG_SIGNAL;
      };
      void setup() {
        pinMode(inputPin, INPUT); // we write signal to the input pin
        pinMode(outputPin, OUTPUT); // and read it from the output pin
      }
      WaterSensor(uint8_t inputPin, uint8_t outputPin): inputPin(inputPin), outputPin(outputPin) {};
  };
  enum WaterLevel {
    Low,
    Medium,
    High,
    Overflow,
  };
  class WaterLevelSensor {
    private:
      // minimal relative conductivity percentage such that a sensor is considered triggered.
      const int relConductivityThreshold;
      WaterSensor* sensorMedium;
      WaterSensor* sensorHigh;
      WaterSensor* sensorOverflow;
      bool aboveThreshold(WaterSensor* sensor) {
        int cond = sensor->conductivityPercentage();
        Serial.println(cond);
        return sensor->conductivityPercentage() >= relConductivityThreshold;
      }
    public:
      WaterLevel currentWaterLevel() {
        if (aboveThreshold(sensorOverflow)) {
          return WaterLevel::Overflow;
        } else if (aboveThreshold(sensorHigh)) {
          return WaterLevel::High;
        } else if (aboveThreshold(sensorMedium)) {
          return WaterLevel::Medium;
        } else {
          return WaterLevel::Low;
        }
      };
      void setup() {
        sensorMedium->setup();
        sensorHigh->setup();
        sensorOverflow->setup();
      };
      WaterLevelSensor(
        int relConductivityThreshold,
        WaterSensor* sensorMedium,
        WaterSensor* sensorHigh,
        WaterSensor* sensorOverflow
      ): relConductivityThreshold(relConductivityThreshold), sensorMedium(sensorMedium), sensorHigh(sensorHigh), sensorOverflow(sensorOverflow) {};
  };
  class ACCondensateLevel {
    public:
      const uint8_t WATER_SENSOR_INPUT_PIN = A0;

      const uint8_t WATER_SENSOR_MEDIUM_OUT_PIN = 10;
      const uint8_t WATER_SENSOR_HIGH_OUT_PIN = 11;
      const uint8_t WATER_SENSOR_OVERFLOW_OUT_PIN = 12;

      const uint8_t WATER_SENSOR_CONDUCTIVITY_THRESHOLD = 50; // percent

      WaterLevelSensor* sensor;

      void setup() {
        sensor->setup();
      };
      ACCondensateLevel () {
        WaterSensor* sensorMedium = new WaterSensor(WATER_SENSOR_INPUT_PIN, WATER_SENSOR_MEDIUM_OUT_PIN);
        WaterSensor* sensorHigh = new WaterSensor(WATER_SENSOR_INPUT_PIN, WATER_SENSOR_HIGH_OUT_PIN);
        WaterSensor* sensorOverflow = new WaterSensor(WATER_SENSOR_INPUT_PIN, WATER_SENSOR_OVERFLOW_OUT_PIN);
        this->sensor = new WaterLevelSensor(WATER_SENSOR_CONDUCTIVITY_THRESHOLD, sensorMedium, sensorHigh, sensorOverflow);
      };

  };
};
WaterLevel::ACCondensateLevel* sensor = new WaterLevel::ACCondensateLevel();
void setup() {
  Serial.begin(6090);
  // put your setup code here, to run once:
  sensor->setup();
}

void loop() {
  switch (sensor->sensor->currentWaterLevel()) {
    case WaterLevel::Low:
      Serial.println("Good");
      break;
    case WaterLevel::Medium:
      Serial.println("Okay");
      break;
    case WaterLevel::High:
      Serial.println("Pour the water tank!");
      break;
    case WaterLevel::Overflow:
      Serial.println("Overflow!");
      break;
    default:
      Serial.println("wtf, cowboy?");
  };
  delay(1500);
  // put your main code here, to run repeatedly:

}