#ifndef BSP_Q7S_CORE_CORECONTROLLER_H_
#define BSP_Q7S_CORE_CORECONTROLLER_H_

#include <fsfw/globalfunctions/PeriodicOperationDivider.h>
#include "fsfw/controller/ExtendedControllerBase.h"
#include "bsp_q7s/memory/SdCardManager.h"

#include "events/subsystemIdRanges.h"


class Timer;
class SdCardManager;

class CoreController: public ExtendedControllerBase {
public:
    enum Chip: uint8_t {
        CHIP_0,
        CHIP_1,
        NO_CHIP,
        SELF_CHIP,
        ALL_CHIP
    };

    enum Copy: uint8_t {
        COPY_0,
        COPY_1,
        NO_COPY,
        SELF_COPY,
        ALL_COPY
    };

    static constexpr char CHIP_PROT_SCRIPT[] = "/home/root/scripts/get-chip-prot-status.sh";
    static constexpr char CHIP_STATE_FILE[] = "/tmp/chip_prot_status.txt";
    static constexpr char CURR_COPY_FILE[] = "/tmp/curr_copy.txt";
    static constexpr char VERSION_FILE[] = "/conf/sd_status";

    static constexpr ActionId_t LIST_DIRECTORY_INTO_FILE = 0;
    static constexpr ActionId_t REBOOT_OBC = 32;
    static constexpr ActionId_t MOUNT_OTHER_COPY = 33;


    static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CORE;

    static constexpr Event ALLOC_FAILURE = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);


    CoreController(object_id_t objectId);
    virtual~ CoreController();

    ReturnValue_t initialize() override;

    ReturnValue_t initializeAfterTaskCreation() override;

    ReturnValue_t executeAction(ActionId_t actionId,
            MessageQueueId_t commandedBy, const uint8_t *data, size_t size) override;

    ReturnValue_t handleCommandMessage(CommandMessage *message) override;
    void performControlOperation() override;

    /**
     * Generate a file containing the chip lock/unlock states inside /tmp/chip_status.txt
     * @return
     */
    static ReturnValue_t generateChipStateFile();
    static ReturnValue_t incrementAllocationFailureCount();
    static void getCurrentBootCopy(Chip& chip, Copy& copy);

    ReturnValue_t updateProtInfo(bool regenerateChipStateFile = true);

    /**
     * Checks whether the target chip and copy are writeprotected and protect them if they are
     * not
     * @param targetChip
     * @param targetCopy
     * @param protect
     * @param protOperationPerformed [out] Can be used to determine whether any operation
     * was performed
     * @param updateProtFile Specify whether the protection info file is updated
     * @return
     */
    ReturnValue_t setBootCopyProtection(Chip targetChip, Copy targetCopy,
            bool protect, bool& protOperationPerformed, bool updateProtFile = true);

    bool sdInitFinished() const;

private:
    static Chip CURRENT_CHIP;
    static Copy CURRENT_COPY;

    // Designated value for rechecking FIFO open
    static constexpr int RETRY_FIFO_OPEN = -2;
    int watchdogFifoFd = 0;

    // States for SD state machine, which is used in non-blocking mode
    enum class SdStates {
        NONE,
        START,
        GET_INFO,
        SET_STATE_SELF,
        MOUNT_SELF,
        // Determine operations for other SD card, depending on redundancy configuration
        DETERMINE_OTHER,
        SET_STATE_OTHER,
        // Mount or unmount other
        MOUNT_UNMOUNT_OTHER,
        // Skip period because the shell command used to generate the info file sometimes is
        // missing the last performed operation if executed too early
        SKIP_CYCLE_BEFORE_INFO_UPDATE,
        UPDATE_INFO,
        // SD initialization done
        IDLE,
        // Used if SD switches or mount commands are issued via telecommand
        SET_STATE_FROM_COMMAND,
    };
    static constexpr bool BLOCKING_SD_INIT = false;

    SdCardManager* sdcMan = nullptr;

    struct SdInfo {
        sd::SdCard pref = sd::SdCard::NONE;
        sd::SdState prefState = sd::SdState::OFF;
        sd::SdCard other = sd::SdCard::NONE;
        sd::SdState otherState = sd::SdState::OFF;
        std::string prefChar = "0";
        std::string otherChar = "1";
        SdStates state = SdStates::START;
        // Used to track whether a command was executed
        bool commandExecuted = true;
        bool initFinished = false;
        SdCardManager::SdStatePair currentState;
        uint16_t cycleCount = 0;
        // These two flags are related to external commanding
        bool commandIssued = false;
        bool commandFinished = false;
        sd::SdState currentlyCommandedState = sd::SdState::OFF;
        sd::SdCard commandedCard = sd::SdCard::NONE;
        sd::SdState commandedState = sd::SdState::OFF;
    };
    SdInfo sdInfo;

    /**
     * Index 0: Chip 0 Copy 0
     * Index 1: Chip 0 Copy 1
     * Index 2: Chip 1 Copy 0
     * Index 3: Chip 1 Copy 1
     */
    std::array<bool, 4> protArray;

    ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
            LocalDataPoolManager& poolManager) override;
    LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
    ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                uint32_t *msToReachTheMode);

    ReturnValue_t initVersionFile();
    ReturnValue_t initBootCopy();
    ReturnValue_t initWatchdogFifo();
    ReturnValue_t initSdCardBlocking();
    void initPrint();

    ReturnValue_t sdStateMachine();
    void updateSdInfoOther();
    ReturnValue_t sdCardSetup(sd::SdCard sdCard, sd::SdState targetState, std::string sdChar,
            bool printOutput = true);
    ReturnValue_t sdColdRedundantBlockingInit();
    void currentStateSetter(sd::SdCard sdCard, sd::SdState newState);
    void determinePreferredSdCard();
    void executeNextExternalSdCommand();
    void checkExternalSdCommandStatus();

    ReturnValue_t actionListDirectoryIntoFile(ActionId_t actionId, MessageQueueId_t commandedBy,
            const uint8_t *data, size_t size);
    ReturnValue_t actionPerformReboot(const uint8_t *data, size_t size);

    PeriodicOperationDivider opDivider;
    void performWatchdogControlOperation();

    ReturnValue_t handleProtInfoUpdateLine(std::string nextLine);
};

#endif /* BSP_Q7S_CORE_CORECONTROLLER_H_ */