#include "pub_utility_api/TimeUtil.h"
#include "pub_logger_api/logger.h"
#include "pub_utility_api/I18N.h"
#include "service/alarm_server_api/AlarmCommonDef.h"

#include "CModuleAlarmCreater.h"
#include "CNodeAction.h"
#include "CNodeSeq.h"
#include "CNodeIterator.h"


CModuleAlarmCreater::CModuleAlarmCreater(int domainId, int appId) :
    m_objAlmApi(domainId, appId)
{
    if(!m_objAlmApi.resumeThread())
    {
        LOGERROR("事件处理启动失败");
    }

}

CModuleAlarmCreater::~CModuleAlarmCreater()
{
    if(!m_objAlmApi.suspendThread())
    {
        LOGERROR("事件处理关闭失败");
    }
}

bool CModuleAlarmCreater::seqCtrl(CNodeSeq& seq,const SHmiOpInfo& op)
{
    using namespace kbd_idlfile;

    SAppAddAlm objAlarm;

    SAlmInfoFromApp* pFromApp = objAlarm.add_alm_info();
    BOOST_ASSERT(pFromApp);

    createHead(seq, *pFromApp, kbd_service::ALM_STAT_OPT_SEQ_CTRL);
    createHmiOpKeyWord(op.eResult, *pFromApp);
    createSeqKeyWord(seq, *pFromApp);
    createActorKeyWord(op.actor, *pFromApp);

    bool bRet = m_objAlmApi.addAlarm(objAlarm);
    if (!bRet)
    {
        LOGERROR("顺控人工操作事件写入失败,顺控名:[%s]", seq.description().c_str());
    }
    afterSleep();
    return bRet;
}

bool CModuleAlarmCreater::seqCtrl(CNodeAction& action,const SOpResultUi& op)
{
    using namespace kbd_idlfile;

    SAppAddAlm objAlarm;

    SAlmInfoFromApp* pFromApp = objAlarm.add_alm_info();
    BOOST_ASSERT(pFromApp);

    createHead(action.getNodeSeq(), *pFromApp, kbd_service::ALM_STAT_OPT_SEQ_CTRL);
    createUiOpKeyWord(op.eResult, *pFromApp);
    createSeqKeyWord(action, *pFromApp);
    createActionDescKeyWord(action, *pFromApp);
    createActorKeyWord(op.actor, *pFromApp);

    bool bRet = m_objAlmApi.addAlarm(objAlarm);
    if (!bRet)
    {
        LOGERROR("顺控人工操作事件写入失败,动作名:[%s]", action.description().c_str());
    }
    afterSleep();
    return bRet;
}

bool CModuleAlarmCreater::seqStart(CNodeSeq& seq)
{
    using namespace kbd_idlfile;

    SAppAddAlm objAlarm;

    SAlmInfoFromApp* pFromApp = objAlarm.add_alm_info();
    BOOST_ASSERT(pFromApp);

    createHead(seq, *pFromApp, kbd_service::ALM_STAT_OPT_SEQ_START);
    createSeqKeyWord(seq, *pFromApp);
    createOpKeyWord(I18N("开始"), *pFromApp);
    createActorKeyWord(seq.getSeqActor(), *pFromApp);

    bool bRet = m_objAlmApi.addAlarm(objAlarm);
    if (!bRet)
    {
        LOGERROR("顺控开始事件写入失败,顺控名:[%s]", seq.description().c_str());
    }
    afterSleep();
    return bRet;
}

bool CModuleAlarmCreater::seqStop(CNodeSeq& seq)
{
    using namespace kbd_idlfile;

    SAppAddAlm objAlarm;

    SAlmInfoFromApp* pFromApp = objAlarm.add_alm_info();
    BOOST_ASSERT(pFromApp);

    createHead(seq, *pFromApp, kbd_service::ALM_STAT_OPT_SEQ_STOP);
    createSeqKeyWord(seq, *pFromApp);
    createOpKeyWord(I18N("结束"), *pFromApp);
    std::string retStr = seq.getStateStr() + " " + getExecSkipDesc(seq);
    createResultKeyWord(retStr, *pFromApp);
    createActorKeyWord(seq.getSeqActor(), *pFromApp);

    bool bRet = m_objAlmApi.addAlarm(objAlarm);
    if (!bRet)
    {
        LOGERROR("顺控结束事件写入失败,顺控名:[%s]", seq.description().c_str());
    }
    afterSleep();
    return bRet;
}

bool CModuleAlarmCreater::actionExecute(CNodeAction& action)
{
    using namespace kbd_idlfile;

    CNodeSeq& seq = action.getNodeSeq();

    SAppAddAlm objAlarm;

    SAlmInfoFromApp* pFromApp = objAlarm.add_alm_info();
    BOOST_ASSERT(pFromApp);

    createHead(seq, *pFromApp, kbd_service::ALM_STAT_OPT_SEQ_ACTION_POINT);
    createSeqKeyWord(seq, *pFromApp);
    createActionDescKeyWord(action, *pFromApp);
    createResultKeyWord(action.getStateStr(), *pFromApp);
    createActorKeyWord(seq.getSeqActor(), *pFromApp);

    bool bRet = m_objAlmApi.addAlarm(objAlarm);
    if (!bRet)
    {
        LOGERROR("顺控执行事件写入失败,顺控名:[%s],动作名[%s]",
            seq.description().c_str(), action.description().c_str());
    }
    afterSleep();
    return bRet;
}

std::string CModuleAlarmCreater::getExecSkipDesc(CNodeSeq &seq)
{
    std::string ret;
    CNodeFuncIterator iter(seq);
    while (iter.hasNext())
    {
        if(ret != "")
        {
            break;
        }

        CNodeFunc& func = iter.getNext();

        CNodeActionIterator actionIter(func);

        while (actionIter.hasNext())
        {
            CNodeAction& action = actionIter.getNext();
            if(action.getState() == SEQ_SKIP_STATUS)
            {
                ret = I18N("有部分动作跳过");
                break;
            }
        }
    }
    return ret;
}

void CModuleAlarmCreater::createHead(
    CNodeSeq& seq,
    kbd_idlfile::SAlmInfoFromApp& fromApp,
    int status)
{
    using namespace kbd_idlfile;
    fromApp.set_alm_type(kbd_service::ALM_TYPE_OPERATE);
    fromApp.set_time_stamp(kbd_public::getUTCTimeMsec());
    fromApp.set_location_id(seq.locationId());
    fromApp.set_status(status);
    fromApp.set_alm_style(enAlmStyle::AS_EVENT_ONLY);
    fromApp.set_region_id(-1);
}

void CModuleAlarmCreater::createSeqKeyWord(CNodeSeq& seq, kbd_idlfile::SAlmInfoFromApp& fromApp)
{
    using namespace kbd_idlfile;

    SAlmKeyword* pKeyword = NULL;

    pKeyword = fromApp.add_alm_keyword();
    pKeyword->set_id(kbd_service::ALM_KEY_SEQ_CTRL_NAME);
    pKeyword->set_value(seq.nodeName()); 

    pKeyword = fromApp.add_alm_keyword();
    pKeyword->set_id(kbd_service::ALM_KEY_SEQ_CTRL_DESC);
    pKeyword->set_value(seq.description());
}

void CModuleAlarmCreater::createSeqKeyWord(CNodeAction &action,
    kbd_idlfile::SAlmInfoFromApp &fromApp)
{
    using namespace kbd_idlfile;

    SAlmKeyword* pKeyword = NULL;

    pKeyword = fromApp.add_alm_keyword();
    pKeyword->set_id(kbd_service::ALM_KEY_SEQ_CTRL_NAME);
    pKeyword->set_value(action.nodeName());

    pKeyword = fromApp.add_alm_keyword();
    pKeyword->set_id(kbd_service::ALM_KEY_SEQ_CTRL_DESC);
    pKeyword->set_value(action.description());
}

void CModuleAlarmCreater::createHmiOpKeyWord(ESeqCtrl_HmiOpType op,
    kbd_idlfile::SAlmInfoFromApp& fromApp)
{
    createOpKeyWord(COpResultHmi::getOpStr(op), fromApp);
}

void CModuleAlarmCreater::createUiOpKeyWord(UI_OP_RESULT_TYPE op,
    kbd_idlfile::SAlmInfoFromApp& fromApp)
{
    createOpKeyWord(COpResultUi::UiOpTypeStr(op), fromApp);
}

void CModuleAlarmCreater::createOpKeyWord(const std::string& op,
    kbd_idlfile::SAlmInfoFromApp& fromApp)
{
    using namespace kbd_idlfile;

    SAlmKeyword* pKeyword = NULL;

    pKeyword = fromApp.add_alm_keyword();
    pKeyword->set_id(kbd_service::ALM_KEY_SEQ_CTRL_ACT);
    pKeyword->set_value(op);
}

void CModuleAlarmCreater::createActorKeyWord(const SNodeSeqActor& actor,
    kbd_idlfile::SAlmInfoFromApp& fromApp)
{
    using namespace kbd_idlfile;

    SAlmKeyword* pKeyword = NULL;

    pKeyword = fromApp.add_alm_keyword();
    pKeyword->set_id(kbd_service::ALM_KEY_OPTERATOR);
    pKeyword->set_value(actor.user_name);

    pKeyword = fromApp.add_alm_keyword();
    pKeyword->set_id(kbd_service::ALM_KEY_OPT_HOST);
    pKeyword->set_value(actor.host_name);
}

void CModuleAlarmCreater::createResultKeyWord(const std::string& state,
    kbd_idlfile::SAlmInfoFromApp& fromApp)
{
    using namespace kbd_idlfile;

    SAlmKeyword* pKeyword = NULL;

    pKeyword = fromApp.add_alm_keyword();
    pKeyword->set_id(kbd_service::ALM_KEY_RTN_RESULT);
    pKeyword->set_value(state);
}

void CModuleAlarmCreater::createActionDescKeyWord(CNodeAction& action,
    kbd_idlfile::SAlmInfoFromApp& fromApp)
{
    using namespace kbd_idlfile;

    SAlmKeyword* pKeyword = NULL;

    pKeyword = fromApp.add_alm_keyword();
    pKeyword->set_id(kbd_service::ALM_KEY_SEQ_CTRL_ACT);
    pKeyword->set_value(action.description());
}

void CModuleAlarmCreater::afterSleep()
{
    using namespace boost::posix_time;
    using namespace boost::this_thread;
    sleep(millisec(1));
}