#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
#define MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_

#include <fsfw/datapoollocal/StaticLocalDataSet.h>
#include <fsfw/devicehandlers/DeviceHandlerIF.h>
#include <linux/payload/mpsocRetvals.h>
#include <mission/payload/plocSpBase.h>

#include "eive/definitions.h"
#include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/serialize/SerializeAdapter.h"
#include "fsfw/serialize/SerializeIF.h"

namespace mpsoc {

enum ParamId : uint8_t { SKIP_SUPV_ON_COMMANDING = 0x01 };

enum FileAccessModes : uint8_t {
  // Opens a file, fails if the file does not exist.
  OPEN_EXISTING = 0x00,
  READ = 0x01,
  WRITE = 0x02,
  // Creates a new file, fails if it already exists.
  CREATE_NEW = 0x04,
  // Creates a new file, existing file is truncated and overwritten.
  CREATE_ALWAYS = 0x08,
  // Opens the file if it is existing. If not, a new file is created.
  OPEN_ALWAYS = 0x10,
  OPEN_APPEND = 0x30
};

static constexpr uint32_t HK_SET_ID = 0;

namespace poolid {
enum {
  STATUS = 0,
  MODE = 1,
  DOWNLINK_PWR_ON = 2,
  DOWNLINK_REPLY_ACTIIVE = 3,
  DOWNLINK_JESD_SYNC_STATUS = 4,
  DOWNLINK_DAC_STATUS = 5,
  CAM_STATUS = 6,
  CAM_SDI_STATUS = 7,
  CAM_FPGA_TEMP = 8,
  CAM_SOC_TEMP = 9,
  SYSMON_TEMP = 10,
  SYSMON_VCCINT = 11,
  SYSMON_VCCAUX = 12,
  SYSMON_VCCBRAM = 13,
  SYSMON_VCCPAUX = 14,
  SYSMON_VCCPINT = 15,
  SYSMON_VCCPDRO = 16,
  SYSMON_MB12V = 17,
  SYSMON_MB3V3 = 18,
  SYSMON_MB1V8 = 19,
  SYSMON_VCC12V = 20,
  SYSMON_VCC5V = 21,
  SYSMON_VCC3V3 = 22,
  SYSMON_VCC3V3VA = 23,
  SYSMON_VCC2V5DDR = 24,
  SYSMON_VCC1V2DDR = 25,
  SYSMON_VCC0V9 = 26,
  SYSMON_VCC0V6VTT = 27,
  SYSMON_SAFE_COTS_CUR = 28,
  SYSMON_NVM4_XO_CUR = 29,
  SEM_UNCORRECTABLE_ERRS = 30,
  SEM_CORRECTABLE_ERRS = 31,
  SEM_STATUS = 32,
  REBOOT_MPSOC_REQUIRED = 33,
};
}

static const DeviceCommandId_t NONE = 0;
static const DeviceCommandId_t TC_MEM_WRITE = 1;
static const DeviceCommandId_t TC_MEM_READ = 2;
static const DeviceCommandId_t ACK_REPORT = 3;
static const DeviceCommandId_t EXE_REPORT = 5;
static const DeviceCommandId_t TM_MEMORY_READ_REPORT = 6;
static const DeviceCommandId_t TC_FLASHFOPEN = 7;
static const DeviceCommandId_t TC_FLASHFCLOSE = 8;
static const DeviceCommandId_t TC_FLASH_WRITE_FULL_FILE = 9;
static const DeviceCommandId_t TC_FLASHDELETE = 10;
static const DeviceCommandId_t TC_REPLAY_START = 11;
static const DeviceCommandId_t TC_REPLAY_STOP = 12;
static const DeviceCommandId_t TC_REPLAY_WRITE_SEQUENCE = 13;
static const DeviceCommandId_t TC_DOWNLINK_PWR_ON = 14;
static const DeviceCommandId_t TC_DOWNLINK_PWR_OFF = 15;
static const DeviceCommandId_t TC_MODE_REPLAY = 16;
static const DeviceCommandId_t TC_CAM_CMD_SEND = 17;
static const DeviceCommandId_t TC_MODE_IDLE = 18;
static const DeviceCommandId_t TM_CAM_CMD_RPT = 19;
static const DeviceCommandId_t SET_UART_TX_TRISTATE = 20;
static const DeviceCommandId_t RELEASE_UART_TX = 21;
static const DeviceCommandId_t TC_CAM_TAKE_PIC = 22;
static const DeviceCommandId_t TC_SIMPLEX_SEND_FILE = 23;
static const DeviceCommandId_t TC_DOWNLINK_DATA_MODULATE = 24;
static const DeviceCommandId_t TC_MODE_SNAPSHOT = 25;
static const DeviceCommandId_t TC_GET_HK_REPORT = 26;
static const DeviceCommandId_t TM_GET_HK_REPORT = 27;
static const DeviceCommandId_t TC_FLASH_GET_DIRECTORY_CONTENT = 28;
static const DeviceCommandId_t TM_FLASH_DIRECTORY_CONTENT = 29;
static constexpr DeviceCommandId_t TC_FLASH_READ_FULL_FILE = 30;

// Will reset the sequence count of the OBSW
static const DeviceCommandId_t OBSW_RESET_SEQ_COUNT = 50;

static const uint16_t SIZE_ACK_REPORT = 14;
static const uint16_t SIZE_EXE_REPORT = 14;
static const uint16_t SIZE_TM_MEM_READ_REPORT = 18;
static const uint16_t SIZE_TM_CAM_CMD_RPT = 18;
static constexpr size_t SIZE_TM_HK_REPORT = 369;

/**
 * SpacePacket apids of PLOC telecommands and telemetry.
 */
namespace apid {
static const uint16_t TC_REPLAY_START = 0x110;
static const uint16_t TC_REPLAY_STOP = 0x111;
static const uint16_t TC_REPLAY_WRITE_SEQUENCE = 0x112;
static const uint16_t TC_DOWNLINK_PWR_ON = 0x113;
static const uint16_t TC_MEM_WRITE = 0x114;
static const uint16_t TC_MEM_READ = 0x115;
static const uint16_t TC_CAM_TAKE_PIC = 0x116;
static constexpr uint16_t TC_FLASHWRITE = 0x117;
static constexpr uint16_t TC_FLASHREAD = 0x118;
static const uint16_t TC_FLASHFOPEN = 0x119;
static const uint16_t TC_FLASHFCLOSE = 0x11A;
static constexpr uint16_t TC_FLASH_GET_DIRECTORY_CONTENT = 0x11B;
static const uint16_t TC_FLASHDELETE = 0x11C;
static constexpr uint16_t TC_FLASH_CREATE_DIR = 0x11D;
static const uint16_t TC_MODE_IDLE = 0x11E;
static const uint16_t TC_MODE_REPLAY = 0x11F;
static const uint16_t TC_MODE_SNAPSHOT = 0x120;
static const uint16_t TC_DOWNLINK_DATA_MODULATE = 0x121;
static constexpr uint16_t TC_HK_GET_REPORT = 0x123;
static const uint16_t TC_DOWNLINK_PWR_OFF = 0x124;
static const uint16_t TC_CAM_CMD_SEND = 0x12C;
static constexpr uint16_t TC_FLASH_COPY_FILE = 0x12E;
static const uint16_t TC_SIMPLEX_SEND_FILE = 0x130;

static const uint16_t ACK_SUCCESS = 0x400;
static const uint16_t ACK_FAILURE = 0x401;
static const uint16_t EXE_SUCCESS = 0x402;
static const uint16_t EXE_FAILURE = 0x403;
static const uint16_t TM_MEMORY_READ_REPORT = 0x404;
static const uint16_t TM_FLASH_READ_REPORT = 0x405;
static constexpr uint16_t TM_FLASH_DIRECTORY_CONTENT = 0x406;
static const uint16_t TM_CAM_CMD_RPT = 0x407;
static constexpr uint16_t TM_HK_GET_REPORT = 0x408;
}  // namespace apid

/** Offset from first byte in space packet to first byte of data field */
static const uint8_t DATA_FIELD_OFFSET = 6;
static const size_t MEM_READ_RPT_LEN_OFFSET = 10;
static const char NULL_TERMINATOR = '\0';
static const uint8_t MIN_SPACE_PACKET_LENGTH = 7;
static const uint8_t SPACE_PACKET_HEADER_SIZE = 6;

static const uint8_t STATUS_OFFSET = 10;

static constexpr size_t CRC_SIZE = 2;

/**
 * The size of payload data which will be forwarded to the requesting object. e.g. PUS Service
 * 8.
 */
static const uint8_t SIZE_MEM_READ_RPT_FIX = 6;

static const size_t MAX_FILENAME_SIZE = 256;

/**
 * PLOC space packet length for fixed size packets. This is the size of the whole packet data
 * field. For the length field in the space packet this size will be substracted by one.
 */
static const uint16_t LENGTH_TC_MEM_WRITE = 12;
static const uint16_t LENGTH_TC_MEM_READ = 8;

/**
 * Maximum SP packet size as specified in the TAS Supversior ICD.
 * https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_TAS-ILH-IRS/ICD-PLOC/TAS&fileid=942896
 * at sheet README
 */
static constexpr size_t SP_MAX_SIZE = 1024;
static constexpr size_t MAX_REPLY_SIZE = SP_MAX_SIZE * 3;
static constexpr size_t MAX_COMMAND_SIZE = SP_MAX_SIZE;
// 1016 bytes.
static constexpr size_t SP_MAX_DATA_SIZE = SP_MAX_SIZE - ccsds::HEADER_LEN - CRC_SIZE;
static constexpr size_t FLASH_READ_MIN_OVERHEAD = 16;
// 1000 bytes.
static const size_t MAX_FLASH_READ_DATA_SIZE = SP_MAX_DATA_SIZE - FLASH_READ_MIN_OVERHEAD;
// 1012 bytes, 4 bytes for the write length.
static constexpr size_t MAX_FLASH_WRITE_DATA_SIZE = SP_MAX_DATA_SIZE - sizeof(uint32_t);

/**
 * The replay write sequence command has a maximum delay for the execution report which amounts to
 * 30 seconds. (80 cycles * 0.5 seconds = 40 seconds).
 */
static const uint16_t TC_WRITE_SEQ_EXECUTION_DELAY = 80;
// Requires approx. 2 seconds for execution. 8 => 4 seconds
static const uint16_t TC_DOWNLINK_PWR_ON_EXECUTION_DELAY = 8;
static const uint16_t TC_CAM_TAKE_PIC_EXECUTION_DELAY = 20;
static const uint16_t TC_SIMPLEX_SEND_FILE_DELAY = 80;

namespace status_code {
static const uint16_t DEFAULT_ERROR_CODE = 0x1;
static const uint16_t UNKNOWN_APID = 0x5DD;
static const uint16_t INCORRECT_LENGTH = 0x5DE;
static const uint16_t INCORRECT_CRC = 0x5DF;
static const uint16_t INCORRECT_PKT_SEQ_CNT = 0x5E0;
static const uint16_t TC_NOT_ALLOWED_IN_MODE = 0x5E1;
static const uint16_t TC_EXEUTION_DISABLED = 0x5E2;
static const uint16_t FLASH_MOUNT_FAILED = 0x5E3;
static const uint16_t FLASH_FILE_ALREADY_CLOSED = 0x5E4;
static const uint16_t FLASH_FILE_OPEN_FAILED = 0x5E5;
static const uint16_t FLASH_FILE_ALREADY_OPEN = 0x5E6;
static const uint16_t FLASH_FILE_NOT_OPEN = 0x5E7;
static const uint16_t FLASH_UNMOUNT_FAILED = 0x5E8;
static const uint16_t HEAP_ALLOCATION_FAILED = 0x5E9;
static const uint16_t INVALID_PARAMETER = 0x5EA;
static const uint16_t NOT_INITIALIZED = 0x5EB;
static const uint16_t REBOOT_IMMINENT = 0x5EC;
static const uint16_t CORRUPT_DATA = 0x5ED;
static const uint16_t FLASH_CORRECTABLE_MISMATCH = 0x5EE;
static const uint16_t FLASH_UNCORRECTABLE_MISMATCH = 0x5EF;
static const uint16_t RESERVED_0 = 0x5F0;
static const uint16_t RESERVED_1 = 0x5F1;
static const uint16_t RESERVED_2 = 0x5F2;
static const uint16_t RESERVED_3 = 0x5F3;
static const uint16_t RESERVED_4 = 0x5F4;
}  // namespace status_code

/**
 * @brief   Abstract base class for TC space packet of MPSoC.
 */
class TcBase : public ploc::SpTcBase, public MPSoCReturnValuesIF {
 public:
  virtual ~TcBase() = default;

  // Initial length field of space packet. Will always be updated when packet is created.
  static const uint16_t INIT_LENGTH = CRC_SIZE;

  /**
   * @brief    Constructor
   *
   * @param sequenceCount Sequence count of space packet which will be incremented with each
   *        sent and received packets.
   */
  TcBase(ploc::SpTcParams params, uint16_t apid, uint16_t sequenceCount)
      : ploc::SpTcBase(params, apid, 0, sequenceCount) {
    payloadStart = spParams.buf + ccsds::HEADER_LEN;
    spParams.setFullPayloadLen(INIT_LENGTH);
  }

  /**
   * @brief   Function to finsh and write the space packet. It is expected that the user has
   * set the payload fields in the child class*
   * @return  returnvalue::OK if packet creation was successful, otherwise error return value
   */
  ReturnValue_t finishPacket() {
    updateSpFields();
    ReturnValue_t res = checkSizeAndSerializeHeader();
    if (res != returnvalue::OK) {
      return res;
    }
    return calcAndSetCrc();
  }
};

/**
 * @brief   This class helps to build the memory read command for the PLOC.
 */
class TcMemRead : public TcBase {
 public:
  /**
   * @brief   Constructor
   */
  TcMemRead(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_MEM_READ, sequenceCount) {
    spParams.setFullPayloadLen(COMMAND_LENGTH + CRC_SIZE);
  }

  uint16_t getMemLen() const { return memLen; }

  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    ReturnValue_t result = returnvalue::OK;
    result = lengthCheck(commandDataLen);
    if (result != returnvalue::OK) {
      return result;
    }
    std::memcpy(payloadStart, commandData, MEM_ADDRESS_SIZE);
    std::memcpy(payloadStart + MEM_ADDRESS_SIZE, commandData + MEM_ADDRESS_SIZE, MEM_LEN_SIZE);
    size_t size = sizeof(memLen);
    const uint8_t* memLenPtr = commandData + MEM_ADDRESS_SIZE;
    result =
        SerializeAdapter::deSerialize(&memLen, &memLenPtr, &size, SerializeIF::Endianness::BIG);
    if (result != returnvalue::OK) {
      return result;
    }
    return result;
  }

 private:
  static const size_t COMMAND_LENGTH = 6;
  static const size_t MEM_ADDRESS_SIZE = 4;
  static const size_t MEM_LEN_SIZE = 2;
  static const uint16_t PACKET_LENGTH = 7;

  uint16_t memLen = 0;

  ReturnValue_t lengthCheck(size_t commandDataLen) {
    if (commandDataLen != COMMAND_LENGTH or checkPayloadLen() != returnvalue::OK) {
      return INVALID_LENGTH;
    }
    return returnvalue::OK;
  }
};

/**
 * @brief   This class helps to generate the space packet to write data to a memory address within
 *          the PLOC.
 */
class TcMemWrite : public TcBase {
 public:
  /**
   * @brief   Constructor
   */
  TcMemWrite(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_MEM_WRITE, sequenceCount) {}

  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    ReturnValue_t result = returnvalue::OK;
    result = lengthCheck(commandDataLen);
    if (result != returnvalue::OK) {
      return result;
    }
    uint16_t memLen =
        *(commandData + MEM_ADDRESS_SIZE) << 8 | *(commandData + MEM_ADDRESS_SIZE + 1);
    spParams.setFullPayloadLen(MIN_FIXED_PAYLOAD_LENGTH + memLen * 4 + CRC_SIZE);
    result = checkPayloadLen();
    if (result != returnvalue::OK) {
      return result;
    }
    std::memcpy(payloadStart, commandData, commandDataLen);
    return result;
  }

 private:
  // 4 byte address, 2 byte mem length field
  static const size_t MEM_ADDRESS_SIZE = 4;
  static const size_t MIN_FIXED_PAYLOAD_LENGTH = MEM_ADDRESS_SIZE + 2;
  // Min length consists of 4 byte address, 2 byte mem length field, 4 byte data (1 word)
  static const size_t MIN_COMMAND_DATA_LENGTH = MIN_FIXED_PAYLOAD_LENGTH + 4;

  ReturnValue_t lengthCheck(size_t commandDataLen) {
    if (commandDataLen < MIN_COMMAND_DATA_LENGTH) {
      sif::warning << "TcMemWrite: Length " << commandDataLen << " smaller than minimum "
                   << MIN_COMMAND_DATA_LENGTH << std::endl;
      return INVALID_LENGTH;
    }
    if (commandDataLen + CRC_SIZE > spParams.maxSize) {
      sif::warning << "TcMemWrite: Length " << commandDataLen << " larger than allowed "
                   << spParams.maxSize - CRC_SIZE << std::endl;
      return INVALID_LENGTH;
    }
    return returnvalue::OK;
  }
};

/**
 * @brief   Class to help creation of flash fopen command.
 */
class FlashFopen : public TcBase {
 public:
  FlashFopen(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_FLASHFOPEN, sequenceCount) {}

  ReturnValue_t setPayload(std::string filename, uint8_t mode) {
    accessMode = mode;
    size_t nameSize = filename.size();
    spParams.setFullPayloadLen(256 + sizeof(uint8_t) + CRC_SIZE);
    ReturnValue_t result = checkPayloadLen();
    if (result != returnvalue::OK) {
      return result;
    }
    std::memcpy(payloadStart, filename.c_str(), nameSize);
    // payloadStart[nameSize] = NULL_TERMINATOR;
    std::memset(payloadStart + nameSize, 0, 256 - nameSize);
    // payloadStart[255] = NULL_TERMINATOR;
    payloadStart[256] = accessMode;
    return returnvalue::OK;
  }

 private:
  uint8_t accessMode = FileAccessModes::OPEN_EXISTING;
};

/**
 * @brief   Class to help creation of flash fclose command.
 */
class FlashFclose : public TcBase {
 public:
  FlashFclose(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_FLASHFCLOSE, sequenceCount) {
    spParams.setFullPayloadLen(CRC_SIZE);
  }
};

/**
 * @brief   Class to build flash write space packet.
 */
class TcFlashWrite : public TcBase {
 public:
  TcFlashWrite(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_FLASHWRITE, sequenceCount) {}

  ReturnValue_t setPayload(const uint8_t* writeData, uint32_t writeLen_) {
    writeLen = writeLen_;
    if (writeLen > MAX_FLASH_WRITE_DATA_SIZE) {
      sif::error << "TcFlashWrite: Command data too big" << std::endl;
      return returnvalue::FAILED;
    }
    spParams.setFullPayloadLen(sizeof(uint32_t) + static_cast<uint16_t>(writeLen) + CRC_SIZE);
    ReturnValue_t result = checkPayloadLen();
    if (result != returnvalue::OK) {
      return result;
    }
    size_t serializedSize = ccsds::HEADER_LEN;
    result = SerializeAdapter::serialize(&writeLen, payloadStart, &serializedSize, spParams.maxSize,
                                         SerializeIF::Endianness::BIG);
    if (result != returnvalue::OK) {
      return result;
    }
    std::memcpy(payloadStart + sizeof(uint32_t), writeData, writeLen);
    updateSpFields();
    result = checkSizeAndSerializeHeader();
    if (result != returnvalue::OK) {
      return result;
    }
    return calcAndSetCrc();
  }

 private:
  uint32_t writeLen = 0;
};

class TcFlashRead : public TcBase {
 public:
  TcFlashRead(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_FLASHREAD, sequenceCount) {}

  ReturnValue_t setPayload(uint32_t readLen) {
    if (readLen > MAX_FLASH_READ_DATA_SIZE) {
      sif::error << "TcFlashRead: Read length " << readLen << " too large" << std::endl;
      return returnvalue::FAILED;
    }
    spParams.setFullPayloadLen(sizeof(uint32_t) + CRC_SIZE);
    ReturnValue_t result = checkPayloadLen();
    if (result != returnvalue::OK) {
      return result;
    }
    size_t serializedSize = ccsds::HEADER_LEN;
    result = SerializeAdapter::serialize(&readLen, payloadStart, &serializedSize, spParams.maxSize,
                                         SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    updateSpFields();
    result = checkSizeAndSerializeHeader();
    if (result != returnvalue::OK) {
      return result;
    }
    result = calcAndSetCrc();
    if (result != returnvalue::OK) {
      return result;
    }
    readSize = readLen;
    return result;
  }

  uint32_t readSize = 0;
};

/**
 * @brief   Class to help creation of flash delete command.
 */
class TcFlashDelete : public TcBase {
 public:
  TcFlashDelete(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_FLASHDELETE, sequenceCount) {}

  ReturnValue_t setPayload(std::string filename) {
    size_t nameSize = filename.size();
    spParams.setFullPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE);
    auto res = checkPayloadLen();
    if (res != returnvalue::OK) {
      return res;
    }
    std::memcpy(payloadStart, filename.c_str(), nameSize);
    *(payloadStart + nameSize) = NULL_TERMINATOR;

    updateSpFields();
    res = checkSizeAndSerializeHeader();
    if (res != returnvalue::OK) {
      return res;
    }
    return calcAndSetCrc();
  }
};

/**
 * @brief   Class to build replay stop space packet.
 */
class TcReplayStop : public TcBase {
 public:
  TcReplayStop(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_REPLAY_STOP, sequenceCount) {}
};

/**
 * @brief   This class helps to build the replay start command.
 */
class TcReplayStart : public TcBase {
 public:
  /**
   * @brief   Constructor
   */
  TcReplayStart(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_REPLAY_START, sequenceCount) {}

  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    ReturnValue_t result = returnvalue::OK;
    spParams.setFullPayloadLen(commandDataLen + CRC_SIZE);
    result = lengthCheck(commandDataLen);
    if (result != returnvalue::OK) {
      return result;
    }
    result = checkData(*commandData);
    if (result != returnvalue::OK) {
      return result;
    }
    std::memcpy(payloadStart, commandData, commandDataLen);
    return result;
  }

 private:
  static const size_t COMMAND_DATA_LENGTH = 1;
  static const uint8_t REPEATING = 0;
  static const uint8_t ONCE = 1;

  ReturnValue_t lengthCheck(size_t commandDataLen) {
    if (commandDataLen != COMMAND_DATA_LENGTH or checkPayloadLen() != returnvalue::OK) {
      sif::warning << "TcReplayStart: Command has invalid length " << commandDataLen << std::endl;
      return INVALID_LENGTH;
    }
    return returnvalue::OK;
  }

  ReturnValue_t checkData(uint8_t replay) {
    if (replay != REPEATING && replay != ONCE) {
      sif::warning << "TcReplayStart::checkData: Invalid replay value" << std::endl;
      return INVALID_PARAMETER;
    }
    return returnvalue::OK;
  }
};

/**
 * @brief   This class helps to build downlink power on command.
 */
class TcDownlinkPwrOn : public TcBase {
 public:
  /**
   * @brief   Constructor
   */
  TcDownlinkPwrOn(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_DOWNLINK_PWR_ON, sequenceCount) {}

  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    ReturnValue_t result = returnvalue::OK;
    result = lengthCheck(commandDataLen);
    if (result != returnvalue::OK) {
      return result;
    }
    result = modeCheck(*commandData);
    if (result != returnvalue::OK) {
      return result;
    }
    result = laneRateCheck(*(commandData + 1));
    if (result != returnvalue::OK) {
      return result;
    }
    spParams.setFullPayloadLen(commandDataLen + sizeof(MAX_AMPLITUDE) + CRC_SIZE);
    result = checkPayloadLen();
    if (result != returnvalue::OK) {
      return result;
    }
    std::memcpy(payloadStart, commandData, commandDataLen);
    std::memcpy(payloadStart + commandDataLen, &MAX_AMPLITUDE, sizeof(MAX_AMPLITUDE));
    return result;
  }

 private:
  static const uint8_t INTERFACE_ID = CLASS_ID::DWLPWRON_CMD;

  //! [EXPORT] : [COMMENT] Received command has invalid JESD mode (valid modes are 0 - 5)
  static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0xE0);
  //! [EXPORT] : [COMMENT] Received command has invalid lane rate (valid lane rate are 0 - 9)
  static const ReturnValue_t INVALID_LANE_RATE = MAKE_RETURN_CODE(0xE1);

  static const size_t COMMAND_DATA_LENGTH = 2;
  static const uint8_t MAX_MODE = 5;
  static const uint8_t MAX_LANE_RATE = 9;
  static const uint16_t MAX_AMPLITUDE = 0;

  ReturnValue_t lengthCheck(size_t commandDataLen) {
    if (commandDataLen != COMMAND_DATA_LENGTH) {
      sif::warning << "TcDownlinkPwrOn: Command has invalid length " << commandDataLen << std::endl;
      return INVALID_LENGTH;
    }
    return returnvalue::OK;
  }

  ReturnValue_t modeCheck(uint8_t mode) {
    if (mode > MAX_MODE) {
      sif::warning << "TcDwonlinkPwrOn::modeCheck: Invalid JESD mode" << std::endl;
      return INVALID_MODE;
    }
    return returnvalue::OK;
  }

  ReturnValue_t laneRateCheck(uint8_t laneRate) {
    if (laneRate > MAX_LANE_RATE) {
      sif::warning << "TcReplayStart::laneRateCheck: Invalid lane rate" << std::endl;
      return INVALID_LANE_RATE;
    }
    return returnvalue::OK;
  }
};

class TcGetHkReport : public TcBase {
 public:
  TcGetHkReport(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_HK_GET_REPORT, sequenceCount) {}
};

class TcGetDirContent : public TcBase {
 public:
  TcGetDirContent(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_FLASH_GET_DIRECTORY_CONTENT, sequenceCount) {}

  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    ReturnValue_t result = returnvalue::OK;
    // Yeah it needs to be 256.. even if the path is shorter.
    spParams.setFullPayloadLen(256 + CRC_SIZE);
    if (result != returnvalue::OK) {
      return result;
    }
    std::memcpy(payloadStart, commandData, commandDataLen);
    payloadStart[255] = '\0';
    return result;
  }
};

/**
 * @brief   Class to build replay stop space packet.
 */
class TcDownlinkPwrOff : public TcBase {
 public:
  TcDownlinkPwrOff(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_DOWNLINK_PWR_OFF, sequenceCount) {}
};

/**
 * @brief   This class helps to build the replay start command.
 */
class TcReplayWriteSeq : public TcBase {
 public:
  /**
   * @brief   Constructor
   */
  TcReplayWriteSeq(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_REPLAY_WRITE_SEQUENCE, sequenceCount) {}

  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    ReturnValue_t result = returnvalue::OK;
    spParams.setFullPayloadLen(commandDataLen + sizeof(NULL_TERMINATOR) + CRC_SIZE);
    result = lengthCheck(commandDataLen);
    if (result != returnvalue::OK) {
      return result;
    }
    std::memcpy(payloadStart, commandData, commandDataLen);
    *(payloadStart + commandDataLen) = NULL_TERMINATOR;
    return result;
  }

 private:
  static const size_t USE_DECODING_LENGTH = 1;

  ReturnValue_t lengthCheck(size_t commandDataLen) {
    if (commandDataLen > USE_DECODING_LENGTH + MAX_FILENAME_SIZE or
        checkPayloadLen() != returnvalue::OK) {
      sif::warning << "TcReplayWriteSeq: Command has invalid length " << commandDataLen
                   << std::endl;
      return INVALID_LENGTH;
    }
    return returnvalue::OK;
  }
};

/**
 * @brief   Helps to extract the fields of the flash write command from the PUS packet.
 */
class FlashBasePusCmd : public MPSoCReturnValuesIF {
 public:
  FlashBasePusCmd() = default;
  virtual ~FlashBasePusCmd() = default;

  virtual ReturnValue_t extractFields(const uint8_t* commandData, size_t commandDataLen) {
    if (commandDataLen > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE + MAX_FILENAME_SIZE)) {
      return INVALID_LENGTH;
    }
    size_t fileLen = strnlen(reinterpret_cast<const char*>(commandData), commandDataLen);
    if (fileLen > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE)) {
      return FILENAME_TOO_LONG;
    }
    obcFile = std::string(reinterpret_cast<const char*>(commandData), fileLen);
    fileLen =
        strnlen(reinterpret_cast<const char*>(commandData + obcFile.size() + SIZE_NULL_TERMINATOR),
                commandDataLen - obcFile.size() - 1);
    if (fileLen > MAX_FILENAME_SIZE) {
      return MPSOC_FILENAME_TOO_LONG;
    }
    mpsocFile = std::string(
        reinterpret_cast<const char*>(commandData + obcFile.size() + SIZE_NULL_TERMINATOR),
        fileLen);
    return returnvalue::OK;
  }

  const std::string& getObcFile() const { return obcFile; }

  const std::string& getMPSoCFile() const { return mpsocFile; }

 protected:
  size_t getParsedSize() const {
    return getObcFile().size() + getMPSoCFile().size() + 2 * SIZE_NULL_TERMINATOR;
  }
  static const size_t SIZE_NULL_TERMINATOR = 1;

 private:
  std::string obcFile;
  std::string mpsocFile;
};

class FlashReadPusCmd : public FlashBasePusCmd {
 public:
  FlashReadPusCmd(){};

  ReturnValue_t extractFields(const uint8_t* commandData, size_t commandDataLen) override {
    ReturnValue_t result = FlashBasePusCmd::extractFields(commandData, commandDataLen);
    if (result != returnvalue::OK) {
      return result;
    }
    if (commandDataLen < (getParsedSize() + 4)) {
      return returnvalue::FAILED;
    }
    size_t deserDummy = 4;
    return SerializeAdapter::deSerialize(&readSize, commandData + getParsedSize(), &deserDummy,
                                         SerializeIF::Endianness::NETWORK);
  }

  size_t getReadSize() const { return readSize; }

 private:
  size_t readSize = 0;
};
/**
 * @brief   Class to build replay stop space packet.
 */
class TcModeReplay : public TcBase {
 public:
  TcModeReplay(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_MODE_REPLAY, sequenceCount) {}
};

/**
 * @brief   Class to build mode idle command
 */
class TcModeIdle : public TcBase {
 public:
  TcModeIdle(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_MODE_IDLE, sequenceCount) {}
};

/**
 * @brief   Class to build mode idle command
 */
class TcModeSnapshot : public TcBase {
 public:
  TcModeSnapshot(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_MODE_SNAPSHOT, sequenceCount) {}
};

/**
 * @brief   Class to build camera take picture command
 */
class TcCamTakePic : public TcBase {
 public:
  TcCamTakePic(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_CAM_TAKE_PIC, sequenceCount) {}

  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    if (commandDataLen > MAX_DATA_LENGTH) {
      return INVALID_LENGTH;
    }
    std::string fileName(reinterpret_cast<const char*>(commandData));
    if (fileName.size() + sizeof(NULL_TERMINATOR) > MAX_FILENAME_SIZE) {
      return FILENAME_TOO_LONG;
    }
    if (commandDataLen - (fileName.size() + sizeof(NULL_TERMINATOR)) != PARAMETER_SIZE) {
      return INVALID_LENGTH;
    }
    spParams.setFullPayloadLen(commandDataLen + CRC_SIZE);
    std::memcpy(payloadStart, commandData, commandDataLen);
    return returnvalue::OK;
  }

 private:
  static const size_t MAX_DATA_LENGTH = 286;
  static const size_t PARAMETER_SIZE = 28;
};

/**
 * @brief   Class to build simplex send file command
 */
class TcSimplexSendFile : public TcBase {
 public:
  TcSimplexSendFile(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_SIMPLEX_SEND_FILE, sequenceCount) {}

  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    if (commandDataLen < MIN_DATA_LENGTH) {
      return INVALID_LENGTH;
    }
    if (commandDataLen > MAX_DATA_LENGTH) {
      return INVALID_LENGTH;
    }
    const uint8_t** dataPtr = &commandData;
    ReturnValue_t result = SerializeAdapter::deSerialize(&chunkParameter, dataPtr, &commandDataLen,
                                                         SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    if (chunkParameter == 0) {
      return INVALID_PARAMETER;
    }
    std::string fileName(reinterpret_cast<const char*>(*dataPtr));
    if (fileName.size() + sizeof(NULL_TERMINATOR) > MAX_FILENAME_SIZE) {
      return FILENAME_TOO_LONG;
    }
    size_t currentCopyIdx = 0;
    size_t payloadLen = fileName.length() + sizeof(NULL_TERMINATOR) + CRC_SIZE;
    if (chunkParameter > 1) {
      char divStr[12]{};
      sprintf(divStr, "DIV%03d", chunkParameter);
      std::memcpy(payloadStart, divStr, DIV_STR_LEN);
      payloadLen += DIV_STR_LEN;
      currentCopyIdx += DIV_STR_LEN;
    }

    std::memcpy(payloadStart + currentCopyIdx, *dataPtr, fileName.length());
    spParams.setFullPayloadLen(payloadLen);
    return returnvalue::OK;
  }

 private:
  uint32_t chunkParameter = 0;
  static constexpr size_t MAX_DATA_LENGTH = 256;
  static constexpr size_t MIN_DATA_LENGTH = 4;
  static constexpr size_t DIV_STR_LEN = 6;
};

/**
 * @brief   Class to build downlink data modulate command
 */
class TcDownlinkDataModulate : public TcBase {
 public:
  TcDownlinkDataModulate(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_DOWNLINK_DATA_MODULATE, sequenceCount) {}

  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    if (commandDataLen > MAX_DATA_LENGTH) {
      return INVALID_LENGTH;
    }
    spParams.setFullPayloadLen(commandDataLen + CRC_SIZE);
    std::memcpy(payloadStart, commandData, commandDataLen);
    return returnvalue::OK;
  }

 private:
  static const size_t MAX_DATA_LENGTH = 11;
};

class TcCamcmdSend : public TcBase {
 public:
  TcCamcmdSend(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_CAM_CMD_SEND, sequenceCount) {}

  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    if (commandDataLen > MAX_DATA_LENGTH) {
      return INVALID_LENGTH;
    }
    uint16_t dataLen = static_cast<uint16_t>(commandDataLen + sizeof(CARRIAGE_RETURN));
    spParams.setFullPayloadLen(sizeof(dataLen) + commandDataLen + sizeof(CARRIAGE_RETURN) +
                               CRC_SIZE);
    auto res = checkPayloadLen();
    if (res != returnvalue::OK) {
      return res;
    }
    size_t size = ccsds::HEADER_LEN;
    SerializeAdapter::serialize(&dataLen, payloadStart, &size, spParams.maxSize,
                                SerializeIF::Endianness::BIG);
    std::memcpy(payloadStart + sizeof(dataLen), commandData, commandDataLen);
    *(payloadStart + sizeof(dataLen) + commandDataLen) = CARRIAGE_RETURN;

    return returnvalue::OK;
  }

 private:
  static const uint8_t MAX_DATA_LENGTH = 10;
  static const uint8_t CARRIAGE_RETURN = 0xD;
};

class HkReport : public StaticLocalDataSet<36> {
 public:
  HkReport(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, HK_SET_ID) {}

  HkReport(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, HK_SET_ID)) {}

  lp_var_t<uint32_t> status = lp_var_t<uint32_t>(sid.objectId, mpsoc::poolid::STATUS, this);
  lp_var_t<uint8_t> mode = lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::MODE, this);
  lp_var_t<uint8_t> downlinkPwrOn =
      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::DOWNLINK_PWR_ON, this);
  lp_var_t<uint8_t> downlinkReplyActive =
      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::DOWNLINK_REPLY_ACTIIVE, this);
  lp_var_t<uint8_t> downlinkJesdSyncStatus =
      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::DOWNLINK_JESD_SYNC_STATUS, this);
  lp_var_t<uint8_t> downlinkDacStatus =
      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::DOWNLINK_DAC_STATUS, this);
  lp_var_t<uint8_t> camStatus = lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::CAM_STATUS, this);
  lp_var_t<uint8_t> camSdiStatus =
      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::CAM_SDI_STATUS, this);
  lp_var_t<float> camFpgaTemp = lp_var_t<float>(sid.objectId, mpsoc::poolid::CAM_FPGA_TEMP, this);
  lp_var_t<float> camSocTemp = lp_var_t<float>(sid.objectId, mpsoc::poolid::CAM_SOC_TEMP, this);
  lp_var_t<float> sysmonTemp = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_TEMP, this);
  lp_var_t<float> sysmonVccInt = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCINT, this);
  lp_var_t<float> sysmonVccAux = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCAUX, this);
  lp_var_t<float> sysmonVccBram =
      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCBRAM, this);
  lp_var_t<float> sysmonVccPaux =
      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCPAUX, this);
  lp_var_t<float> sysmonVccPint =
      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCPINT, this);
  lp_var_t<float> sysmonVccPdro =
      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCPDRO, this);
  lp_var_t<float> sysmonMb12V = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_MB12V, this);
  lp_var_t<float> sysmonMb3V3 = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_MB3V3, this);
  lp_var_t<float> sysmonMb1V8 = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_MB1V8, this);
  lp_var_t<float> sysmonVcc12V = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC12V, this);
  lp_var_t<float> sysmonVcc5V = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC5V, this);
  lp_var_t<float> sysmonVcc3V3 = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC3V3, this);
  lp_var_t<float> sysmonVcc3V3VA =
      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC3V3VA, this);
  lp_var_t<float> sysmonVcc2V5DDR =
      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC2V5DDR, this);
  lp_var_t<float> sysmonVcc1V2DDR =
      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC1V2DDR, this);
  lp_var_t<float> sysmonVcc0V9 = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC0V9, this);
  lp_var_t<float> sysmonVcc0V6VTT =
      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC0V6VTT, this);
  lp_var_t<float> sysmonSafeCotsCur =
      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_SAFE_COTS_CUR, this);
  lp_var_t<float> sysmonNvm4XoCur =
      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_NVM4_XO_CUR, this);
  lp_var_t<uint16_t> semUncorrectableErrs =
      lp_var_t<uint16_t>(sid.objectId, mpsoc::poolid::SEM_UNCORRECTABLE_ERRS, this);
  lp_var_t<uint16_t> semCorrectableErrs =
      lp_var_t<uint16_t>(sid.objectId, mpsoc::poolid::SEM_CORRECTABLE_ERRS, this);
  lp_var_t<uint8_t> semStatus = lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::SEM_STATUS, this);
  lp_var_t<uint8_t> rebootMpsocRequired =
      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::REBOOT_MPSOC_REQUIRED, this);
};

uint16_t getStatusFromRawData(const uint8_t* data);
std::string getStatusString(uint16_t status);

}  // namespace mpsoc

#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ */