#include "AnaProcess.h"

using namespace std;
using namespace iot_service;
using namespace iot_idl;
using namespace iot_public;
using namespace iot_dbms;

CAnaProcess::CAnaProcess(iot_public::SRunAppInfo stRunAppInfo,
                         CDataProcessApiPtr ptrDataProcApi,\
                         CSrvDataPublishPtr ptrDataPublish)
{
    m_lCurTime = 0;
    m_strSourceTagLocal = "";
    m_strSrcTagRecv = "";
    m_strSourceTag = "";
    m_ptrLimitProcess = nullptr;

    m_stSysInfo.nAppNo = stRunAppInfo.nAppId;
    m_stSysInfo.bIsCommApp = false;
    m_stRunAppInfo = stRunAppInfo ;

    m_ptrDataProcApi = ptrDataProcApi;
    m_ptrDataPublish = ptrDataPublish;
}

CAnaProcess::~CAnaProcess()
{
}

bool CAnaProcess::initialize()
{
    m_mapDelayLimitType.clear();

    //初始化模拟量越线处理-先不考虑累计量越限
    //=============================================================================================
    m_ptrLimitProcess =  boost::make_shared<CLimitProcess>(m_stRunAppInfo,m_ptrDataProcApi,\
                                    m_ptrDataPublish);
    if (m_ptrLimitProcess == NULL)
    {
        LOGERROR("CAnaProcess::initialize(),  make_shared<CLimitProcess> fail!\n");
        return false;
    }
    if(m_ptrLimitProcess->initialize() == false)
    {
        LOGERROR("CAnaProcess::initialize(),  initialize CLimitProcess fail!\n");
        return false;
    }

    return CPointBase::initialize();
}

//初始化参数
int CAnaProcess::initPara()
{
    m_lCurTime = getUTCTimeMsec() ;
    //LOGDEBUG("CAnaProcess::initPara(), m_ulCurTime = %ul", m_ulCurTime);

    return true;
}

/**
@brief  变化模拟量的处理，处理入口函数；
@param  const SFesUpdatePiPkg &stChgAnaPkg：数据包结构
@return 无
@retval
*/
int CAnaProcess::procAnaChange(const SFesChangeAiPkg &stChgAnaPkg)
{
    initPara();

    int nChangeNum = 0;
    int nLoop = 0;
    int nRetCode = 0;
	int nTmpStatus = 0;

    SNewValueStatus stNewValueStatus;
    SOldValueStatus stOldValueStatus;

    SChangeAiData   stOneAiLimit;

    m_strSrcTagRecv = stChgAnaPkg.sthead().strfessource();
    m_strSourceTag  = m_strSrcTagRecv ;
    m_strSourceTag +=":";
    m_strSourceTag +=m_strSourceTagLocal;
    m_strSourceTag +=":AiChange";

    m_stSysInfo.strSrcTagRecv = m_strSrcTagRecv;
    m_stSysInfo.strSourceTag = m_strSourceTag;

    nChangeNum = stChgAnaPkg.staidata_size();

    if(nChangeNum>0)
    {
        LOGDEBUG("procAnaChange:收到变化数据报文,数目[%d],时间[%" PRId64 "].",nChangeNum,(int64)stChgAnaPkg.staidata(0).ultime());
    }

    for (nLoop = 0; nLoop < nChangeNum; ++nLoop)
    {
        initChangeAnaInfo(); //Clear stOneAiLimit;

        SFesAiDataWithTm objAiData =  stChgAnaPkg.staidata().Get(nLoop);

        m_stChangeAiInfo.strTableName   = objAiData.strapptablename();
        m_stChangeAiInfo.strColumnName  = objAiData.strappcolumnname();
        m_stChangeAiInfo.strPointName   = objAiData.strapptagname();

        stOneAiLimit.strTableName     = objAiData.strapptablename();
        stOneAiLimit.strColumnName    = objAiData.strappcolumnname();
        stOneAiLimit.strPointName     = objAiData.strapptagname();
        stOneAiLimit.lTime            = objAiData.ultime();
        stOneAiLimit.dValue           = objAiData.fvalue();

        //1.根据前置送来点值和状态；判断收到的数据和状态是否有效
        //====================================================================================
		nTmpStatus = 0xffff & objAiData.ustatus();
		m_ptrDataProcApi->changeAnaStatusRawToRipe(stOneAiLimit.uStatus, nTmpStatus);

        /*
        if (stOneAiLimit.uStatus & (1 <<(m_mapAiState["MENU_STATE_AI_NOT_CHANGE"]))) //变化报文不应该包含不刷新
        {
            LOGINFO("::aiChange, stOneAiLimit.strPointName = %s, value=%d,second=%d,msecond=%d, include of  MENU_STATE_AI_NOT_CHANGE!",
                       stOneAiLimit.strPointName.c_str(), stOneAiLimit.dValue, stOneAiLimit.ulTime, stOneAiLimit.ulTime);
        }
        stOneAiLimit.uStatus &= ~(1 << (m_mapAiState["MENU_STATE_AI_NOT_CHANGE"] ));//清掉不刷新

        if (stOneAiLimit.uStatus & (1 <<(m_mapAiState["MENU_STATE_AI_GK_OFF"] ))) //变化报文不应该包含工况退出
        {
            LOGINFO("::aiChange, stOneAiLimit.strPointName = %s, value=%d,msecond=%d, include of  MENU_STATE_AI_GK_OFF!",
                       stOneAiLimit.strPointName.c_str(), stOneAiLimit.dValue,  stOneAiLimit.ulTime);

        }
        stOneAiLimit.uStatus &= ~(1 << (m_mapAiState["MENU_STATE_AI_GK_OFF"]));//清掉工况退出
        */

        if (stOneAiLimit.uStatus ==0)//清掉工况退出和不刷新后，如果为0，则添加个正常状态add_status(procOneAi.uStatus)
        {
            stOneAiLimit.uStatus = 1 << (m_mapAiState["MENU_STATE_AI_NORMAL"]);
        }

        //LOGDEBUG("CAnaProcess::aiChange, point_name= %s, value = %f, status = %d, times = %lld, source_tag = %s",
        //           stOneAiLimit.strPointName.c_str(), stOneAiLimit.dValue, stOneAiLimit.uStatus, stOneAiLimit.ulTime, m_strSrcTagRecv.c_str());

        initAnaValueStatus(stOldValueStatus, stNewValueStatus);

        nRetCode = procOneAnaChange(stOneAiLimit,stNewValueStatus,stOldValueStatus,CHANGE_TYPE);
        if (nRetCode < 0)
        {
            LOGWARN("CAnaProcess::procAnaChange,  tableName = %s, tagName=%s procOneAnaChange error!",
                       stOneAiLimit.strTableName.c_str(), stOneAiLimit.strPointName.c_str());
            continue;
        }

        //AO CONTROL 表
        //=============================================================================================

    } //end for

    return 1;
}


/**
@brief  处理前置数据，遥测系数处理 基码+前置值*系数
@param
@return 无
@retval
*/
int CAnaProcess:: dealFertValue(SChangeAiData &stOneAiLimit)
{
    //<< 后台系数处理
    //============================================================================================
    string strKeyIdTag = RT_ANA_TBL;
    strKeyIdTag += ".";
    strKeyIdTag += stOneAiLimit.strPointName;
    strKeyIdTag.resize(128);
    int nIndex = m_ptrRdbTableMng->searchRecordByKey(RT_ANA_MAP_TO_FES,strKeyIdTag.c_str());
    if( nIndex >=0 )
    {
        SAnaMapToFes* pAnaMaptoFes = (SAnaMapToFes*)m_ptrRdbTableMng->getRecordAllColumnByIndex(RT_ANA_MAP_TO_FES,nIndex);
        if(pAnaMaptoFes)
        {
            stOneAiLimit.dValue = pAnaMaptoFes->base + (stOneAiLimit.dValue * pAnaMaptoFes->coeff); //基码+前置值*系数
        }
        else
        {
            LOGDEBUG("dealFertValue, PointName = %s 获取测点内存地址失败 !",stOneAiLimit.strPointName.c_str());
            return -1;
        }
    }
    else
    {
        LOGDEBUG("dealFertValue, PointName = %s 获取测点前置参数失败 !",stOneAiLimit.strPointName.c_str());
        return -1;
    }
    return 1;
}


/**
@brief  处理One PI变化量，处理入口函数；
@param  SChangeAiData &stChangeAnaData,      变化数据/全数据<-fes
        SAnaNewValueStatus stNewValueStatus, 新值 计算服务/fbd_server
        SAnaOldValueStatus stOldValueStatus, 老值 <-rdb
        const  int nChangeType
@return 无
@retval
*/
int CAnaProcess::procOneAnaChange(SChangeAiData &stOneAiLimit,SNewValueStatus stNewValueStatus,\
                                  SOldValueStatus stOldValueStatus,const  int nChangeType,const bool bInit)
{
    int nRetCode = 0;

    if (!strcmp(stOneAiLimit.strTableName.c_str(), RT_ANA_TBL)) //AI点
    {
        SAnaPointAll  stAiPoint;

        //获取测点全信息参数；
        //=============================================================================================================
        string strKeyTagName = stOneAiLimit.strPointName;
        strKeyTagName.resize(64);
        nRetCode = m_ptrRdbTableMng->getRecordAllColumnByKey(RT_ANA_TBL,strKeyTagName.c_str() ,stAiPoint);
        if (nRetCode <=0)
        {
            LOGERROR("CAnaProcess::procOneAnaChange, nRetCode = %d, appNo = %d, tableName = %s, getRecordAllColumnByKey\
                        (key_tag_name=%s) error!", nRetCode, m_stRunAppInfo.nAppId,
                     stOneAiLimit.strTableName.c_str(), stOneAiLimit.strPointName.c_str());
            return -1;
        }

        //<< 处理前置数据，遥测系数处理 基码+前置值*系数
        //=============================================================================================================
        if(dealFertValue(stOneAiLimit)<0)//处理前置数据，遥测系数处理 基码+前置值*系数
        {
            LOGERROR("CAnaProcess::procOneAnaChange,  tag_name = %s, dealFertValue error!", stOneAiLimit.strPointName.c_str());
            return -1;
        }

        //从RDB获得上一次的值
        stOldValueStatus.oldvalue  = stAiPoint.value;
        stOldValueStatus.oldstatus = stAiPoint.status;
        m_stChangeAiInfo.dValue  = stOldValueStatus.oldvalue;
        m_stChangeAiInfo.uStatus = stOldValueStatus.oldstatus;

        stOneAiLimit.nLocation  = stAiPoint.location_id;
        stOneAiLimit.nSubSystem = stAiPoint.sub_system;

        UTagValue  unSetValue;
        unSetValue.dValue = stOneAiLimit.dValue ;//

        //变化数据/全数据+计算点->return；
        if(((stAiPoint.point_property & (1<<0)) == 1) &&
                (UPDATE_TYPE == nChangeType || CHANGE_TYPE == nChangeType) ) //计算点&前置数据（变化+全数据）
        {
            LOGDEBUG("procOneAnaChange::计算点[%s],nChangeType=%d return 1",stAiPoint.tag_name,nChangeType);
            return 1;
        }
        //LOGDEBUG("CAnaProcess::procOneAnaChange, table_name=%s,point_name = %s, value = %f, status = %d, msecond = %lld,
        //            oldValue = %f, oldStatus = %d,point_class = %d,source_tag = %s",
        //           stOneAiLimit.strTableName.c_str(), stOneAiLimit.strPointName.c_str() , stOneAiLimit.dValue, stOneAiLimit.uStatus,
        //           stOneAiLimit.ulTime,  stOldValueStatus.oldvalue,stOldValueStatus.oldstatus, stAiPoint.point_class, m_strSrcTagRecv.c_str());

        //< 变化数据，全数据,fes
        //=============================================================================================================
        if(UPDATE_TYPE == nChangeType || CHANGE_TYPE == nChangeType )
        {
            //禁止刷新/人工置数-> 保存旧的值；同时返回
            nRetCode = checkTagStatus(stAiPoint.tag_name,stOldValueStatus.oldstatus,
                                      unSetValue,stAiPoint.last_change_time, POINT_TYPE_ANA);
            if (nRetCode == false)
            {
                LOGDEBUG( "CAnaProcess::procOneAnaChange, nRetCode = %d, point_name = %s, value = %f, status = %d,  time = [%" PRId64 "],\
                             oldStatus = %d, checkOldStatus return false! source_tag = %s",
                           nRetCode, stOneAiLimit.strPointName.c_str(), stOneAiLimit.dValue, stOneAiLimit.uStatus,
                            stOneAiLimit.lTime, stOldValueStatus.oldstatus, m_strSrcTagRecv.c_str());
                return 1;
            }
            stNewValueStatus.newvalue = stOneAiLimit.dValue;
            stNewValueStatus.addstatus = stOneAiLimit.uStatus;
            stNewValueStatus.delstatus = 0 ;
        }
        //< 计算服务计算点处理,fbd_server
        //=============================================================================================================
        else if(OPT_TYPE_CAL_SET == nChangeType)
        {
            if((stAiPoint.point_property & (1<<0)) == 0) //采集点
            {
                LOGDEBUG("processOperate::操作错误，对采集点[%s]人工置数，请检查配置！",stAiPoint.tag_name);
                return 1;
            }
            //禁止刷新/人工置数-> 保存旧的值；同时返回
            nRetCode = checkTagStatus(stAiPoint.tag_name,stOldValueStatus.oldstatus,
                                      unSetValue,stAiPoint.last_change_time, POINT_TYPE_ANA);
            if (nRetCode == false)
            {
                LOGDEBUG( "CAnaProcess::procOneAnaChange, nRetCode = %d, point_name = %s, value = %f, status = %d,  time = [%" PRId64 "],\
                             oldStatus = %d, checkOldStatus return false! source_tag = %s",
                           nRetCode, stOneAiLimit.strPointName.c_str(), stOneAiLimit.dValue, stOneAiLimit.uStatus,
                            stOneAiLimit.lTime, stOldValueStatus.oldstatus, m_strSrcTagRecv.c_str());
                return 1;
            }
        }
        //< 人工操作-标签操作,operate_server
        //=============================================================================================================
        else if(OPERATE_TYPE == nChangeType) //人工操作-标签操作
        {
            STagStatusValue stTagInfo ; //获得测点原先的值和状态
            stTagInfo.strTagName = stAiPoint.tag_name;
            stTagInfo.lTimes = stAiPoint.last_change_time;
            stTagInfo.unValue.dValue = stAiPoint.value ;
            stTagInfo.nStatus = stAiPoint.status;

            //如果禁止刷新，保存标签数据 ；否则，还原标签数据
            if(procTagOperate(stNewValueStatus.addstatus ,stNewValueStatus.delstatus,
                              unSetValue,stTagInfo,POINT_TYPE_ANA)== false)
            {
                LOGERROR("CAnaProcess::procOneAnaChange,procTagOperate Error tagname=%s ",stAiPoint.tag_name);
            }
            stNewValueStatus.newvalue = stTagInfo.unValue.dValue ;
        }

        //得到新状态stNewValueStatus，更新 变化时间到RDB ;更新成员m_stChangeAiInfo 状态+值
        //=============================================================================================================
        nRetCode = writeAnaRtdb(stOneAiLimit.strPointName, stOldValueStatus, stNewValueStatus, m_lCurTime,nChangeType);
        if (nRetCode < 0)
        {
            LOGWARN("CAnaProcess::procOneAnaChange, nRetCode = %d, point_name= %s, value = %f, addstatus = %d, msecond = [%" PRId64 "], \
                        oldValue = %f, oldStatus = %d, occTime = [%" PRId64 "], writeAnaRtdb error! ",
                       nRetCode, stOneAiLimit.strPointName.c_str(), stNewValueStatus.newvalue, stNewValueStatus.addstatus,
                       stOneAiLimit.lTime, stOldValueStatus.oldvalue,stOldValueStatus.oldstatus, m_lCurTime);
            return -1;
        }
        stOneAiLimit.uStatus = stNewValueStatus.newstatus;

        //2.点值发生变化，调用越限动态库做越限判断,遥测越线要判断状态OK
        //=============================================================================================================
        bool bAlarmDisable = checkAlarmDisable(stNewValueStatus.newstatus ,POINT_TYPE_ANA,false) ;
        if (m_stChangeAiInfo.bIfNeedLimit && (bInit == false) && stAiPoint.is_limit)//现在改为只有值变化才做做越线处理
        {
            int nRetProcss = 0;
            nRetProcss = m_ptrLimitProcess->limitProcess(stOneAiLimit, m_mapDelayLimitType, m_stChangeAiInfo,\
                                             m_stSysInfo, bAlarmDisable); //处理原来AI_LIMIT越限
            if (nRetProcss < 0)
            {
                LOGWARN("CAnaProcess::procOneAnaChange, ret_process = %d, key_id= %s, value = %f, status = %d, \
                            msecond = [%" PRId64 "],  oldValue = %f, oldStatus = %d, m_ulCurTime = [%" PRId64 "], limitProcess error! ",
                           nRetProcss, stOneAiLimit.strPointName.c_str(), stOneAiLimit.dValue, stOneAiLimit.uStatus,
                           stOneAiLimit.lTime,  stOldValueStatus.oldvalue,
                           stOldValueStatus.oldstatus, m_lCurTime);
            }//限值出错时候，只写AICHANGE变化的VALUE OR STATUS
        }

        //3.根据最新的点值变化以及状态信息更新实时库值变化才作最做最后的更新状态和实时值
        //=============================================================================================================
        if (m_stChangeAiInfo.bIfProcess)
        {
            m_stChangeAiInfo.bIfProcess = false;
            int nRet = 0;
            nRet = writeRdbAndSendMsg(stOneAiLimit, nChangeType); //将产生变化的点组包变化报文
            if (nRet < 0)
            {
                LOGWARN("CAnaProcess::procOneAnaChange, ret = %d, point_name= %s, value = %f, status = %d,  \
                        msecond = [%" PRId64 "], m_ulCurTime = [%" PRId64 "], writeRdbAndSendMsg error! source_tag = %s",
                        nRet, stOneAiLimit.strPointName.c_str(), stOneAiLimit.dValue, stOneAiLimit.uStatus,
                        stOneAiLimit.lTime, m_lCurTime, m_strSrcTagRecv.c_str());
                return -1;
            }
        }
    }
    else  //NOT FOUND POINT TYPE
    {
        LOGWARN("aichange, tablename[%s] is not analog  error! ",stOneAiLimit.strTableName.c_str());
        return -1;
    }

    return 1;
}
/**
@brief  处理全数据模拟量，处理入口函数；
@param  const SFesUpdatePiPkg &stUpPiPkg：数据包结构
@return 无
@retval
*/
int CAnaProcess::procAnaUpdate(const SFesUpdateAiPkg &stUpAnaPkg)
{
    initPara();

    int     nUpdateNum = 0;
    int     nLoop = 0;
    int     nRetCode = 0;
    int     nTmpStatus = 0;

    SChangeAiData  stOneAiLimit;
    SNewValueStatus stNewValueStatus;
    SOldValueStatus stOldValueStatus;

    m_strSrcTagRecv = stUpAnaPkg.sthead().strfessource();
    m_strSourceTag  = m_strSrcTagRecv ;
    m_strSourceTag +=":";
    m_strSourceTag +=m_strSourceTagLocal;
    m_strSourceTag +=":optLockData";

    m_stSysInfo.strSrcTagRecv = m_strSrcTagRecv;
    m_stSysInfo.strSourceTag = m_strSourceTag;

    nUpdateNum = stUpAnaPkg.staidata_size();

    LOGDEBUG("procAnaUpdate:收到全数据报文,数目[%d],时间[%" PRId64 "].",nUpdateNum,(int64)stUpAnaPkg.ultime());

    for (nLoop = 0; nLoop < nUpdateNum; ++nLoop)
    {
        initChangeAnaInfo();

        m_stChangeAiInfo.strTableName  = stUpAnaPkg.staidata(nLoop).strapptablename();
        m_stChangeAiInfo.strPointName  = stUpAnaPkg.staidata(nLoop).strapptagname(); //点名
        m_stChangeAiInfo.strColumnName = stUpAnaPkg.staidata(nLoop).strappcolumnname(); //列名

        stOneAiLimit.strTableName  = stUpAnaPkg.staidata(nLoop).strapptablename(); //表名
        stOneAiLimit.strPointName  = stUpAnaPkg.staidata(nLoop).strapptagname(); //点名
        stOneAiLimit.strColumnName = stUpAnaPkg.staidata(nLoop).strappcolumnname(); //列名

        stOneAiLimit.dValue = stUpAnaPkg.staidata(nLoop).fvalue();
        stOneAiLimit.lTime = m_lCurTime;

        nTmpStatus = 0xffff & stUpAnaPkg.staidata(nLoop).ustatus();
        m_ptrDataProcApi->changeAnaStatusRawToRipe(stOneAiLimit.uStatus, nTmpStatus);

        //LOGDEBUG("CAnaProcess::procAnaUpdate,tablename=%s,tag_name=%s,colum_name=%s,
        //            value=%f,nTmpStatus =%d,stOneAiLimit.uStatus=%d,sec=%d,msec=%d ",
        //           stOneAiLimit.strTableName.c_str(), stOneAiLimit.strPointName.c_str(), stOneAiLimit.strColumnName.c_str(),
        //           stOneAiLimit.dValue, nTmpStatus, stOneAiLimit.uStatus, stOneAiLimit.ulTime/1000,
        //           stOneAiLimit.ulTime%1000);

        if (stOneAiLimit.uStatus == 0)
        {
            stOneAiLimit.uStatus = 1 << (m_mapAiState["MENU_STATE_AI_NORMAL"]);
        }

        //LOGDEBUG("CAnaProcess::aiUpdate,table_name = %s, point_name = %s,column_name = %s, value = %f, status = %d, source_tag = %s",
        //           stOneAiLimit.strTableName.c_str(), stOneAiLimit.strPointName.c_str(), stOneAiLimit.strColumnName.c_str(),
        //           stOneAiLimit.dValue, stOneAiLimit.uStatus, m_strSrcTagRecv.c_str());

        initAnaValueStatus(stOldValueStatus, stNewValueStatus);

        nRetCode = procOneAnaChange(stOneAiLimit,stNewValueStatus,stOldValueStatus,UPDATE_TYPE);
        if (nRetCode < 0)
        {
            LOGWARN("CAnaProcess::procAnaChange,  tableName = %s, tagName=%s procOneAnaChange error!",
                       stOneAiLimit.strTableName.c_str(), stOneAiLimit.strPointName.c_str());
            continue;
        }
    }//endfor

    return 1;

}

/**
@brief  判断模拟量是否有置数 禁止刷新等，有跳过不处理
@param  const SChangeAiData &stOneAiLimit 变化AI量结构
        float newValue：值
        int newStatus：新状态
        int domain ：
@return 无
@retval
*/
bool CAnaProcess::checkNewValue(const double &/*fNewValue*/)
{

    //LOGDEBUG("checkNewValue, fNewValue = %f !", fNewValue);

    return true;
}


/**
@brief  更新模拟量实时库的值、状态、时间
@param
@return 无
@retval
*/
int CAnaProcess:: writeAnaRtdb(const string &strPointName, SOldValueStatus &stOldValueStatus,
                            SNewValueStatus &stNewValueStatus, int64 &occurTime, char updateType)
{
    int nRetCode = 0;
    int nOriType = STATUS_ORI_RECV ;
    string strKeyTagName = strPointName;
    strKeyTagName.resize(64);

    //LOGDEBUG("CAnaProcess::writeAnaRtdb, tag_name = %s, newValue = %lf, addStatus = %d,oldvalue=%lf,oldStatus = %d, occurTime = %lld, updateType = %d",
    //           strKeyTagName.c_str(), stNewValueStatus.newvalue, stNewValueStatus.addstatus, stOldValueStatus.oldvalue,
    //           stOldValueStatus.oldstatus, occurTime, updateType);

    //更新变化数据时间
    //=======================================================================================
    if (updateType == UPDATE_TYPE) // 全数据
    {
        if ((fabs(stOldValueStatus.oldvalue - stNewValueStatus.newvalue) > EPSINON) //HAVE CHANGE, INCLUDE VALUE OR STATUS
                || (stOldValueStatus.oldstatus != stNewValueStatus.newstatus))
        {
            nRetCode = m_ptrRdbTableMng->updateRecordOneValueByKey(RT_ANA_TBL,strKeyTagName.c_str(), "last_update_time",occurTime);
            if (nRetCode == false)
            {
                LOGERROR("CAnaProcess::writeAnaRtdb, nRetCode = %d, point_name=%s, occurTime = [%" PRId64 "], 更新参数错误!",
                           nRetCode, strPointName.c_str(), occurTime);
            }
        }
    }
    else if(updateType == CHANGE_TYPE) // 变化数据
    {
        nRetCode = m_ptrRdbTableMng->updateRecordOneValueByKey(RT_ANA_TBL,strKeyTagName.c_str(), "last_change_time",occurTime);
        if (nRetCode == false)
        {
            LOGERROR("CAnaProcess::writeAnaRtdb, nRetCode = %d, point_name = %s, occurTime = [%" PRId64 "],更新参数错误!",
                       nRetCode, strPointName.c_str(), occurTime);
        }
    }
    else  // OPT置数数据
    {
        nOriType = STATUS_ORI_OPT ;
        nRetCode = m_ptrRdbTableMng->updateRecordOneValueByKey(RT_ANA_TBL,strKeyTagName.c_str(), "last_change_time",occurTime);
        if (nRetCode == false)
        {
            LOGERROR("CAnaProcess::writeAnaRtdb, nRetCode = %d, point_name = %s, occurTime = [%" PRId64 "]更新参数错误!",
                       nRetCode, strPointName.c_str(), occurTime);
        }
    }

    //根据原来status和新加入的几位进行一些与或运算得到newstatus
    //======================================================================================
    nRetCode = m_ptrDataProcApi->getNewStatus(TYPE_STATUS_AI, stNewValueStatus.newstatus,\
                                     stOldValueStatus.oldstatus, stNewValueStatus.addstatus, stNewValueStatus.delstatus, nOriType,\
                                     updateType);
    if (nRetCode < 0)
    {
        LOGINFO("CAnaProcess::writeAnaRtdb, nRetCode = %d, strPointName= %s, addStatus = %d, oldStatus = %d, new_status =%d,\
                   occurTime = [%" PRId64 "], updateType = %d, m_ptrDataProcApi->GetNewStatus error!",\
                   nRetCode, strPointName.c_str(), stNewValueStatus.addstatus, stOldValueStatus.oldstatus,
                   stNewValueStatus.newstatus, occurTime, updateType);
        return -1;
    }
    //LOGDEBUG("CAnaProcess::writeAnaRtdb:GetNewStatus newstatus = %d", stNewValueStatus.newstatus);

    //新状态工况退出只修改状态
    //======================================================================================
    if ( (stNewValueStatus.newstatus & (1 << (m_mapAiState["MENU_STATE_AI_GK_OFF"])))
            && (stNewValueStatus.newstatus != stOldValueStatus.oldstatus) )
    {
        m_stChangeAiInfo.bIfProcess = true;
        m_stChangeAiInfo.dValue = stOldValueStatus.oldvalue;
        m_stChangeAiInfo.uStatus = stNewValueStatus.newstatus;
        m_stChangeAiInfo.bIfLimitChange = false;
        LOGINFO("CAnaProcess::writeAnaRtdb  MENU_STATE_AI_GK_OFF!,ifprocess =%d,strPointName =%s,value =%f,status =%d,iflimitchange =%d",
                   m_stChangeAiInfo.bIfProcess, m_stChangeAiInfo.strPointName.c_str(), m_stChangeAiInfo.dValue, m_stChangeAiInfo.uStatus,
                   m_stChangeAiInfo.bIfLimitChange);
        return 2;
    }

    //1：值变化才作最做最后的更新状态和实时值 2：值变化后面需要做越限处理,
    //======================================================================================
    if ((fabs(stOldValueStatus.oldvalue - stNewValueStatus.newvalue) > EPSINON)
            || (stOldValueStatus.oldstatus != stNewValueStatus.newstatus))
    {
        m_stChangeAiInfo.bIfProcess = true; //值变化才作最做最后的更新状态和实时值
        m_stChangeAiInfo.dValue = stNewValueStatus.newvalue;
        m_stChangeAiInfo.uStatus = stNewValueStatus.newstatus;
        m_stChangeAiInfo.bIfLimitChange = false;
        if ((fabs(stOldValueStatus.oldvalue - stNewValueStatus.newvalue) >EPSINON))//值变化后面需要做越限处理
        {
            m_stChangeAiInfo.bIfNeedLimit = true;
        }
        //LOGDEBUG("CAnaProcess::writeAnaRtdb  value status all change,ifprocess =%d,point_id =%s,value =%f,status =%d,iflimitchange =%d",
        //           m_stChangeAiInfo.bIfProcess, m_stChangeAiInfo.strPointName.c_str(), m_stChangeAiInfo.dValue, m_stChangeAiInfo.uStatus,
        //           m_stChangeAiInfo.bIfLimitChange);
    }
    return 1;
}

/**
@brief  更新模拟量实时库的值、状态、时间//传入点表关键字
@param
@return 无
@retval
*/
/*
bool CAnaProcess::findAoCtrl(const char *strPointName, const float &curValue, const int &reportType)
{
    LOGINFO("CAnaProcess::findAoCtrl begin, strPointName = %s,curvalue =%f,reportType =%d " , strPointName, curValue,
               reportType);
    AiContralInfoStruct stAiCtrlInfo;
    std::vector<std::string>vecSelColumn ={"nRetCode","msg_type","target_value", "ctrl_tolerance","is_tagt_state"};
    int nRetCode = m_ptrRdbTableMng->getRecordSelColumnByKey(RT_ANA_CTRL_TBL, strPointName , vecSelColumn,stAiCtrlInfo);
    if (nRetCode == false)
    {
        LOGERROR( "CAnaProcess::findAoCtrl,ret_code=%d, strPointName = %s, rdb error!" , nRetCode, strPointName);
        return false;
    }
    else
    {
        if (!stAiCtrlInfo.is_tagt_state)
        {
            LOGINFO("CAnaProcess::findAoCtrl,is_tagt_state==0");
            return false;
        }
        if ((stAiCtrlInfo.ctrl_tolerance - fabs(curValue - stAiCtrlInfo.target_value)) < 0)
        {

            LOGERROR("CAnaProcess::findAoCtrl, strPointName = %s, curValue = %f, targetValue = %f, ctrl_tolerance = %f,\
                         reportType = %d, ctrl_tolerance < fabs(curValue - targetValue) error!",\
                       strPointName, curValue, stAiCtrlInfo.target_value, stAiCtrlInfo.ctrl_tolerance, reportType);

            return false;
        }

        if ((stAiCtrlInfo.msg_type == reportType))
        {
            LOGINFO( "CAnaProcess::findAoCtrl, strPointName= %s, reportType = %d, findAoCtrlNodeToShm success!",
                       strPointName, reportType);
            return true;
        }
    }
    LOGERROR("CAnaProcess::findAoCtrl, strPointName = %s, reportType = %d, findAoCtrlNodeToShm fail!",
               strPointName, reportType);

    return false;
}
*/

/**
@brief  置数、取消置数、取消禁止刷新处理,操作数据处理入口
@param  const SLockDataPkg &stTransDataPkg
@return 无
@retval
*/
int CAnaProcess::processOperate(const SOptSetDataPkg &stOptSetDataPkg,const int nOperateType)
{
    int nNum = 0;
    int nRetCode = 0;

    nNum = stOptSetDataPkg.seq_set_data_info_size();

    int64 lTimes = stOptSetDataPkg.package_head().n_opt_time();
    bool bNotAlarm = stOptSetDataPkg.package_head().b_not_alarm() ;

    for (int nLoop = 0; nLoop < nNum; nLoop++)
    {
        SChangeAiData  stChangeAnaData;
        SNewValueStatus stNewValueStatus;
        SOldValueStatus stOldValueStatus;

        SOptSetDataMsg  stOptSetData = stOptSetDataPkg.seq_set_data_info(nLoop);

        stChangeAnaData.strTableName  = RT_ANA_TBL;
        stChangeAnaData.strPointName  = stOptSetData.str_tag_name();
        stChangeAnaData.strColumnName = "value";
        stChangeAnaData.dValue        = stOptSetData.var_value().dvalue();
        stChangeAnaData.lTime         = lTimes ;

        initAnaValueStatus(stOldValueStatus, stNewValueStatus);

        stNewValueStatus.addstatus = stOptSetData.u_add_status();
        stNewValueStatus.delstatus = stOptSetData.u_del_status();
        stNewValueStatus.newvalue  = stChangeAnaData.dValue ;

        LOGDEBUG("CAnaProcess::processOperate,bInit=%d,tableName =%s,tagName=%s ,addstatus =%d,delstatus=%d,newValue=%f !",
                 bNotAlarm,stChangeAnaData.strTableName.c_str(),stChangeAnaData.strPointName.c_str(),stNewValueStatus.addstatus,\
                 stNewValueStatus.delstatus,stChangeAnaData.dValue );

        nRetCode = procOneAnaChange(stChangeAnaData,stNewValueStatus,stOldValueStatus, nOperateType,bNotAlarm);
        if (nRetCode < 0)
        {
            LOGWARN("CAnaProcess::processOperate,  tableName = %s, tagName=%s procOneAnaChange error!",
                       stChangeAnaData.strTableName.c_str(), stChangeAnaData.strPointName.c_str());
            continue;
        }
    }
    return 1;
}

/**
@brief  初始化 initChangeAnaInfo 结构体
@param  无
@return 无
@retval
*/
void CAnaProcess::initChangeAnaInfo()
{
    m_stChangeAiInfo.bIfProcess = false;
    m_stChangeAiInfo.strTableName.clear();
    m_stChangeAiInfo.strPointName.clear() ;
    m_stChangeAiInfo.strColumnName.clear();
    m_stChangeAiInfo.dValue = 0;
    m_stChangeAiInfo.uStatus = 0;
    m_stChangeAiInfo.bIfLimitChange = false;
    m_stChangeAiInfo.bIfNeedLimit = false;

    return;
}


/**
@brief  AI/PI报警延时处理
@param
@return 无
@retval
*/
int CAnaProcess::delayTimeProcess(int nDomain)
{
    int nRetCode;

    int64 lCurTime = getMonotonicMsec();
    nRetCode = m_ptrLimitProcess->delayProcess(m_mapDelayLimitType, nDomain, lCurTime);
    if (nRetCode <0 )
    {
        LOGERROR("CAnaProcess::delayTimeProcess, nRetCode = %d, delayProcess error!",nRetCode);
        return -1;
    }

    return 1;
}

/**
@brief  修改RDB，同时并通过接口addAiChange()发送变位实时消息到消息总线；
@param  stOneAiLimit: IN 需要修改的测点参数
@return 无
@retval
*/
int CAnaProcess::writeRdbAndSendMsg(const SChangeAiData &stOneAiLimit, int /*style*/)
{
    int nRetCode = -1 ;
    string strKeyTagName = stOneAiLimit.strPointName;

    //<< 后台系数处理
    /*
    //============================================================================================
    string strKeyIdTag = RT_ANA_TBL;
    strKeyIdTag += ".";
    strKeyIdTag += strKeyTagName;
    strKeyIdTag.resize(128);
    int nIndex = m_ptrRdbTableMng->searchRecordByKey(RT_ANA_MAP_TO_FES,strKeyIdTag.c_str());
    if( nIndex >=0 )
    {
        SAnaMapToFes* pAnaMaptoFes = (SAnaMapToFes*)m_ptrRdbTableMng->getRecordAllColumnByIndex(RT_ANA_MAP_TO_FES,nIndex);
        if(pAnaMaptoFes)
        {
            double dAccOldValue = m_stChangeAiInfo.dValue ;
            m_stChangeAiInfo.dValue =  pAnaMaptoFes->base + dAccOldValue * pAnaMaptoFes->coeff;
        }
    }
    else
    {
        LOGDEBUG("writeAnaRtdbAndSendMsg, PointName = %s 获取测点前置参数失败 !",stOneAiLimit.strPointName.c_str());
    }*/

    //<< 实时值写入数据库中同时发布到 HMI
    //============================================================================================
    strKeyTagName.resize(64);
    nRetCode  = m_ptrRdbTableMng->updateRecordTwoValueByKey(stOneAiLimit.strTableName,strKeyTagName.c_str(),\
                  "status",m_stChangeAiInfo.uStatus, "value", m_stChangeAiInfo.dValue);
    if (nRetCode == false)
    {
        LOGERROR("CAnaProcess::writeRdbAndSendMsg, nRetCode = %d, point_id = %s, updateRecordTwoValueByKey value and status error!",
                   nRetCode, stOneAiLimit.strPointName.c_str());
        return -3;
    }

    m_ptrDataPublish->addOneChangeFloat( stOneAiLimit.nLocation,stOneAiLimit.nSubSystem,stOneAiLimit.strTableName,stOneAiLimit.strPointName,\
                                         stOneAiLimit.strColumnName, m_stChangeAiInfo.dValue, m_stChangeAiInfo.uStatus);

    //LOGDEBUG( "CAnaProcess::writeRdbAndSendMsg,not optlock" );

    return 1;
}

/**
@brief  初始化 SOldValueStatus，SNewValueStatus，SMiOldValueStatus，SMiNewValueStatus并清空
@param  无
@return 无
@retval
*/
void CAnaProcess::initAnaValueStatus(iot_service::SOldValueStatus &stOldValueStatus,
                             iot_service::SNewValueStatus &stNewValueStatus)
{
    stOldValueStatus.oldstatus = 0;
    stOldValueStatus.oldvalue = 0;

    stNewValueStatus.addstatus = 0;
    stNewValueStatus.newstatus = 0;
    stNewValueStatus.newvalue = 0;
}