#include "ScexDeviceHandler.h"

#include <linux/devices/ScexHelper.h>
#include <mission/memory/SdCardMountedIF.h>

#include <algorithm>
#include <iostream>
#include <random>

#include "fsfw/globalfunctions/CRC.h"
#include "mission/devices/devicedefinitions/ScexDefinitions.h"

using std::ofstream;

ScexDeviceHandler::ScexDeviceHandler(object_id_t objectId, ScexUartReader& reader, CookieIF* cookie,
                                     SdCardMountedIF* sdcMan)
    : DeviceHandlerBase(objectId, reader.getObjectId(), cookie), sdcMan(sdcMan), reader(reader) {}

ScexDeviceHandler::~ScexDeviceHandler() {}

void ScexDeviceHandler::doStartUp() {
  // mode on
  setMode(MODE_ON);
}

void ScexDeviceHandler::doShutDown() { setMode(_MODE_POWER_DOWN); }

ReturnValue_t ScexDeviceHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
  return RETURN_OK;
}

ReturnValue_t ScexDeviceHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
  return RETURN_OK;
}

ReturnValue_t ScexDeviceHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                         const uint8_t* commandData,
                                                         size_t commandDataLen) {
  using namespace scex;

  auto cmdTyped = static_cast<scex::Cmds>(deviceCommand);
  if (std::find(VALID_CMDS.begin(), VALID_CMDS.end(), deviceCommand) == VALID_CMDS.end()) {
    return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
  }
  bool tempCheck = false;
  if (commandDataLen == 1) {
    tempCheck = commandData[0];
  }

  switch (deviceCommand) {
    case (PING): {
      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen, {nullptr, 0},
                     tempCheck);
      break;
    }
    case (EXP_STATUS_CMD): {
      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen, {nullptr, 0},
                     tempCheck);
      break;
    }
    case (ION_CMD): {
      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen, {nullptr, 0},
                     tempCheck);
      break;
    }
    case (TEMP_CMD): {
      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen, {nullptr, 0},
                     tempCheck);
      break;
    }
    case (FRAM): {
      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
                     {commandData + 1, commandDataLen - 1}, tempCheck);
      break;
    }
    case (ONE_CELL): {
      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
                     {commandData + 1, commandDataLen - 1}, tempCheck);
      break;
    }
    case (ALL_CELLS_CMD): {
      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
                     {commandData + 1, commandDataLen - 1}, tempCheck);
      break;
    }
    default: {
      return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
    }
  }
  rawPacket = cmdBuf.data();
  return RETURN_OK;
}

void ScexDeviceHandler::fillCommandAndReplyMap() {
  insertInCommandAndReplyMap(scex::Cmds::PING, 3);
  insertInCommandAndReplyMap(scex::Cmds::ION_CMD, 3);
  insertInCommandAndReplyMap(scex::Cmds::TEMP_CMD, 3);
  insertInCommandAndReplyMap(scex::Cmds::EXP_STATUS_CMD, 3);

  insertInCommandMap(scex::Cmds::ALL_CELLS_CMD);
  insertInCommandMap(scex::Cmds::ONE_CELL);
  insertInCommandMap(scex::Cmds::FRAM);

  insertInReplyMap(scex::Cmds::ERROR_REPLY, 3);
}

ReturnValue_t ScexDeviceHandler::scanForReply(const uint8_t* start, size_t remainingSize,
                                              DeviceCommandId_t* foundId, size_t* foundLen) {
  uint8_t* decodedPacket = nullptr;
  size_t len = 0;

  const uint8_t* helperPtr = decodedPacket;
  ReturnValue_t result = helper.deSerialize(&helperPtr, &len);

  if (result == ScexHelper::INVALID_CRC) {
    sif::warning << "ScexDeviceHandler::scanForReply: CRC invalid" << std::endl;
    return result;
  }
  *foundId = helper.getCmd();
  *foundLen = remainingSize;

  return RETURN_OK;
}

ReturnValue_t ScexDeviceHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
  // cmd auswertung (in file reinschreiben)
  using namespace scex;

  auto oneFileHandler = [&](std::string cmdName) {
    fileId = random_string(6);
    std::ostringstream oss("/tmp/scex-");
    oss << cmdName << fileId << ".bin";
    fileName = oss.str();
    ofstream out(fileName, ofstream::binary);
    if (out.bad()) {
      sif::error << "ScexDeviceHandler::interpretDeviceReply: Could not open file " << fileName
                 << std::endl;
      return RETURN_FAILED;
    }
    if (debugMode) {
      out << helper;
    }
    return RETURN_OK;
  };
  auto multiFileHandler = [&](std::string cmdName) {
    if ((helper.getPacketCounter() == 1) or (not fileNameSet)) {
      // countdown starten
      finishCountdown.resetTimer();

      fileId = random_string(6);
      std::ostringstream oss("/tmp/scex-");
      oss << cmdName << fileId << ".bin";
      fileName = oss.str();
      fileNameSet = true;
      ofstream out(fileName, ofstream::binary);
      if (out.bad()) {
        sif::error << "ScexDeviceHandler::interpretDeviceReply: Could not open file " << fileName
                   << std::endl;
        return RETURN_FAILED;
      }
    } else {
      ofstream out(fileName,
                   ofstream::binary | ofstream::app);  // append
      if (debugMode) {
        out << helper;
      }

      if (finishCountdown.hasTimedOut()) {
        triggerEvent(scex::EXPERIMENT_TIMEDOUT, id, 0);
        reader.finish();
        sif::warning << "ScexDeviceHandler::interpretDiviceReply: Reader timeout" << std::endl;
        fileNameSet = false;
      }
    }

    return RETURN_OK;
  };
  switch (id) {
    case (PING): {
      return oneFileHandler("ping_");
    }
    case (ION_CMD): {
      return oneFileHandler("ion_");
    }
    case (TEMP_CMD): {
      return oneFileHandler("temp_");
    }
    case (EXP_STATUS_CMD): {
      return oneFileHandler("exp_status_");
    }
    case (FRAM): {
      return multiFileHandler("fram_");
    }
    case (ONE_CELL): {
      return multiFileHandler("one_cell_");
    }
    case (ALL_CELLS_CMD): {
      return multiFileHandler("all_cell_");
    }
    default:
      // Unknown DeviceCommand
      return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
  }
  if (helper.getPacketCounter() == helper.getTotalPacketCounter()) {
    reader.finish();
    if (id != PING) {
      sif::info << "Reader is finished" << std::endl;
      fileNameSet = false;
    }
  }

  return RETURN_OK;
}

uint32_t ScexDeviceHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
  return RETURN_OK;
}

ReturnValue_t ScexDeviceHandler::getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches) {
  return RETURN_OK;
}

ReturnValue_t ScexDeviceHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                         LocalDataPoolManager& poolManager) {
  return RETURN_OK;
}

std::string ScexDeviceHandler::random_string(std::string::size_type length) {
  static auto& chrs =
      "0123456789"
      "abcdefghijklmnopqrstuvwxyz"
      "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

  thread_local static std::mt19937 rg{std::random_device{}()};
  thread_local static std::uniform_int_distribution<std::string::size_type> pick(0,
                                                                                 sizeof(chrs) - 2);

  std::string s;

  s.reserve(length);

  while (length--) s += chrs[pick(rg)];

  return s;
}

void ScexDeviceHandler::modeChanged() {}