//
// Created by ps on 18-9-26.
//

#include "RtspAnalysElement.h"

#include <basic/http_server/HttpSrvRetRecieve.hpp>

using std::string;

//RtspAnalysElement::RtspAnalysElement() {}

std::string RtspAnalysElement::resetFdfs(std::string ip, unsigned int port, std::string content) {

    std::thread reset([&]() {
        fdfsClient.rwLock.rdlock();
        if (fdfsClient.fastFds != nullptr) {
            delete fdfsClient.fastFds;
        }
        fdfsClient.fastFds = new FastFds("fastDfsClient.conf");
        fdfsClient.rwLock.unlock();
    });
    reset.detach();

    return "";
}

RtspAnalysElement::RtspAnalysElement(LDBTool *_dbTool) : m_lDBTool(_dbTool), maxCount(50), currentCount(0) {
    init();
    resetFdfs();
    {
//        std::thread httpServer([&]() {
//            //#todo port
//            HttpSrvRetRecieve httpSrvRetRecieve("0.0.0.0", 12306, 1);
//            httpSrvRetRecieve.setInfo("^/resetFdfs$", "POST", std::bind(&RtspAnalysElement::resetFdfs, this,
//                                                                        std::placeholders::_1,
//                                                                        std::placeholders::_2,
//                                                                        std::placeholders::_3));
//            httpSrvRetRecieve.start();
//            httpSrvRetRecieve.waitForShutDown();
//        });
//        httpServer.detach();
    }
}

#define SETSCORE(VEC, POS, IDENT) appPref.setFloatData(IDENT, POS >= VEC.size() ? 80 : VEC[POS]);
//#define GETSCORE(IDENT) appPref.getFloatData(IDENT) == -1 ? 0.1 : appPref.getFloatData(IDENT);

static std::string rtspAddrBuild(std::string ip, const int port, std::string username,
                                 std::string passwd, std::string brand) {
    std::string rtsp_url;
    if (brand == "haikang") {
        rtsp_url = "rtsp://" + username + ":" + passwd + "@" + ip + ":" + std::to_string(port) +
                   "/h264/ch1/main/av_stream";
    } else if (brand == "dahua") {
        //rtsp://username:password@ip:port/cam/realmonitor?channel=1&subtype=0
        rtsp_url = "rtsp://" + username + ":" + passwd + "@" + ip + ":" + std::to_string(port) +
                   "/cam/realmonitor?channel=1&subtype=0";
        //TODO
    } else if (brand == "yushi") {
        rtsp_url = "rtsp://" + username + ":" + passwd + "@" + ip + ":" + std::to_string(port) +
                   "/video1";
    } else {
        //TODO
    }

    return rtsp_url;
}

void RtspAnalysElement::init() {
    auto lst = m_lDBTool->searchCamDevTableAll();
    auto lst_dev = m_lDBTool->searchConfigTableWithinServerInfo();

    appPref.setIntData("n_cut_max_duration", lst_dev.n_cut_max_duration);

    if (lst.size() > 0) {
        Json::Value json;
        for (auto item : lst) {
            string t_camIdex = item.str_cam_dev_id.toStdString();
//            std::string rtsp_url;
//            if (item.str_brand.toStdString() == "haikang") {
//                //调用rtsp流rtsp://admin:a1234567@192.168.1.215:554/h264/ch1/main/av_stream
//                int port = 554;//TODO
//                string username =;
//                DBG("username:" << username << "!!!");
//                string passwd = item.str_password.toStdString();
//                string ip = item.str_ip.toStdString();
//
//                rtsp_url = "rtsp://" + username + ":" + passwd + "@" + ip + ":" + std::to_string(port) +
//                           "/h264/ch1/main/av_stream";
//
//            }//else if(){}

            std::string rtsp_url = rtspAddrBuild(item.str_ip.toStdString(), 554, item.str_username.toStdString(),
                                                 item.str_password.toStdString(), item.str_brand.toStdString());


//            lRec.str_det_thr = rec.value("det_thr").toString();
//            lRec.str_cmp_thr = rec.value("cmp_thr").toString();
            auto en_sdk = m_lDBTool->searchCamSdkTableByCamId(item.str_cam_dev_id);
            vector<int> sdkVec = chnString2Vec(en_sdk.str_sdks.toStdString());

            //设置检测得分
//            std::string s_d = str_det_thr;
//            std::string s_c = str_cmp_thr;
            vector<int> sdkDetCoVec = chnString2Vec(en_sdk.str_det_thr.toStdString());
            vector<int> sdkComCoVec = chnString2Vec(en_sdk.str_cmp_thr.toStdString());

            int camId=item.str_cam_dev_id.toInt();
            int t_size = sdkVec.size();
            for (int i = 0; i < t_size; i++) {
                switch (sdkVec[i]) {
                    case 1: {
//                        INFO("face.enable");
                        json["face.enable"] = "1";
                        SETSCORE(sdkDetCoVec, i, t_camIdex + "face.det");
                        SETSCORE(sdkComCoVec, i, t_camIdex + "face.cmp");
                        DBG(" TESTCODE " << sdkDetCoVec[i] << " " << sdkComCoVec[i]);

                        break;
                    }
                    case 2: {
                        DBG("XX.enable    " << "1");
                        SETSCORE(sdkDetCoVec, i, t_camIdex + "XX.det");
                        SETSCORE(sdkComCoVec, i, t_camIdex + "XX.cmp");
                        break;
                    }
                    case 3: {
//                        INFO("face.enable");
                        json["yolo.enable"] = "1";
                        SETSCORE(sdkDetCoVec, i, t_camIdex + "yolo.det");
                        SETSCORE(sdkComCoVec, i, t_camIdex + "yolo.cmp");
                        break;
                    }
                    case 4: {

                        json["perimeter.enable"] = "1";
                        SETSCORE(sdkDetCoVec, i, t_camIdex + "perimeter.det");
                        SETSCORE(sdkComCoVec, i, t_camIdex + "perimeter.cmp");
                        setDataByType(4,json,camId);
                        break;
                      }
                    case 5: {

                        json["crowd.enable"] = "1";
                        SETSCORE(sdkDetCoVec, i, t_camIdex + "crowd.det");
                        SETSCORE(sdkComCoVec, i, t_camIdex + "crowd.cmp");
                        setDataByType(5,json,camId);
                        break;
                    }
                    case 6: {

                        json["keepRight.enable"] = "1";
                        SETSCORE(sdkDetCoVec, i, t_camIdex + "keepRight.det");
                        SETSCORE(sdkComCoVec, i, t_camIdex + "keepRight.cmp");
                        setDataByType(6,json,camId);
                        break;
                    }
                }
            }
            json["rtsp"] = rtsp_url;
            json["addr"] = item.str_addr.toStdString();

            INFO("cam add is " << item.str_addr.toStdString());

//            DBG(t_camIdex);

            appPref.getLongData("gpu.index");
            addCamera(t_camIdex, json.toStyledString());
        }
    } else {
        ERR("searchCamDevTableAll size is 0");
    }

}

RtspAnalysElement::~RtspAnalysElement() {
    for (auto controller: controllers) {
        delete controller.second;
    }
    controllers.clear();
}

int RtspAnalysElement::addCamera(const std::string &index, const std::string &json) {
    if (controllers.find(index) == controllers.end()) {
        if (currentCount >= maxCount) {
            ERR("addCamera faild, camera's num is full!")
            return -1;
        }
        Json::Reader reader;
        Json::Value value;

        if (reader.parse(json, value)) {

            controllers[index] = new AppPipeController(index, std::move(value), true);
//            controllers[index] = new AppPipeController(index, std::move(value), false);

            controllers[index]->setfdfsClient(&fdfsClient);
            controllers[index]->start();
            currentCount++;
            return 0;
        }
        return -1;
    } else {
        removeCamera(index);
        DBG("removeCamera " << index)
        return addCamera(index, json);
    }
}

int RtspAnalysElement::removeCamera(const std::string &index) {
    if (controllers.find(index) == controllers.end())return -1;
    auto controller = controllers[index];
    controller->stop();
    controller->wait();
    delete controller;
    controllers.erase(index);
    currentCount--;
    return 0;
}

int RtspAnalysElement::removeAll() {
    for (auto controller: controllers) {
        controller.second->stop();
    }
    for (auto controller: controllers) {
        controller.second->wait();
        delete controller.second;
    }
    controllers.clear();
    currentCount = 0;
    return 0;
}

int RtspAnalysElement::getMaxCamCount() {
    return maxCount;
}

int RtspAnalysElement::getCurrentCamCount() {
    return currentCount;
}

std::string RtspAnalysElement::getRtmp(std::string &index) {
    if (controllers.find(index) == controllers.end())return "";
    auto controller = controllers[index];
    return controller->getRtmp();
}


std::vector<int> RtspAnalysElement::chnString2Vec(std::string str_list) {
    std::vector<int> result;
    char *property_list = const_cast<char *>(str_list.c_str());
    const char *c_Analyse = ",";
    char *t_property;

    char *t_save = NULL;
    t_property = strtok_r(property_list, c_Analyse, &t_save);

    while (t_property) {
        std::string str_pro(t_property);

        result.push_back(atoi(str_pro.c_str()));

        t_property = strtok_r(t_save, c_Analyse, &t_save);

    }
    return result;
}
void RtspAnalysElement::setDataByType(int type,Json::Value& json,int camId)
{
    switch (type) {
    case 4:
    {
        auto rule=m_lDBTool->searchPerimeterRuleByCamId(camId);
        json["perimeter.area"]=rule.strAreas.toStdString();
        json["perimeter.num"]=rule.nAlarmPeopleNum;
        json["perimeter.delay"]=rule.nTriggerDelay;
        json["perimeter.tolerance"]=rule.nTriggertolerance;
        break;
    }
    case 5:
    {
        auto rule=m_lDBTool->searchCrowdRuleByCamId(camId);
        json["crowd.area"]=rule.strAreas.toStdString();
        json["crowd.num"]=rule.nAlarmPeopleNum;
        json["crowd.delay"]=rule.nTriggerDelay;
        json["crowd.tolerance"]=rule.nTriggertolerance;
        break;
    }
    case 6:
    {
         auto rule=m_lDBTool->searchActRuleByCamId(camId);
         json["keepRight.leftArea"]=rule.strAreas.toStdString();
         json["keepRight.leftLine"]=rule.strLine.toStdString();
         json["keepRight.rightArea"]=rule.strExAreas.toStdString();
         json["keepRight.rightLine"]=rule.strExLine.toStdString();
         json["keepRight.delay"]=rule.nTriggerDelay;
         json["keepRight.tolerance"]=rule.nTriggertolerance;
        break;
    }
    default:
        break;
    }
}