/*
 bool begin(uint8_t switchvcc = SSD1306_SWITCHCAPVCC, uint8_t i2caddr = 0,
             bool reset = true, bool periphBegin = true);
  void display(void);
  void clearDisplay(void);
  void invertDisplay(bool i);
  void dim(bool dim);
  void drawPixel(int16_t x, int16_t y, uint16_t color);
  virtual void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
  virtual void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
  void startscrollright(uint8_t start, uint8_t stop);
  void startscrollleft(uint8_t start, uint8_t stop);
  void startscrolldiagright(uint8_t start, uint8_t stop);
  void startscrolldiagleft(uint8_t start, uint8_t stop);
  void stopscroll(void);
  void ssd1306_command(uint8_t c);
  bool getPixel(int16_t x, int16_t y);
  uint8_t *getBuffer(void);
*/

String Zeitraum_1 = "3T";
String Tagesspanne = "8H";

const float SCALE_FAK = 0.75;

const char* windbezeichnungen[] = {
  "Stille",
  "Leiser Zug",
  "Leichte Brise",
  "Schwache Brise",
  "Maessige Brise",
  "frische Brise",
  "starker Wind",
  "steifer Wind",
  "stuermischer Wind",
  "Sturm"
};

const char* wolkendichten[] = {
  "Wolkenlos",
  "Heiter",
  "Leicht bewoelkt",
  "Wolkig",
  "Stark bewoelkt",
  "Bedeckt"
};

void SwitchDisplays() {
  static int counter = 0;

  switch (counter) {
    case 0:
      DrawPowerGraph(&oled2);
      break;
    case 1:
      DrawTotalPowerGraph();
      break;
    case 2:
      DrawSpannungsGraph();
      break;
    case 3:
      DrawPressureGraph();
      break;
    case 4:
      DrawTemperaturGraph();
      break;
    case 5:
      DrawWolkenGraph();
      break;
    case 6:
      DrawWindGraph();
      break;
    case 7:
      DrawRegenGraph();
      break;
    case 8:
      DrawBattNetzZyklen();
      break;

    default:
      break;
  }
  counter = (counter + 1) % 9;
}

bool IsInRange(int variable, int min, int max) {
  if (variable >= min && variable <= max) {
    return true;
  } else {
    return false;
  }
}

/* Füllt die Arrays mit Daten */
void FillArray(int16_t* array, int neu) {
  for (int i = 0; i < X_LEN - 1; i++) {
    array[i] = array[i + 1];
  }
  array[X_LEN - 1] = neu;
}

/* ------------------------------------------------ */
/*                    POWER GRAFIK                  */
/* ------------------------------------------------ */

/* Zeichne den Solar Power Graphen */
void DrawPowerGraph(Adafruit_SSD1306* oled) {

  // Berechne die Skalierung
  const float scale = Y_LEN / (MAX_WATT / SCALE_FAK);

  oled->clearDisplay();
  // Zeichne eine Linie für jeden Wert im Array
  for (int i = 0; i < X_LEN; i++) {
    // Berechne die x- und y-Koordinaten der Linie
    int length = (Tables.Power[i] * scale);
    int x = i;
    int y = Y_LEN - length;

    // Zeichne die Linie
    oled->drawFastVLine(x, y, length, SSD1306_WHITE);
  }
  
  /* Beschriftung einfügen */
  oled->setTextColor(SSD1306_WHITE, SSD1306_BLACK);
  oled->setTextSize(1);
  oled->setCursor(0, 0);  // Start at top-left corner
  oled->print("Power ");
  oled->print((int)Data.PSolar);
  oled->print(" W");
  /* Oben rechts die Dauer */
  oled->etCursor(96, 0);  // Start at top-left corner
  float dauer = (((float)DISPLAY_SPAN_1DAY/60) * X_LEN) / 60;
  oled->print(dauer,1);
  oled->print("H");
  oled->display();
}

/* ------------------------------------------------ */
/*               TOTAL POWER GRAFIK                 */
/* ------------------------------------------------ */

/* Zeichne den Solar Power Graphen */
void DrawTotalPowerGraph() {
  // Berechne die Skalierung
  const float scale = Y_LEN / (MAX_WATT / SCALE_FAK);

  oled2.clearDisplay();
  // Zeichne eine Linie für jeden Wert im Array
  for (int i = 0; i < X_LEN; i++) {
    // Berechne die x- und y-Koordinaten der Linie
    int length = (Tables.PowerTotal[i] * scale);
    int x = i;
    int y = Y_LEN - length;

    // Zeichne die Linie
    oled2.drawFastVLine(x, y, length, SSD1306_WHITE);
  }
  
  /* Beschriftung einfügen */
  oled2.setTextColor(SSD1306_WHITE, SSD1306_BLACK);
  oled2.setTextSize(1);
  oled2.setCursor(0, 0);  // Start at top-left corner
  oled2.print("Historie");
  /* Oben rechts die Dauer */
  float dauer = (((float)DISPLAY_SPAN_DYNAMIC/60) * X_LEN) / 60;
  oled2.setCursor(106, 0);  // Start at top-left corner
  oled2.print((int)dauer);
  oled2.print("H");
  oled2.display();
}

/* ------------------------------------------------ */
/*               Umgebungsdruck  GRAFIK             */
/* ------------------------------------------------ */

/* Zeichne den Druckgraphen */
void DrawPressureGraph() {

  /* Finde Extremstellen */
  int MinPressure = 9999;
  int MaxPressure = 0;

  /* Finde Extremstellen */
  for (int i = 0; i < X_LEN; i++) {
    MinPressure = (int)fmin(MinPressure, Tables.Druck[i]);
    MaxPressure = (int)fmax(MaxPressure, Tables.Druck[i]);
  }

  // Berechne die Skalierung
  const float scale = Y_LEN / (fmax(1.0f, MaxPressure - MinPressure) / SCALE_FAK);

  oled2.clearDisplay();
  // Zeichne eine Linie für jeden Wert im Array
  for (int i = 0; i < X_LEN; i++) {
    // Berechne die x- und y-Koordinaten der Linie
    int length = ((Tables.Druck[i] - MinPressure) * scale);
    int x = i;
    int y = Y_LEN - length;

    // Zeichne die Linie
    oled2.drawFastVLine(x, y, length, SSD1306_WHITE);
  }

  /* Beschriftung einfügen */
  oled2.setTextColor(SSD1306_WHITE, SSD1306_BLACK);
  oled2.setTextSize(1);
  oled2.setCursor(0, 0);  // Start at top-left corner
  oled2.print("Druck ");
  oled2.print(Druck);
  oled2.print(" mBar");

  /* Oben rechts die Dauer */
  oled2.setCursor(116, 0);  // Start at top-left corner
  oled2.print(Zeitraum_1);

  oled2.display();
}

/* ------------------------------------------------ */
/*               Temperatur  GRAFIK             */
/* ------------------------------------------------ */

void DrawTemperaturGraph() {

  /* Finde Extremstellen */
  int16_t MinTemp = 99;
  int16_t MaxTemp = -99;

  /* Finde Extremstellen */
  for (int i = 0; i < X_LEN; i++) {
    MinTemp = fmin(MinTemp, Tables.Temperatur[i]);
    MaxTemp = fmax(MaxTemp, Tables.Temperatur[i]);
  }

  // Berechne die Skalierung
  float scale = Y_LEN / ((MaxTemp - MinTemp) / SCALE_FAK);
  if (scale < 0.1)
    scale = 0.1;

  oled2.clearDisplay();
  // Zeichne eine Linie für jeden Wert im Array
  for (int i = 0; i < X_LEN; i++) {
    // Berechne die x- und y-Koordinaten der Linie
    int length = ((Tables.Temperatur[i] - MinTemp) * scale);
    int x = i;
    int y = Y_LEN - length;

    // Zeichne die Linie
    oled2.drawFastVLine(x, y, length, SSD1306_WHITE);
  }

  /* Beschriftung einfügen */
  oled2.setTextColor(SSD1306_WHITE, SSD1306_BLACK);
  oled2.setTextSize(1);
  oled2.setCursor(0, 0);  // Start at top-left corner
  oled2.print("Temp ");
  if (Temperatur > 0) {
    oled2.print("+");
  }
  oled2.print(Temperatur);
  oled2.print(".0 C");

  /* Oben rechts die Dauer */
  oled2.setCursor(116, 0);  // Start at top-left corner
  oled2.print(Zeitraum_1);

  oled2.display();
}

/* ------------------------------------------------ */
/*             Batteriespannung GRAFIK              */
/* ------------------------------------------------ */

void DrawSpannungsGraph() {
#define HIGHERLIMIT (2 * 145)
#define LOWERLIMIT (2 * 124)

  // Berechne die Skalierung
  const float scale = Y_LEN / ((float)(HIGHERLIMIT - LOWERLIMIT) / SCALE_FAK);

  oled2.clearDisplay();
  // Zeichne eine Linie für jeden Wert im Array
  for (int i = 0; i < X_LEN; i++) {
    // Berechne die x- und y-Koordinaten der Linie
    int length = ((Tables.Spannung[i] - LOWERLIMIT) * scale);
    int x = i;
    int y = Y_LEN - length;

    // Zeichne die Linie
    oled2.drawFastVLine(x, y, length, SSD1306_WHITE);
  }

  /* Beschriftung einfügen */
  oled2.setTextColor(SSD1306_WHITE, SSD1306_BLACK);
  oled2.setTextSize(1);
  oled2.setCursor(0, 0);  // Start at top-left corner
  oled2.print("UBatt ");
  oled2.print(Data.UBatt / 2);
  oled2.print(" V");

  /* Oben rechts die Dauer */
  oled2.setCursor(116, 0);  // Start at top-left corner
  oled2.print(Tagesspanne);

  oled2.display();
}

/* ------------------------------------------------ */
/*             Windgeschwindigkeit GRAFIK           */
/* ------------------------------------------------ */

void DrawWindGraph() {
  // Berechne die Skalierung
  const float scale = Y_LEN / (MAX_WIND / SCALE_FAK);

  oled2.clearDisplay();
  // Zeichne eine Linie für jeden Wert im Array
  for (int i = 0; i < X_LEN; i++) {
    // Berechne die x- und y-Koordinaten der Linie
    int length = (Tables.Wind[i] * scale);
    int x = i;
    int y = Y_LEN - length;
    // Zeichne die Linie
    oled2.drawFastVLine(x, y, length, SSD1306_WHITE);
  }

  /* Beschriftung einfügen */
  oled2.setTextColor(SSD1306_WHITE, SSD1306_BLACK);
  oled2.setTextSize(1);
  oled2.setCursor(0, 0);  // Start at top-left corner
  oled2.print("Wind ");
  oled2.print((int)Windstaerke);
  oled2.print(" bft");

  /* Oben rechts die Dauer */
  oled2.setCursor(116, 0);  // Start at top-left corner
  oled2.print(Zeitraum_1);

  oled2.display();
}

/* ------------------------------------------------ */
/*             Bewölkungs GRAFIK                    */
/* ------------------------------------------------ */

void DrawWolkenGraph() {
  // Berechne die Skalierung
  const float scale = Y_LEN / (100.0 / SCALE_FAK);

  oled2.clearDisplay();
  // Zeichne eine Linie für jeden Wert im Array
  for (int i = 0; i < X_LEN; i++) {
    // Berechne die x- und y-Koordinaten der Linie
    int length = (Tables.Bewoelkung[i] * scale);
    int x = i;
    int y = Y_LEN - length;

    // Zeichne die Linie
    oled2.drawFastVLine(x, y, length, SSD1306_WHITE);
  }

  /* Beschriftung einfügen */
  oled2.setTextColor(SSD1306_WHITE, SSD1306_BLACK);
  oled2.setTextSize(1);
  oled2.setCursor(0, 0);  // Start at top-left corner
  if (Wolkendichte > 10) {
    oled2.print("Wolken ");
    oled2.print(Wolkendichte);
    oled2.print("%");
  } else
    oled2.print("Klarer Himmel");

  /* Oben rechts die Dauer */
  oled2.setCursor(116, 0);  // Start at top-left corner
  oled2.print(Zeitraum_1);
  oled2.display();
}

/* ------------------------------------------------ */
/*             Regenwetter GRAFIK                   */
/* ------------------------------------------------ */

void DrawRegenGraph() {
  // Berechne die Skalierung
  const float scale = Y_LEN / (100.0 / SCALE_FAK);

  oled2.clearDisplay();
  // Zeichne eine Linie für jeden Wert im Array
  for (int i = 0; i < X_LEN; i++) {
    // Berechne die x- und y-Koordinaten der Linie
    int length = (Tables.Regen[i] * scale);
    int x = i;
    int y = Y_LEN - length;

    // Zeichne die Linie
    oled2.drawFastVLine(x, y, length, SSD1306_WHITE);
  }

  /* Beschriftung einfügen */
  oled2.setTextColor(SSD1306_WHITE, SSD1306_BLACK);
  oled2.setTextSize(1);
  oled2.setCursor(0, 0);  // Start at top-left corner
  if ((WetterID >= 500) && (WetterID < 600))
    oled2.print("Regen");
  else if ((WetterID >= 600) && (WetterID < 700))
    oled2.print("Schnee");
  else
    oled2.print("Trocken");

  /* Oben rechts die Dauer */
  oled2.setCursor(116, 0);  // Start at top-left corner
  oled2.print(Zeitraum_1);

  oled2.display();
}

/* ------------------------------------------------ */
/*            Batterie Netz Zyklen 5 Tage           */
/* ------------------------------------------------ */

void DrawBattNetzZyklen() {
  // Berechne die Skalierung
  const float scale = Y_LEN / (100.0 / SCALE_FAK);

  oled2.clearDisplay();
  // Zeichne eine Linie für jeden Wert im Array
  for (int i = 0; i < X_LEN; i++) {
    // Berechne die x- und y-Koordinaten der Linie
    int length = (Tables.Zyklen[i] * scale);
    int x = i;
    int y = Y_LEN - length;

    // Zeichne die Linie
    oled2.drawFastVLine(x, y, length, SSD1306_WHITE);
  }

  /* Beschriftung einfügen */
  oled2.setTextColor(SSD1306_WHITE, SSD1306_BLACK);
  oled2.setTextSize(1);
  oled2.setCursor(0, 0);  // Start at top-left corner
  oled2.print("Load Akku");

  /* Oben rechts die Dauer */
  oled2.setCursor(116, 0);  // Start at top-left corner
  oled2.print(Zeitraum_1);

  oled2.display();
}


/* Gesamtleistung */
void DrawTotalPower() {
  oled2.clearDisplay();
  oled2.setTextSize(2);
  oled2.setCursor(0, 0);  // Start at top-left corner
  oled2.print("D:");
  oled2.print((int)(Data.WhSolarNetz + Data.WhSolarBatt));
  oled2.println(" Wh");
  oled2.print("T:");
  if (f_IsDayTime)
    oled2.print((float)(Tables.TotalPower + Data.WhSolarNetz + Data.WhSolarBatt) / 1000);
  else
    oled2.print((float)(Tables.TotalPower) / 1000);

  oled2.print(" kWh");
  oled2.display();
}

/* Display 1 mit einem String beschreiben */
void PrintBuf_D1(const char* satz) {
  oled1.setTextSize(2);
  oled1.clearDisplay();
  oled1.setCursor(0, 0);  // Start at top-left corner
  oled1.print(satz);
  oled1.display();
}

/* Display 2 mit einem String beschreiben */
void PrintBuf_D2(const char* satz) {
  oled2.setTextSize(3);
  oled2.clearDisplay();
  oled2.setCursor(0, 0);  // Start at top-left corner
  oled2.print(satz);
  oled2.display();
}

int GetWindstaerke(int Windspeed) {
  int staerke;

  if (Windspeed < 1)
    staerke = 0;
  else if (IsInRange(Windspeed, 1, 5)) staerke = 1;
  else if (IsInRange(Windspeed, 6, 11)) staerke = 2;
  else if (IsInRange(Windspeed, 12, 19)) staerke = 3;
  else if (IsInRange(Windspeed, 20, 28)) staerke = 4;
  else if (IsInRange(Windspeed, 29, 38)) staerke = 5;
  else if (IsInRange(Windspeed, 39, 49)) staerke = 6;
  else if (IsInRange(Windspeed, 50, 61)) staerke = 7;
  else if (IsInRange(Windspeed, 62, 74)) staerke = 8;
  else if (IsInRange(Windspeed, 75, 88)) staerke = 9;
  else if (IsInRange(Windspeed, 89, 102)) staerke = 10;
  else if (IsInRange(Windspeed, 103, 117)) staerke = 11;
  else
    staerke = 12;

  return (staerke);
}