#include "AppPipeController.h"
#include <basic/util/app/AppPreference.hpp>
#include <basic/util/app/AppUtil.h>
#include <algorithm>
#include <basic/util/app/AppConfig.h>
#include <QtCore/QDateTime>
#include <QtCore/QtGlobal>
#include <net_config.h>

AppPipeController::AppPipeController(std::string folderPath, const Json::Value &json) :
    videoCaptureElement("filePath", 25, -1, appPref.getLongData("gpu.index")), m_index(0),
    m_folderPath(folderPath),
    m_json(json), fdfsClient(nullptr), yoloRpcElement(folderPath + "yoloRpc"), faceRpcElement(folderPath + "faceRpc"),
    faceExtractElement(folderPath + "faceExtract"), triggerElement(25, 10),
    recordVideoElement(-1, json["rtsp"].asString()), bRecordVideoEnable(false) {

    init();

}

AppPipeController::AppPipeController(int index, const Json::Value &json, bool RecordVideoEnable) :
    videoCaptureElement(json["rtsp"].asString(), 25, 3000, appPref.getLongData("gpu.index"), RecordVideoEnable),
    m_index(index), fdfsClient(nullptr), yoloRpcElement(to_string(index) + "yoloRpc"),
    faceRpcElement(to_string(index) + "faceRpc"), m_json(json), faceExtractElement(to_string(index) + "faceExtract"),
    triggerElement(25, 4), recordVideoElement(index, json["rtsp"].asString()), bRecordVideoEnable(RecordVideoEnable) {
    init();
}


AppPipeController::AppPipeController(std::string camId, const Json::Value &json, bool RecordVideoEnable) :
    videoCaptureElement(json["rtsp"].asString(), 25, 3000, appPref.getLongData("gpu.index")),
    m_index(0),
    m_camId(camId),
    fdfsClient(nullptr),
    yoloRpcElement(camId + "yoloRpc"),
    faceRpcElement(camId + "faceRpc"),
    m_json(json),
    faceExtractElement(camId + "faceExtract"),
    // peTriggerElement(json["perimeter.tolerance"].asInt(), json["perimeter.delay"].asInt()),
//    leftTriggerElement(json["keepRight.tolerance"].asInt(), json["keepRight.delay"].asInt()),
//    rightTriggerElement(json["keepRight.tolerance"].asInt(), json["keepRight.delay"].asInt()),
    // crowdTriggerElement(json["crowd.tolerance"].asInt(), json["crowd.delay"].asInt()),
    triggerElement(25, 4),
    recordVideoElement(camId, json["rtsp"].asString()),
    newRecordVideoElement(camId),
    perimeterElement(1),
    crowdElement(json["crowd.num"].asInt()),
    bRecordVideoEnable(RecordVideoEnable) {
    init();
    initPerimeter();
    initCrowd();
    intKeepRight();
}

AppPipeController::~AppPipeController() {

}

//************************************
// Method:    string_replace
// FullName:  string_replace
// Access:    public
// Returns:   void
// Qualifier: 把字符串的strsrc替换成strdst
// Parameter: std::string & strBig
// Parameter: const std::string & strsrc
// Parameter: const std::string & strdst
//************************************
static void string_replace(std::string &strBig, const std::string &strsrc, const std::string &strdst) {
    std::string::size_type pos = 0;
    std::string::size_type srclen = strsrc.size();
    std::string::size_type dstlen = strdst.size();

    while ((pos = strBig.find(strsrc, pos)) != std::string::npos) {
        strBig.replace(pos, srclen, strdst);
        pos += dstlen;
    }
}

bool AppPipeController::resetVideoCapturePath(std::string path) {
//    videoCaptureElement.stop();
//    videoCaptureElement.wait();

    string_replace(path, "//", "/");

    videoCaptureElement.setVideoPath(path);
    auto dev_pos = path.find("/cut/") + 5;
    auto ch_pos = path.find("/", dev_pos) + 1;
    auto str_device_id = path.substr(dev_pos, ch_pos - dev_pos - 1);
    auto str_ch_id = path.substr(ch_pos, path.find("/", ch_pos) - ch_pos);
    faceExtractElement.setProperty("dev_id", str_device_id);
    faceExtractElement.setProperty("ch_id", str_ch_id);
    faceExtractElement.setProperty("path", path);
    yoloRpcElement.setProperty("dev_id", str_device_id);
    yoloRpcElement.setProperty("ch_id", str_ch_id);
    yoloRpcElement.setProperty("path", path);

    //修改时间为实际发生时间
    QString strPath = QString::fromStdString(path);
    QStringList list = strPath.split("/");
    QString fileName;
    QString time;
    QString strNewTime;
    if (list.size() != 0) {
        fileName = list.last();
        time = fileName.split(".").first();
        //#todo
//        time = fileName.split("_").first();
    } else {
        ERR("list.size() == 0)");
    }

    if (!time.isEmpty()) {
        m_dt = QDateTime::fromString(time, "yyyy-MM-dd hh:mm:ss");
    } else {
        m_dt = QDateTime::currentDateTime();
    }

//  deciceId
//  chenle

}

bool AppPipeController::getRunning() {
    return videoCaptureElement.isRunning();
}

string test_str;

void AppPipeController::init() {

    unsigned char ip_old[15] = {0};
    std::string net_ifname = appConfig.getStringProperty("netIfName");
    if (!(GetIpAddress(net_ifname.c_str(), ip_old))) {
        ERR("couldn't get ip");
    }

    bUp = false;

    yoloRpcElement.setProperty("str_addr", m_json["addr"].asString());
    yoloRpcElement.setProperty("local_ip", std::string((char *) ip_old));

    faceExtractElement.setProperty("str_addr", m_json["addr"].asString());
    faceExtractElement.setProperty("local_ip", std::string((char *) ip_old));


    if (bRecordVideoEnable) {
        faceExtractElement.setProperty("dev_id", m_camId);
        yoloRpcElement.setProperty("dev_id", m_camId);
        m_json_Record["rtsp"] = m_json["rtsp"].asString();
    }


    //#todo
    //  int max=appPref.getIntData("n_cut_max_duration");
    // recordInit(40,100);
    videoCaptureElement.registerConnector([&] {

        cv::Mat imageTemp = videoCaptureElement.getImage();

        std::string strNewTime;
        strNewTime = AppUtil::getTimeUSecString();

//        cv::putText(imageTemp, strNewTime, cv::Point(408, 540), cv::HersheyFonts::FONT_HERSHEY_PLAIN, 5,
//                    cv::Scalar(255, 255, 0), 2);
        if (m_camId.size() > 0) {


            if (bRecordVideoEnable) {
                newRecordVideoElement.pushImgBuf(strNewTime, imageTemp);
                newRecordVideoElement.setSdkTrigger(faceRpcElement.getTriggerState() ||//TODO
                                                    yoloRpcElement.getTrigger() ||
                                                    leftJudgment.getTriggerState() ||
                                                    rightJudgment.getTriggerState() ||
                                                    perimeterElement.getTriggerState() ||
                                                    crowdElement.getTriggerState());
                if (!newRecordVideoElement.isBusy()) {
                    newRecordVideoElement.submit();
                }

            }

        } else {
            //#todo 计算当前文件时间
            //#TODO 输出间隔用于计算时间
            // 现为每三帧计算一次，导致计算的时间长于文件的实际时间
            auto opit = 25;// videoCaptureElement.getOutPutInterval();
            auto opidx = videoCaptureElement.getoutPutIndex();
            int second = opidx / opit;
            qint64 newTime = m_dt.toMSecsSinceEpoch() + second * 1000;
            QDateTime newDt = QDateTime::fromMSecsSinceEpoch(newTime);
            strNewTime = newDt.toString("yyyy-MM-dd hh:mm:ss").toStdString();

        }
//        DBG(strNewTime);

        if (!faceRpcElement.isBusy()) {
//            faceRpcElement.setProperty("uuid", uuid);
            //#todo
            faceRpcElement.setProperty("time", strNewTime);
//            faceRpcElement.setProperty("time", uuid);
            faceRpcElement.setImage(imageTemp);
            faceRpcElement.submit();
        }

        if (!yoloRpcElement.isBusy()) {
//            yoloRpcElement.setProperty("uuid", uuid);
            //#todo
            yoloRpcElement.setProperty("time", strNewTime);
            yoloRpcElement.setImage(imageTemp);
            yoloRpcElement.submit();
        }

        if (!imageDrawElement.isBusy()) {
            imageDrawElement.setImage(imageTemp);
            imageDrawElement.submit();
        }

        if (bRecordVideoEnable) {
            registerElement(triggerElement);
        }
    });


    yoloRpcElement.registerConnector([&] {
        imageDrawElement.setYoloObjects(yoloRpcElement.getLastScoreRects());
    });

    faceRpcElement.registerConnector([&] {
        imageDrawElement.setFaces(faceRpcElement.getLastScoreRects());
    });

    yoloRpcElement.registerConnector("YoloTrigger", [&] {
//        auto images = yoloRpcElement.getTriggerMats();
    });

    faceRpcElement.registerConnector("FaceTrigger", [&] {
//        auto images = faceRpcElement.getTriggerMats();
        faceExtractElement.submitFaceExtract({faceRpcElement.getProperty("uuid"),
                                              AppUtil::getTimeString(),
                                              faceRpcElement.getImage().clone(),
                                              faceRpcElement.getTriggerFaces(),
                                              faceRpcElement.getTriggerScoreRects(),
                                              faceRpcElement.getTriggerMats()});
    });

    imageDrawElement.registerConnector([&] {
        if (appPref.getIntData("show.image") == 1) {
            ImageShowElement::showImage(to_string(this->m_index), *imageDrawElement.getImage());
        }
    });

    registerElement(videoCaptureElement);
    if (m_json["yolo.enable"].asString() == "1") {
        registerElement(yoloRpcElement);
    }
    if (m_json["face.enable"].asString() == "1") {
        registerElement(faceRpcElement);
        registerElement(faceExtractElement);
    }
    registerElement(imageDrawElement);
    registerElement(newRecordVideoElement);
    videoCaptureElement.setOutPutInterval(3);
    faceExtractElement.setProperty("index", to_string(m_index));
    //#todo setProperty
//    faceExtractElement.setProperty("index", to_string(m_index));
//    faceExtractElement.setProperty("index", to_string(m_index));
}

std::string AppPipeController::getFullFileName() {
    string tmppath = appConfig.getStringProperty("cutPath");
    auto findCutSize = tmppath.begin() + tmppath.find("/cut");
    if (tmppath.back() != '/') {
        tmppath.push_back('/');
    }
    string t_FilePath = tmppath;
//    string t_FilePath = tmppath.replace(findCutSize, findCutSize + 4, "/realtime/");

    //# ./camIndex/YYYYMM/DD/camIndex-YYYYMMDDHHMMSS/
    //# ./camIndex/YYYYMM/DD/
    string t_strTime = AppUtil::getTimeSecString();
    // 2018-09-01 11:30:48.mp4
    t_FilePath.append(
        m_camId + "/" + t_strTime.substr(0, 4) + t_strTime.substr(5, 2) + "/" +
        t_strTime.substr(8, 2) + "/");
    //camIndex-YYYYMMDDHH/
    string tt = t_strTime;
    //2018-09-27 14:26:58
    //#todo 优化
    tt.erase(16, 1);
    tt.erase(13, 1);
    tt.erase(10, 1);
    tt.erase(7, 1);
    tt.erase(4, 1);
    //20180927142658
    t_FilePath.append(m_camId + "-" + tt.substr(0, 10) + "/");
    string t_cmd = "mkdir -p '";
    t_cmd.append(t_FilePath + "'");
    //#get path mkdir path
    system(t_cmd.c_str());
    //#get time and file name
    t_FilePath.append(t_strTime + ".mp4");
    return t_FilePath;
}

void AppPipeController::setfdfsClient(FastFdsWithLock *p_fdfsClient) {
    fdfsClient = p_fdfsClient;
    faceExtractElement.setFdfs(fdfsClient);
    yoloRpcElement.setFdfs(fdfsClient);
}

std::string AppPipeController::getRtmp() {
    std::string ret = "";// = videoPublishElement.getPath();
    size_t pos = ret.find(".flv");
    ret = ret.substr(0, pos);
    INFO(ret);
    return ret;
}

void AppPipeController::initPerimeter() {
    if (!m_json["perimeter.enable"] == "1") {
        return;
    }
    std::string area = m_json["perimeter.area"].asString();
    //area="[{\"x\":100,\"y\":6},{\"x\":100,\"y\":1200},{\"x\":1800,\"y\":1200},{\"x\":1800,\"y\":6}]";
    perimeterElement.setMask(area);
    perimeterElement.setFdfs(fdfsClient);
    perimeterElement.setProperty("sdkType", "perimeter");
    yoloRpcElement.registerConnector([&] {
        if (!perimeterElement.isBusy()) {

            perimeterElement.setObjsResults(yoloRpcElement.getObjects());
            perimeterElement.submit();
        }
    });
//    perimeterElement.registerConnector([&] {

//        peTriggerElement.setState(perimeterElement.getRealNum() > 0);
//        peTriggerElement.triggerOnce();
//    });
//    peTriggerElement.registerConnector([&] {

//        switch (peTriggerElement.getTriggerType()) {
//            case UP: DBG("peTriggerElement Up");
//                // startRecord(SdkType_Perimeter);
//                break;
//            case DOWN: DBG("peTriggerElement Down");
//                // endRecord(SdkType_Perimeter);
//            default:
//                break;
//        }
//    });
    registerElement(perimeterElement);
//    registerElement(peTriggerElement);
}

void AppPipeController::initCrowd() {
    if (m_json["crowd.enable"] != "1") {
        return;
    }
    std::string area = m_json["crowd.area"].asString();
    //area="[{\"x\":100,\"y\":6},{\"x\":100,\"y\":1200},{\"x\":1800,\"y\":1200},{\"x\":1800,\"y\":6}]";
    crowdElement.setMask(area);
    crowdElement.setFdfs(fdfsClient);
    crowdElement.setProperty("sdkType", "crowd");
    yoloRpcElement.registerConnector([&] {
        if (!crowdElement.isBusy()) {
            crowdElement.setObjsResults(yoloRpcElement.getObjects());
            crowdElement.submit();
        }
    });
//    crowdElement.registerConnector([&] {
//        crowdTriggerElement.setState(crowdElement.getRealNum() >= m_json["crowd.num"].asInt());
//        crowdTriggerElement.triggerOnce();
//    });
//    crowdTriggerElement.registerConnector([&] {

//        switch (crowdTriggerElement.getTriggerType()) {
//            case UP:
//                //reqRecordMap[SdkType_Perimeter]=true;
//                // startRecord(SdkType_Perimeter);
//            DBG("crowdTriggerElement UP");
//                break;
//            case DOWN:
//                // reqRecordMap[SdkType_Perimeter]=false;
//                //endRecord(SdkType_Perimeter);
//            DBG("crowdTriggerElement Down");
//                break;
//            default:
//                break;
//        }
//    });
    registerElement(crowdElement);
//    registerElement(crowdTriggerElement);
}

void AppPipeController::intKeepRight() {
    if (m_json["keepRight.enable"] != "1") {
        return;
    }
    std::string leftArea = m_json["keepRight.leftArea"].asString();
    std::string leftLine = m_json["keepRight.leftLine"].asString();
    std::string rightArea = m_json["keepRight.rightArea"].asString();
    std::string rightLine = m_json["keepRight.rightLine"].asString();
    leftJudgment.init(QString::fromStdString(leftArea), QString::fromStdString(leftLine));
    rightJudgment.init(QString::fromStdString(rightArea), QString::fromStdString(rightLine));
    yoloRpcElement.registerConnector([&] {
        leftJudgment.setYoloObjects(yoloRpcElement.getLastScoreRects());
        rightJudgment.setYoloObjects(yoloRpcElement.getLastScoreRects());
    });
    registerElement(leftJudgment);
    registerElement(rightJudgment);

}