#include "program_config.hpp"

#include <filesystem>
#include <iostream>
#include "file_api.hpp"
#include "json.hpp"

#include <cstdint>

using json = nlohmann::json;
using string = std::string;

static bool programconf_readfile(json& j, std::string& file_path)
{
    ///string config_str;

    try
    {
        ///config_str = fileapi_read_full_stream( fileapi_read_file(file_path) );
        j = json::parse(fileapi_read_file(file_path));
    }
    catch(const std::exception& e)
    {
        std::cerr << e.what() << '\n';
        return false;
    }
    
    return true;
}

bool programconf_getProfinetSettings(std::string file_path, ProfinetSettings& pn_sett)
{
    json j;

    if (!programconf_readfile(j, file_path))
    {
        return false;
    }

    pn_sett.ticks_us = j["ProfinetSettings"]["ticks_us"].get<int>();
    pn_sett.cyclic_ms = j["ProfinetSettings"]["cyclic_ms"].get<int>();
    pn_sett.eth_dev_name = j["ProfinetSettings"]["eth_dev_name"].get<string>();
    pn_sett.profinet_device_config = j["ProfinetSettings"]["profinet_device_config"].get<string>();
    
    return true;
}

static uint32_t hexstring_to_int(string s)
{
    uint32_t n;

    if (s.find("0x") != string::npos)
    {
        s = s.substr(2); //Игнорируем 0x
        std::istringstream(s) >> std::hex >> n;
    }
    else
    {
        std::istringstream(s) >> std::dec >> n;
    }

    return n;
}

static bool programconf_getPnetDeviceSettings(json& j, ProfinetDeviceSettings& pnet_sett)
{
    if (!j.contains("ProfinetDeviceSettings"))
        return false;
    
    auto& sett = j["ProfinetDeviceSettings"];
    pnet_sett.product_name = sett["product_name"].get<string>();
    pnet_sett.station_name = sett["station_name"].get<string>();
    pnet_sett.station_name = sett["station_name"].get<string>();
    

    if (!sett.contains("im_0"))
        return false;

    auto& im_0 = sett["im_0"];

    pnet_sett.im_0.vendor_id = hexstring_to_int( im_0["vendor_id"].get<string>() );
    pnet_sett.im_0.hw_revision = im_0["hw_revision"].get<int>();


    if (!im_0.contains("sw_revision"))
        return false;
    
    auto& sw_revision = im_0["sw_revision"];

    string prefix = sw_revision["prefix"].get<string>();
    if (prefix.length())
    {
        pnet_sett.im_0.sw_revision.prefix = prefix.c_str()[0];
    }
    else
    {
        pnet_sett.im_0.sw_revision.prefix = ' ';
    }
    
    pnet_sett.im_0.sw_revision.functional_enhancement = sw_revision["functional_enhancement"].get<int>();
    pnet_sett.im_0.sw_revision.bug_fix = sw_revision["bug_fix"].get<int>();
    pnet_sett.im_0.sw_revision.internal_change = sw_revision["internal_change"].get<int>();


    pnet_sett.im_0.revision_counter      = im_0["revision_counter"].get<int>();
    pnet_sett.im_0.profile_id            = hexstring_to_int(im_0["profile_id"].get<string>());
    pnet_sett.im_0.profile_specific_type = hexstring_to_int(im_0["profile_specific_type"].get<string>());
    pnet_sett.im_0.supported             = hexstring_to_int(im_0["supported"].get<string>());
    pnet_sett.im_0.order_id              = im_0["order_id"].get<string>();
    pnet_sett.im_0.serial_number         = im_0["serial_number"].get<string>();


    if (!sett.contains("im_1"))
        return false;
    
    auto& im_1 = sett["im_1"];
    pnet_sett.im_1.tag_function = im_1["tag_function"].get<string>();
    pnet_sett.im_1.tag_location = im_1["tag_location"].get<string>();


    pnet_sett.im_2.date       = sett["im_2"]["date"].get<string>();
    pnet_sett.im_3.descriptor = sett["im_3"]["descriptor"].get<string>();
    pnet_sett.im_4.signature  = sett["im_4"]["signature"].get<string>();

    pnet_sett.device_id = hexstring_to_int(sett["device_id"].get<string>());
    pnet_sett.oem_vendor_id = hexstring_to_int(sett["oem_vendor_id"].get<string>());
    pnet_sett.oem_device_id = hexstring_to_int(sett["oem_device_id"].get<string>());
    pnet_sett.send_hello = sett["send_hello"].get<bool>();
    pnet_sett.min_device_interval = sett["min_device_interval"].get<int>();

    return true;
}

static pnet_submodule_dir_t programconf_dataDirConvert(string dir_str)
{
    pnet_submodule_dir_t out = PNET_DIR_NO_IO;

    if (dir_str == "PNET_DIR_IO")
    {
        out = PNET_DIR_IO;
    }
    else if (dir_str == "PNET_DIR_INPUT")
    {
        out = PNET_DIR_INPUT;
    }
    else if (dir_str == "PNET_DIR_OUTPUT")
    {
        out = PNET_DIR_OUTPUT;
    }

    return out;
}

static bool programconf_getProfinetModulesSettings(json& j, std::vector<std::shared_ptr<ProfinetModule>>& modules_vect)
{   
    if (!j.contains("ProfinetDeviceModulesSettings"))
        return false;

    auto& modules_sett = j["ProfinetDeviceModulesSettings"]["modules"];

    for (auto& mod_set : modules_sett)
    {
        uint32_t mod_id = hexstring_to_int(mod_set["id"].get<string>());
        string mod_name = mod_set["name"].get<string>();

        auto module_ptr = ProfinetModule::Create(mod_id, mod_name);
        if (module_ptr == nullptr)
        {
            return false;
        }

        auto& submodules_sett = mod_set["submodules"];

        for (auto& submod_sett : submodules_sett)
        {
            uint32_t submod_id = hexstring_to_int(submod_sett["id"].get<string>());
            string submod_name = submod_sett["name"].get<string>();

            pnet_data_cfg_t data_cfg;

            data_cfg.data_dir = programconf_dataDirConvert(submod_sett["cyc_data_dir"].get<string>());
            data_cfg.insize = submod_sett["cyc_inp_data_size"].get<int>();
            data_cfg.outsize = submod_sett["cyc_out_data_size"].get<int>();

            auto submodule_ptr = ProfinetSubmodule::Create(submod_id, submod_name, data_cfg);
            
            if (submodule_ptr == nullptr)
            {
                return false;
            }

            auto& params_sett = submod_sett["parameters"];
           
            /// Записываем параметры в подмодуль
            for (auto& parm_sett : params_sett)
            {
                uint32_t index = parm_sett["index"].get<int>();
                string parm_name = parm_sett["name"].get<string>();
                uint16_t length =  parm_sett["data_size"].get<int>();
                
                auto submod_param_ptr = ProfinetParameter::Create(index, parm_name, length);

                if (submod_param_ptr == nullptr)
                {
                    return false;
                }

                submodule_ptr->addParameter(submod_param_ptr);
            }
            
            module_ptr->addSubmodule(submodule_ptr);
        }

        modules_vect.push_back(module_ptr);
    }

    return true;
}

bool programconf_getProfinetDeviceSettings(std::string file_path, ProfinetDeviceSettings& pn_sett, std::vector<std::shared_ptr<ProfinetModule>>& modules_vect)
{
    json j;

    if (!programconf_readfile(j, file_path))
    {
        return false;
    }

    if (!programconf_getPnetDeviceSettings(j, pn_sett))
    {
        return false;
    }

    if (!programconf_getProfinetModulesSettings(j, modules_vect))
    {
        return false;
    }

    return true;
}