#include "Config.h"
#include "BS_Log.h"
#include "CCFIleInStream.h"
#include "CCFileOutStream.h"
#include "CCProcess.h"
#include "ConnectionService.h"
#include "NetInfo/NetWork.h"
#include "PortService/ByteTool.h"

void Config::Save() {
    const auto Setting = getConfig();
    try {
        const CTL::JSONObject Json = *Setting;
        const auto Path = GetSettingDB();
        CTL::FileOutStream::WriteFile(Path,Json.to_String());
    }
    catch (CCException& e) {
        BS_Log::Error("Config::Save Error: {}",e.what());
    }
}

void Config::Init() {
    const auto Setting = getConfig();
    try {
        const auto Path = GetSettingDB();
        const CCFile file(Path);
        if (file.isExists()) {
            const auto str = CTL::FileInputStream::ReadFileDataAll(Path);
            CTL::JSONObject Json = CTL::JSONObject::parse(str);
            Setting->IP = Json["IP"];
            Setting->OrderPort = Json["OrderPort"];
            Setting->StreamPort = Json["StreamPort"];
            Setting->HttpPort = Json["HttpPort"];
            Setting->Flag = Json["Flag"];
            Setting->ServerID = Json["ServerID"];
            Setting->ServerIP = Json["ServerIP"];
            Setting->ServerPort = Json["ServerPort"];
            Setting->ID = Json["ID"];
            Setting->Name = Json["Name"];
            Setting->WorkingMode = Json["WorkingMode"];
            Setting->TermNumber = Json["TermNumber"];
            Setting->DHCPFlag = Json["DHCPFlag"];
        }
    }
    catch (CCException& e) {
        BS_Log::Error("Config::Init Error: {}",e.what());
    }
    Setting->IP = GetIP();
    BS_Log::Log("Local IP: {}",Setting->IP.c_str());
    BS_Log::Log("Local ID: {}",Setting->ID);
}

Config * Config::getConfig() {
    static Config config;
    return &config;
}

bool Config::IsRunning() {
    return getConfig()->Flag;
}

CTL::String Config::GetIP() {
    const auto Setting = Config::getConfig();
    try {
        Setting->MacAddr = CTL::System::GetMac();
        Setting->TermIPGw = NetWorkInfo::getGw();
        Setting->TermIPNm = NetWorkInfo::getNm();
    }
    catch (...){}
    const auto List = CTL::Socket::GetLocalIP(Setting->IP_x);
    CCVector<CTL::String> IPList;
    for (const auto IP : List) {
        if (IP != "127.0.0.1") {
            IPList.push_back(IP);
        }
        if (IP == Setting->IP) {
            return IP;
        }
    }
    return IPList.empty() ? "127.0.0.1" : IPList[0];
}

ConfigTerm * Config::getThisInfo() {
    const auto Setting = getConfig();
    const auto Data = new ConfigTerm;
    std::strcpy(Data->termIDnVerStr,Setting->Ver.c_str());
    std::strcpy(Data->macStr,Setting->MacAddr.c_str());
    std::strcpy(Data->macChkStr,Setting->MacAddr.c_str());
    std::strcpy(Data->servIPAddrStr,Setting->ServerIP.c_str());
    std::strcpy(Data->termIPAddrStr,Setting->IP.c_str());
    std::strcpy(Data->termIPGwStr,Setting->TermIPGw.c_str());
    std::strcpy(Data->termIPNmStr,Setting->TermIPNm.c_str());
    std::strcpy(Data->termCmdPortStr,CC::to_String(Setting->OrderPort).c_str());
    std::strcpy(Data->servCmdPortStr,CC::to_String(Setting->ServerPort).c_str());
    std::strcpy(Data->termStmPortStr,CC::to_String(Setting->StreamPort).c_str());
    // const auto workModeStrS = APPTool::GetBytes(Setting->WorkingMode);
    // std::strcpy(Data->workModeStr,CC::to_String(Setting->WorkingMode).c_str());
    // Data->workModeStr[0] = workModeStrS[0];
    // Data->workModeStr[1] = workModeStrS[1];
    Data->workModeStr[0] = getTermWorkInfo(Setting->WorkingMode);
    Data->workModeStr[1] = '\0';
    std::strcpy(Data->btNameStr,"");
    std::strcpy(Data->dhcpFlagStr,CC::to_String(Setting->DHCPFlag).c_str());
    std::strcpy(Data->btPwdStr,"");
    std::strcpy(Data->termTypeStr,CC::to_String(Setting->TermNumber).c_str());
    std::strcpy(Data->sipUsrNameStr,"");
    std::strcpy(Data->sipUsrPwdStr,"");
    std::strcpy(Data->sipProxyRealmStr,"");
    std::strcpy(Data->cmdFlagByteStr,CC::to_String("").c_str());
    std::strcpy(Data->onlineFlagStr,CC::to_String(Setting->isConnect).c_str());
    return Data;
}

void Config::groupBroadcast(const CTL::ByteArray &data, int port) {
    std::shared_lock lock(m_mutex_udp_tool);
    const auto Setting = getConfig();
    if (Setting->m_socket_udp_tool) {
        CTL::DatagramPacket packet;
        packet.setPort(port);
        packet.setData(data);
        Setting->m_socket_udp_tool->broadcast(packet);
    }
}

void Config::SetNetWorkInfo(const CTL::String& IP,const CTL::String& GW,const CTL::String& Mask) {
    try{
        //获取当前网络名称
        const CTL::String GetNetName = ("nmcli -t -f NAME,TYPE,DEVICE,STATE con show --active");
        CTL::Process Process;
        Process.Command(GetNetName);
        Process.Start();
        auto NetName = Process.ReadLineBuffer().toString();
        NetName = CTL::String(NetName.substr(0,NetName.find(":")).c_str());
        BS_Log::Log("[fun-configure|MainConfigure] NetName: %s",NetName.c_str());
        Process.Stop();
        //设置为手动
        CTL::String SetManual = ("sudo nmcli con modify '" + NetName + "' ipv4.method manual");
        CTL::System::Execute(SetManual);
        //设置IP与子网掩码
        CTL::String SetIP = ("sudo nmcli con modify '" + NetName + "' ipv4.addresses " + IP +"/" + GetNetMaskCIDR(Mask));
        CTL::System::Execute(SetIP);
        //设置默认网关
        CTL::String SetGateway = ("sudo nmcli con modify '" + NetName + "' ipv4.gateway " + GW);
        CTL::System::Execute(SetGateway);
        //重启网络
        CTL::String NetDown = ("sudo nmcli con down '" + NetName + "'");
        CTL::System::Execute(NetDown);
        CTL::String NetUp = ("sudo nmcli con up '" + NetName + "'");
        CTL::System::Execute(NetUp);
    }
    catch (CCException& e){
        BS_Log::Error("[fun-configure|MainConfigure] NetInit Error: {}",e.what());
    }
}

void Config::CloseService() {
    const auto Setting = getConfig();
    const auto sock = ConnectionService::getSocket();
    const auto IDS = APPTool::GetBytes(Setting->ID);
    sock->SendBinary({0x66,0xAB,0xA1,0x00,IDS[0],IDS[1],0x01,0x00});
    CTL::Thread::SleepMS(500);
    sock->Stop();
}

CTL::String Config::GetNetMaskCIDR(const CTL::String& Mask) {
    std::vector<int> octets;
    std::stringstream ss(Mask);
    std::string segment;

    while (std::getline(ss, segment, '.')){
        octets.push_back(std::stoi(segment));
    }

    // 转换每个八位组为二进制并计算连续的 1 的数量
    int cidr = 0;
    for (int octet : octets){
        while (octet > 0){
            cidr += (octet & 1); // 统计每一位是否为 1
            octet >>= 1;
        }
    }
    CTL::String cidr_str = CTL::String::format("%d",cidr);
    return cidr_str;
}

char Config::getTermWorkInfo(const char index) {
    static constexpr char mappings[] = {
        0x30, 0x31, 0x32, 0x33, 0x34,
        0x35, 0x36, 0x37, 0x38, 0x39,
        'a', 'b', 'c', 'd', 'e',
        'f', 'g', 'h', 'i', 'j',
        'k', 'l', 'm', 'n', 'o',
        'p', 'q', 'r', 's', 't',
    };
    const auto size = std::size(mappings) - 1;
    if (index >= 0 && index <= size) {
        return mappings[index];
    }
    return 0x30;
}