#include <WiFi.h>
#include <esp_wifi.h>
#include <HTTPClient.h>
#include <WiFiClientSecure.h>
#include <ArduinoJson.h>
#include "secrets.h"

tm timeInfo;

String strTodayDate;
String strAddressAPI;
String strCookie;
String strBearer;
String strAuthor;
String strRequestData;
String strResponse;
String strHeaderReferer;

int intCallMethod;
int intSigningTime;
int intSigningType;
int intDayType;
int intWorkType;

StaticJsonDocument<2048> jsonDocu;

void setup() {
#ifdef DEBUG_MODE
  Serial.begin(9600);
  delay(5000);
  Serial.print(F("[FREE MEM] begin Setup "));
  Serial.println(esp_get_free_heap_size());
#endif

  strTodayDate.reserve(12);
  strAddressAPI.reserve(200);
  strCookie.reserve(20);
  strBearer.reserve(1500);
  strAuthor.reserve(1500);
  strRequestData.reserve(1500);
  strResponse.reserve(10000);
  strHeaderReferer.reserve(50);

  configTime(GMT_OFFSET_SEC, DAY_LIGHT_OFFSET_SEC, NTP_SERVER);
  connectWiFi();
  getTime();
}
// -----------------------------------------------------------------------------
void loop() {
#ifdef DEBUG_MODE
  Serial.print(F("[FREE MEM] begin loop "));
  Serial.println(esp_get_free_heap_size());
#endif
  getTime();

  intDayType = (isWeekEnd()) ? HOLIDAY : WORKDAY;

  if (intDayType == WORKDAY) {
    if (WiFi.status() != WL_CONNECTED) {
      connectWiFi();
      getTime();
    }

    callGoogleSheet(GET_MAM_CONFIG);
    intSigningTime = signingTime();

    switch (intSigningTime) {
      case MORNING_SIGNING_TIME :
        intSigningType = (intWorkType == WORK_ALLDAY || intWorkType == WORK_MORNING) ? SIGNING_IN : NOT_SIGNING_TIME;
        break;
      case NOON_SIGNING_TIME :
        intSigningType = (intWorkType == WORK_MORNING) ? SIGNING_OUT : (intWorkType == WORK_AFTERNOON) ? SIGNING_IN : NOT_SIGNING_TIME;
        break;
      case EVENING_SIGNING_TIME :
        intSigningType = (intWorkType == WORK_ALLDAY || intWorkType == WORK_AFTERNOON) ? SIGNING_OUT : NOT_SIGNING_TIME;
        break;
      default :
        intSigningType = NOT_SIGNING_TIME;
        break;
    }
    // #define NOT_SIGNING_TIME 0
    // #define MORNING_SIGNING_TIME 1
    // #define NOON_SIGNING_TIME 2
    // #define EVENING_SIGNING_TIME 3

    // switch (intSigningType) {
    //   case WORK_ALLDAY :
    //     MORNING_SIGNING_TIME ? SIGNING_IN : ;
    //     EVENING_SIGNING_TIME ? SIGNING_OUT : ;
    //     break;
    //   case WORK_MORNING :
    //     MORNING_SIGNING_TIME ? SIGNING_IN : ;
    //     NOON_SIGNING_TIME ? SIGNING_OUT : ;
    //     break;
    //   case WORK_AFTERNOON :
    //     NOON_SIGNING_TIME ? SIGNING_IN : ;
    //     EVENING_SIGNING_TIME ? SIGNING_OUT : ;
    //     break;
    //   default : //LEAVE_ALLDAY
    //     break;
    // }
    processSigning();
  }

  WiFi.disconnect(true);
  delay(delayMilliSec(intDayType));
}
// -----------------------------------------------------------------------------
void connectWiFi() {
  int counter = 0;
  uint8_t newMACAddress[] = {MAC_ADDR_1, MAC_ADDR_2, MAC_ADDR_3, MAC_ADDR_4, MAC_ADDR_5, MAC_ADDR_6};

#ifdef DEBUG_MODE
  Serial.print(F("Connecting to network: "));
  Serial.println(SSID);
#endif

  WiFi.disconnect(true);
  WiFi.mode(WIFI_STA);
  WiFi.setHostname(MOBILE_NAME);
  esp_wifi_set_mac(WIFI_IF_STA, newMACAddress);
  //WiFi.begin(SSID, WPA2_AUTH_PEAP, WIFI_IDENTITY, WIFI_USERNAME, WIFI_PASSWORD);
  WiFi.begin(SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    delay(5000);
    counter++;
    if (counter >= 5) ESP.restart();
  }

#ifdef DEBUG_MODE
  Serial.print(F("WiFi connected IP address : "));
  Serial.println(WiFi.localIP());
  Serial.println(WiFi.getHostname());
  Serial.println(WiFi.macAddress());
#endif
}
// -----------------------------------------------------------------------------
void getTime() {
  int counter = 0;

  while (!getLocalTime(&timeInfo)) {
    delay(5000);
    counter++;
    if (counter >= 5) ESP.restart();
  }

  strTodayDate = String(timeInfo.tm_year + 1900);
  strTodayDate += "-";
  strTodayDate += String(timeInfo.tm_mon + 1);
  strTodayDate += "-";
  strTodayDate += String(timeInfo.tm_mday);

#ifdef DEBUG_MODE
  Serial.println(&timeInfo, "%A, %d %B %Y %H:%M:%S");
#endif
}
// -----------------------------------------------------------------------------
bool isWeekEnd () {
  return (timeInfo.tm_wday == 0 || timeInfo.tm_wday == 6) ? true : false;
}
// -----------------------------------------------------------------------------
long delayMilliSec (int intDayType) {
  int minFromMidNight;
  int minToMidNight;
  int minToDelay;

  minFromMidNight = (timeInfo.tm_hour * 60) + timeInfo.tm_min;
  minToMidNight = (MIN_ALLDAY - minFromMidNight);

  switch (intDayType) {
    case HOLIDAY :
      if (timeInfo.tm_wday == 6) { // saturday
        minToDelay = (minToMidNight + MIN_ALLDAY + MIN_MIDNIGHT_TO_MORNING); // next monday morning
      }
      else { // sunday or holiday
        minToDelay = (minToMidNight + MIN_MIDNIGHT_TO_MORNING); // next morning
      }
      break;
    default : // WORKDAY
      if (minFromMidNight < MIN_MIDNIGHT_TO_MORNING) {  // less than morining sign time
        minToDelay = (MIN_MIDNIGHT_TO_MORNING - minFromMidNight); // till morning
      }
      else if ((minFromMidNight < MIN_MIDNIGHT_TO_NOON)) {  // less than noon sign time
        minToDelay = (MIN_MIDNIGHT_TO_NOON - minFromMidNight); // till noon
      }
      else if ((minFromMidNight < MIN_MIDNIGHT_TO_EVENING)) {  // less than eveing sign time
        minToDelay = (MIN_MIDNIGHT_TO_EVENING - minFromMidNight); // till evening
      }
      else {
        if (timeInfo.tm_wday == 5) { // friday
          minToDelay = (minToMidNight + (MIN_ALLDAY * 2) + MIN_MIDNIGHT_TO_MORNING); // next monday morning
        }
        else {
          minToDelay = (minToMidNight + MIN_MIDNIGHT_TO_MORNING); // next morning
        }
      }
      break;
  }
#ifdef DEBUG_MODE
  Serial.print(F("delay min :"));
  Serial.println(minToDelay);
#endif

  return ((minToDelay + random(5)) * 60 * 1000); // add random minitue (0 - 5 min) and convert to millisec
}
// -----------------------------------------------------------------------------
int signingTime () {
  int minFromMidNight;

  minFromMidNight = (timeInfo.tm_hour * 60) + timeInfo.tm_min;

  if (minFromMidNight >= MIN_MIDNIGHT_TO_MORNING && minFromMidNight <= MIN_MIDNIGHT_TO_MORNING_END) {  // 7.15 - 7.25
    return MORNING_SIGNING_TIME;
  }
  else if (minFromMidNight >= MIN_MIDNIGHT_TO_NOON && minFromMidNight <= MIN_MIDNIGHT_TO_NOON_END) {  // 12.15 - 12-25
    return NOON_SIGNING_TIME;
  }
  else if (minFromMidNight >= MIN_MIDNIGHT_TO_EVENING && minFromMidNight <= MIN_MIDNIGHT_TO_EVENING_END) {  // 16.45 - 16.55
    return EVENING_SIGNING_TIME;
  }
  else {
    return NOT_SIGNING_TIME;
  }
}
// -----------------------------------------------------------------------------
bool sendRequest(WiFiClientSecure &client) {
  bool isSucessed = false;
  int httpResponseCode;
  HTTPClient http;

  http.setFollowRedirects(HTTPC_FORCE_FOLLOW_REDIRECTS);

#ifdef DEBUG_MODE
  Serial.println(strHeaderReferer);
  Serial.println(strAddressAPI);
  Serial.println(strRequestData);
#endif

  // if (http.begin(client, strAddressAPI)) {
  if (http.begin(strAddressAPI)) {

    if (strHeaderReferer != HEADER_REFERER_SHEET) {
      http.setUserAgent(HTTP_HEADER_USER_AGENT);
      http.addHeader("Host", HTTP_HEADER_HOST);
      http.addHeader("Cookie", strCookie);
      http.addHeader("Accept", HTTP_HEADER_ACCEPT);
      http.addHeader("Authorization", strAuthor);
      http.addHeader("Origin", HTTP_HEADER_ORIGIN);
      http.addHeader("X-Requested-With", HTTP_HEADER_X_REQUESTED_WITH);
      http.addHeader("Sec-Fetch-Site", HTTP_HEADER_SEC_FETCH_SITE);
      http.addHeader("Sec-Fetch-Mode", HTTP_HEADER_SEC_FETCH_MODE);
      http.addHeader("Sec-Fetch-Dest", HTTP_HEADER_SEC_FETCH_DEST);
      http.addHeader("Referer", strHeaderReferer);
      // http.addHeader("Accept-Encoding", HTTP_HEADER_ACCEPT_ENCODEING);
      http.addHeader("Accept-Language", HTTP_HEADER_ACCEPT_LANGUAGE);
      http.addHeader("Connection", HTTP_HEADER_CONNECTION);
    }

    switch (intCallMethod) {
      case METHOD_POST :
        if (strHeaderReferer != HEADER_REFERER_SHEET) http.addHeader("Content-Type", HTTP_HEADER_CONTENT_TYPE_JSON);
        httpResponseCode = http.POST(strRequestData);
        break;
      case METHOD_PUT :
        httpResponseCode = http.PUT(strRequestData);
        break;
      default : //METHOD_GET
        httpResponseCode = http.GET();
        break;
    }

    if (httpResponseCode > 0) {
      strResponse = http.getString();
      isSucessed = true;

#ifdef DEBUG_MODE
      Serial.print(F("HTTP :"));
      Serial.println(httpResponseCode);
      Serial.println(strResponse);
#endif
    }
    // http.end();
  }
  http.end();

  return isSucessed;
}
// -----------------------------------------------------------------------------
bool connectServer() {
  bool isSucessed = false;
  int counter = 0;
  WiFiClientSecure *client = new WiFiClientSecure;

  if (client) {
    client->setInsecure();
    while (!isSucessed) {
      strResponse = "";
      isSucessed = sendRequest(*client);
      delay(1000);
      counter++;
      if (counter >= 3) break;
    }
  }
  delete client;

  return isSucessed;
}
// -----------------------------------------------------------------------------
void processSigning () {
  bool tempResult;

  if (mamLogin() && notHoliday() && isOnWiFi()) {
    strHeaderReferer = HEADER_REFERER_MAIN_MENU;
    strRequestData = "{\"activity_text\":\"" ACT_MAIN_MENU "\",\"activity_type_id\":\"" ACT_ID_LOGIN "\"}";
    tempResult = writeLog (); // write log

    tempResult = deviceSeen();
    tempResult = wifiLocation();
    // signingInOut();
  }
  else {

  }
}
// -----------------------------------------------------------------------------
bool mamLogin () {
  bool isSucessed = false;
  bool tempResult;

  strHeaderReferer = HEADER_REFERER_SIGN;
  strRequestData = "{\"token\":\"";
  strRequestData += strBearer;
  strRequestData += "\"}";
  strAddressAPI = API_VERIFY;
  intCallMethod = METHOD_POST;

  if (connectServer()) {  // check bearer is good
    if (strResponse == "\"ok\"") {
      strAuthor = HTTP_HEADER_AUTHORIZATION;
      strAuthor += strBearer;
      isSucessed = true;
    }
    else {
      strHeaderReferer = HEADER_REFERER_SIGN;
      strRequestData = "{\"username\":\"" WIFI_USERNAME "\",\"password\":\"" WIFI_PASSWORD "\",\"device_id\":\"" MOBILE_ID "\"}";
      strAddressAPI = API_LOGIN;
      intCallMethod = METHOD_POST;

      if (connectServer()) { // log in
        strResponse.replace("\"", "");
        strBearer = strResponse;
        strAuthor = HTTP_HEADER_AUTHORIZATION;
        strAuthor += strBearer;

        strHeaderReferer = HEADER_REFERER_LOGIN;
        strRequestData = "{\"activity_text\":\"" ACT_LOGIN "\",\"activity_type_id\":\"" ACT_ID_LOGIN "\"}";
        tempResult = writeLog (); // write log

        isSucessed = true;
      }
    }
  }

  return isSucessed;
}
// -----------------------------------------------------------------------------
bool notHoliday () {
  bool isWorkDay = false;

  strHeaderReferer = HEADER_REFERER_SIGN;
  strRequestData = "{}";
  strAddressAPI = API_HOLIDAY;
  strAddressAPI += strTodayDate;
  strAddressAPI += "/";
  strAddressAPI += strTodayDate;
  intCallMethod = METHOD_GET;

  if (connectServer()) { // check holiday
    if (strResponse == "[]") {
      isWorkDay = true;
    }
    else {
      intDayType = HOLIDAY;
    }
  }

  return isWorkDay;
}
// -----------------------------------------------------------------------------
bool isOnWiFi () {
  bool isConnected = false;

  strHeaderReferer = HEADER_REFERER_MAIN_MENU;
  strRequestData = "{}";
  strAddressAPI = API_CHECK_WIFI;
  intCallMethod = METHOD_GET;

  if (connectServer()) {
    if (strResponse == "true") isConnected = true;
  }

  return isConnected;
}
// -----------------------------------------------------------------------------
bool deviceSeen () {
  bool isSucessed;

  strHeaderReferer = HEADER_REFERER_MAIN_MENU;
  strRequestData = "{}";
  strAddressAPI = API_DEVICE_SEEN;
  intCallMethod = METHOD_PUT;

  isSucessed = connectServer();

  return isSucessed;
}
// -----------------------------------------------------------------------------
bool wifiLocation () {
  bool isSucessed;

  strHeaderReferer = HEADER_REFERER_MAIN_MENU;
  strRequestData = "{}";
  strAddressAPI = API_CHECK_WIFI_LOCATION;
  intCallMethod = METHOD_GET;

  isSucessed = connectServer();

  return isSucessed;
}
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
// void signingInOut() {

//   intSigningTime = timeToSign();

//   switch (intSigningTime) {
//     case MORNING_SIGNING_TIME :
//       strRequestData = "{\"activity_text\":\"" ACT_CLICK_SIGN_BUTTON "\",\"activity_type_id\":\"" ACT_ID_SIGN "\"}";
//       returnBin = connectServer(METHOD_POST, API_ACTIVITY_LOG, HEADER_REFERER_MAIN_MENU);  // write log
//       if (intSigningType == WORK_ALLDAY && !checkSigned(SIGNING_IN)) {
//         strRequestData = "{\"input_method\":\"W\",\"status\":\"" STATUS_IN_MORNING "\",\"device_id\":\"" MOBILE_ID "\"}";
//         if (connectServer(METHOD_POST, API_CHECK_INOUT, HEADER_REFERER_MAIN_MENU)) { // signing in morning
//           // strResponse.replace("\"", "");
//           strRequestData = "{\"activity_text\":\"" ACT_SIGNED_IN_MORNING "\",\"activity_type_id\":\"" ACT_ID_SIGN "\"}";
//           returnBin = connectServer(METHOD_POST, API_ACTIVITY_LOG, HEADER_REFERER_MAIN_MENU);  // write log
//         }

//         break;
//       case NOON_SIGNING_TIME :
//         strRequestData = "{\"activity_text\":\"" ACT_CLICK_SIGN_BUTTON "\",\"activity_type_id\":\"" ACT_ID_SIGN "\"}";
//         returnBin = connectServer(METHOD_POST, API_ACTIVITY_LOG, HEADER_REFERER_MAIN_MENU);  // write log
//         if (intSigningType == WORK_MORNING && !checkSigned(SIGNING_OUT)) {
//           strRequestData = "{\"input_method\":\"W\",\"status\":\"" STATUS_OUT_NOON "\",\"device_id\":\"" MOBILE_ID "\"}";
//           if (connectServer(METHOD_POST, API_CHECK_INOUT, HEADER_REFERER_MAIN_MENU)) { // signing out noon
//             // strResponse.replace("\"", "");
//             strRequestData = "{\"activity_text\":\"" ACT_SIGNED_OUT_NOON "\",\"activity_type_id\":\"" ACT_ID_SIGN "\"}";
//             returnBin = connectServer(METHOD_POST, API_ACTIVITY_LOG, HEADER_REFERER_MAIN_MENU);  // write log
//           }
//         }
//         else if (intSigningType == WORK_AFTERNOON && !checkSigned(SIGNING_IN)) {
//           strRequestData = "{\"activity_text\":\"" ACT_CLICK_SIGN_BUTTON "\",\"activity_type_id\":\"" ACT_ID_SIGN "\"}";
//           returnBin = connectServer(METHOD_POST, API_ACTIVITY_LOG, HEADER_REFERER_MAIN_MENU);  // write log
//           strRequestData = "{\"input_method\":\"W\",\"status\":\"" STATUS_IN_AFTERNOON "\",\"device_id\":\"" MOBILE_ID "\"}";
//           if (connectServer(METHOD_POST, API_CHECK_INOUT, HEADER_REFERER_MAIN_MENU)) { // signing in afternoon
//             // strResponse.replace("\"", "");
//             strRequestData = "{\"activity_text\":\"" ACT_SIGNED_IN_AFTERNOON "\",\"activity_type_id\":\"" ACT_ID_SIGN "\"}";
//             returnBin = connectServer(METHOD_POST, API_ACTIVITY_LOG, HEADER_REFERER_MAIN_MENU);  // write log
//           }
//         }

//         break;
//       case EVENING_SIGNING_TIME :
//         strRequestData = "{\"activity_text\":\"" ACT_CLICK_SIGN_BUTTON "\",\"activity_type_id\":\"" ACT_ID_SIGN "\"}";
//         returnBin = connectServer(METHOD_POST, API_ACTIVITY_LOG, HEADER_REFERER_MAIN_MENU);  // write log
//         if ((intSigningType == WORK_ALLDAY || intSigningType == WORK_AFTERNOON) && !checkSigned(SIGNING_OUT)) {
//           strRequestData = "{\"input_method\":\"W\",\"status\":\"" STATUS_OUT_EVENING "\",\"device_id\":\"" MOBILE_ID "\"}";
//           if (connectServer(METHOD_POST, API_CHECK_INOUT, HEADER_REFERER_MAIN_MENU)) { // signing out evening
//             // strResponse.replace("\"", "");
//             strRequestData = "{\"activity_text\":\"" ACT_SIGNED_OUT_EVENING "\",\"activity_type_id\":\"" ACT_ID_SIGN "\"}";
//             returnBin = connectServer(METHOD_POST, API_ACTIVITY_LOG, HEADER_REFERER_MAIN_MENU);  // write log
//           }
//         }

//         break;
//       default : //NOT_SIGNING_TIME
//         break;
//       }
//   }
// }
// -----------------------------------------------------------------------------
bool clickSignButton(int periodType) {
  bool isSucessed = false;
  bool tempResult;

  strHeaderReferer = HEADER_REFERER_MAIN_MENU;
  strRequestData = "{\"activity_text\":\"" ACT_CLICK_SIGN_BUTTON "\",\"activity_type_id\":\"" ACT_ID_SIGN "\"}";
  tempResult = writeLog (); // write log

  strHeaderReferer = HEADER_REFERER_MAIN_MENU;
  strRequestData = "{\"input_method\":\"W\",\"status\":\"";
  switch (periodType) {
    case WORK_ALLDAY_SIGN_IN :
    case WORK_MORNING_SIGN_IN :
      strRequestData += STATUS_IN_MORNING;
      break;
    case WORK_AFTERNOON_SIGN_IN :
      strRequestData += STATUS_IN_AFTERNOON;
      break;
    case WORK_MORNING_SIGN_OUT :
      strRequestData += STATUS_OUT_NOON;
      break;
    case WORK_ALLDAY_SIGN_OUT :
    case WORK_AFTERNOON_SIGN_OUT :
      strRequestData += STATUS_OUT_EVENING;
      break;
      // default : // unknown
      //   break;
  }
  strRequestData += "\",\"device_id\":\"" MOBILE_ID "\"}";
  strAddressAPI = API_CHECK_INOUT;
  intCallMethod = METHOD_POST;

  if (connectServer()) {
    strHeaderReferer = HEADER_REFERER_MAIN_MENU;
    strRequestData = "{\"activity_text\":\"";
    switch (periodType) {
      case WORK_ALLDAY_SIGN_IN :
      case WORK_MORNING_SIGN_IN :
        strRequestData += ACT_SIGNED_IN_MORNING;
        break;
      case WORK_AFTERNOON_SIGN_IN :
        strRequestData += ACT_SIGNED_IN_AFTERNOON;
        break;
      case WORK_MORNING_SIGN_OUT :
        strRequestData += ACT_SIGNED_OUT_NOON;
        break;
      case WORK_ALLDAY_SIGN_OUT :
      case WORK_AFTERNOON_SIGN_OUT :
        strRequestData += ACT_SIGNED_OUT_EVENING;
        break;
        // default : // unknown
        //   break;
    }
    strRequestData += "\",\"activity_type_id\":\"" ACT_ID_SIGN "\"}";

    tempResult = writeLog (); // write log

    isSucessed = true;
  }

  return isSucessed;
}
// -----------------------------------------------------------------------------
bool writeLog () {
  bool isSucessed = false;

  strAddressAPI = API_ACTIVITY_LOG;
  intCallMethod = METHOD_POST;

  if (connectServer()) isSucessed = true;

  return isSucessed;
}
// -----------------------------------------------------------------------------
// bool isSigned (int workPeriod, int signType) {
//   bool alreadySigned = true;
//   bool signedInMorning;
//   bool signedInAfternoon;
//   bool signedOutNoon;
//   bool signedOutEvening;
//   int checkSigned;

//   strHeaderReferer = HEADER_REFERER_SIGN;
//   strRequestData = "{}";
//   strAddressAPI = API_CHECK_SIGNED;
//   strAddressAPI += strTodayDate;
//   strAddressAPI += "/";
//   strAddressAPI += strTodayDate;
//   intCallMethod = METHOD_GET;

//   if (connectServer()) { // check signed

//     signedInMorning = (strResponse.indexOf(SIGNED_IN_MORNING) != -1) ? true : false;
//     signedInAfternoon = (strResponse.indexOf(SIGNED_IN_AFTERNOON) != -1) ? true : false;
//     signedOutNoon = (strResponse.indexOf(SIGNED_OUT_NOON) != -1) ? true : false;
//     signedOutEvening = (strResponse.indexOf(SIGNED_OUT_EVENING) != -1) ? true : false;

//     checkSigned = workPeriod + signType;

//     switch (checkSigned) {
//       case WORK_ALLDAY_SIGN_IN :
//       case WORK_MORNING_SIGNED_IN :
//       case WORK_AFTERNOON_SIGNED_IN :
//         alreadySigned = (signedInMorning || signedInAfternoon || signedOutNoon || signedOutEvening) ? true : false;
//         break;
//       case WORK_ALLDAY_SIGNED_OUT :
//         alreadySigned = (signedInMorning && !signedInAfternoon && !signedOutNoon && !signedOutEvening) ? false : true;
//         break;
//       case WORK_MORNING_SIGNED_OUT :
//         alreadySigned = (signedInMorning && !signedInAfternoon && !signedOutNoon && !signedOutEvening) ? false : true;
//         break;
//       case WORK_AFTERNOON_SIGNED_OUT :
//         alreadySigned = (!signedInMorning && signedInAfternoon && !signedOutNoon && !signedOutEvening) ? false : true;
//         break;
//       default : // unknown
//         alreadySigned = true;
//         break;
//     }
//   }

//   return alreadySigned;
// }
// -----------------------------------------------------------------------------
// bool isSigned (int workPeriod, int signType) {
//   bool alreadySigned = true;
//   bool signedInMorning;
//   bool signedInAfternoon;
//   bool signedOutNoon;
//   bool signedOutEvening;
//   int checkSigned;

//   strHeaderReferer = HEADER_REFERER_SIGN;
//   strRequestData = "{}";
//   strAddressAPI = API_CHECK_SIGNED;
//   strAddressAPI += strTodayDate;
//   strAddressAPI += "/";
//   strAddressAPI += strTodayDate;
//   intCallMethod = METHOD_GET;

//   if (connectServer()) { // check signed

//     signedInMorning = (strResponse.indexOf(SIGNED_IN_MORNING) != -1) ? true : false;
//     signedInAfternoon = (strResponse.indexOf(SIGNED_IN_AFTERNOON) != -1) ? true : false;
//     signedOutNoon = (strResponse.indexOf(SIGNED_OUT_NOON) != -1) ? true : false;
//     signedOutEvening = (strResponse.indexOf(SIGNED_OUT_EVENING) != -1) ? true : false;

//     checkSigned = workPeriod + signType;

//     switch (checkSigned) {
//       case WORK_ALLDAY_SIGN_IN :
//       case WORK_MORNING_SIGNED_IN :
//       case WORK_AFTERNOON_SIGNED_IN :
//         alreadySigned = (signedInMorning || signedInAfternoon || signedOutNoon || signedOutEvening) ? true : false;
//         break;
//       case WORK_ALLDAY_SIGNED_OUT :
//         alreadySigned = (signedInMorning && !signedInAfternoon && !signedOutNoon && !signedOutEvening) ? false : true;
//         break;
//       case WORK_MORNING_SIGNED_OUT :
//         alreadySigned = (signedInMorning && !signedInAfternoon && !signedOutNoon && !signedOutEvening) ? false : true;
//         break;
//       case WORK_AFTERNOON_SIGNED_OUT :
//         alreadySigned = (!signedInMorning && signedInAfternoon && !signedOutNoon && !signedOutEvening) ? false : true;
//         break;
//       default : // unknown
//         alreadySigned = true;
//         break;
//     }
//   }

//   return alreadySigned;
// }
// -----------------------------------------------------------------------------
bool signingInOut () {
  bool isSucessed = false;
  bool alreadySigned = true;
  bool signedInMorning;
  bool signedInAfternoon;
  bool signedOutNoon;
  bool signedOutEvening;
  int periodType;

  strHeaderReferer = HEADER_REFERER_SIGN;
  strRequestData = "{}";
  strAddressAPI = API_CHECK_SIGNED;
  strAddressAPI += strTodayDate;
  strAddressAPI += "/";
  strAddressAPI += strTodayDate;
  intCallMethod = METHOD_GET;

  if (connectServer()) { // check signed

    signedInMorning = (strResponse.indexOf(SIGNED_IN_MORNING) != -1) ? true : false;
    signedInAfternoon = (strResponse.indexOf(SIGNED_IN_AFTERNOON) != -1) ? true : false;
    signedOutNoon = (strResponse.indexOf(SIGNED_OUT_NOON) != -1) ? true : false;
    signedOutEvening = (strResponse.indexOf(SIGNED_OUT_EVENING) != -1) ? true : false;

    periodType = intWorkType + intSigningType;

    switch (periodType) {
      case WORK_ALLDAY_SIGN_IN :
      case WORK_MORNING_SIGN_IN :
      case WORK_AFTERNOON_SIGN_IN :
        alreadySigned = (signedInMorning || signedInAfternoon || signedOutNoon || signedOutEvening) ? true : false;
        break;
      case WORK_ALLDAY_SIGN_OUT :
        alreadySigned = (signedInMorning && !signedInAfternoon && !signedOutNoon && !signedOutEvening) ? false : true;
        break;
      case WORK_MORNING_SIGN_OUT :
        alreadySigned = (signedInMorning && !signedInAfternoon && !signedOutNoon && !signedOutEvening) ? false : true;
        break;
      case WORK_AFTERNOON_SIGN_OUT :
        alreadySigned = (!signedInMorning && signedInAfternoon && !signedOutNoon && !signedOutEvening) ? false : true;
        break;
      default : // unknown
        alreadySigned = true;
        break;
    }

    if (!alreadySigned) {
      isSucessed = clickSignButton(periodType);
    }
    else {
      isSucessed = true;
    }
  }

  return isSucessed;
}

// -----------------------------------------------------------------------------
bool callGoogleSheet (int callOption) {
  bool isSucessed = false;
  int counter = 0;
  int returnSetBerer;
  int returnSetLog;
  DeserializationError desError;

  strHeaderReferer = HEADER_REFERER_SHEET;
  strRequestData = "{}";
  strAddressAPI = API_GOOGLE;

  switch (callOption) {
    case GET_MAM_CONFIG :
      strAddressAPI += "&getWorkType=yes";
      strAddressAPI += "&getCookie=yes";
      if (strBearer == "") strAddressAPI += "&getBearer=yes";
      break;
    case SET_MAM_BEARER :
      strAddressAPI += "&setBearer=";
      strAddressAPI += strBearer;
      break;
    case SET_MAM_LOG :
      strAddressAPI += "&setLogSubject=yes";
      strAddressAPI += "&setLogDetail=yes";
      break;
    default : //not option
      break;
  }

  intCallMethod = METHOD_GET;

  while (!isSucessed) {
    if (connectServer()) {
      desError = deserializeJson(jsonDocu, strResponse);
      if (desError) {
        isSucessed = false;
      }
      else {
        isSucessed = true;

        switch (callOption) {
          case GET_MAM_CONFIG :
            intWorkType = jsonDocu["data"]["WorkType"].as<signed int>();
            strCookie = jsonDocu["data"]["Cookie"].as<String>();
            if (strBearer == "") strBearer = jsonDocu["data"]["Bearer"].as<String>();
            break;
          case SET_MAM_BEARER :
            returnSetBerer = jsonDocu["data"]["setBearer"].as<signed int>();
            isSucessed = (returnSetBerer == 1) ? true : false;
            break;
          case SET_MAM_LOG :
            returnSetLog = jsonDocu["data"]["setLog"].as<signed int>();
            break;
          default : //not option
            break;
        }
      }
    }
    delay(1000);
    counter++;
    if (counter >= 3) break;
  }
}
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------