//
// Created by Matthew on 2025/3/4.
//

#include "HangYuCtrl.h"
#include "netcamera.h"
#include "httpclient.h"
#include <LogThread.h>

#include <SpecData_JSON.h>

#include <cstring>
#include <algorithm>

HangYuCtrl::~HangYuCtrl()
{

}

bool HangYuCtrl::SetResolution(uint8_t channel, uint8_t streamID, uint32_t resX, uint32_t resY)
{
    //流类型范围1-4,1为主流
    char url[128] = { 0 };
    snprintf(url, sizeof(url), "http://%s/Streams/%u/1", m_ip.c_str(), (uint32_t)channel);

    std::vector<uint8_t> resData;

    int res = DoGetRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, resData);
    if (res != 0 || resData.empty())
    {
        return 0;
    }

    std::string xmlString(resData.begin(), resData.end());

    size_t widthStart = xmlString.find("<ResolutionWidth>");
    size_t widthEnd = xmlString.find("</ResolutionWidth>");
    if (widthStart != std::string::npos && widthEnd != std::string::npos) {
        widthStart += std::string("<ResolutionWidth>").length();
        xmlString.replace(widthStart, widthEnd - widthStart, std::to_string(resX));
    }

    size_t heightStart = xmlString.find("<ResolutionHeigth>");
    size_t heightEnd = xmlString.find("</ResolutionHeigth>");
    if (heightStart != std::string::npos && heightEnd != std::string::npos) {
        heightStart += std::string("<ResolutionHeigth>").length();
        xmlString.replace(heightStart, heightEnd - heightStart, std::to_string(resY));
    }

    res = DoPutRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, xmlString.c_str(), resData);

    if (res != 0)
    {
        return 0;
    }
    return true;
}

bool HangYuCtrl::SetOsd(uint8_t channel, std::string osdstring, uint8_t pos)
{
    // /LAPI/V1.0/Channels/<ID>/Media/OSDs/Contents
    //左上OSD

    bool hasDateTime = (osdstring.find("$$DATETIME$$") != std::string::npos);
    size_t posi = osdstring.find("$$DATETIME$$");
    if (posi != std::string::npos) {
        size_t endPos = posi + 12;
        while (endPos < osdstring.size() && (osdstring[endPos] == ' ' || osdstring[endPos] == '\n')) {
            endPos++;
        }
        osdstring.erase(posi, endPos - posi);
    }

    char url[128] = { 0 };
    snprintf(url, sizeof(url), "http://%s/Pictures/%u/MultiOSDV2", m_ip.c_str(), (uint32_t)channel);
    std::vector<uint8_t> resData;
    std::replace(osdstring.begin(), osdstring.end(), '\n', '^');
    string xmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?><MultiLineOSD><DisplayTime><Enable>" + string(hasDateTime ? "true" : "false") + "</Enable><PosX>8</PosX><PosY>0</PosY></DisplayTime><OSD><ID>1</ID><Enable>false</Enable><Text>"+ osdstring+ "</Text><x>8</x><y>" + string(hasDateTime ? "24" : "0") + "</y></MultiLineOSD>";
    int res = DoPutRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, xmlString.c_str(), resData);
    return res;
}

void HangYuCtrl::EnableOsd(bool enable, uint8_t channel)
{
    //航煜 只能显示时间和一个OSD
    char url[128] = { 0 };
    snprintf(url, sizeof(url), "http://%s/Pictures/%u/MultiOSDV2", m_ip.c_str(), (uint32_t)channel);

    std::vector<uint8_t> resData;

    int res = DoGetRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, resData);
    if (res != 0 || resData.empty())
    {
        return;
    }

    std::string xmlString(resData.begin(), resData.end());

    std::string enableStartTag = "<Enable>";
    std::string enableEndTag = "</Enable>";

    size_t pos = 0;
    while ((pos = xmlString.find(enableStartTag, pos)) != std::string::npos) {
        size_t startPos = pos + enableStartTag.length();
        size_t endPos = xmlString.find(enableEndTag, startPos);
        if (endPos == std::string::npos) {
            break;
        }
        std::string newValue = enable ? "true" : "false";
        xmlString.replace(startPos, endPos - startPos, newValue);
        pos = endPos + enableEndTag.length();
    }

    res = DoPutRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, xmlString.c_str(), resData);

    if (res != 0)
    {
//        return;
    }


}

std::string HangYuCtrl::GetStreamingUrl(uint8_t channel)
{
    // /LAPI/V1.0/Channels/<ID>/Media/Video/Streams/<ID>/LiveStreamURL?TransType=<Tran
    // sType>&TransProtocol=<TransProtocol>
    char url[128] = { 0 };
    snprintf(url, sizeof(url), "http://%s/Streams/%u/1/Transport", m_ip.c_str(), (uint32_t)channel);

    std::vector<uint8_t> resData;

    int res = 0;
    for (int idx = 0; idx < 10; idx++)
    {
        res = DoGetRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, resData);
        if (res == 0 && !resData.empty())
        {
            break;
        }
    }
    if (res != 0 || resData.empty())
    {
        return "";
    }

    resData.push_back(0);
    const char* start = strstr((const char*)&resData[0], "<RTSPURI>");
    if (start == NULL)
    {
        return "";
    }
    start += 9;
    const char* end = strstr(start, "</RTSPURI>");
    if (end == NULL)
    {
        return "";
    }

    return std::string(start, end);
}

bool HangYuCtrl::UpdateTime(time_t ts)
{
    // /LAPI/V1.0/System/Time

    // <?xml version="1.0" encoding="utf-8"?>
    //<Time>
    //<DateTimeFormat>
    //<!--req,string,YYYYMMDDWhhmmss,YYYYMMDDhhmmss,MMDDYYYYWhhmmss,MMD
    // DYYYYhhmmss,DDMMYYYYWhhmmss,DDMMYYYYhhmmss-->
    //</DateTimeFormat>
    //<TimeFormat><!--req,xs:string,12hour,24hour--></TimeFormat>
    //<SystemTime><!--req,xs:datetime,” 20040503T173008+08”--></SystemTime>
    //<SyncNTPFlag><!--req,xs:string,"Sync,NoSync"--></SyncNTPFlag>
    //</Time>

    std::string reqData = "<?xml version=\"1.0\" encoding=\"utf-8\"?><Time><SystemTime>"
            + FormatLocalDateTime("%d%02d%02dT%02d%02d%02d") + "+08</SystemTime></Time>";

    std::string url = "http://" + m_ip + "/System/Time";
    std::vector<uint8_t> resData;
    int res = DoPutRequest(url.c_str(), HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, reqData.c_str(), resData);

    if (res != 0)
    {
        return false;
    }

    return true;
}

bool HangYuCtrl::TakePhoto(uint8_t streamID, std::vector<uint8_t>& img)
{
    bool res = false;

    std::vector<uint8_t> data;

    // /Snapshot/%u/1/RemoteImageCaptureV2?ImageFormat=jpg
    char url[128] = { 0 };
    snprintf(url, sizeof(url), "http://%s/Snapshot/%u/1/RemoteImageCaptureV2?ImageFormat=jpg", m_ip.c_str(), (uint32_t)streamID);

    int nRet = DoGetRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, img);
    if (0 == nRet)
    {
        bool qualityDowngraded = false;
        std::string originalConfig;
        if (img.size() < 1000)
        {
            qualityDowngraded = DowngradeQuality(originalConfig);
            XYLOG(XYLOG_SEVERITY_INFO,"Reduce Img Quality");
        }
        nRet = DoGetRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, img);
        if (!originalConfig.empty())
        {
            UpdateQuality(originalConfig);
        }

        std::vector<uint8_t> header = {0xFF, 0xD8, 0xFF, 0xE0}; // JPEG
        std::vector<uint8_t>::iterator it = std::search(img.begin(), img.end(), header.begin(), header.end());
        if (it != img.end() && it != img.begin())
        {
            img.erase(img.begin(), it);
#ifndef NDEBUG
            int aa = 0;
#endif
        }
    }

    return nRet == 0;
}

bool HangYuCtrl::DowngradeQuality(std::string& originalConfig)
{
    bool res = false;
    char url[64] = { 0 };
    snprintf(url, sizeof(url), "http://%s/Snapshot/Config", m_ip.c_str());

    std::vector<uint8_t> data;
    int nRet = DoGetRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, data);
    if (0 == nRet)
    {
        std::string str = ByteArrayToString(&data[0], data.size());
        originalConfig = str;
        if (replaceAll(str, "<Quality>middle</Quality>", "<Quality>low</Quality>") == 0)
        {
            res = (replaceAll(str, "<Quality>high</Quality>", "<Quality>middle</Quality>") != 0);
        }
        else
        {
            res = true;
        }

        if (!res)
        {
            return res;
        }

        data.clear();
        if (res)
        {
            nRet = DoPutRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, str.c_str(), data);
            return 0 == nRet;
        }
    }

    return false;
}

bool HangYuCtrl::UpdateQuality(const std::string& originalConfig)
{
    std::vector<uint8_t> data;
    char url[64] = { 0 };
    snprintf(url, sizeof(url), "http://%s/Snapshot/Config", m_ip.c_str());
    int nRet = DoPutRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, originalConfig.c_str(), data);
    return 0 == nRet;
}

bool HangYuCtrl::UpgradeQuality()
{
    bool res = false;
    char url[64] = { 0 };
    snprintf(url, sizeof(url), "http://%s/Snapshot/Config", m_ip.c_str());

    std::vector<uint8_t> data;
    int nRet = DoGetRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, data);
    if (0 == nRet)
    {
        std::string str = ByteArrayToString(&data[0], data.size());
        if (replaceAll(str, "<Quality>low</Quality>", "<Quality>middle</Quality>") == 0)
        {
            res = (replaceAll(str, "<Quality>middle</Quality>", "<Quality>high</Quality>") != 0);
        }
        else
        {
            res = true;
        }

        if (!res)
        {
            return res;
        }

        data.clear();
        if (res)
        {
            nRet = DoPutRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, str.c_str(), data);
            return 0 == nRet;
        }
    }

    return false;
}

bool HangYuCtrl::QueryQuality(std::string& qualityContents)
{
    char url[64] = { 0 };
    snprintf(url, sizeof(url), "http://%s/Snapshot/Config", m_ip.c_str());

    std::vector<uint8_t> data;
    int nRet = DoGetRequest(url, HTTP_AUTH_TYPE_BASIC, m_userName.c_str(), m_password.c_str(), m_netHandle, data);
    if (0 == nRet && !data.empty())
    {
        qualityContents = ByteArrayToString(&data[0], data.size());
    }
    return (0 == nRet);
}

bool HangYuCtrl::TakeVideo(uint8_t streamID, uint32_t duration, std::string path)
{
    return false;
}