/*
  Подключения:
  NodeMCU    -> Matrix
  MOSI-D7-GPIO13  -> DIN
  CLK-D5-GPIO14   -> Clk
  GPIO0-D3        -> LOAD
*/
#include <WiFiUdp.h>
#include <PubSubClient.h>
#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <Adafruit_GFX.h>
#include <ESP8266mDNS.h>
#include <Max72xxPanel.h>

// =======================================================================
// Конфигурация устройства:
// =======================================================================
const char* host = "informer_in";
const char* ssid     = "katya";                      // SSID
const char* password = "89086401772";                    // пароль
// =======================================================================

ESP8266WebServer server(80);
const char* serverIndex = "<form method='POST' action='/update' enctype='multipart/form-data'><input type='file' name='update'><input type='submit' value='Update'></form>";

const char *mqtt_server = "192.168.1.70"; // Имя сервера MQTT
const int mqtt_port = 1883; // Порт для подключения к серверу MQTT
const char *mqtt_user = "yunin"; // Логи от сервер
const char *mqtt_pass = "yunindenis"; // Пароль от сервера

WiFiClient wclient;
PubSubClient client(wclient);

int clouds;
float windSpeed;
float temp = 0;
String date;
String line;
String currencyRates;
String scroll_String;
String text1;

//датчик света
const int inRaw = A0; //вход датчик света
int raw = 0; //сила света
int raw_mean = 0; //сила света среднее
int raw_old = 0; //сила света

String str;

//подсчет времени
long previousMillis_time = 0;  // храним время последнего подключения
long interval_time = 3600000;     //интервал 1 час

//raw
long previousMillis_raw = 0;  // храним время последнего подключения
long interval_raw = 60000;     //интервал

//mqtt send
long previousMillis_mqtt_send = 0;  // храним время последнего подключения
long interval_mqtt_send = 15000;     //интервал

//mqtt raw
long previousMillis_mqtt_raw = 0;  // храним время последнего подключения
long interval_mqtt_raw = 60000;     //интервал

//wifi
long previousMillis_wifi = 0;  // храним время последнего подключения
long interval_wifi = 10000;     //интервал
unsigned long currentMillis_wifi = 0;

//mqtt broker
long previousMillis_mqtt_connect = 0;  // храним время последнего подключения
long interval_mqtt_connect = 60000;     //интервал
unsigned long currentMillis_mqtt_connect = 0;

long period;
int offset = 1, refresh = 0;
int pinCS = 0; // Подключение пина CS
int numberOfHorizontalDisplays = 4; // Количество светодиодных матриц по Горизонтали
int numberOfVerticalDisplays = 1; // Количество светодиодных матриц по Вертикали
String decodedMsg;
Max72xxPanel matrix = Max72xxPanel(pinCS, numberOfHorizontalDisplays, numberOfVerticalDisplays);
//matrix.cp437(true);

int wait = 50; // скорость бегущей строки

int spacer = 2;
int width = 5 + spacer; // Регулируем расстояние между символами

// =======================================================================
// Функция получения данных от сервера
void callback(char* topic, byte* payload, unsigned int length)
{
  //--------------------------------------------------------------------------------------
  //строка
  if (String(topic) == "ihouse/gadget/informerIn")
  {
    str = "";
    for (int i = 0; i < length; i++)
    {
      str = str + (char)payload[i];
    }
  }
}

// =======================================================================
void mqtt_reconnect()
{
  unsigned long currentMillis_mqtt_connect = millis();

  // подключаемся к MQTT серверу
  if (currentMillis_mqtt_connect - previousMillis_mqtt_connect >= interval_mqtt_connect)
  {
    String clientId = "informerIn";
    clientId += String(random(0xffff), HEX);
    if (client.connect(clientId.c_str(), mqtt_user, mqtt_pass))
    {
      //подписываемся по топики
      client.subscribe("ihouse/gadget/informerIn");
      client.loop();
    }
    previousMillis_mqtt_connect = currentMillis_mqtt_connect;
  }
}
// =======================================================================
void setup_wifi()
{
  unsigned long currentMillis_wifi = millis();

  if (currentMillis_wifi - previousMillis_wifi >= interval_wifi)
  {
    WiFi.begin(ssid, password); //конектимся
    previousMillis_wifi = currentMillis_wifi;
  }
}

// =======================================================================
void setup()
{
  // присваиваем статичесий IP адрес
  WiFi.mode(WIFI_STA); // режим клиента
  WiFi.config(IPAddress(192, 168, 1, 71), IPAddress(192, 168, 1, 1), IPAddress(255, 255, 255, 0), IPAddress(192, 168, 1, 1));

  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
  delay(10);

  WiFi.begin(ssid, password);
  delay(10);

  //запуск web сервера для удаленной прошивки
  if (WiFi.waitForConnectResult() == WL_CONNECTED) {
    MDNS.begin(host);
    server.on("/", HTTP_GET, []() {
      server.sendHeader("Connection", "close");
      server.send(200, "text/html", serverIndex);
    });
    server.on("/update", HTTP_POST, []() {
      server.sendHeader("Connection", "close");
      server.send(200, "text/plain", (Update.hasError()) ? "FAIL" : "OK");
      ESP.restart();
    }, []() {
      HTTPUpload& upload = server.upload();
      if (upload.status == UPLOAD_FILE_START) {
        Serial.setDebugOutput(true);
        WiFiUDP::stopAll();
        uint32_t maxSketchSpace = (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
        if (!Update.begin(maxSketchSpace)) { //start with max available size
          Update.printError(Serial);
        }
      } else if (upload.status == UPLOAD_FILE_WRITE) {
        if (Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
          Update.printError(Serial);
        }
      } else if (upload.status == UPLOAD_FILE_END) {
        if (Update.end(true)) { //true to set the size to the current progress
          } else {
          Update.printError(Serial);
        }
        Serial.setDebugOutput(false);
      }
      yield();
    });
    server.begin();
    MDNS.addService("http", "tcp", 80);
  }

  // начальные координаты матриц 8*8
  matrix.setRotation(0, 1);        // 1 матрица
  matrix.setRotation(1, 1);        // 2 матрица
  matrix.setRotation(2, 1);        // 3 матрица
  matrix.setRotation(3, 1);        // 4 матрица

  getTime();
  updateTime();

  pinMode(inRaw,  INPUT);
}

// =======================================================================
#define MAX_DIGITS 16
byte dig[MAX_DIGITS] = {0};
byte digold[MAX_DIGITS] = {0};
byte digtrans[MAX_DIGITS] = {0};
int updCnt = 0;
int dots = 0;
long dotTime = 0;
long clkTime = 0;
int dx = 0;
int dy = 0;
byte del = 0;
int h, m, s;
int h_old, m_old;

// =======================================================================
// Функция отправки в mqtt
void TempSend()
{
  unsigned long currentMillis_mqtt_send = millis();
  unsigned long currentMillis_mqtt_raw = millis();

  if (currentMillis_mqtt_send - previousMillis_mqtt_send >= interval_mqtt_send)
  {
    previousMillis_mqtt_send = currentMillis_mqtt_send;
    client.publish("ihouse/work/informerIn", String(random(1000)).c_str());
  }

  if (h != h_old)
  {
    client.publish("ihouse/clock/h", String(h).c_str());
    h_old = h;
  }

  if (m != m_old)
  {
    //client.publish("ihouse/clock/h", String(h).c_str());
    client.publish("ihouse/clock/m", String(m).c_str());
    m_old = m;
  }

  if (currentMillis_mqtt_raw - previousMillis_mqtt_raw >= interval_mqtt_raw)
  {
    previousMillis_mqtt_raw = currentMillis_mqtt_raw;
    client.publish("ihouse/raw", String(raw).c_str()); // отправляем в топик значение освещенности
  }
  delay(10);
}

//=======================================================================
void DisplayTime()
{
  updateTime();
  matrix.fillScreen(LOW);
  int y = (matrix.height() - 8) / 2; // Центрируем текст по Вертикали

  if (s & 1) {
    matrix.drawChar(14, y, (String(":"))[0], HIGH, LOW, 1); //каждую четную секунду печатаем двоеточие по центру (чтобы мигало)
  }
  else {
    matrix.drawChar(14, y, (String(" "))[0], HIGH, LOW, 1);
  }

  String hour1 = String (h / 10);
  String hour2 = String (h % 10);
  String min1 = String (m / 10);
  String min2 = String (m % 10);
  String sec1 = String (s / 10);
  String sec2 = String (s % 10);
  int xh = 2;
  int xm = 19;
  //    int xs = 28;

  matrix.drawChar(xh, y, hour1[0], HIGH, LOW, 1);
  matrix.drawChar(xh + 6, y, hour2[0], HIGH, LOW, 1);
  matrix.drawChar(xm, y, min1[0], HIGH, LOW, 1);
  matrix.drawChar(xm + 6, y, min2[0], HIGH, LOW, 1);

  matrix.write(); // Вывод на дисплей
}

// =======================================================================
void DisplayText(String text) {
  matrix.fillScreen(LOW);
  for (int i = 0; i < text.length(); i++)
  {
    int letter = (matrix.width()) - i * (width - 1);
    int x = (matrix.width() + 1) - letter;
    int y = (matrix.height() - 8) / 2; // Центрируем текст по Вертикали
    matrix.drawChar(x, y, text[i], HIGH, LOW, 1);
    matrix.write(); // Вывод на дисплей

  }
}
// =======================================================================
void ScrollText (String text) {
  for ( int i = 0 ; i < width * text.length() + matrix.width() - 1 - spacer; i++ )
  {
    if (refresh == 1) i = 0;
    refresh = 0;
    matrix.fillScreen(LOW);
    int letter = i / width;
    int x = (matrix.width() - 1) - i % width;
    int y = (matrix.height() - 8) / 2; // Центрируем текст по Вертикали

    while ( x + width - spacer >= 0 && letter >= 0 ) {
      if ( letter < text.length() ) {
        matrix.drawChar(x, y, text[letter], HIGH, LOW, 1);
      }
      letter--;
      x -= width;
    }
    matrix.write(); // Вывод на дисплей
    delay(wait);
  }
}

// =======================================================================
void getStringData()
{
  String deg = String(char('~' + 25));
  scroll_String = str;
}

// =======================================================================
// Берем время у GOOGLE
// =======================================================================

float utcOffset = 8; //поправка часового пояса
long localEpoc = 0;
long localMillisAtUpdate = 0;

void getTime()
{
  WiFiClient time_client;
  if (!time_client.connect("www.google.com", 80))
  {
    return;
  }

  time_client.print(String("GET / HTTP/1.1\r\n") +
                    String("Host: www.google.com\r\n") +
                    String("Connection: close\r\n\r\n"));
  int repeatCounter = 0;
  while (!time_client.available() && repeatCounter < 10) {
    delay(500);
    repeatCounter++;
  }

  String line;
  time_client.setNoDelay(false);
  while (time_client.connected() && time_client.available()) {
    line = time_client.readStringUntil('\n');
    line.toUpperCase();
    if (line.startsWith("DATE: ")) {
      date = "     " + line.substring(6, 22);
      h = line.substring(23, 25).toInt();
      m = line.substring(26, 28).toInt();
      s = line.substring(29, 31).toInt();
      localMillisAtUpdate = millis();
      localEpoc = (h * 60 * 60 + m * 60 + s);
    }
  }
  time_client.stop();
}

// =======================================================================r

void updateTime()
{
  long curEpoch = localEpoc + ((millis() - localMillisAtUpdate) / 1000);
  long epoch = round(curEpoch + 3600 * utcOffset + 86400L) % 86400L;
  h = ((epoch  % 86400L) / 3600) % 24;
  m = (epoch % 3600) / 60;
  s = epoch % 60;
}

// =======================================================================


String utf8rus(String source)
{
  int i, k;
  String target;
  unsigned char n;
  char m[2] = { '0', '\0' };

  k = source.length(); i = 0;

  while (i < k) {
    n = source[i]; i++;

    if (n >= 0xC0) {
      switch (n) {
        case 0xD0: {
            n = source[i]; i++;
            if (n == 0x81) {
              n = 0xA8;
              break;
            }
            if (n >= 0x90 && n <= 0xBF) n = n + 0x30 - 1;
            break;
          }
        case 0xD1: {
            n = source[i]; i++;
            if (n == 0x91) {
              n = 0xB8;
              break;
            }
            if (n >= 0x80 && n <= 0x8F) n = n + 0x70 - 1;
            break;
          }
      }
    }
    m[0] = n; target = target + String(m);
  }
  return target;
}

// =======================================================================
void loop()
{
  unsigned long currentMillis_time = millis();
  unsigned long currentMillis_raw = millis();

  //--------------------------------------------------------------------------------------
  if (WiFi.status() != WL_CONNECTED) //если нет подключения к вифи
  {
    setup_wifi();
  }

  //--------------------------------------------------------------------------------------
  if (WiFi.status() == WL_CONNECTED)
  {
    if (!client.connected())
    {
      mqtt_reconnect();
    }
  }

  //--------------------------------------------------------------------------------------
  client.loop();
  TempSend();

  raw = analogRead(inRaw);

  //запуск синхронизации времени
  if (currentMillis_time - previousMillis_time >= interval_time)
  {
    previousMillis_time = currentMillis_time;
    getTime();
  }

  server.handleClient();
  delay(1);

  if (updCnt <= 0)
  { // каждые 100 циклов получаем данные температуры и давления
    updCnt = 2;
    getStringData();
    //getTime();
    clkTime = millis();
  }

  //каждые 15 секунд запускаем бегущую строку
  if (millis() - clkTime > 15000 && !del && dots)
  {
    ScrollText(utf8rus(scroll_String));
    updCnt--;
    clkTime = millis();
  }

  DisplayTime();
  if (millis() - dotTime > 500)
  {
    dotTime = millis();
    dots = !dots;
  }

  //--------------------------------------------------------------------------------------
  //яркость дисплея
  if (raw <= 50)
  {
    if (currentMillis_raw - previousMillis_raw > interval_raw)
    {
      previousMillis_raw = currentMillis_raw;
      matrix.setIntensity(15); // Яркость матрицы от 0 до 15
    }
  }
  if (raw > 50 && raw <= 100)
  {
    if (currentMillis_raw - previousMillis_raw > interval_raw)
    {
      previousMillis_raw = currentMillis_raw;
      matrix.setIntensity(12); // Яркость матрицы от 0 до 15
    }
  }
  if (raw > 100 && raw <= 200)
  {
    if (currentMillis_raw - previousMillis_raw > interval_raw)
    {
      previousMillis_raw = currentMillis_raw;
      matrix.setIntensity(10); // Яркость матрицы от 0 до 15
    }
  }
  if (raw > 200 && raw <= 500)
  {
    if (currentMillis_raw - previousMillis_raw > interval_raw)
    {
      previousMillis_raw = currentMillis_raw;
      matrix.setIntensity(8); // Яркость матрицы от 0 до 15
    }
  }
  if (raw > 500 && raw <= 700)
  {
    if (currentMillis_raw - previousMillis_raw > interval_raw)
    {
      previousMillis_raw = currentMillis_raw;
      matrix.setIntensity(5); // Яркость матрицы от 0 до 15
    }
  }
  if (raw > 700 && raw <= 900)
  {
    if (currentMillis_raw - previousMillis_raw > interval_raw)
    {
      previousMillis_raw = currentMillis_raw;
      matrix.setIntensity(3); // Яркость матрицы от 0 до 15
    }
  }
  if (raw > 900)
  {
    if (currentMillis_raw - previousMillis_raw > interval_raw)
    {
      previousMillis_raw = currentMillis_raw;
      matrix.setIntensity(0); // Яркость матрицы от 0 до 15
    }
  }

}