#include "MotorConfig.h"
#include <sys/stat.h>
#include <fstream>
#include <iostream>
#include <iomanip>

using namespace std;
MotorConfig::MotorConfig()
{
    initconfigfile();
}

MotorConfig::~MotorConfig()
{
}

std::string MotorConfig::GetParams(bool bzouzhi, MTBDType mttype)
{
    std::string j_str;
    json j;
    if (mttype == MTBDType::MT_TMC)
    {
        std::ifstream i(bzouzhi ? MT_TMC216_ZOU_PATH : MT_TMC216_CUO_PATH);
        i >> j;
        j_str = j.dump();
        i.close();
    }
    else
    {
        std::ifstream i(bzouzhi ? MT_DRV888_ZOU_PATH : MT_DRV888_CUO_PATH);
        i >> j;
        j_str = j.dump();
        i.close();
    }
    return j_str;
}

void MotorConfig::SetParams(bool bzouzhi, MTBDType mttype, MotorSpeedParamEx &param)
{
    std::string path;
    auto params = GetMotorSpeedParams(bzouzhi, mttype);
    for (int i = 0; i < params.size(); i++)
    {
        if (params[i].dpi == param.dpi &&
            params[i].colormode == param.colormode &&
            params[i].speed == param.speed)
        {
            params[i] = param;
        }
    }

    json j = json::array();

    for (int i = 0; i < params.size(); i++)
    {
        json t_j;
        to_json(params[i], t_j);
        j.push_back(t_j);
    }

    if (mttype == MTBDType::MT_TMC)
        path = bzouzhi?MT_TMC216_ZOU_PATH:MT_TMC216_CUO_PATH;
    else
        path = bzouzhi?MT_DRV888_ZOU_PATH:MT_DRV888_CUO_PATH;
    
    ofstream ofs(path);
    ofs << std::setw(4) << j << std::endl;
    ofs.close();
}

std::vector<MotorSpeedParamEx> MotorConfig::GetMotorSpeedParams(bool bzouzhi, MTBDType mttype)
{
    std::vector<MotorSpeedParamEx> ret;
    if (mttype == MTBDType::MT_TMC)
    {
        std::ifstream i(bzouzhi ? MT_TMC216_ZOU_PATH : MT_TMC216_CUO_PATH);
        json j;
        i >> j;
        i.close();
        for (json::iterator it = j.begin(); it != j.end(); ++it)
        {
            auto tmv = it.value();
            MotorSpeedParamEx param;
            from_json(tmv, param);
            ret.push_back(param);
        }
    }
    else
    {
        std::ifstream i(bzouzhi ? MT_DRV888_ZOU_PATH : MT_DRV888_CUO_PATH);
        json j;
        i >> j;
        i.close();
        for (json::iterator it = j.begin(); it != j.end(); ++it)
        {
            auto tmv = it.value();
            MotorSpeedParamEx param;
            from_json(tmv, param);
            ret.push_back(param);
        }
    }
    return ret;
}

void MotorConfig::initconfigfile()
{
    struct stat buff;
    for (int s = 0; s < m_jsonpaths.size(); s++)
    {
        if (stat(m_jsonpaths[s].c_str(), &buff) != 0) //不存在
        {
            {
                json j = json::array();
                for (int i = 1; i < 6; i++)
                {
                    MotorSpeedParamEx param;
                    for (int k = 1; k < 4; k++)
                    {
                        float ratio = k == 1 ? 1 : (k == 2 ? 1.51 : 2.81);
                        param.mt_param.finalPeriod = s >= 2 ? 2000 / 4 *ratio: 2000*ratio; // s < 2 drv888
                        param.mt_param.finalPeriod = s >= 2 ? 2000 / 4 : 2000; // s < 2 drv888
                        param.mt_param.Fmin = s >= 2 ? 80000 / 4 : 80000;
                        param.mt_param.stepnum = 0.5;
                        param.mt_param.a = 0.35;
                        param.mt_param.offset = -5.7;
                        param.mt_param.finalDelay = 2500;
                        param.mt_param.acceleration_time = 2;
                        param.speed = i; // 0 gray 1 color
                        param.dpi = k; // 1 200dpi 2 300dpi 3 600dpi
                        param.sp = 1200;
                        for(int t = 0;t<2;t++)
                        {
                            param.colormode = t;
                            json t_j;
                            to_json(param, t_j);
                            j.push_back(t_j);
                        }
                    }
                }
                ofstream ofs(m_jsonpaths[s]);
                ofs << std::setw(4) << j << std::endl;
                ofs.close();
            }
        }
    }
}

std::vector<MotorSpeedParamEx> MotorConfig::GetMotorSpeedParams(const std::string& json_str)
{
    std::vector<MotorSpeedParamEx> ret;
    if(json_str.length())
    {
        json j = json::parse(json_str);
        for (json::iterator it = j.begin(); it != j.end(); ++it)
        {
            auto tmv = it.value();
            MotorSpeedParamEx param;
            from_json(tmv, param);
            ret.push_back(param);
        }

    }
    return ret;
}

void MotorConfig::to_json(MotorSpeedParamEx &param, json &j)
{
    j = json{
        {"A", param.mt_param.a},
        {"FINALDELAY", param.mt_param.finalDelay},
        {"FINALPERIOD", param.mt_param.finalPeriod},
        {"FMIN", param.mt_param.Fmin},
        {"OFFSET", param.mt_param.offset},
        {"STEPNUM", param.mt_param.stepnum},
        {"DPI", param.dpi},
        {"COLORMODE", param.colormode},
        {"ACCELERATIONTIME",param.mt_param.acceleration_time},
        {"SPEED", param.speed},
        {"SP",param.sp}};
}

void MotorConfig::from_json(json &j, MotorSpeedParamEx &param)
{
    j.at("A").get_to(param.mt_param.a);
    j.at("FINALDELAY").get_to(param.mt_param.finalDelay);
    j.at("FINALPERIOD").get_to(param.mt_param.finalPeriod);
    j.at("FMIN").get_to(param.mt_param.Fmin);
    j.at("OFFSET").get_to(param.mt_param.offset);
    j.at("STEPNUM").get_to(param.mt_param.stepnum);
    j.at("DPI").get_to(param.dpi);
    j.at("ACCELERATIONTIME").get_to(param.mt_param.acceleration_time);
    j.at("COLORMODE").get_to(param.colormode);
    j.at("SPEED").get_to(param.speed),
    j.at("SP").get_to(param.sp);
}