/*
 * Copyright (C) EdgeTX
 *
 * Based on code named
 *   opentx - https://github.com/opentx/opentx
 *   th9x - http://code.google.com/p/th9x
 *   er9x - http://code.google.com/p/er9x
 *   gruvin9x - http://code.google.com/p/gruvin9x
 *
 * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program 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.
 */

#include "edgetx.h"
#include "ff.h"

#include "analogs.h"
#include "switches.h"
#include "hal/adc_driver.h"
#include "hal/switch_driver.h"
#include "hal/usb_driver.h"

#include "os/timer.h"
#include "tasks/mixer_task.h"

FIL g_oLogFile __DMA;
uint8_t logDelay100ms;
static tmr10ms_t lastLogTime = 0;

static timer_handle_t loggingTimer = TIMER_INITIALIZER;

static void loggingTimerCb(timer_handle_t* timer)
{
  (void)timer;
  if (mixerTaskRunning()) {
    DEBUG_TIMER_START(debugTimerLoggingWakeup);
    logsWrite();
    DEBUG_TIMER_STOP(debugTimerLoggingWakeup);
  }
}

void loggingTimerStart(uint32_t period)
{
  if (!timer_is_created(&loggingTimer)) {
    timer_create(&loggingTimer, loggingTimerCb, "logs", period, true);
  }

  timer_start(&loggingTimer);
}

void loggingTimerStop() { timer_stop(&loggingTimer); }

bool loggingTimerIsRunning()
{
  return timer_is_active(&loggingTimer);
}

void initLoggingTimer()
{  // called cyclically by main.cpp:perMain()
  static uint8_t logDelay100msOld = 0;

  if(!timer_is_active(&loggingTimer)) {                         // log Timer not running
    if(isFunctionActive(FUNCTION_LOGS) && logDelay100ms > 0) {  // if SF Logging is active and log rate is valid
      loggingTimerStart(logDelay100ms * 100);                   // start log timer
    }  
  } else {                                                      // log timer is already running
    if(logDelay100msOld != logDelay100ms) {                     // if log rate was changed
      logDelay100msOld = logDelay100ms;                         // memorize new log rate
      if(logDelay100ms > 0) {
        timer_set_period(&loggingTimer, logDelay100ms * 100);
      }
    }
  }
}

void writeHeader();

int getSwitchState(uint8_t swtch) {
  int value = getValue(MIXSRC_FIRST_SWITCH + swtch);
  return (value == 0) ? 0 : (value < 0) ? -1 : +1;
}

void logsInit()
{
  memset(&g_oLogFile, 0, sizeof(g_oLogFile));
}

const char * logsOpen()
{
  if (!sdMounted())
    return STR_NO_SDCARD;

  // Determine and set log file filename
  FRESULT result;

  // /LOGS/modelnamexxxxxx_YYYY-MM-DD-HHMMSS.log
  char filename[sizeof(LOGS_PATH) + LEN_MODEL_NAME + 18 + 4 + 1];

  // check and create folder here
  char* tmp = strAppend(filename, LOGS_PATH);
  const char * error = sdCheckAndCreateDirectory(filename);
  if (error) {
    return error;
  }

  tmp = strAppend(tmp, "/");
  if (g_model.header.name[0]) {
    tmp = strAppend(tmp, sanitizeForFilename(g_model.header.name, LEN_MODEL_NAME));
  } else {
    // TODO
    uint8_t num = 1;
    tmp = strAppend(tmp, STR_MODEL);
    tmp = strAppendUnsigned(tmp, num, 2);
  }

#if defined(RTCLOCK)
  tmp = strAppendDate(tmp, true);
#endif

  strAppend(tmp, LOGS_EXT);

  result = f_open(&g_oLogFile, filename, FA_OPEN_ALWAYS | FA_WRITE | FA_OPEN_APPEND);
  if (result != FR_OK) {
    return SDCARD_ERROR(result);
  }

  if (f_size(&g_oLogFile) == 0) {
    writeHeader();
  }

  return nullptr;
}

void logsClose()
{
  if (g_oLogFile.obj.fs && sdMounted()) {
    if (f_close(&g_oLogFile) != FR_OK) {
      // close failed, forget file
      g_oLogFile.obj.fs = nullptr;
    }
    lastLogTime = 0;
  }

}

void writeHeader()
{
#if defined(RTCLOCK)
  f_puts("Date,Time,", &g_oLogFile);
#else
  f_puts("Time,", &g_oLogFile);
#endif

  char label[TELEM_LABEL_LEN+7];
  for (int i=0; i<MAX_TELEMETRY_SENSORS; i++) {
    if (isTelemetryFieldAvailable(i)) {
      TelemetrySensor & sensor = g_model.telemetrySensors[i];
      if (sensor.logs) {
        memset(label, 0, sizeof(label));
        strncpy(label, sensor.label, TELEM_LABEL_LEN);
        uint8_t unit = sensor.unit;
        if (unit == UNIT_CELLS ) unit = UNIT_VOLTS;
        if (UNIT_RAW < unit && unit < UNIT_FIRST_VIRTUAL) {
          strcat(label, "(");
          strncat(label, STR_VTELEMUNIT[unit], 3);
          strcat(label, ")");
        }
        strcat(label, ",");
        f_puts(label, &g_oLogFile);
      }
    }
  }

  auto n_inputs = adcGetMaxInputs(ADC_INPUT_MAIN);
  for (uint8_t i = 0; i < n_inputs; i++) {
    const char* p = analogGetCanonicalName(ADC_INPUT_MAIN, i);
    f_puts(p, &g_oLogFile);
    f_puts(",", &g_oLogFile);
  }

  n_inputs = adcGetMaxInputs(ADC_INPUT_FLEX);
  for (uint8_t i = 0; i < n_inputs; i++) {
    if (!IS_POT_AVAILABLE(i)) continue;
    const char* p = analogGetCanonicalName(ADC_INPUT_FLEX, i);
    f_puts(p, &g_oLogFile);
    f_puts(",", &g_oLogFile);
  }

  for (uint8_t i = 0; i < switchGetMaxAllSwitches(); i++) {
    if (SWITCH_EXISTS(i)) {
      char s[LEN_SWITCH_NAME + 2];
      char * temp;
      temp = getSwitchName(s, i);
      *temp++ = ',';
      *temp = '\0';
      f_puts(s, &g_oLogFile);
    }
  }
  f_puts("LSW,", &g_oLogFile);
  
  for (uint8_t channel = 0; channel < MAX_OUTPUT_CHANNELS; channel++) {
    f_printf(&g_oLogFile, "CH%d(us),", channel+1);
  }

  f_puts("TxBat(V)\n", &g_oLogFile);
}

uint32_t getLogicalSwitchesStates(uint8_t first)
{
  uint32_t result = 0;
  for (uint8_t i=0; i<32; i++) {
    result |= (getSwitch(SWSRC_FIRST_LOGICAL_SWITCH+first+i) << i);
  }
  return result;
}

void logsWrite()
{
  static const char * error_displayed = nullptr;

  if (!sdMounted()) {
    return;
  }

  if (isFunctionActive(FUNCTION_LOGS) && logDelay100ms > 0 && !usbPlugged()) {
    #if defined(SIMU) || !defined(RTCLOCK)
    tmr10ms_t tmr10ms = get_tmr10ms();                                        // tmr10ms works in 10ms increments
    if (lastLogTime == 0 || (tmr10ms_t)(tmr10ms - lastLogTime) >= (tmr10ms_t)(logDelay100ms*10)-1) {
      lastLogTime = tmr10ms;
    #else
    {
    #endif

      bool sdCardFull = sdIsFull();

      // check if file needs to be opened
      if (!g_oLogFile.obj.fs) {
        const char *result = sdCardFull ? STR_SDCARD_FULL_EXT : logsOpen();

        // SD card is full or file open failed
        if (result) {
          if (result != error_displayed) {
            error_displayed = result;
            POPUP_WARNING_ON_UI_TASK(result, nullptr);
          }
          return;
        }
      }

      // check at every write cycle
      if (sdCardFull) {
        logsClose();  // timer is still running and code above will try to
                      // open the file again but will fail with error
                      // which will trigger the warning popup
        return;
      }

#if defined(RTCLOCK)
      {
        static struct gtm utm;
        static gtime_t lastRtcTime = 0;
        if (g_rtcTime != lastRtcTime) {
          lastRtcTime = g_rtcTime;
          gettime(&utm);
        }
        f_printf(&g_oLogFile, "%4d-%02d-%02d,%02d:%02d:%02d.%02d0,", utm.tm_year+TM_YEAR_BASE, utm.tm_mon+1, utm.tm_mday, utm.tm_hour, utm.tm_min, utm.tm_sec, g_ms100);
      }
#else
      f_printf(&g_oLogFile, "%d,", tmr10ms);
#endif

      for (int i=0; i<MAX_TELEMETRY_SENSORS; i++) {
        if (isTelemetryFieldAvailable(i)) {
          TelemetrySensor & sensor = g_model.telemetrySensors[i];
          TelemetryItem telemetryItem;
          
          if (sensor.logs) {
            if(TELEMETRY_STREAMING() && !telemetryItems[i].isOld())
              telemetryItem = telemetryItems[i];

            if (sensor.unit == UNIT_GPS) {
              if (telemetryItem.gps.longitude && telemetryItem.gps.latitude) {
                div_t qr = div((int)telemetryItem.gps.latitude, 1000000);
                if (telemetryItem.gps.latitude < 0) f_printf(&g_oLogFile, "-");
                f_printf(&g_oLogFile, "%d.%06d ", abs(qr.quot), abs(qr.rem));
                qr = div((int)telemetryItem.gps.longitude, 1000000);
                if (telemetryItem.gps.longitude < 0) f_printf(&g_oLogFile, "-");
                f_printf(&g_oLogFile, "%d.%06d,", abs(qr.quot), abs(qr.rem));
              }
              else {
                f_printf(&g_oLogFile, ",");
              }
            }
            else if (sensor.unit == UNIT_DATETIME) {
              f_printf(&g_oLogFile, "%4d-%02d-%02d %02d:%02d:%02d,", telemetryItem.datetime.year, telemetryItem.datetime.month, telemetryItem.datetime.day, telemetryItem.datetime.hour, telemetryItem.datetime.min, telemetryItem.datetime.sec);
            }
            else if (sensor.unit == UNIT_TEXT) {
              f_printf(&g_oLogFile, "\"%s\",", telemetryItem.text);
            }
            else if (sensor.prec == 2) {
              div_t qr = div((int)telemetryItem.value, 100);
              if (telemetryItem.value < 0) f_printf(&g_oLogFile, "-");
              f_printf(&g_oLogFile, "%d.%02d,", abs(qr.quot), abs(qr.rem));
            }
            else if (sensor.prec == 1) {
              div_t qr = div((int)telemetryItem.value, 10);
              if (telemetryItem.value < 0) f_printf(&g_oLogFile, "-");
              f_printf(&g_oLogFile, "%d.%d,", abs(qr.quot), abs(qr.rem));
            }
            else {
              f_printf(&g_oLogFile, "%d,", telemetryItem.value);
            }
          }
        }
      }

      auto n_inputs = adcGetMaxInputs(ADC_INPUT_MAIN);
      auto offset = adcGetInputOffset(ADC_INPUT_MAIN);

      for (uint8_t i = 0; i < n_inputs; i++) {
        f_printf(&g_oLogFile, "%d,", calibratedAnalogs[inputMappingConvertMode(offset + i)]);
      }

      n_inputs = adcGetMaxInputs(ADC_INPUT_FLEX);
      offset = adcGetInputOffset(ADC_INPUT_FLEX);

      for (uint8_t i = 0; i < n_inputs; i++) {
        if (IS_POT_AVAILABLE(i))
          f_printf(&g_oLogFile, "%d,", calibratedAnalogs[offset + i]);
      }

      for (uint8_t i = 0; i < switchGetMaxAllSwitches(); i++) {
        if (SWITCH_EXISTS(i)) {
          f_printf(&g_oLogFile, "%d,", getSwitchState(i));
        }
      }
      f_printf(&g_oLogFile, "0x%08X%08X,", getLogicalSwitchesStates(32),
               getLogicalSwitchesStates(0));

      for (uint8_t channel = 0; channel < MAX_OUTPUT_CHANNELS; channel++) {
        f_printf(&g_oLogFile, "%d,", PPM_CENTER+channelOutputs[channel]/2); // in us
      }

      div_t qr = div(g_vbat100mV, 10);
      int result = f_printf(&g_oLogFile, "%d.%d\n", abs(qr.quot), abs(qr.rem));

      if (result<0 && !error_displayed) {
        error_displayed = STR_SDCARD_ERROR;
        POPUP_WARNING_ON_UI_TASK(STR_SDCARD_ERROR, nullptr);
        logsClose();
      }
    }
  }
  else {
    error_displayed = nullptr;
    logsClose();
    
    #if !defined(SIMU)
    loggingTimerStop();
    #endif
  }
}