#include "debugExport.h"
#include "Arith_EOController.h"
#include "Arith_CoordModule.h"


void ARIDLL_GetDeBugOutput(ArithHandle hArithSrc, ARIDLL_INPUTPARA* stInputPara, ARIDLL_DEBUG_OUTPUT* pstOutput, GLB_OUTPUT* pGlb_Output)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    // 输出单帧检测结果
    TARGET_OBJECT* pFrameTargets = pArith->g_pFrameTargetArray;
    ARIDLL_DEBUG_OUTPUT* info = pstOutput;
    info->nDetectObjsNum = MIN(pArith->g_TotalTargetNum, 50);
    // memcpy(info->stFrameObjsInfo,pFrameTargets,sizeof(TARGET_OBJECT) * info->nDetectObjsNum);
    info->Arith_time = pArith->g_GLB_stArithPara.fArithRunTimes;
     // 管道资源占用
    info->nMaxPipeNum = pArith->g_GLB_PipeProc->PIPE_GetMaxPipeNum();
    info->nUsePipeNum = pArith->g_GLB_PipeProc->PIPE_GetOccupyNum();

    Tracker* pTracker = pArith->g_GLB_Trackers[pArith->g_GLB_stPara.nLockPipeInd];

    if (pTracker != NULL && pTracker->pGroundTracker)
    {
        OBJECTSTATUS *pDeciOutput = &pTracker->pGroundTracker->ObjStatus;
        OBJECTSTATUS *pKCFOutput = &pTracker->pGroundTracker->ObjStatusKCF;

        OccJudge* pOccJudgeKCF = pTracker->pGroundTracker->m_pOccJudgeKCF;

        TargetArrest* pArrestOut = pTracker->pGroundTracker->m_pTargetArrest;
        TLD_Para* pTLDPara = pTracker->pGroundTracker->m_pTLDTracker->TLD_GetPara();

        // 注意：不要对临时变量取地址，改为返回指针
        MASTERAIDMONITOR  *masterMonitor = pTracker->pGroundTracker->Ai_DMonitor->getAIDMasterInfo();
        AIDMAINOBJ *nMainAIObj = &masterMonitor->nMainInfo;

        //对地调试参数传值
        info->fKCFRes = pKCFOutput->fConfidence;
        info->nLearnCnt = pTLDPara->nLearnedNum;
        info->nTLDNum = pTLDPara->nClusterNum;
        info->fMaxNNConf = pTLDPara->fNNConfMax;
        info->fLargeResTH = pOccJudgeKCF->m_Occ_Para.fFilteredMaxRes;
        info->fArrKCFRes = pArrestOut->m_fArrestKcfRes;
        info->nOccKCFStatus = pOccJudgeKCF->nOccKCFStatus;
        info->nArrestKCFStatus = pArrestOut->m_nArrestKCFStatus;
        info->nArrestAIStatus = pArrestOut->m_nArrestAIStatus;
        info->nOccAIDStatus = pTracker->pGroundTracker->Ai_DMonitor->m_ubLostStatus;
        info->nArrestAIDStatus = pTracker->pGroundTracker->Ai_DMonitor->m_ubArrestStatus;
        info->nAIDBestId = nMainAIObj->nTrackId;
        info->nAIDLostCnt = nMainAIObj->unContiLostCnt;
        info->unContiTrackedCnt = nMainAIObj->unContiTrackedCnt;
        info->nArrestNum = masterMonitor->nTargetNum;
        info->nAIDJamCnt = nMainAIObj->nJamCnt;
        info->nDecisionStatus = pDeciOutput->nDeciStatus;
        info->nKcfStatus = pKCFOutput->nOcclude_flag;
        info->nX = (int)pDeciOutput->ptPos.x;
        info->nY = (int)pDeciOutput->ptPos.y;
        info->nW = (int)pDeciOutput->sfSize.w;
        info->nH = (int)pDeciOutput->sfSize.h;
        pGlb_Output->fKCFRes = pKCFOutput->fConfidence;
        pGlb_Output->nLearnCnt = pTLDPara->nLearnedNum;
        pGlb_Output->nTLDNum = pTLDPara->nClusterNum;
        pGlb_Output->fMaxNNConf = pTLDPara->fNNConfMax;
        pGlb_Output->fLargeResTH = pOccJudgeKCF->m_Occ_Para.fFilteredMaxRes;
        pGlb_Output->fArrKCFRes = pArrestOut->m_fArrestKcfRes;
    }
    else if (pTracker != NULL && pTracker->pSkyTracker)
    {
        //UBYTE8 ubBkgIndex = 0;
        //BBOOL bComplexEnv = FALSE;
        //BBOOL bInterferenceMem = FALSE;
        //UBYTE8 bInfrnDirection = 0;

        //getBKMInform(hArithSrc, pArith->g_GLB_stPara.nLockPipeInd, NULL, NULL, &ubBkgIndex,
        //    &bComplexEnv, &bInterferenceMem, &bInfrnDirection, NULL);
        //info->sky_bComplexEnv = bComplexEnv;
        //info->sky_bInterferenceMem = bInterferenceMem;

        TSky_Output* pSky_Output = GetSkyTrackerObjectStatus(hArithSrc, pArith->g_GLB_stPara.nLockPipeInd);
        // 注意：不要对临时变量取地址，改为返回指针
        MASTERAIDMONITOR* masterMonitor = pTracker->pSkyTracker->Ai_DMonitor->getAIDMasterInfo();
        AIDMAINOBJ* nMainAIObj = &masterMonitor->nMainInfo;

        info->sky_TrkDownRatio = pSky_Output->mTrakingPara_Output.prmTSkyDet.nDSmpScale;
        info->sky_TrkMemFrm = pSky_Output->ObjectStatusDesc.unContiLostCnt;
        info->sky_nTrkCX = pSky_Output->ObjectStatusDesc.ptPos.x;
        info->sky_nTrkCY = pSky_Output->ObjectStatusDesc.ptPos.y;
        info->sky_nTrkW = pSky_Output->ObjectStatusDesc.sfSize.w;
        info->sky_nTrkH = pSky_Output->ObjectStatusDesc.sfSize.h;
        info->sky_nTrkPxlsCnt = (SINT32)pSky_Output->ObjectStatusDesc.fObjPxlsCnt;
        info->sky_fTrkConf = pSky_Output->ObjectStatusDesc.fConfidence;

        pGlb_Output->sky_TrkDownRatio = pSky_Output->mTrakingPara_Output.prmTSkyDet.nDSmpScale;
        pGlb_Output->sky_TrkMemFrm = pSky_Output->ObjectStatusDesc.unContiLostCnt;
        pGlb_Output->sky_nObjTypeSrc = pSky_Output->ObjectStatusDesc.nObjTypeSrc;
        pGlb_Output->sky_nTrkCX = pSky_Output->ObjectStatusDesc.ptPos.x;
        pGlb_Output->sky_nTrkCY = pSky_Output->ObjectStatusDesc.ptPos.y;
        pGlb_Output->sky_nTrkW = pSky_Output->ObjectStatusDesc.sfSize.w;
        pGlb_Output->sky_nTrkH = pSky_Output->ObjectStatusDesc.sfSize.h;
        pGlb_Output->sky_nTrkPxlsCnt = (SINT32)pSky_Output->ObjectStatusDesc.fObjPxlsCnt;
        pGlb_Output->sky_fTrkConf = pSky_Output->ObjectStatusDesc.fConfidence;
        pGlb_Output->sky_nClassSource = pSky_Output->ObjectStatusDesc.emClsSrc;
        pGlb_Output->sky_nClsType = pSky_Output->ObjectStatusDesc.unClsType;
        pGlb_Output->sky_emFindState = pSky_Output->findState;

        pGlb_Output->sky_bComplexEnv = pSky_Output->m_bComplexEnv;
        pGlb_Output->sky_bInterferenceMem = pSky_Output->m_bInterferenceMem;
        pGlb_Output->sky_bSimIntercept = pSky_Output->m_bSimInflunce;
        pGlb_Output->sky_emTUFlag = pTracker->emTUFlag;

        info->nOccAIDStatus = pTracker->pSkyTracker->Ai_DMonitor->m_ubLostStatus;
        info->nArrestAIDStatus = pTracker->pSkyTracker->Ai_DMonitor->m_ubArrestStatus;
        info->nAIDBestId = nMainAIObj->nTrackId;
        info->nAIDLostCnt = nMainAIObj->unContiLostCnt;
        info->unContiTrackedCnt = nMainAIObj->unContiTrackedCnt;
        info->nArrestNum = masterMonitor->nTargetNum;
        info->nAIDJamCnt = nMainAIObj->nJamCnt;
    }
    else if (pTracker != NULL && pTracker->pAitTracker)
    {
        //info->AiNano_out = pTracker->pAitTracker->m_Ai_TkOut.stNanoTrack_out;
        //memcpy(info->responeMap, pTracker->pAitTracker->responeMap, sizeof(unsigned char) * 127 * 127);
    }
}

GLB_OUTPUT ARIDLL_Export_GLB_OUTPUT(ArithHandle hArithSrc)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;
    return pArith->g_GLB_stOutput;
}

PIPE* ARIDLL_ExportPipeArrayPtr(ArithHandle hArithSrc)
{
    // 获取算法指针
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    return pArith->g_GLB_PipeProc->getPipeArray();
}


RECT32S TLD_GetBestNNRect(ArithHandle hArithSrc, int pipeID)
{
    RECT32S res = {0};
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;
    if (NULL == pArith->g_GLB_Trackers[pipeID] || NULL == pArith->g_GLB_Trackers[pipeID]->pGroundTracker)
    {
        return res;
    }
    return pArith->g_GLB_Trackers[pipeID]->pGroundTracker->m_pTLDTracker->TLD_GetBestNNRect();
}

RECT16S* ARIDLL_AID_GetObservInfo(ArithHandle hArithSrc, int pipeID, int& num)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;
    if (NULL == pArith->g_GLB_Trackers[pipeID])
    {
        return NULL;
    }
    if (pArith->g_GLB_Trackers[pipeID]->pGroundTracker)
    {
        num = pArith->g_GLB_Trackers[pipeID]->pGroundTracker->Ai_DMonitor->masterPipeMonitor.nNeighborCnt;
        return &pArith->g_GLB_Trackers[pipeID]->pGroundTracker->Ai_DMonitor->ObservRect;
    }
    else if (pArith->g_GLB_Trackers[pipeID]->pSkyTracker)
    {
        num = pArith->g_GLB_Trackers[pipeID]->pSkyTracker->Ai_DMonitor->masterPipeMonitor.nNeighborCnt;
        return &pArith->g_GLB_Trackers[pipeID]->pSkyTracker->Ai_DMonitor->ObservRect;
    }
    
    return NULL;
}

RECT16S* ARIDLL_AID_GetRecapRect(ArithHandle hArithSrc, int pipeID)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;
    if (NULL == pArith->g_GLB_Trackers[pipeID])
    {
        return NULL;
    }
    if (pArith->g_GLB_Trackers[pipeID]->pGroundTracker)
    {
        return &pArith->g_GLB_Trackers[pipeID]->pGroundTracker->Ai_DMonitor->RecapRect;
    }
    else if (pArith->g_GLB_Trackers[pipeID]->pSkyTracker)
    {
        return &pArith->g_GLB_Trackers[pipeID]->pSkyTracker->Ai_DMonitor->RecapRect;
    }
    return NULL;
}

POINT32F ARIDLL_GetImagePosFromStablePole(ArithHandle hArithSrc,ANGLE32F agl)
{
    POINT32S pOut = { 0 };
    // 获取算法指针
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    Pole p = { 0};
    p.alpha = agl.fPt;
    p.beta = agl.fAz;
    POINT32F imgPos = getImagePosFromStablePole(p, pArith->g_GLB_stInput.stCamera, pArith->g_GLB_stInput.servoInfo, pArith->g_GLB_stInput.afPlatformRPY, pArith->g_GLB_stInput.setupErr);

    return imgPos;
}

ANGLE32F ARIDLL_GetStablePoleFromImagePos(ArithHandle hArithSrc, POINT32F fImagePos)
{
    // 获取算法指针
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    Pole pole = getStablePoleFromImagePos(fImagePos, pArith->g_GLB_stInput.stCamera, pArith->g_GLB_stInput.servoInfo, pArith->g_GLB_stInput.afPlatformRPY, pArith->g_GLB_stInput.setupErr);

    ANGLE32F stablePole = { 0 };
    stablePole.fAz = (FLOAT32)pole.beta;
    stablePole.fPt = (FLOAT32)pole.alpha;
    return stablePole;
}


POINT16S* ARIDLL_GetSATracker_DSTPoint(ArithHandle hArithSrc, int pipeID)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    if (pArith->g_GLB_Trackers[pipeID] == NULL)
    {
        return NULL;
    }
    return pArith->g_GLB_Trackers[pipeID]->pSkyTracker->GetDST_MaxPoint_Sky();
}


TARGET_OBJECT* ARIDLL_GetTrackerTarget(ArithHandle hArithSrc,int pipeID, int& num)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    if (pArith->g_GLB_Trackers[pipeID] == NULL || pArith->g_GLB_Trackers[pipeID]->m_type == GLB_SCEN_GROUND)
    {
        num = 0;
        return NULL;
    }

    return pArith->g_GLB_Trackers[pipeID]->pSkyTracker->getTrackerSATargetList(num);
}

DAT_PARAMETERS* ARIDLL_GetTrkDAT_stPara(ArithHandle hArithSrc, int pipeID)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    if (pArith->g_GLB_Trackers[pipeID] == NULL || pArith->g_GLB_Trackers[pipeID]->m_type == GLB_SCEN_GROUND)
    {
        return NULL;
    }
    return pArith->g_GLB_Trackers[pipeID]->pSkyTracker->pSATracker->pDAT_Module->GetDatParm();
}

DAT_PARAMETERS* ARIDLL_GetDAT_stPara(ArithHandle hArithSrc)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;
    if (NULL == pArith->g_GLB_Detectors || NULL == pArith->g_GLB_Detectors->pDAT_Module)
    {
        return NULL;
    }
    return pArith->g_GLB_Detectors->pDAT_Module->GetDatParm();
}

DAT_OUTPUT* ARIDLL_GetDAT_stOutput(ArithHandle hArithSrc)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;
    if (NULL == pArith->g_GLB_Detectors || NULL == pArith->g_GLB_Detectors->pDAT_Module)
    {
        return NULL;
    }
    return pArith->g_GLB_Detectors->pDAT_Module->getDAT_stOutput();
}

TARGET_OBJECT* ARIDLL_GetFullSATarget(ArithHandle hArithSrc, int& SANum)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    SANum = pArith->g_GLB_Detectors->m_FrmObjsCnt;
    TARGET_OBJECT* pFrameTargetArray = pArith->g_GLB_Detectors->GetTargetArray();
    return pFrameTargetArray;
}



DAT_OUTPUT* ARIDLL_GetTrkDAT_stOutput(ArithHandle hArithSrc, int pipeID)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    if (pArith->g_GLB_Trackers[pipeID] == NULL || pArith->g_GLB_Trackers[pipeID]->m_type == GLB_SCEN_GROUND)
    {
        return NULL;
    }
    return pArith->g_GLB_Trackers[pipeID]->pSkyTracker->pSATracker->pDAT_Module->getDAT_stOutput();
}

DBG_TRACKER_API int ARIDLL_GetSkyLineY(ArithHandle hArithSrc)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    auto input = &pArith->g_GLB_stInput;

    if (pArith->g_GLB_stPara.bFiteredAlarm)
    {
        Pole skyPole = { 0 };
        skyPole.alpha = pArith->g_GLB_stPara.fFilterPt;
        skyPole.beta = input->servoInfo.fAz;  //这个车基本是平的，不然需要找到当前视场方位角

        POINT32F Skypos = getImagePosFromStablePole(skyPole, input->stCamera, input->servoInfo, input->afPlatformRPY, input->setupErr);

        return Skypos.y;
    }

    return -1;
}


FilterMeanNL* ARIDLL_GetTrackerHistInfo(ArithHandle hArithSrc, int pipeID)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;
    PIPE* pPipe = &pArith->g_GLB_PipeProc->getPipeArray()[pipeID];
    if (pPipe->bOccupy)
    {
        return &pPipe->stMotionMod_mean;
    }

    return nullptr;
}

POINT16S * ARIDLL_GetMaxPoint(ArithHandle hArithSrc)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;
    return pArith->g_GLB_Detectors->GetDST_MaxPoint();
}

TargetGuideInner* ARIDLL_GetTargetGuide(ArithHandle hArithSrc)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;
    return pArith->g_GLB_stPara.targetGuide;
}

GLB_SCEN_MODE ARIDLL_ExportSceneMode(ArithHandle hArithSrc)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;
    return pArith->m_SceneType;
}


GLB_SCEN_MODE ARIDLL_ExportTrkSceneMode(ArithHandle hArithSrc, int pipeID)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;
    if (NULL == pArith->g_GLB_Trackers[pipeID])
    {
        return GLB_SCEN_NONE;
    }
    return pArith->g_GLB_Trackers[pipeID]->m_type;
}



ALARM_TARGET* ARIDLL_GetAlarmArray(ArithHandle hArithSrc)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    return pArith->g_GLB_PipeProc->PIPE_GetAlarmTarget();
}


BBOOL* ARIDLL_GetIDArray(ArithHandle hArithSrc)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    return pArith->g_GLB_PipeProc->PIPE_GetAlarmIDArray();
}


//获取背景监控信息
void getBKMInform(ArithHandle hArithSrc, int pipeID, FLOAT32* pdObj8BkgStdArray, BBOOL* pbObj8BkgStatus, UBYTE8* ubBkgIndex,
    BBOOL* bComplexEnv, BBOOL* bInterferenceMem, UBYTE8* bInfrnDirection, MINMAXRECT32S *mrnBkgBlks)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    if (pArith->g_GLB_Trackers[pipeID] == NULL || pArith->g_GLB_Trackers[pipeID]->m_type == GLB_SCEN_GROUND)
    {
        return;
    }
    BkgMonitor* pBkgMonitor = pArith->g_GLB_Trackers[pipeID]->pSkyTracker->pBkgMonitor;
    if (NULL != mrnBkgBlks)
    {
        memcpy(mrnBkgBlks, pBkgMonitor->mrnBkgBlks, sizeof(MINMAXRECT32S) * 8);
    }
    if (NULL != pdObj8BkgStdArray)
    {
        memcpy(pdObj8BkgStdArray, pBkgMonitor->DSP_GLB_Obj8BkgStdArray, sizeof(FLOAT32) * GLB_OBJ_BKG_FRM_NUM * GLB_OBJ_BKG_NUM);
    }
    if (NULL != pbObj8BkgStatus)
    {
        memcpy(pbObj8BkgStatus, pBkgMonitor->g_GLB_bObj8BkgStatus, sizeof(BBOOL) * GLB_OBJ_BKG_NUM);
    }
    
    *ubBkgIndex = pBkgMonitor->g_GLB_nObj8BkgArrayIndex;
    *bComplexEnv = pBkgMonitor->g_GLB_bComplexEnv;
    *bInterferenceMem = pBkgMonitor->g_GLB_bInterferenceMem;
    *bInfrnDirection = pBkgMonitor->g_GLB_bInfrnDirection;
}


TSky_Output * GetSkyTrackerObjectStatus(ArithHandle hArithSrc, int pipeID)
{

    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    if (pArith->g_GLB_Trackers[pipeID] == NULL || pArith->g_GLB_Trackers[pipeID]->m_type != GLB_SCEN_SKY)
    {
        return NULL;
    }
    Tracker_Ptr pTracker = pArith->g_GLB_Trackers[pipeID];
    return &pTracker->pSkyTracker->m_TSky_Output;
}

Param_SkyTracker* GetSkyTrackerParam(ArithHandle hArithSrc, int pipeID)
{
    Arith_EOController* pArith = (Arith_EOController*)hArithSrc;

    if (pArith->g_GLB_Trackers[pipeID] == NULL || pArith->g_GLB_Trackers[pipeID]->m_type != GLB_SCEN_SKY)
    {
        return NULL;
    }
    Tracker_Ptr pTracker = pArith->g_GLB_Trackers[pipeID];

    return &pTracker->pSkyTracker->m_TSky_Output.mTrakingPara_Output;
}