class VariableStrategy {
public:
  virtual float read() = 0;
};

class BatteryINTStrategy : public VariableStrategy {
public:
  BatteryINTStrategy(uint8_t pin)
    : pin(pin) {}
  float read() override {
    uint8_t analogValue = analogRead(pin);
    float voltage = (analogValue * 5.0) / 1023.0;
    return voltage;
  }
private:
  uint8_t pin;
};

class TemperatureRTCStrategy : public VariableStrategy {
public:
  TemperatureRTCStrategy(uint8_t pin, float betta)
    : pin(pin), betta(betta) {}
  float read() override {
    uint8_t analogValue = analogRead(pin);
    float celsius = 1 / (log(1 / (1023.0 / analogValue - 1)) / betta + 1.0 / 298.15) - 273.15;
    return celsius;
  }
private:
  uint8_t pin;
  float betta;
};


#include <dht.h>
dht DHTSensor;
class TemperatureDHTStrategy : public VariableStrategy {
public:
  TemperatureDHTStrategy(uint8_t pin)
    : pin(pin) {}
  float read() override {
    int chk = DHTSensor.read22(pin);
    return DHTSensor.temperature;
  }
private:
  uint8_t pin;
};

class HumidityDHTStrategy : public VariableStrategy {
public:
  HumidityDHTStrategy(uint8_t pin)
    : pin(pin) {}
  float read() override {
    int chk = DHTSensor.read22(pin);
    return DHTSensor.humidity;
  }
private:
  uint8_t pin;
};


// ---------------------------------------------------------------- //
// Reader definition
class SensorReader {
public:
  SensorReader(VariableStrategy* strategy)
    : strategy(strategy) {}

  float readValue() {
    return strategy->read();
  }

private:
  VariableStrategy* strategy;
};


// Equation definition
struct Linear {
  float m = 1.0;
  float b = 0.0;
};

enum Var {
  BATTERY,
  TEMPERATURE,
  HUMIDITY
};

class Variable {
private:
  Linear equation;
  float _value = 0.0;
public:
  Var type;
  Variable(Var type)
    : type(type) {}
  void set(float value) {
    _value = (equation.m * value) + equation.b;
  }
  float get(void) {
    return _value;
  }
};

BatteryINTStrategy batteryINTStrategy(A1);
TemperatureRTCStrategy firstTempRTCStrategy(A0, 3950);
TemperatureDHTStrategy firstTempDHTStrategy(5);
HumidityDHTStrategy firstHumDHTStrategy(5);
TemperatureDHTStrategy secondTempDHTStrategy(4);
HumidityDHTStrategy secondHumDHTStrategy(4);
SensorReader sensors[] = {
  SensorReader(&batteryINTStrategy),
  SensorReader(&firstTempRTCStrategy),
  SensorReader(&firstTempDHTStrategy),
  SensorReader(&firstHumDHTStrategy),
  SensorReader(&secondTempDHTStrategy),
  SensorReader(&secondHumDHTStrategy),
};

Variable variables[] = {
  Variable(BATTERY),
  Variable(TEMPERATURE),
  Variable(TEMPERATURE),
  Variable(HUMIDITY),
  Variable(TEMPERATURE),
  Variable(HUMIDITY),
};

#define SIZE 5
uint8_t lenght = 0;
float auxiliar[SIZE];

float median(void) {
  for (uint8_t i = 0; i < SIZE; i++) {
    for (uint8_t j = i + 1; j < SIZE; j++) {
      if (auxiliar[i] > auxiliar[j]) {
        float aux = auxiliar[i];
        auxiliar[i] = auxiliar[j];
        auxiliar[j] = aux;
      }
    }
  }
  return auxiliar[int(SIZE / 2)];
}

void setup() {
  Serial.begin(9600);
  Serial.println("Welcome");
  lenght = sizeof(sensors) / sizeof(SensorReader);
}

String toString(Var type) {
  switch (type) {
    case Var::BATTERY:
      return "BATTERY";
    case Var::TEMPERATURE:
      return "TEMPERATURE";
    case Var::HUMIDITY:
      return "HUMIDITY";
    default:
      return "UNKNOWN";
  }
}

void loop() {
  for (uint8_t i = 0; i < lenght; i++) {
    for (uint8_t j = 0; j < SIZE; j++) {
      auxiliar[j] = sensors[i].readValue();
      delay(5);
    }
    variables[i].set(median());
    Serial.print("The value of ");
    Serial.print(toString(variables[i].type));
    Serial.print(" is ");
    Serial.println(variables[i].get());
  }
  delay(1000);
}