//
// Created by basic on 18-8-23.
//

#include <basic/util/app/AppConfig.h>
#include "DBManageClass.h"
#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

DBManageClass::DBManageClass(LDBTool *_dbTool) :
    m_fileManage(_dbTool), m_downloadFileRet(true), m_cutManage(_dbTool), m_cutVideoRet(true),
    m_sdkHdlManage(_dbTool), m_sdkHdlRet(true),
    //#todo
    m_HcDowloadElement(std::bind(&DBManageClass::downFileFuncFinish, this, std::placeholders::_1)),
    m_HcAnalysVideo(std::bind(&DBManageClass::cutVideoFuncFinish, this, std::placeholders::_1)),
    m_BasicSDKAnalysVideo(
        std::bind(&DBManageClass::sdkhlVideoFuncFinish, this, std::placeholders::_1, std::placeholders::_2)) {}

DBManageClass::~DBManageClass() {
    stop();
}

void DBManageClass::addDevice(const std::string strDevID, const char *ip, const unsigned short port,
                              const char *usrname, const char *passwd) {
    m_HcDowloadElement.addDevice(strDevID, ip, port, usrname, passwd);
}

void DBManageClass::start(int fileManagePSize, int cutManagePSize, int sdkHdlManagePSize) {
    //#todo init threads num
    init(fileManagePSize, cutManagePSize, sdkHdlManagePSize);
}

void DBManageClass::testSdk() {
    m_BasicSDKAnalysVideo.beginThreads(1);
    std::thread tpf_sdkHlVideoFile(sdkHlVideo, this);
    tpf_sdkHlVideoFile.detach();
}

void DBManageClass::stop() {
    //Ret =false
    m_downloadFileRet = false;
    m_cutVideoRet = false;
    m_sdkHdlRet = false;
}

void DBManageClass::downFileFuncFinish(std::shared_ptr<ChannelLoadFileManage> &spPacket) {
    m_fileManage.finishTask(spPacket.get());
}

void DBManageClass::cutVideoFuncFinish(std::shared_ptr<finishCutFileManage> &spPacket) {
    if (m_cutManage.finishTask(spPacket.get())) {
        //#todo delete src_file
        string cmd = "rm -rf ";
        cmd.append(spPacket->src_path).append(" & ");
        system(cmd.c_str());
        //#todo have bug
//        IOOperate::RemoveDir(spPacket->src_path.c_str());
    } else {
        ERR("m_cutManage.finishTask err");
    }
}

void DBManageClass::sdkhlVideoFuncFinish(std::shared_ptr<finishSdkHdlManage> &spPacket, int listSize) {
    bool ret = false;
    if (listSize == 0) {
        ret = m_sdkHdlManage.finishTask(spPacket.get());
    } else {
        ret = m_sdkHdlManage.updateSdkHdlPos(spPacket.get());
    }
    if (!ret) ERR("sdkhlVideoFuncFinish err ; listSize is " << listSize);
}


void DBManageClass::init(int fileManagePSize, int cutManagePSize, int sdkHdlManagePSize) {
    m_fileManagePSize = fileManagePSize;
    m_cutManagePSize = cutManagePSize;
    m_sdkHdlManagePSize = sdkHdlManagePSize;

    m_HcDowloadElement.beginThreads(m_fileManagePSize);
    m_HcAnalysVideo.beginThreads(m_cutManagePSize);
    m_BasicSDKAnalysVideo.beginThreads(m_sdkHdlManagePSize);
    //Thread(start)
    std::thread tpf_downloadFile(downloadFile, this);
    std::thread tpf_cutVideoFile(cutVideoFile, this);
    std::thread tpf_sdkHlVideoFile(sdkHlVideo, this);
    tpf_downloadFile.detach();
    tpf_cutVideoFile.detach();
    tpf_sdkHlVideoFile.detach();
}

std::string getCmdResult(const std::string &strCmd) {
    char buf[10240] = {0};
    FILE *pf = NULL;

    if ((pf = popen(strCmd.c_str(), "r")) == NULL) {
        return "";
    }

    std::string strResult;
    while (fgets(buf, sizeof buf, pf)) {
        strResult += buf;
    }

    pclose(pf);

    unsigned int iSize = strResult.size();
    if (iSize > 0 && strResult[iSize - 1] == '\n')  // linux
    {
        strResult = strResult.substr(0, iSize - 1);
    }

    return strResult;
}

void DBManageClass::downloadFile(DBManageClass *dbManageClass) {
    while (dbManageClass->m_downloadFileRet) {
        //#todo sdkhl size
        bool t_ret = true;
        std::string loadPath = appConfig.getStringProperty("loadPath");
        std::string loadMaxSize_auto = appConfig.getStringProperty("TotalLoadSize");
        long int loadMaxSize = atol(loadMaxSize_auto.c_str());
        char cmd[100] = {0};
        sprintf(cmd, "du -s %s | awk '{print $1}'", loadPath.c_str());
        std::string str_cmd(cmd);
        std::string cmd_result = getCmdResult(str_cmd);
        int currentSize = atol(cmd_result.c_str());

        //超出给定下载的存储空间的80%，sleep 10分钟
        if (currentSize >= (loadMaxSize * 1024 * 1024 * 80 / 100)) {
            INFO(" 超出给定下载的存储空间的80%，sleep 10分钟 ");
            sleep(10 * 60);
        }

        if (dbManageClass->m_HcDowloadElement.get_taskListSize() < dbManageClass->m_fileManagePSize) {
            auto sp_task(std::make_shared<ChannelLoadFileManage>(dbManageClass->m_fileManage.getTask()));
            if (sp_task->strDevID.size() <= 0) {
                sleep(WAITTASKTIME);
            } else {
                INFO(" channel " << sp_task->nChannelID
                                 << "   Month " << sp_task->startTime.Month
                                 << "   Day " << sp_task->startTime.Day
                                 << "   Hour " << sp_task->startTime.Hour
                                 << "   Minute " << sp_task->startTime.Minute
                                 << "   Second " << sp_task->startTime.Second
                );
                dbManageClass->m_HcDowloadElement.put_task(sp_task);
            }
        } else {
            sleep(WAITTASKPOOLTIME);
        }
    }
}

void DBManageClass::cutVideoFile(DBManageClass *dbManageClass) {
    while (dbManageClass->m_cutVideoRet) {
        //#todo sdkhl size
        if (dbManageClass->m_HcAnalysVideo.get_taskListSize() < dbManageClass->m_cutManagePSize) {
            auto sp_task(std::make_shared<getCutFileManage>(dbManageClass->m_cutManage.getTask()));
            if (sp_task->src_path.size() <= 0) {
                sleep(WAITTASKTIME);
            } else {
                dbManageClass->m_HcAnalysVideo.put_task(sp_task);
            }
        } else {
            sleep(WAITTASKPOOLTIME);
        }
    }
}

void DBManageClass::sdkHlVideo(DBManageClass *dbManageClass) {
    while (dbManageClass->m_sdkHdlRet) {
        //#todo sdkhl size
//        DBG("???????");
        if (dbManageClass->m_BasicSDKAnalysVideo.get_taskListSize() <= dbManageClass->m_sdkHdlManagePSize) {
            auto sp_task(std::make_shared<getsdkHdlManage>(dbManageClass->m_sdkHdlManage.getTask()));
            if (sp_task->src_path.size() <= 0) {
//                DBG("??????? size <0");
                sleep(WAITTASKTIME);
            } else {
                DBG("sdk work " << sp_task->src_path);
                dbManageClass->m_BasicSDKAnalysVideo.put_task(sp_task);
            }
        } else {
//            DBG("??????? get_taskListSize < m_sdkHdlManagePSize");
            sleep(WAITTASKPOOLTIME);
        }

    }
}