/*
 * 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 "boot.h"
#include "firmware_files.h"

#include "hal/usb_driver.h"
#include "hal/rotary_encoder.h"
#include "os/time.h"

#include "lcd.h"

#define FRAME_INTERVAL_MS 20

#if defined(SPI_FLASH)
  #define MAIN_MENU_LEN 3
#else
  #define MAIN_MENU_LEN 2
#endif

#if defined(SPI_FLASH)
  #include "diskio_spi_flash.h"
  #define SEL_CLEAR_FLASH_STORAGE_MENU_LEN 2
#endif

void pollInputs()
{
  keysPollingCycle();

  // TODO: use rotaryEncoderPollingCycle() instead
#if defined(ROTARY_ENCODER_NAVIGATION) && !defined(USE_HATS_AS_KEYS)
  static rotenc_t rePreviousValue;

  rotenc_t reNewValue = rotaryEncoderGetValue();
  int8_t scrollRE = reNewValue - rePreviousValue;
  if (scrollRE) {
    rePreviousValue = reNewValue;
    pushEvent(scrollRE < 0 ? EVT_ROTARY_LEFT : EVT_ROTARY_RIGHT);
  }
#endif
}

// poll inputs every 10ms
void per5ms()
{
  static uint32_t cnt = 0;
  if (++cnt & 1) { pollInputs(); }
}

FlashCheckRes valid;

int menuFlashFile(uint32_t index, event_t event)
{
  valid = checkFirmwareFile(index, valid);

  if (valid == FC_ERROR) {
    if (event == EVT_KEY_BREAK(KEY_EXIT) || event == EVT_KEY_BREAK(KEY_ENTER))
      return 0;

    return -1;
  }

  if (event == EVT_KEY_LONG(KEY_ENTER)) {
    return openFirmwareFile(index) == FR_OK ? 1 : -1;
  } else if (event == EVT_KEY_BREAK(KEY_EXIT))
    return 0;

  return -1;
}

void bootloaderMenu()
{
  BootloaderState state = ST_START;
  uint32_t vpos = 0;
  uint32_t radioMenuItem = 0;
  uint8_t index = 0;
  FRESULT fr;
  uint32_t nameCount = 0;
  
  sdInit();

  uint32_t next_frame = time_get_ms();

  for (;;) {

    if (time_get_ms() - next_frame >= FRAME_INTERVAL_MS) {
      next_frame += FRAME_INTERVAL_MS;

      if (state != ST_USB && state != ST_FLASHING
          && state != ST_FLASH_DONE && state != ST_RADIO_MENU) {
        if (usbPlugged()) {
          state = ST_USB;
#if !defined(SIMU)
          usbStart();
#endif
        }
      }

      if (state == ST_USB) {
        if (usbPlugged() == 0) {
          vpos = 0;
#if !defined(SIMU)
          usbStop();
#endif
          state = ST_START;
        }
        bootloaderDrawScreen(state, 0);
      }

      lcdRefreshWait();
      event_t event = getEvent();

      if (state == ST_START) {

        bootloaderDrawScreen(state, vpos);

        if (IS_NEXT_EVENT(event)) {
          if (vpos < bootloaderGetMenuItemCount(MAIN_MENU_LEN) - 1) { vpos++; }
          continue;
        }
        else if (IS_PREVIOUS_EVENT(event)) {
          if (vpos > 0) { vpos--; }
          continue;
        }
        else if (event == EVT_KEY_BREAK(KEY_ENTER)) {
          switch (vpos) {
            case 0:
              state = ST_DIR_CHECK;
              break;
#if defined(SPI_FLASH)
            case 1:
              state = ST_CLEAR_FLASH_CHECK;
              vpos = 0;
              break;
#endif
            default:
              if(vpos < bootloaderGetMenuItemCount(MAIN_MENU_LEN-1))
              {
                state = ST_RADIO_MENU;
                radioMenuItem = vpos - MAIN_MENU_LEN - 1;
              } else {
                state = ST_REBOOT;
              }
              break;
          }

          // next loop
          continue;
        }
      }
      else if (state == ST_DIR_CHECK) {
        nameCount = 0;
        fr = openFirmwareDir();
        if (fr == FR_OK)
          nameCount = fetchFirmwareFiles(index);

        if (nameCount > 0) {
          index = vpos = 0;
          state = ST_FILE_LIST;
          continue;
        } else {
          bootloaderDrawScreen(state, fr);

          if (event == EVT_KEY_BREAK(KEY_EXIT) || event == EVT_KEY_BREAK(KEY_ENTER)) {
            vpos = 0;
            state = ST_START;
            continue;
          }
        }
      }

      if (state == ST_FILE_LIST) {
        uint32_t limit = MAX_NAMES_ON_SCREEN;
        if (nameCount < limit) {
          limit = nameCount;
        }

        if (IS_NEXT_EVENT(event)) {
          if (vpos < limit - 1) {
            vpos += 1;
          } else {
            if (nameCount > limit) {
              index += 1;
              nameCount = fetchFirmwareFiles(index);
            }
          }
        } else if (IS_PREVIOUS_EVENT(event)) {
          if (vpos > 0) {
            vpos -= 1;
          }
          else {
            if (index) {
              index -= 1;
              nameCount = fetchFirmwareFiles(index);
            }
          }
        }

        bootloaderDrawScreen(state, 0);

        for (uint32_t i = 0; i < limit; i++) {
          bootloaderDrawFilename(getFirmwareFileNameByIndex(i), i, (vpos == i));
        }

        if (event == EVT_KEY_BREAK(KEY_ENTER)) {
          // Select file to flash
          state = ST_FLASH_CHECK;
          valid = FC_UNCHECKED;
          continue;
        } else if (event == EVT_KEY_BREAK(KEY_EXIT)) {
          state = ST_START;
          vpos = 0;
          continue;
        }
      } else if (state == ST_FLASH_CHECK) {
        bootloaderDrawScreen(state, valid, getFirmwareFileNameByIndex(vpos));

        int result = menuFlashFile(vpos, event);
        if (result == 0) {
          // canceled
          state = ST_FILE_LIST;
        } else if (result == 1) {
          // confirmed
          firmwareInitWrite(vpos);
          state = ST_FLASHING;
        }
      } else if (state == ST_FLASHING) {
        uint32_t progress = 0;
        bool done = firmwareWriteBlock(&progress);
        bootloaderDrawScreen(state, progress);
        if(done) {
          state = ST_FLASH_DONE;
        }
#if defined(SPI_FLASH)
      } else if (state == ST_CLEAR_FLASH_CHECK) {
        bootloaderDrawScreen(state, vpos);
        if (event == EVT_KEY_LONG(KEY_ENTER))
        {
          state = ST_CLEAR_FLASH;
        } else if (event == EVT_KEY_BREAK(KEY_EXIT)) {
          vpos = 0;
          state = ST_START;
          continue;
        }
      } else if (state == ST_CLEAR_FLASH) {
        bootloaderDrawScreen(state, 0);
        lcdRefresh();
        sdDone();
        spiFlashDiskEraseAll();
        sdInit();
        vpos = 0;
        state = ST_START;
#endif
      } else if (state == ST_RADIO_MENU) {
        if(bootloaderRadioMenu(radioMenuItem, event))
        {
          state = ST_START;
          vpos = 0;
          bootloaderDrawScreen(state, vpos);
        }
      }

      if (state == ST_FLASH_DONE) {
        if (event == EVT_KEY_BREAK(KEY_EXIT) || event == EVT_KEY_BREAK(KEY_ENTER)) {
          state = ST_START;
          vpos = 0;
        }

        bootloaderDrawScreen(state, 100);
      }

      if (event == EVT_KEY_LONG(KEY_EXIT)) {
        // Start the main application
        state = ST_REBOOT;
      }

      lcdRefresh();
    }

    if (state != ST_FLASHING && state != ST_USB) {
      if (pwrOffPressed()) {
        sdDone();
        boardOff();
      }
    }

    if (state == ST_REBOOT) {
      sdDone();
#if !defined(SIMU)
      blExit();
      NVIC_SystemReset();
#else
      exit(1);
#endif
    }
  }
}