#include <WiFi.h>                 //
#include <esp_wifi.h>             //
#include <Ticker.h>

#include "common.h"

/////////////////////////////////////////////////////////////////////////
Ticker flipper;

/////////////////////////////////////////////////////////////////////////

#define DASHED_LINES "\n-------------------------------------------------------\n"
#define PRINT_DASHED_LINES printf("-------------------------------------------------------\n");  // DASHED_LINES

#define LED_1 15
#define LED_2 16
#define LED_3 17

const uint8_t LEDS[] = { LED_1, LED_2, LED_3 };  //
const size_t NUM_OUT = sizeof(LEDS);

char BaffESPinfo[40];

int count = 0;
bool FlagStop = true;

// ======================================================================
void flip() {
  ++count;
  // when the counter reaches yet another value, stop blinking
  if (count == 60) {
    flipper.detach();
    FlagStop = false;
    digitalWrite(LED_1, 0);
    digitalWrite(LED_2, 0);
    digitalWrite(LED_3, 1);
    printf("- stop blinking -  count : %d\n", count);
  }
}


// ======================================================================
// ESP Flash Chip Mode
static const char *const PROGMEM FlashChipMode[] = { "QIO", "QOUT", "DIO", "DOUT", "FM FAST READ", "FM SLOW READ", "UNKNOWN" };


//======================================================================
// Arduino Core Version
static const char *GetCoreVersion() {
  sprintf(BaffESPinfo, "%u.%u.%u", ESP_ARDUINO_VERSION_MAJOR, ESP_ARDUINO_VERSION_MINOR, ESP_ARDUINO_VERSION_PATCH);
  return BaffESPinfo;
}

// ======================================================================
// ESP id
static char *GetESPid() {
  sprintf(BaffESPinfo, "%012llX", ESP.getEfuseMac());
  return BaffESPinfo;
}

// ======================================================================
// ESP Chip Model
static char *GetChipModel() {
  sprintf(BaffESPinfo, "%s Rev.%d", ESP.getChipModel(), ESP.getChipRevision());
  return BaffESPinfo;
}

// ======================================================================
// format bytes
static const char *formatBytes(size_t bytes) {
  if (bytes < 1024) {
    sprintf(BaffESPinfo, "%d Byte", bytes);
    return BaffESPinfo;
  } else if (bytes < (1024 * 1024)) {
    sprintf(BaffESPinfo, "%.2f KB", (bytes / 1024.0));
    return BaffESPinfo;
  } else if (bytes < (1024 * 1024 * 1024)) {
    sprintf(BaffESPinfo, "%.2f MB", (bytes / 1024.0 / 1024.0));
    return BaffESPinfo;
  } else {
    sprintf(BaffESPinfo, "%.2f GB", (bytes / 1024.0 / 1024.0 / 1024.0));
    return BaffESPinfo;
  }
}

/////////////////////////////////////////////////////////////////////////
//=======================================================================
void setup() {
  Serial.begin(115200);

  printf("\n------ Hello, ESP32-S3! -------------------------------\n\r");
  printf("Arduino IDE     : %d.%d.%d \n", ARDUINO / 10000, ARDUINO % 10000 / 100, ARDUINO % 100 / 10 ? ARDUINO % 100 : ARDUINO % 10);
  printf("Compiler ver.   : %s\n", __VERSION__);  // gcc version
  printf("Compile Date    : %s\n", (__DATE__ ", " __TIME__));  // compilation date, time
  printf("Author          : Kernel Panic\n");
  PRINT_DASHED_LINES;

  for (uint8_t i = 0; i < NUM_OUT; i++) {
    pinMode(LEDS[i], OUTPUT);
  }
  // flip the pin every 0.3s
  flipper.attach(0.3, flip);

  PrintReport();
  //  printESPinfo();
}





//=======================================================================
void loop() {
  if (FlagStop) {
    vTaskDelay(500);
    digitalWrite(LED_1, !digitalRead(LED_1));
    // printf("Time LED_1: %.2f sec. \r\n", (millis() / 1000.0));

    vTaskDelay(500);
    digitalWrite(LED_2, !digitalRead(LED_2));
    // printf("Time LED_2: %.2f sec. \r\n", (millis() / 1000.0));

    vTaskDelay(500);
    digitalWrite(LED_3, !digitalRead(LED_3));
    // printf("Time LED_3: %.2f sec. \r\n", (millis() / 1000.0));

    //  digitalWrite(LED_3, millis() % 1005 < 505);
  }
  delay(2);
}


//=======================================================================
// print ESP info
void printESPinfo() {
  uint32_t chipId;
  for (int i = 0; i < 17; i = i + 8) {
    chipId |= ((ESP.getEfuseMac() >> (40 - i)) & 0xff) << i;
  }

  printf("\r\n===========  i n f o r m a t i o n s  ====================\r\n");
  printf("\r\t--- ESP info --- \r\n");
  printf("My Board              : %s \r\n", ARDUINO_BOARD);
  printf("ESP32 Chip model      : %s \r\n", GetChipModel());
  printf("This chip has         : %d cores \r\n", ESP.getChipCores());
  printf("ESP Chip ID           : %d \r\n", chipId);
  printf("ESP Mac Address       : %s \r\n", WiFi.macAddress().c_str());  //
  printf("ESP CPU Frequency     : %d MHz \r\n", ESP.getCpuFreqMHz());
  printf("ESP XTAL FREQ         : %d MHz \r\n", getXtalFrequencyMhz());
  printf("ESP Flash chip Speed  : %d MHz \r\n", ESP.getFlashChipSpeed() / 1000000UL);
  printf("ESP Flash chip Size   : %d MB \r\n", ESP.getFlashChipSize() / 1000000UL);
  printf("ESPSPI Flash Mode     : %s \r\n", FlashChipMode[ESP.getFlashChipMode()]);  // SPI Flash Mode
  printf("Arduino core ver.     : %s \r\n", GetCoreVersion());     // version of this core : 2.0.14
  printf("ESP-IDF version       : %s \r\n", ESP.getSdkVersion());  // version of ESP-IDF   : v4.4.6-dirty (IDF = IoT Development Framework)
  printf("Sketch Size           : %s \r\n", formatBytes(ESP.getSketchSize()));
  printf("Available Free Ram    : %s \r\n", formatBytes(ESP.getFreeHeap()));
  printf("Available Free PsRam  : %s \r\n", formatBytes(ESP.getFreePsram()));
  printf("\r=============  END informations ===========================\r\n\n");
}  //== Close printInfo ===




char BufReport[700];

//=======================================================================
char *ReportCoreVer() {
#define ESP_VER   "ESP version of this core:"
#define ARD_VER   "  Arduino core version  : "
#define IDF_VER   "  ESP-IDF version       : "

  BufReport[0] = { '\0' }; // Reset char array
  snprintf(BufReport, sizeof(BufReport), "%s%s%s%s\n%s%s%s",
           ESP_VER, DASHED_LINES, ARD_VER, ESP_ARDUINO_VERSION_STR,
           IDF_VER, ESP.getSdkVersion(), DASHED_LINES);
  return BufReport;

}

//=======================================================================
char *ReporBoardInfo() {
#define TXT1   "ESP Board info:"
#define TXT2   "  My Board is           : "
#define TXT3   "  Board Variant         : "

  BufReport[0] = { '\0' }; // Reset char array
  snprintf(BufReport, sizeof(BufReport), "%s%s%s%s\n%s%s%s",
           TXT1, DASHED_LINES,
           TXT2, ARDUINO_BOARD,
           TXT3, ARDUINO_VARIANT,
           DASHED_LINES);
  return BufReport;
}

//=======================================================================
char *ReporChipInfo() {
#define TXT1   "ESP Chip info:"
#define TXT2   "  ESP Chip model        : "
#define TXT3   "  CPU Temperature       : "
#define TXT4   "  ESP CPU Frequency     : "
#define TXT5   "  ESP XTAL Frequency    : "
#define TXT6   "  ESP Chip has          : "
#define TXT7   "  ESP Mac Address       : "

  BufReport[0] = { '\0' }; // Reset char array

  snprintf(BufReport, sizeof(BufReport), "%s%s%s%s\n%s%.1f°C\n%s%d MHz\n%s%d MHz\n%s%d\n%s%s%s",
           TXT1, DASHED_LINES,
           TXT2, GetChipModel(), // %s%s\n
           TXT3, temperatureRead(), // %s%.1f°C\n
           TXT4, ESP.getCpuFreqMHz(), // %s%d MHz\n
           TXT5, getXtalFrequencyMhz(), //  %s%d MHz\n
           TXT6, ESP.getChipCores(), //  %s%d\n
           TXT7, WiFi.macAddress().c_str(), // %s%s
           DASHED_LINES);
  return BufReport;
}



//=======================================================================
void PrintReport() {
  printf("\r\n========  i n f o r m a t i o n s  ====================\n");
  printf(ReportCoreVer());
  printf(ReporBoardInfo());
  printf(ReporChipInfo());
}

/*********************************
      end of this page
**********************************/