#include "ModuleBase.h"
#include <algorithm>

namespace mdd {

    size_t ModuleBase::getNumInputs(){
        return inputs.size();
    }

    size_t ModuleBase::getNumOutputs() {
        return outputs.size();
    }


    std::shared_ptr<IInput> ModuleBase::getInput(size_t index) {
        if (index <= inputs.size())
        {
            return inputs[index];
        }
        return nullptr;
    }

    std::shared_ptr<IInput> ModuleBase::getInput(const std::string& input_id){
        for(auto& input : inputs){
            if (input->getID() == input_id) {
                return input;
            }
        }
        return nullptr;
    }

    std::shared_ptr<IOutput> ModuleBase::getOutput(size_t index) {
        if (index <= outputs.size())
        {
            return outputs[index];
        }
        return nullptr;
    }

    std::shared_ptr<IOutput> ModuleBase::getOutput(const std::string& output_id) {
        for (auto& output : outputs) {
            if (output->getID() == output_id) {
                return output;
            }
        }
        return nullptr;
    }

    std::vector<std::shared_ptr<IInput>> ModuleBase::getOptimizableInputs() {
        std::vector<std::shared_ptr<IInput>> ret;
        for (size_t i = 0; i < inputs.size(); i++)
        {
            if (inputs[i]->isOptimizable())
            {
                ret.push_back(inputs[i]);
            }
        }
        
        return ret;
    }

    std::vector<std::shared_ptr<IOutput>> ModuleBase::getOptimizableOutputs() {
        std::vector<std::shared_ptr<IOutput>> ret;
        for (size_t i = 0; i < outputs.size(); i++)
        {
            if (outputs[i]->isOptimizable())
            {
                ret.push_back(outputs[i]);
            }
        }
        
        return ret;
    }

    ModuleBase::ModuleBase(const std::string& base_config)
    {
        json jparse = json::parse(base_config);
        if (jparse.contains("configure"))
        {
            _base_config = base_config;
        }
        else {
            json jconfig;
            jconfig["configure"] = jparse;
            _base_config = jconfig.dump();
        }
        
    }
    bool ModuleBase::configure(const std::string& config) {
        json j = json::parse(config);
        json jbase = json::parse(_base_config);
        if (j.contains("GUI"))
        {
            jbase["GUI"] = j["GUI"];
        }
        _base_config = jbase.dump();
        return true;
    }
   

    std::string ModuleBase::getConfiguration()
    {
        return _base_config;
    }

    std::string ModuleBase::getType() {
        return  type;
    }

    std::string ModuleBase::getGeneratorKey() {
        return  key;
    }

    std::string ModuleBase::setName(const std::string& name) {
        _name = name;
        return getID();
    }

    std::string ModuleBase::getName() {
        return  _name;
    }

    std::string ModuleBase::setAppendix(int appendix) {
        _appendix = appendix;
        return  getID();
    }

    int ModuleBase::getAppendix() {
        return _appendix;
    }

    std::string ModuleBase::getID() {
        return _name + std::to_string(_appendix);
    }

    void ModuleBase::load(const json& j)
    {
        if (j.contains("configure"))
        {
            configure(j["configure"].get<std::string>());
        }
    }
    json ModuleBase::dump()
    {
        json ret = getIdentifier();
        json jconfig = json::parse(_base_config);
        if (jconfig.contains("configure"))
        {
            ret["configure"] = jconfig["configure"];
        }
        if (jconfig.contains("GUI"))
        {
            ret["GUI"] = jconfig["GUI"];
        }

        for (auto& in : inputs)
        {
            ret["inputs"].push_back(in->dump());
        }

        for (auto& out : outputs)
        {
            ret["outputs"].push_back(out->dump());
        }

        return ret;
    }

    void ModuleBase::disconnect() {
        for (size_t i = 0; i < inputs.size(); i++)
        {
            inputs[i]->disconnect();
        }
        for (size_t i = 0; i < outputs.size(); i++)
        {
            outputs[i]->disconnect();
        }
    }

    json ModuleBase::getIdentifier() {
        json jID;
        jID["name"] = _name;
        jID["id"] = getAppendix();
        jID["type"] = type;
        jID["key"] = key;
        jID["prefix"] = std::vector<std::string>(); 
        return jID;
    }
}