#include "CameraWrapperServer.h"
#include "RemoteFuncServer.h"
#include <logger.h>
#include <Logger/src/logger.hpp>
#include <MaterialBuffer.h>
#include <PL_Gainer.h>
#include <PL_Paint.h>
#include <PL_Scale.h>
#include <PL_BlockGrouping.h>
#include <PL_ColorConv.h>
#include <PL_AndroidMediaCodecEncoder.h>
#include <PL_RTSPServer2.h>
#include <iostream>

CameraWrapper::~CameraWrapper()
{
	stop();
    delete pipeLineRender;
    delete pipeLineAnalyzer;
    delete pipeLineDecoderDetector;
}

bool CameraWrapper::start()
{
	LOG_INFO << "CameraWrapper::start" << LOG_ENDL;

    pthread_mutex_init(&live_daemon_mut, NULL);

    running = true;
	int ret = pthread_create(&decoder_thid, NULL, CameraWrapper::decoder_thd, this);
	if(ret != 0)
	{
		LOGP(ERROR, "pthread_create decoder_thid: %s/n", strerror(ret));
		running = false;
		return false;
	}

	//struct sched_param param;
	//int policy = -1;
	//int rc = pthread_getschedparam(decoder_thid, &policy, &param);
	//LOGP(INFO, "pthread_getschedparam, rc=%d, policy=%d, priority=%d", rc, policy, param.__sched_priority);
	//policy = SCHED_RR;
	//param.__sched_priority = 1;
	//rc = pthread_setschedparam(decoder_thid, policy, &param);
	//LOGP(INFO, "pthread_getschedparam, rc=%d, policy=%d, priority=%d", rc, policy, param.__sched_priority);

    ret = pthread_create(&live_daemon_thid, NULL, CameraWrapper::live_daemon_thd, this);
    if(ret != 0)
    {
        LOGP(ERROR, "pthread_create live_daemon_thid: %s/n", strerror(ret));
        running = false;
        return false;
    }

	return true;
}

void CameraWrapper::stop()
{
	LOG_INFO << "CameraWrapper::stop" << LOG_ENDL;
	
	if (!running)
		return;

	running = false;
    pthread_join(decoder_thid, NULL);
    pthread_join(live_daemon_thid, NULL);

    pthread_mutex_destroy(&live_daemon_mut);
}

static float pl_analizer_plbg_user_score_2_func(const MB_Frame* frame, const PLGH_Rect& rects, uint8_t* croppedData)
{
    return 0.0f;
}

static void pl_analizer_plbg_get_rect_func(const PipeMaterial& ptr_pm, const MB_Frame& data_frame, std::list<RectWrapper>& rects)
{
    const st_ff_vect_t& faceFeatures(*(const st_ff_vect_t*)(ptr_pm.buffer));

    for (st_ff_vect_t::const_iterator iter = faceFeatures.begin(); iter != faceFeatures.end(); ++iter)
    {
        if (!iter->test_face_in_cone(35.0f, 35.0f, 35.0f))
            continue;

        RectWrapper rw;
        rw.rect = iter->rect;
        rw.user_score_1 = ((90.0f - std::abs(iter->yaw)) + (90.0f - std::abs(iter->pitch)) + (90.0f - std::abs(iter->roll))) / 90.0f / 3 * iter->score;
        rw.userData = (void*)(iter->id);
        rects.push_back(rw);
    }
}

bool CameraWrapper::initPl()
{
    PipeLine::register_global_elem_creator("PL_RTSPClient", create_PL_RTSPClient);
    PipeLine::register_global_elem_creator("PL_AndroidMediaCodecDecoder", create_PL_AndroidMediaCodecDecoder);
    PipeLine::register_global_elem_creator("PL_AndroidSurfaceViewRender", create_PL_AndroidSurfaceViewRender);
    //PipeLine::register_global_elem_creator("PL_SensetimeFaceTrack", create_PL_SensetimeFaceTrack);
    PipeLine::register_global_elem_creator("PL_SensetimeFaceTrackMitiTrd", create_PL_SensetimeFaceTrackMultiTrd);
    PipeLine::register_global_elem_creator("PL_Gainer", create_PL_Gainer);
    PipeLine::register_global_elem_creator("PL_Scale", create_PL_Scale);
    PipeLine::register_global_elem_creator("PL_ColorConv", create_PL_ColorConv);
    PipeLine::register_global_elem_creator("PL_Paint", create_PL_Paint);
    PipeLine::register_global_elem_creator("PL_BlockGrouping", create_PL_BlockGrouping);
	PipeLine::register_global_elem_creator("PL_AndroidMediaCodecEncoder", create_PL_AndroidMediaCodecEncoder);
	PipeLine::register_global_elem_creator("PL_RTSPServer2", create_PL_RTSPServer2);

    bool ret = initPl_DecoderPl();
    if (!ret)
    {
        LOG_ERROR << "pipeLineDecoderDetector init error" << LOG_ENDL;
        return  false;
    }

    {
        PL_Gainer* plGainer = (PL_Gainer*)pipeLineAnalyzer->push_elem("PL_Gainer");
        ret = plGainer->init(nullptr);
        if (!ret)
        {
            LOG_ERROR << "pipeLineAnalyzer.plGainer.init error" << LOG_ENDL;
            return  false;
        }

        PL_BlockGrouping* plBG = (PL_BlockGrouping*)pipeLineAnalyzer->push_elem("PL_BlockGrouping");
        PL_BlockGrouping_Config plbgConfig;
        plbgConfig.user_score_2_func = pl_analizer_plbg_user_score_2_func;
        plbgConfig.get_rect_func = pl_analizer_plbg_get_rect_func;
        ret = plBG->init(&plbgConfig);
        if (!ret)
        {
            LOG_ERROR << "pipeLineAnalyzer.plBG.init error" << LOG_ENDL;
            return  false;
        }
    }

    {
        PL_Gainer* plGainer = (PL_Gainer*)pipeLineRender->push_elem("PL_Gainer");
        ret = plGainer->init(nullptr);
        if (!ret)
        {
            LOG_ERROR << "pipeLineRender.plGainer init error" << LOG_ENDL;
            return  false;
        }

		PL_Scale* plScale = (PL_Scale*)pipeLineRender->push_elem("PL_Scale");
		plScaleCfg.toWidth = 640;
		plScaleCfg.toHeight = 480;//#todo config
		ret = plScale->init(&plScaleCfg);
		if (!ret)
		{
		    LOG_ERROR << "pipeLineRender.plScale init error" << LOG_ENDL;
		    return  false;
		}

		//PL_ColorConv_Config PLColorConvCfg;
		//PL_ColorConv* plColorConv = (PL_ColorConv*)pipeLineRender->push_elem("PL_ColorConv");
		//ret = plColorConv->init(&PLColorConvCfg);
		//if (!ret)
		//{
		//	LOG_ERROR << "pipeLineRender.plPaint init error" << LOG_ENDL;
		//	return  false;
		//}

		PL_Paint_Config plPaintCfg;
		plPaintCfg.fontPath = fontPath;
		plPaintCfg.plplCtx = &plplContext;
		PL_Paint* plPaint = (PL_Paint*)pipeLineRender->push_elem("PL_Paint");
		ret = plPaint->init(&plPaintCfg);
		if (!ret)
		{
			LOG_ERROR << "pipeLineRender.plPaint init error" << LOG_ENDL;
			return  false;
		}

		//PL_AndroidSurfaceViewRender* asvRender = (PL_AndroidSurfaceViewRender*)pipeLineRender->push_elem("PL_AndroidSurfaceViewRender");
		//ret = asvRender->init(&asvrConfig);
		//if (!ret)
		//{
		//	LOG_ERROR << "pipeLineRender.asvRender init error" << LOG_ENDL;
		//	return  false;
		//}

		PL_AndroidMediaCodecEncoder_Config amceCfg;
		amceCfg.ak_bit_rate = 512 * 1024 * 8; // 512KB
		amceCfg.ak_color_format = 21; // COLOR_FormatYUV420SemiPlanar;
		amceCfg.ak_frame_rate = 40;
		amceCfg.ak_height = 480;
		amceCfg.ak_i_frame_interval = 1;
		amceCfg.ak_mime = "video/avc";
		amceCfg.ak_width = 640;
		amceCfg.codecProfileLevel.profile = Android_CodecProfileLevel::AVCProfileBaseline;
		amceCfg.codecProfileLevel.level = Android_CodecProfileLevel::AVCLevel1;
		PL_AndroidMediaCodecEncoder* plAMCE = (PL_AndroidMediaCodecEncoder*)pipeLineRender->push_elem("PL_AndroidMediaCodecEncoder");
		ret = plAMCE->init(&amceCfg);
		if (!ret)
		{
			LOG_ERROR << "pipeLineRender.plAMCE init error" << LOG_ENDL;
			return  false;
		}

		PL_RTSPServer2* plRtspServer = (PL_RTSPServer2*)pipeLineRender->push_elem("PL_RTSPServer2");
		RTSPServer2Config rtspServerConfig;
		//rtspServerConfig.payBlockFullQueue = true;
		ret = plRtspServer->init(&rtspServerConfig);
		if (!ret)
		{
			LOG_ERROR << "pipeLineRender.plRtspServer init error" << LOG_ENDL;
			return  false;
		}
	}

	return true;
}

bool CameraWrapper::initPl_DecoderPl()
{
    bool ret = false;

    PL_RTSPClient* rtspClient = (PL_RTSPClient*)pipeLineDecoderDetector->push_elem("PL_RTSPClient");
    ret = rtspClient->init(&rtspConfig);
    if (!ret)
    {
        LOG_ERROR << "pipeLineDecoderDetector.rtspClient.init error" << LOG_ENDL;
        return  false;
    }

    PL_AndroidMediaCodecDecoder* amcDecoder = (PL_AndroidMediaCodecDecoder*)pipeLineDecoderDetector->push_elem("PL_AndroidMediaCodecDecoder");
    ret = amcDecoder->init(&amcdConfig);
    if (!ret)
    {
        LOG_ERROR << "pipeLineDecoderDetector.amcDecoder.init error" << LOG_ENDL;
        return  false;
    }

    //PL_V4L2Source *v4l2Source = (PL_V4L2Source *) pipeLineDecoderDetector->push_elem("PL_V4L2Source");
    //PL_V4L2Source_Config v4l2Config;
    //v4l2Config.width = 640;
    //v4l2Config.height = 480;
    //ret = v4l2Source->init(&v4l2Config);
    //if (!ret) {
    //    LOG_ERROR << "pipeLineDecoderDetector.v4l2Source.init error" << LOG_ENDL;
    //    return false;
    //}

#ifdef USE_ST_SDK
    //PL_SensetimeFaceTrack *sfTrack = (PL_SensetimeFaceTrack *) pipeLineDecoderDetector->push_elem("PL_SensetimeFaceTrack");//#todo   use multi
    //ret = sfTrack->init(&sftConfig);
    //if (!ret)
    //{
    //    LOG_ERROR << "pipeLineDecoderDetector.sfTrack.init error" << LOG_ENDL;
    //    return false;
    //}
    PL_SensetimeFaceTrackMultiTrd *sfTrack = (PL_SensetimeFaceTrackMultiTrd *) pipeLineDecoderDetector->push_elem("PL_SensetimeFaceTrackMitiTrd");
    ret = sfTrack->init(&sftConfig);
    if (!ret)
    {
        LOG_ERROR << "pipeLineDecoderDetector.sfTrack.init error" << LOG_ENDL;
        return false;
    }
#endif

    return ret;
}

void CameraWrapper::lockFace()
{
    faceCacheLocked = true;
}

void CameraWrapper::releaseFace()
{
    faceCacheLocked = false;
}

void CameraWrapper::setFaceLabel(int st_track_id, const std::wstring& label)
{
    if (faceLabels.size() > 32)
        faceLabels.clear();
    faceLabels.insert(std::make_pair(st_track_id, label));
}

static void invokeCallback(CameraWrapper& cameraWrapper, int faceCount)
{
    //jni thread may not able to invoke java callback
    // double check it's all ok
    int getEnvStat = cameraWrapper.javaVM->GetEnv((void **)&(cameraWrapper.javaEnv), JNI_VERSION_1_6);
    if (getEnvStat == JNI_EDETACHED)
    {
        //LOG_WARN << "GetEnv: not attached" << std::endl;
        if (cameraWrapper.javaVM->AttachCurrentThread(&(cameraWrapper.javaEnv), NULL) != 0)
            LOG_WARN << "Failed to attach" << LOG_ENDL;
        else
            getEnvStat = JNI_OK;
    }
    else if (getEnvStat == JNI_OK)
    {
    }
    else if (getEnvStat == JNI_EVERSION)
        LOG_WARN << "GetEnv: version not supported" << LOG_ENDL;
    else if (getEnvStat == JNI_ERR)
        LOG_WARN << "GetEnv: JNI_ERR" << LOG_ENDL;

    cameraWrapper.javaEnv->CallStaticVoidMethod(cameraWrapper.faceCallbackClazz, cameraWrapper.faceCallbackFunc, cameraWrapper.cameraIdx, faceCount);

    if (cameraWrapper.javaEnv->ExceptionCheck())
        cameraWrapper.javaEnv->ExceptionDescribe();

    cameraWrapper.javaVM->DetachCurrentThread();
}

bool cw_pm_breaker_ptr_paint(const PipeMaterial* pm, void* args)
{
    CameraWrapper& cameraWrapper = *(CameraWrapper*)args;
    PLPLContext& plplContext(cameraWrapper.plplContext);
    const st_ff_vect_t& faceFeatures(*(const st_ff_vect_t*)(pm->buffer));

    plplContext.cmds.clear();
    plplContext.params.clear();

    float width_scale = ((float)cameraWrapper.plScaleCfg.toWidth) / cameraWrapper.amcdConfig.ak_width;
    float height_scale = ((float)cameraWrapper.plScaleCfg.toHeight) / cameraWrapper.amcdConfig.ak_height;

    for (st_ff_vect_t::const_iterator iter = faceFeatures.begin(); iter != faceFeatures.end(); ++iter)
    {
        plplContext.cmds.push_back(PLPLC_COLOR);
        plplContext.params.push_back('F');
        if (iter->test_face_in_cone(35.0f, 35.0f, 35.0f))
        {
            if (iter->outOfFrame)
            {
                plplContext.params.push_back(255);
                plplContext.params.push_back(255);
                plplContext.params.push_back(0);
                plplContext.params.push_back(255);
            }
            else
            {
                plplContext.params.push_back(255);
                plplContext.params.push_back(0);
                plplContext.params.push_back(0);
                plplContext.params.push_back(255);
            }
        }
        else
        {
            plplContext.params.push_back(0);
            plplContext.params.push_back(255);
            plplContext.params.push_back(0);
            plplContext.params.push_back(255);
        }

        plplContext.cmds.push_back(PLPLC_RECT);
        plplContext.params.push_back((int)(iter->rect.leftTop.X * width_scale));
        plplContext.params.push_back((int)(iter->rect.leftTop.Y * height_scale));
        plplContext.params.push_back((int)(iter->rect.rightBottom.X * width_scale));
        plplContext.params.push_back((int)(iter->rect.rightBottom.Y * height_scale));

        std::map<int, std::wstring>::iterator iterFaceLabel = cameraWrapper.faceLabels.find(iter->id);
        if (iterFaceLabel != cameraWrapper.faceLabels.end())
        {
            plplContext.cmds.push_back(PLPLC_WTEXT);
            plplContext.params.push_back((int)(iter->rect.leftTop.X * width_scale));
            plplContext.params.push_back((int)(iter->rect.leftTop.Y * height_scale));
            const wchar_t* label = iterFaceLabel->second.c_str();
            plplContext.params.push_back(PLPLType(label));
        }
    }

    return false;
}

bool cw_pm_breaker_ptr_face(const PipeMaterial* pm, void* args)
{
    CameraWrapper& cameraWrapper = *(CameraWrapper*)args;
    if (cameraWrapper.faceCacheLocked)
        return false;
    int faceCount = cameraWrapper.faceCache.getFaceCount(*pm);
    if (faceCount <= 0 || cameraWrapper.faceCallbackFunc == 0)
        return false;
    cameraWrapper.faceCache.cachePm(*pm);
    //remote call start, 为了保证通用性，未将以下步骤封入RtspFaceDetectClient
    //#todo 优化封装
    try
    {
        LOG_INFO <<"try start"<< LOG_ENDL;

//        RtspFaceDetect::Client* rClient = getRtspFaceDetectClient()->getClient();
//        auto& waitScope = getRtspFaceDetectClient()->getWaitScope();

       RtspFaceDetectClient* client = getRtspFaceDetectClient();
       RtspFaceDetect::Client rClient = client->getEzRpcClient()->getMain<RtspFaceDetect>();
       auto& waitScope = client->getWaitScope();

       auto  request = rClient.fireFaceCountListenerRequest();
       request.setCameraIndex(cameraWrapper.cameraIdx);
       request.setFaceCount(faceCount);
       LOG_INFO <<"!!!!!"<<cameraWrapper.cameraIdx << "+" << faceCount << LOG_ENDL;
       LOG_INFO <<"call client : i have face!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<< LOG_ENDL;
       auto sendAct = request.send();
       sendAct.ignoreResult().wait(waitScope);
    }
    catch (const kj::Exception& e)
    {
        LOG_INFO <<"catch!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<< LOG_ENDL;
        LOG_ERROR << "catch!!!" <<e.getDescription().cStr() << LOG_ENDL;
        std::cout << e.getDescription().cStr() << std::endl;
        return false;
    }
    catch (std::exception e){
        LOG_ERROR << "catch!!!" <<e.what() << LOG_ENDL;
    }
    //remote call end
    return true;
}

void test_paint(CameraWrapper& cameraWrapper)
{
    cameraWrapper.plplContext.cmds.push_back(PLPLC_WTEXT);
    cameraWrapper.plplContext.params.push_back(100);
    cameraWrapper.plplContext.params.push_back(100);
    cameraWrapper.plplContext.params.push_back(PLPLType(L"中文是啊"));

    cameraWrapper.setFaceLabel(0, L"会员vi");
    cameraWrapper.setFaceLabel(1, L"会员ab");
    cameraWrapper.setFaceLabel(3, L"会员wr");

    cameraWrapper.plplContext.cmds.push_back(PLPLC_COLOR);
    cameraWrapper.plplContext.params.push_back('F');
    cameraWrapper.plplContext.params.push_back(255);
    cameraWrapper.plplContext.params.push_back(255);
    cameraWrapper.plplContext.params.push_back(255);
    cameraWrapper.plplContext.params.push_back(255);
    cameraWrapper.plplContext.cmds.push_back(PLPLC_RECT);
    cameraWrapper.plplContext.params.push_back(20);
    cameraWrapper.plplContext.params.push_back(20);
    cameraWrapper.plplContext.params.push_back(100);
    cameraWrapper.plplContext.params.push_back(100);
}

void cw_elem_destory_func(PipeLineElem* elem)
{
    delete elem;
}

bool CameraWrapper::resetPl()
{
    pipeLineDecoderDetector->finit(cw_elem_destory_func);
    sleep(2);
    return initPl_DecoderPl();
}

/*static*/ void* CameraWrapper::decoder_thd(void* arg)
{
	LOG_INFO << "CameraWrapper::decoder_thd start" << LOG_ENDL;
	CameraWrapper& cameraWrapper = *(CameraWrapper*)arg;

	while(cameraWrapper.running)
	{
        if (cameraWrapper.killed)
        {
            LOG_WARN << "CameraWrapper::killed" << LOG_ENDL;
            cameraWrapper.resetPl();
            cameraWrapper.killed = false;
            sleep(2);
        }

		PipeLineElem* last = cameraWrapper.pipeLineDecoderDetector->pipe();
		bool ret = cameraWrapper.pipeLineDecoderDetector->check_pipe_complete(last);
		//LOG_DEBUG << "pipe ret=" << ret << LOG_ENDL;

		if (!ret)
			continue;

        PipeMaterial pm;
        ret = last->gain(pm);
        if (!ret)
            continue;

        cameraWrapper.lastAliveTime = time(nullptr);

        if (! cameraWrapper.faceCacheLocked)
        {
            PipeMaterial pmAnalizer(pm);
            PipeLineElem* last = cameraWrapper.pipeLineAnalyzer->pipe(&pmAnalizer);
            bool ret = last->gain(pmAnalizer);
            if (ret)
                pmAnalizer.breake(PipeMaterial::PMT_PTR, MB_Frame::MBFT__FIRST, cw_pm_breaker_ptr_face, &(cameraWrapper));
        }

        pm.breake(PipeMaterial::PMT_PTR, MB_Frame::MBFT__FIRST, cw_pm_breaker_ptr_paint, &(cameraWrapper));

        //#debug
        //test_paint(cameraWrapper);

		cameraWrapper.pipeLineRender->pipe(&pm);
    }
	
	LOG_INFO << "CameraWrapper::decoder_thd stop, ret=" << LOG_ENDL;
}

/*static*/ void* CameraWrapper::live_daemon_thd(void* arg)
{
    LOG_INFO << "CameraWrapper::live_daemon_thd start" << LOG_ENDL;
    CameraWrapper& cameraWrapper = *(CameraWrapper*)arg;

    while(cameraWrapper.running)
    {
        sleep(10);

        if (time(nullptr) - cameraWrapper.lastAliveTime > 20)
        {
            PL_RTSPClient* rtspClient = (PL_RTSPClient*)cameraWrapper.pipeLineDecoderDetector->at(0);
            rtspClient->kill();

            cameraWrapper.killed = true;
        }
    }
}