/*
 * Copyright (c) 2025 Fraunhofer IESE. All rights reserved.
 *
 * Authors:
 *    Iron Prando da Silva
 */

#include "dramtimedependenciesbase.h"

#include <QJsonDocument>

DRAMTimeDependenciesBase::DRAMTimeDependenciesBase(const QJsonObject& memspec, const uint inTCK)
{
    mMemspecJson = memspec;
    tCK = inTCK;
}

DependencyMap
DRAMTimeDependenciesBase::getDependencies(std::vector<QString>& dependencyFilter) const
{
    DependencyMap dependenciesMap;

    std::vector<StringMapper> dependencyFilterStrMapper(dependencyFilter.begin(),
                                                        dependencyFilter.end());
    std::sort(dependencyFilterStrMapper.begin(), dependencyFilterStrMapper.end());

    dependenciesMap = mSpecializedGetDependencies();

    mFilterDependencyMap(dependenciesMap, dependencyFilterStrMapper);

    auto it = dependenciesMap.begin();
    while (it != dependenciesMap.end())
    {
        mFilterDependencyList(it->second.dependencies, dependencyFilterStrMapper);
        it->second.maxTime = mFindVectorMaximum(it->second.dependencies);

        ++it;
    }

    return dependenciesMap;
}

PoolControllerMap DRAMTimeDependenciesBase::getPools() const
{
    return PoolControllerMap(mPools);
}

void DRAMTimeDependenciesBase::mFilterDependencyList(
    std::vector<TimeDependency>& dependencyList,
    const std::vector<StringMapper>& dependencyFilter) const
{
    std::vector<TimeDependency> newDepList(dependencyList.size());

    // TODO - probably there is a smarter way to filter these values,
    // although the lists are not to be greater than 20-50 elements

    std::copy_if(
        dependencyList.begin(),
        dependencyList.end(),
        newDepList.begin(),
        [dependencyFilter](const TimeDependency& dep)
        {
            auto it = std::lower_bound(dependencyFilter.begin(),
                                       dependencyFilter.end(),
                                       dep.phaseDep,
                                       [](const StringMapper& cmd, const StringMapper& depName)
                                       { return depName.isPool() || cmd < depName; });

            if (dep.phaseDep.isPool() || (it != dependencyFilter.end() && *it == dep.phaseDep))
                return true;

            return false;
        });

    newDepList.shrink_to_fit();

    dependencyList = newDepList;

    std::sort(dependencyList.begin(),
              dependencyList.end(),
              [](const TimeDependency& v1, const TimeDependency& v2)
              { return v1.timeValue < v2.timeValue; });
}

void DRAMTimeDependenciesBase::mFilterDependencyMap(
    DependencyMap& dependencyMap, const std::vector<StringMapper>& dependencyFilter) const
{
    if (!dependencyMap.empty())
    {

        auto itFilter = dependencyFilter.begin();
        auto itFilterLast = std::lower_bound(
            dependencyFilter.begin(), dependencyFilter.end(), dependencyMap.rbegin()->first);

        auto itDependencyMap = dependencyMap.begin();

        while (true)
        {

            auto pair =
                std::mismatch(itFilter,
                              itFilterLast,
                              itDependencyMap,
                              [](const StringMapper& cmd,
                                 const std::pair<StringMapper, PhaseTimeDependencies>& vpair)
                              { return cmd == vpair.first; });

            if (pair.first == dependencyFilter.end() || pair.second == dependencyMap.end())
            {
                dependencyMap.erase(pair.second, dependencyMap.end());
                break;
            }
            else if (*(pair.first) < pair.second->first)
            {
                ++(pair.first);
            }
            else if (*(pair.first) == pair.second->first)
            {
                ++(pair.second);
            }
            else
            {
                pair.second = dependencyMap.erase(pair.second);
            }

            itFilter = pair.first;
            itDependencyMap = pair.second;
        }
    }
}

uint DRAMTimeDependenciesBase::mFindVectorMaximum(
    const std::vector<TimeDependency>& dependencyList) const
{
    auto maxElement = std::max_element(dependencyList.begin(),
                                       dependencyList.end(),
                                       [](const TimeDependency& dep1, const TimeDependency& dep2)
                                       { return dep1.timeValue < dep2.timeValue; });

    if (maxElement == dependencyList.end())
        return 0;

    return maxElement->timeValue;
}