#include "GpioHelpers.hpp"
#include "FansFeatureID.hpp"
#include <gpio-0/gpio.hpp>
#include <log/LoggingSystem.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <iostream>

using namespace pss::gpio;
namespace ho = ::hlapi::ho;

namespace memoryaccess
{
struct MemoryAccess
{
    std::uint32_t mapped_size = 0u;
    int fd = 0;
    void* map_base = nullptr;
    void* virt_addr = nullptr;
};

void openForRead(MemoryAccess& memoryAccess, std::uint32_t address)
{
    const std::uint32_t width          = 32u;
    const std::uint32_t page_size      = static_cast<std::uint32_t>(::getpagesize());
    const std::uint32_t offset_in_page = static_cast<std::uint32_t>(address) & (page_size - 1);

    memoryAccess.mapped_size      = ((offset_in_page + width) > page_size) ? page_size : page_size * 2;
    memoryAccess.fd               = ::open("/dev/mem", (O_RDONLY | O_SYNC));
    memoryAccess.map_base         = ::mmap(nullptr, memoryAccess.mapped_size, PROT_READ, MAP_SHARED,
                                           memoryAccess.fd, address & ~static_cast<off_t>(page_size - 1));
    memoryAccess.virt_addr        = static_cast<char*>(memoryAccess.map_base) + offset_in_page;
}

void read(const MemoryAccess& memoryAccess, std::uint32_t& value)
{
    value = *static_cast<volatile std::uint32_t*>(memoryAccess.virt_addr);
}

void close(const MemoryAccess& memoryAccess)
{
    ::munmap(memoryAccess.map_base, memoryAccess.mapped_size);
    ::close(memoryAccess.fd);
}

void read(std::uint32_t address, std::uint32_t& value)
{
    MemoryAccess memoryAccess;
    openForRead(memoryAccess, address);
    read(memoryAccess, value);
    close(memoryAccess);
}
}

namespace fans
{

bool FanModuleReader::gpioDefined(const gpioInfo& gpio)
{
    std::cout<<"gpioDefined"<<std::endl;
    return gpio.id > 0 && !gpio.name.empty();
}

bool FanModuleReader::registerDefined(const registerInfo&)
{
    //For GEN3H GPIO is not definied, so fan presence need to be checked by register.
    return true;
}

EReadResult FanModuleReader::readGpioValue(const gpioInfo& gpioSignal)
{
    std::cout<<"readGpioValue"<<std::endl;
    try
    {

        Gpio gpioPin(gpioSignal.id);
         gpioPin.setDirection(Direction::Input);

        gpioPin.setMux(Mux::A);
        bool pinValue = gpioPin;

        if (gpioSignal.inverted) pinValue = !pinValue;
        return pinValue ? EReadResult::True : EReadResult::False;
    }
    catch (std::runtime_error& e)
    {
        // invalid_content derivate after runtime_error and also will be catch
        // here
        inut::LoggingSystem log(EradFansServiceGpioHelpers);
        log.warning("gpio %u read failure : %s", gpioSignal.id, e.what());
        return EReadResult::Fail;
    }
}

EReadResult FanModuleReader::readRegisterValue(const registerInfo& regInfo)
{
        std::cout<<"readRegisterValue"<<std::endl;

    try
    {
        std::uint32_t registerValue{0x0};
        memoryaccess::read(regInfo.offset, registerValue);
        if(!regInfo.inverted)
            return ((registerValue & regInfo.mask) ? EReadResult::True : EReadResult::False);
        else
            return ((registerValue & regInfo.mask) ? EReadResult::False : EReadResult::True);
    }
    catch (std::runtime_error& e)
    {
        inut::LoggingSystem log(EradFansServiceGpioHelpers);
        log.warning("register value read failure : %s", e.what());
        return EReadResult::Fail;
    }
}

using ReadResultPair = std::pair<EReadResult, EReadResult>;

ho::EFanModStatus FanModuleReader::findStatusForPairInTruthTable(const std::map<ReadResultPair, ho::EFanModStatus>& truthTable,
                                                ReadResultPair pair)
{
    auto iter = truthTable.find(pair);
    if (iter != truthTable.end()) return iter->second;
    return ho::EFanModStatus_NothingInstalled;
}

ho::EFanModStatus FanModuleReader::getFanModuleStatusForModeSelectDefined(const FanModuleConf& fanModConf)
{
    static const std::map<ReadResultPair, ho::EFanModStatus> truthTable = {
        // fanModInst				modeSelect				 status
        {{EReadResult::False, EReadResult::False}, ho::EFanModStatus_NothingInstalled},
        {{EReadResult::False, EReadResult::True}, ho::EFanModStatus_NothingInstalled},
        {{EReadResult::True, EReadResult::False}, ho::EFanModStatus_FanModuleInstalled},
        {{EReadResult::True, EReadResult::True}, ho::EFanModStatus_NothingInstalled},
        {{EReadResult::Fail, EReadResult::False}, ho::EFanModStatus_NothingInstalled},
        {{EReadResult::Fail, EReadResult::True}, ho::EFanModStatus_NothingInstalled},
        {{EReadResult::False, EReadResult::Fail}, ho::EFanModStatus_NothingInstalled},
        {{EReadResult::True, EReadResult::Fail}, ho::EFanModStatus_NothingInstalled},
        {{EReadResult::Fail, EReadResult::Fail}, ho::EFanModStatus_NothingInstalled},
    };
    return findStatusForPairInTruthTable(
        truthTable, {readGpioValue(fanModConf.fanModInstalledGpio), readGpioValue(fanModConf.modeSelectGpio)});
}

IFanModuleStatusDetector::IFanModuleStatusDetector(std::shared_ptr<IFanModuleReader> p): fanModuleReader(p){}

FanModuleStatusDetector::FanModuleStatusDetector(std::shared_ptr<IFanModuleReader> p): IFanModuleStatusDetector(p){}


ho::EFanModStatus FanModuleStatusDetector::detectFanModuleStatus(const FanModuleConf& fanModConf) const
{

    bool modInstDefined {false};
    bool ipCapInstDefined {false};

    if (fanModuleReader->gpioDefined(fanModConf.modeSelectGpio))
    {
        return fanModuleReader->getFanModuleStatusForModeSelectDefined(fanModConf);
    }

    EReadResult modInstalled {EReadResult::Fail};
    EReadResult ipCapInstalled {EReadResult::Fail};

    if (fanModuleReader->gpioDefined(fanModConf.fanModInstalledGpio))
    {
        modInstDefined = true;
        modInstalled = fanModuleReader->readGpioValue(fanModConf.fanModInstalledGpio);
    }
    else if(fanModuleReader->registerDefined(fanModConf.fanModInstalledRegister))
    {
        modInstDefined = true;
        modInstalled = fanModuleReader->readRegisterValue(fanModConf.fanModInstalledRegister);
    }

    if (fanModuleReader->gpioDefined(fanModConf.ipCapInstalledGpio))
    {
        ipCapInstDefined = true;
        ipCapInstalled = fanModuleReader->readGpioValue(fanModConf.ipCapInstalledGpio);
    }
    else if(fanModuleReader->registerDefined(fanModConf.ipCapInstalledRegister))
    {
        ipCapInstDefined = true;
        ipCapInstalled = fanModuleReader->readRegisterValue(fanModConf.ipCapInstalledRegister);
    }

    if (!modInstDefined && !ipCapInstDefined)
    {
        return ho::EFanModStatus_NothingInstalled;
    }
    else if (modInstDefined && ipCapInstDefined)
    {
        static const std::map<ReadResultPair, ho::EFanModStatus> truthTable = {
            // fanModInst				IpCapInst				 status
            {{EReadResult::True, EReadResult::True}, ho::EFanModStatus_HwError},
            {{EReadResult::True, EReadResult::False}, ho::EFanModStatus_FanModuleInstalled},
            {{EReadResult::False, EReadResult::True}, ho::EFanModStatus_IpCapInstalled},
            {{EReadResult::False, EReadResult::False}, ho::EFanModStatus_NothingInstalled},
            {{EReadResult::Fail, EReadResult::True}, ho::EFanModStatus_IpCapInstalled},
            {{EReadResult::Fail, EReadResult::False}, ho::EFanModStatus_NothingInstalled},
            {{EReadResult::True, EReadResult::Fail}, ho::EFanModStatus_FanModuleInstalled},
            {{EReadResult::False, EReadResult::Fail}, ho::EFanModStatus_NothingInstalled},
            {{EReadResult::Fail, EReadResult::Fail}, ho::EFanModStatus_NothingInstalled},
        };
        return ifanModuleReader->findStatusForPairInTruthTable(
            truthTable, {modInstalled, ipCapInstalled});
    }
    else if (modInstDefined)
    {
        if (modInstalled == EReadResult::False)
            return ho::EFanModStatus_NothingInstalled;
        else if (modInstalled == EReadResult::True)
            return ho::EFanModStatus_FanModuleInstalled;
        else
            return ho::EFanModStatus_HwError;
    }
    else
    {
        if (ipCapInstalled == EReadResult::False)
            return ho::EFanModStatus_NothingInstalled;
        else if (ipCapInstalled == EReadResult::True)
            return ho::EFanModStatus_IpCapInstalled;
        else
            return ho::EFanModStatus_HwError;
    }
}

FsFansDetector::FsFansDetector(const Config& config) : config(config)
{
}

void FsFansDetector::detectFixedSpeedFan(fsFan& fan)
{
    FanModuleReader fanModuleReader;
    auto getFromCacheOrReadTheValue = [this](auto& gpio) {
        auto iter = gpioMemoizer.find(gpio.id);
        if (iter != gpioMemoizer.end())
        {
            return iter->second;
        }
        else
        {
            FanModuleReader fanModuleReader;
            auto value = fanModuleReader.readGpioValue(gpio);
            gpioMemoizer.emplace(gpio.id, value);
            return value;
        }
    };

    const auto& fanConf = config.getFanConfig(fan.fanId);
    auto fanStatExt = fan.statusObj.MutableExtension(ho::FanStatus::object);

    if (!fanModuleReader.gpioDefined(fanConf.fanStatusGpio) ||
        getFromCacheOrReadTheValue(fanConf.fanStatusGpio) != EReadResult::True)
    {
        fanStatExt->set_detected(false);
        fanStatExt->set_working(false);
        return;
    }

    fanStatExt->set_detected(true);

    if (fanModuleReader.gpioDefined(fanConf.fanBrokenGpio))
    {
        auto fanBroken = getFromCacheOrReadTheValue(fanConf.fanBrokenGpio);
        if (fanBroken == EReadResult::Fail)
            fanStatExt->set_working(true);  // assuming working by default
        else
            fanStatExt->set_working(fanBroken == EReadResult::True);
    }
    else
    {
        fanStatExt->set_working(true);  // assuming working by default
    }
}

unsigned int VendorIdGpioReader::detectVendorBasedOnGpio(const FanModuleConf& fanModConf)
{
    FanModuleReader fanModuleReader;
    unsigned int vendorId = 0;
    for (const auto& vendGpio : fanModConf.vendorIdGpio)
    {
        vendorId = vendorId << 1;
        if (fanModuleReader.gpioDefined(vendGpio))
        {
            auto result = fanModuleReader.readGpioValue(vendGpio);
            if (result == EReadResult::Fail) return VendorDetectionNotPossible;
            vendorId += (result == EReadResult::True) ? 1 : 0;
        }
        else
        {
            return VendorDetectionNotPossible;
        }
    }
    return vendorId;
}
}  // namespace fans