/*
  This file is part of esp-find3-client by Sylwester aka DatanoiseTV.
  The original source can be found at https://github.com/DatanoiseTV/esp-find3-client.

  26/04/2020: Adjustments by Wizardry and Steamworks.

  esp-find3-client is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  esp-find3-client is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with esp-find3-client.  If not, see <http://www.gnu.org/licenses/>.
*/

///////////////////////////////////////////////////////////////////////////
//                             CONFIGURATION                             //
///////////////////////////////////////////////////////////////////////////

// Set to the WiFi AP name.
#define WIFI_SSID ""
// Set to the WiFi AP password.
#define WIFI_PSK ""

// Set to 1 for learning mode.
#define MODE_LEARNING 1
#define LOCATION ""

// Family name.
#define FAMILY_NAME ""

// BLE requires large app partition or the sketch will not fit.
// Please choose:
// * Tools -> Partition scheme -> Minimal SPIFFS (1.9MB APP / 190KB SPIFFS)
// and set to 1 to enable BLE.
#define USE_BLE 1
#define BLE_SCANTIME 5

// Official server: cloud.internalpositioning.com
#define FIND_HOST "cloud.internalpositioning.com"
// Official port: 443 and SSL set to 1
#define FIND_PORT 443
// Whether to use SSL for the HTTP connection.
// Set to 1 for official cloud server.
#define USE_HTTP_SSL 1
// Timeout connecting to find3 server expressed in milliseconds.
#define HTTP_TIMEOUT 2500

// The NTP server to use for time updates.
#define NTP_HOST "pool.ntp.org"
// The offset in seconds from UTC, ie: 3600 for +1 Hour.
#define UTC_OFFSET 2 * 3600

// The password to use for OTA updates.
#define OTA_PASSWORD ""

// Set to 1 to enable. Used for verbose debugging.
#define DEBUG 1

///////////////////////////////////////////////////////////////////////////
//                              INTERNALS                                //
///////////////////////////////////////////////////////////////////////////

#ifdef ARDUINO_ARCH_ESP32
#include <WiFiClientSecure.h>
#include <WiFi.h>
#else
#include <ESP8266WiFi.h>
#endif
#include <WiFiUdp.h>
#include <NTPClient.h>
#include <ArduinoOTA.h>

#if defined(ARDUINO_ARCH_ESP8266)
#define GET_CHIP_ID() String(ESP.getChipId(), HEX)
#elif defined(ARDUINO_ARCH_ESP32)
#define GET_CHIP_ID() String(((uint16_t)(ESP.getEfuseMac()>>32)), HEX)
#endif

#define uS_TO_S_FACTOR 1000000  /* Conversion factor for micro seconds to seconds */

#define ARDUINOJSON_USE_LONG_LONG 1
#include <ArduinoJson.h>

// Automagically disable BLE on ESP8266
#if defined(ARDUINO_ARCH_ESP8266) && !defined(ARDUINO_ARCH_ESP32)
#define USE_BLE 0
#endif

#if defined(ARDUINO_ARCH_ESP32) && (USE_BLE == 1)
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEScan.h>

class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
    void onResult(BLEAdvertisedDevice advertisedDevice) {
      // Serial.printf("Advertised Device: %s \n", advertisedDevice.toString().c_str());
    }
};
#endif

#ifdef ARDUINO_ARCH_ESP32
RTC_DATA_ATTR int bootCount = 0;
#endif

WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, NTP_HOST, UTC_OFFSET, 60000);

// Retrieves the WiFi MAC address.
String getWiFiMAC() {
  String result;
  byte mac[6];
  WiFi.macAddress(mac);
  for (int i = 5; i > -1; --i) {
    result += String(mac[i], HEX);
    if (i != 0) {
      result += ":";
    }
  }
  return result;
}

void SubmitWiFi(void)
{
  Serial.println("[ INFO ]\tWiFi MAC: " + getWiFiMAC());

  String request;

  StaticJsonDocument<256> jsonBuffer;
  JsonObject root = jsonBuffer.to<JsonObject>();

  root["d"] = "esp-" + GET_CHIP_ID();
  root["f"] = FAMILY_NAME;
  root["t"] = timeClient.getEpochTime();
#if (MODE_LEARNING == 1)
  Serial.println("[ iNFO ]\tLearning enabled, sending learning data.");
  root["l"] = LOCATION;
#endif

  JsonObject data = root.createNestedObject("s");

  Serial.println("[ INFO ]\tWiFi scan starting..");
  int n = WiFi.scanNetworks(false, true);
  Serial.println("[ INFO ]\tWiFi Scan finished.");
  if (n == 0) {
    Serial.println("[ ERROR ]\tNo networks found");
  } else {
    Serial.print("[ INFO ]\t");
    Serial.print(n);
    Serial.println(" WiFi networks found.");
    JsonObject wifi_network = data.createNestedObject("wifi");
    for (int i = 0; i < n; ++i) {
      wifi_network[WiFi.BSSIDstr(i)] = WiFi.RSSI(i);
    }

#if (USE_BLE == 1)
    Serial.println("[ INFO ]\tBLE scan starting..");
    BLEDevice::init("");
    BLEAddress btMAC = BLEDevice::getAddress();
    Serial.println("[ INFO ]\tBT MAC: " + String(btMAC.toString().c_str()));
    BLEScan* pBLEScan = BLEDevice::getScan(); // create new scan
    pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
    pBLEScan->setActiveScan(true); // active scan uses more power, but get results faster
    BLEScanResults foundDevices = pBLEScan->start(BLE_SCANTIME);

    Serial.print("[ INFO ]\t");
    Serial.print(foundDevices.getCount());
    Serial.println(" BLE devices found.");

    JsonObject bt_network = data.createNestedObject("bluetooth");
    for (int i = 0; i < foundDevices.getCount(); i++)
    {
      std::string mac = foundDevices.getDevice(i).getAddress().toString();
      bt_network[(String)mac.c_str()] = (int)foundDevices.getDevice(i).getRSSI();
    }
#else
    Serial.println("[ INFO ]\tBLE scan skipped (BLE disabled)..");
#endif // USE_BLE

    serializeJson(root, request);

#if (DEBUG == 1)
    Serial.println("[ DEBUG ]\t" + request);
#endif

#if (USE_HTTP_SSL == 1)
    WiFiClientSecure client;
#else
    WiFiClient client;
#endif
    if (!client.connect(FIND_HOST, FIND_PORT)) {
      Serial.println("[ WARN ]\tConnection to server failed, restarting in 5s...");
      delay(5000);
      ESP.restart();
    }

    // We now create a URI for the request
    String url = "/data";

    Serial.print("[ INFO ]\tRequesting URL: ");
    Serial.println(url);

    // This will send the request to the server
    client.print(String("POST ") + url + " HTTP/1.1\r\n" +
                 "Host: " + FIND_HOST + "\r\n" +
                 "Content-Type: application/json\r\n" +
                 "Content-Length: " + request.length() + "\r\n\r\n" +
                 request +
                 "\r\n\r\n"
                );
                
    client.flush();

    unsigned long timeout = millis();
    while (client.available() == 0) {
      if (millis() - timeout > HTTP_TIMEOUT) {
        Serial.println("[ ERROR ]\tHTTP Client Timeout!");
        client.stop();
        return;
      }
    }

    // Check HTTP status
    char status[60] = {0};
    client.readBytesUntil('\r', status, sizeof(status));
    if (strcmp(status, "HTTP/1.1 200 OK") != 0) {
      Serial.print(F("[ ERROR ]\tUnexpected Response: "));
      Serial.println(status);
      return;
    }
    else
    {
      Serial.println(F("[ INFO ]\tGot a 200 OK."));
    }

    char endOfHeaders[] = "\r\n\r\n";
    if (!client.find(endOfHeaders)) {
      Serial.println(F("[ ERROR ]\t Invalid Response"));
      return;
    }
    else
    {
      Serial.println("[ INFO ]\tLooks like a valid response.");
    }

    Serial.println("[ INFO ]\tClosing connection.");
    Serial.println("=============================================================");
  }
}

void setup() {
  Serial.begin(115200);
  delay(1000);

#if defined(ARDUINO_ARCH_ESP32) && (USE_BLE == 1)
  Serial.println("Find3 ESP client by DatanoiseTV (WiFi + BLE support.)");
#else
  Serial.println("Find3 ESP client by DatanoiseTV (WiFi support WITHOUT BLE.)");
#endif

  Serial.print("[ INFO ]\tESP ID is: ");
  Serial.println("esp-" + GET_CHIP_ID());

  // Hostname defaults to esp8266-[ChipID]
  ArduinoOTA.setHostname(String("esp-" + GET_CHIP_ID()).c_str());
  // Set the OTA password
  ArduinoOTA.setPassword(OTA_PASSWORD);
  ArduinoOTA.onStart([]() {
    Serial.println("=============================================================");
    switch (ArduinoOTA.getCommand()) {
      case U_FLASH: // Sketch
        Serial.println("[ INFO ]\tOTA start updating sketch.");
        break;
#if defined(ARDUINO_ARCH_ESP8266)
      case U_FS:
#elif defined(ARDUINO_ARCH_ESP32)
      case U_SPIFFS:
#endif
        Serial.println("[ INFO ]\tOTA start updating filesystem.");
        break;
      default:
        Serial.println("[ WARN ]\tUnknown OTA update type.");
        break;
    }
  });
  ArduinoOTA.onEnd([]() {
    Serial.println("[ INFO ]\tOTA update complete.");
    Serial.println("=============================================================");
    ESP.restart();
  });
  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
    Serial.printf("[ INFO ]\tOTA update progress: %u%%\r", (progress / (total / 100)));
  });
  ArduinoOTA.onError([](ota_error_t error) {
    Serial.printf("[ ERROR ]\tOTA update error [%u]: ", error);
    switch (error) {
      case OTA_AUTH_ERROR:
        Serial.println("OTA authentication failed");
        break;
      case OTA_BEGIN_ERROR:
        Serial.println("OTA begin failed");
        break;
      case OTA_CONNECT_ERROR:
        Serial.println("OTA connect failed");
        break;
      case OTA_RECEIVE_ERROR:
        Serial.println("OTA receive failed");
        break;
      case OTA_END_ERROR:
        Serial.println("OTA end failed");
        break;
      default:
        Serial.println("Unknown OTA failure");
        break;
    }
    ESP.restart();
  });
}

void loop() {
  // If WiFi is not connected, attempt to reconnect and if that fails then restart.
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("[ WARN ]\tWiFi not connected, retrying...");
    WiFi.disconnect();
#if defined(ARDUINO_ARCH_ESP32)
    WiFi.setHostname(String("esp-" + GET_CHIP_ID()).c_str());
#elif defined(ARDUINO_ARCH_ESP8266)
    WiFi.hostname(String("esp-" + GET_CHIP_ID()).c_str());
#endif
    WiFi.mode(WIFI_STA);
    WiFi.begin(WIFI_SSID, WIFI_PSK);
    while (WiFi.waitForConnectResult() != WL_CONNECTED) {
      Serial.println("[ ERROR ]\tFailed to connect to Wifi, rebooting in 5s...");
      delay(5000);
      ESP.restart();
    }
    Serial.println("[ INFO ]\tStarting OTA...");
    ArduinoOTA.begin();

    Serial.println("[ INFO ]\tStarting NTP...");
    timeClient.begin();
  }
  ArduinoOTA.handle();
  timeClient.update();
  SubmitWiFi();
}