#include <bsp_q7s/core/CoreController.h>
#include <bsp_q7s/memory/FileSystemHandler.h>
#include <fsfw/objectmanager/ObjectManager.h>
#include "Q7STestTask.h"

#include "bsp_q7s/memory/SdCardManager.h"
#include "bsp_q7s/memory/scratchApi.h"

#include "fsfw/timemanager/Stopwatch.h"
#include "fsfw/tasks/TaskFactory.h"

#include "test/DummyParameter.h"

#include <nlohmann/json.hpp>
#include <gps.h>
#include <libgpsmm.h>

#include <ctime>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstdio>

Q7STestTask::Q7STestTask(object_id_t objectId): TestTask(objectId) {
    doTestSdCard = false;
    doTestScratchApi = false;
    doTestGps = false;
}

ReturnValue_t Q7STestTask::performOneShotAction() {
    if (doTestSdCard) {
        testSdCard();
    }
    if (doTestScratchApi) {
        testScratchApi();
    }
    //testJsonLibDirect();
    //testDummyParams();
    //testProtHandler();
    FsOpCodes opCode = FsOpCodes::APPEND_TO_FILE;
    testFileSystemHandlerDirect(opCode);
    return TestTask::performOneShotAction();
}

ReturnValue_t Q7STestTask::performPeriodicAction() {
    if(doTestGps) {
        testGpsDaemon();
    }
    return TestTask::performPeriodicAction();
}

void Q7STestTask::testSdCard() {
    using namespace std;
    Stopwatch stopwatch;
    int result = std::system("q7hw sd info all > /tmp/sd_status.txt");
    if(result != 0) {
        sif::debug << "system call failed with " << result << endl;
    }
    ifstream sdStatus("/tmp/sd_status.txt");
    string line;
    uint8_t idx = 0;
    while (std::getline(sdStatus, line)) {
        std::istringstream iss(line);
        string word;
        while(iss >> word) {
            if(word == "on") {
                sif::info << "SD card " << static_cast<int>(idx) << " is on" << endl;
            }
            else if(word == "off") {
                sif::info << "SD card " << static_cast<int>(idx) << " is off" << endl;
            }
        }
        idx++;
    }
    std::remove("/tmp/sd_status.txt");
}

void Q7STestTask::fileTests() {
	using namespace std;
    ofstream testFile("/tmp/test.txt");
    testFile << "Hallo Welt" << endl;
    testFile.close();

    system("echo \"Hallo Welt\" > /tmp/test2.txt");
    system("echo \"Hallo Welt\"");
}

void Q7STestTask::testScratchApi() {
    ReturnValue_t result = scratch::writeNumber("TEST", 1);
    if(result != HasReturnvaluesIF::RETURN_OK) {
        sif::debug << "Q7STestTask::scratchApiTest: Writing number failed" << std::endl;
    }
    int number = 0;
    result = scratch::readNumber("TEST", number);
    sif::info << "Q7STestTask::testScratchApi: Value for key \"TEST\": " << number << std::endl;
    if(result != HasReturnvaluesIF::RETURN_OK) {
        sif::debug << "Q7STestTask::scratchApiTest: Reading number failed" << std::endl;
    }

    result = scratch::writeString("TEST2", "halloWelt");
    if(result != HasReturnvaluesIF::RETURN_OK) {
        sif::debug << "Q7STestTask::scratchApiTest: Writing string failed" << std::endl;
    }
    std::string string;
    result = scratch::readString("TEST2", string);
    if(result != HasReturnvaluesIF::RETURN_OK) {
        sif::debug << "Q7STestTask::scratchApiTest: Reading number failed" << std::endl;
    }
    sif::info << "Q7STestTask::testScratchApi: Value for key \"TEST2\": " << string << std::endl;

    result = scratch::clearValue("TEST");
    result = scratch::clearValue("TEST2");
}

void Q7STestTask::testJsonLibDirect() {
    Stopwatch stopwatch;
    // for convenience
    using json = nlohmann::json;
    json helloTest;
    // add a number that is stored as double (note the implicit conversion of j to an object)
    helloTest["pi"] = 3.141;
    std::string mntPrefix = SdCardManager::instance()->getCurrentMountPrefix();
    std::string fileName = mntPrefix + "/pretty.json";
    std::ofstream o(fileName);
    o << std::setw(4) << helloTest  << std::endl;
}

void Q7STestTask::testDummyParams() {
    std::string mntPrefix = SdCardManager::instance()->getCurrentMountPrefix();
    DummyParameter param(mntPrefix, "dummy_json.txt");
    param.printKeys();
    param.print();
    if(not param.getJsonFileExists()) {
        param.writeJsonFile();
    }

    ReturnValue_t result = param.readJsonFile();
    if(result != HasReturnvaluesIF::RETURN_OK) {

    }

    param.setValue(DummyParameter::DUMMY_KEY_PARAM_1, 3);
    param.setValue(DummyParameter::DUMMY_KEY_PARAM_2, "blirb");

    param.writeJsonFile();
    param.print();

    int test = 0;
    result = param.getValue<int>(DummyParameter::DUMMY_KEY_PARAM_1, &test);
    if (result != HasReturnvaluesIF::RETURN_OK) {
        sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1
                << " does not exist" << std::endl;
    }
    std::string test2;
    result = param.getValue<std::string>(DummyParameter::DUMMY_KEY_PARAM_2, &test2);
    if (result != HasReturnvaluesIF::RETURN_OK) {
        sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1
                << " does not exist" << std::endl;
    }
    sif::info << "Test value (3 expected): " << test << std::endl;
    sif::info << "Test value 2 (\"blirb\" expected): " << test2 << std::endl;
}

ReturnValue_t Q7STestTask::initialize() {
    coreController = ObjectManager::instance()->get<CoreController>(objects::CORE_CONTROLLER);
    if(coreController == nullptr) {
        sif::warning << "Q7STestTask::initialize: Could not retrieve CORE_CONTROLLER object" <<
                std::endl;
    }
    return TestTask::initialize();
}

void Q7STestTask::testProtHandler() {
    bool opPerformed = false;
    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
    // If any chips are unlocked, lock them here
    result = coreController->setBootCopyProtection(
            CoreController::Chip::ALL_CHIP, CoreController::Copy::ALL_COPY, true,
            opPerformed, true);
    if(result != HasReturnvaluesIF::RETURN_OK) {
         sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
    }

    // unlock own copy
    result = coreController->setBootCopyProtection(
            CoreController::Chip::SELF_CHIP, CoreController::Copy::SELF_COPY, false,
            opPerformed, true);
    if(result != HasReturnvaluesIF::RETURN_OK) {
        sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
    }
    if(not opPerformed) {
        sif::warning << "Q7STestTask::testProtHandler: No op performed" << std::endl;
    }
    int retval = std::system("print-chip-prot-status.sh");
    if(retval != 0) {
        utility::handleSystemError(retval, "Q7STestTask::testProtHandler");
    }

    // lock own copy
    result = coreController->setBootCopyProtection(
            CoreController::Chip::SELF_CHIP, CoreController::Copy::SELF_COPY, true,
            opPerformed, true);
    if(result != HasReturnvaluesIF::RETURN_OK) {
        sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
    }
    if(not opPerformed) {
        sif::warning << "Q7STestTask::testProtHandler: No op performed" << std::endl;
    }
    retval = std::system("print-chip-prot-status.sh");
    if(retval != 0) {
        utility::handleSystemError(retval, "Q7STestTask::testProtHandler");
    }

    // unlock specific copy
    result = coreController->setBootCopyProtection(
            CoreController::Chip::CHIP_1, CoreController::Copy::COPY_1, false,
            opPerformed, true);
    if(result != HasReturnvaluesIF::RETURN_OK) {
        sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
    }
    if(not opPerformed) {
        sif::warning << "Q7STestTask::testProtHandler: No op performed" << std::endl;
    }
    retval = std::system("print-chip-prot-status.sh");
    if(retval != 0) {
        utility::handleSystemError(retval, "Q7STestTask::testProtHandler");
    }

    // lock specific copy
    result = coreController->setBootCopyProtection(
            CoreController::Chip::CHIP_1, CoreController::Copy::COPY_1, true,
            opPerformed, true);
    if(result != HasReturnvaluesIF::RETURN_OK) {
        sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
    }
    if(not opPerformed) {
        sif::warning << "Q7STestTask::testProtHandler: No op performed" << std::endl;
    }
    retval = std::system("print-chip-prot-status.sh");
    if(retval != 0) {
        utility::handleSystemError(retval, "Q7STestTask::testProtHandler");
    }
}

void Q7STestTask::testGpsDaemon() {
    gpsmm gpsmm(GPSD_SHARED_MEMORY, 0);
    gps_data_t* gps;
    gps = gpsmm.read();
    if(gps == nullptr) {
        sif::warning << "Q7STestTask: Reading GPS data failed" << std::endl;
    }
    sif::info << "-- Q7STestTask: GPS shared memory read test --" << std::endl;
    time_t timeRaw = gps->fix.time.tv_sec;
    std::tm* time = gmtime(&timeRaw);
    sif::info << "Time: " << std::put_time(time, "%c %Z") << std::endl;
    sif::info << "Visible satellites: " << gps->satellites_visible << std::endl;
    sif::info << "Satellites used: " << gps->satellites_used << std::endl;
    sif::info << "Fix (0:Not Seen|1:No Fix|2:2D|3:3D): " << gps->fix.mode << std::endl;
    sif::info << "Latitude: " << gps->fix.latitude << std::endl;
    sif::info << "Longitude: " << gps->fix.longitude << std::endl;
    sif::info << "Altitude(MSL): " << gps->fix.altMSL << std::endl;
    sif::info << "Speed(m/s): " << gps->fix.speed << std::endl;
}

void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
    auto fsHandler = ObjectManager::instance()->
            get<FileSystemHandler>(objects::FILE_SYSTEM_HANDLER);
    if(fsHandler == nullptr) {
        sif::warning << "Q7STestTask::testFileSystemHandlerDirect: No FS handler running.."
                << std::endl;
    }
    FileSystemHandler::FsCommandCfg cfg = {};
    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;

    // Lambda for common code
    auto createNonEmptyTmpDir = [&]() {
        if(not std::filesystem::exists("/tmp/test")) {
            result = fsHandler->createDirectory("/tmp", "test", false, &cfg);
            if(result != HasReturnvaluesIF::RETURN_OK) {
                return result;
            }
        }
        // Creating sample files
        sif::info << "Creating sample files in directory" << std::endl;
        result = fsHandler->createFile("/tmp/test", "test1.txt", nullptr, 0, &cfg);
        if(result != HasReturnvaluesIF::RETURN_OK) {
            return result;
        }
        result = fsHandler->createFile("/tmp/test", "test2.txt", nullptr, 0, &cfg);
        if(result != HasReturnvaluesIF::RETURN_OK) {
            return result;
        }
        return result;
    };


    switch(opCode) {
    case(FsOpCodes::CREATE_EMPTY_FILE_IN_TMP): {
        // No mount prefix, cause file is created in tmp
        cfg.useMountPrefix = false;
        sif::info << "Creating empty file in /tmp folder" << std::endl;
        // Do not delete file, user can check existence in shell
        fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
        break;
    }
    case(FsOpCodes::REMOVE_TMP_FILE): {
        sif::info << "Deleting /tmp/test.txt sample file" << std::endl;
        // No mount prefix, cause file is created in tmp
        cfg.useMountPrefix = false;
        if(not std::filesystem::exists("/tmp/test.txt")) {
            // Creating sample file
            sif::info << "Creating sample file /tmp/test.txt to delete" << std::endl;
            fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
        }
        result = fsHandler->removeFile("/tmp", "test.txt", &cfg);
        if(result == HasReturnvaluesIF::RETURN_OK) {
            sif::info << "File removed successfully" << std::endl;
        }
        else {
            sif::warning << "File removal failed!" << std::endl;
        }
        break;
    }
    case(FsOpCodes::CREATE_DIR_IN_TMP): {
        // No mount prefix, cause file is created in tmp
        cfg.useMountPrefix = false;
        sif::info << "Creating empty file in /tmp folder" << std::endl;
        // Do not delete file, user can check existence in shell
        ReturnValue_t result = fsHandler->createDirectory("/tmp/", "test", false, &cfg);
        if(result == HasReturnvaluesIF::RETURN_OK) {
            sif::info << "Directory created successfully" << std::endl;
        }
        else {
            sif::warning << "Directory creation failed!" << std::endl;
        }
        break;
    }
    case(FsOpCodes::REMOVE_EMPTY_DIR_IN_TMP): {
        // No mount prefix, cause file is created in tmp
        cfg.useMountPrefix = false;
        if(not std::filesystem::exists("/tmp/test")) {
            result = fsHandler->createDirectory("/tmp", "test", false, &cfg);
        }
        else {
            // Delete any leftover files to regular dir removal works
            std::remove("/tmp/test/*");
        }
        result = fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
        if(result == HasReturnvaluesIF::RETURN_OK) {
            sif::info << "Directory removed successfully" << std::endl;
        }
        else {
            sif::warning << "Directory removal failed!" << std::endl;
        }
        break;
    }
    case(FsOpCodes::REMOVE_FILLED_DIR_IN_TMP): {
        result = createNonEmptyTmpDir();
        if(result != HasReturnvaluesIF::RETURN_OK) {
            return;
        }
        result = fsHandler->removeDirectory("/tmp/", "test", true, &cfg);
        if(result == HasReturnvaluesIF::RETURN_OK) {
            sif::info << "Directory removed recursively successfully" << std::endl;
        }
        else {
            sif::warning << "Recursive directory removal failed!" << std::endl;
        }
        break;
    }
    case(FsOpCodes::ATTEMPT_DIR_REMOVAL_NON_EMPTY): {
        result = createNonEmptyTmpDir();
        if(result != HasReturnvaluesIF::RETURN_OK) {
            return;
        }
        result = fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
        if(result != HasReturnvaluesIF::RETURN_OK) {
            sif::info << "Directory removal attempt failed as expected" << std::endl;
        }
        else {
            sif::warning << "Directory removal worked when it should not have!" << std::endl;
        }
        break;
    }
    case(FsOpCodes::RENAME_FILE): {
        // No mount prefix, cause file is created in tmp
        cfg.useMountPrefix = false;
        if(std::filesystem::exists("/tmp/test.txt")) {
            fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
        }
        sif::info << "Creating empty file /tmp/test.txt and rename to /tmp/test2.txt" << std::endl;
        // Do not delete file, user can check existence in shell
        fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
        fsHandler->renameFile("/tmp/", "test.txt", "test2.txt", &cfg);
        break;
    }
    case(FsOpCodes::APPEND_TO_FILE): {
        // No mount prefix, cause file is created in tmp
        cfg.useMountPrefix = false;
        if(std::filesystem::exists("/tmp/test.txt")) {
            fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
        }
        if(std::filesystem::exists("/tmp/test.txt")) {
            fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
        }
        sif::info << "Creating empty file /tmp/test.txt and adding content" << std::endl;
        std::string content = "Hello World\n";
        // Do not delete file, user can check existence in shell
        fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
        fsHandler->appendToFile("/tmp/", "test.txt", reinterpret_cast<const uint8_t*>(
                content.data()), content.size(), 0, &cfg);
    }
    }
}