#include "boost/thread.hpp"
#include "pub_utility_api/TimeUtil.h"
#include "boost/format.hpp"

#include "pub_logger_api/logger.h"
#include "pub_utility_api/I18N.h"

#include "CMethodAction.h"
#include "CNodeAction.h"
#include "CNodeFunc.h"
#include "CNodeSeq.h"
#include "CMbCommunicateInfo.h"
#include "CModuleDbAccessMngr.h"
#include "CModuleAlarmCreater.h"

#include "CDbSaveCtrl.h"
#include "CRecoverNode.h"

CMethodAction::CMethodAction(CNodeAction& action)
    : m_objAction(action),
    m_ptrFailedPro(NULL),
    m_nStartTime(0),
    m_nStopTime(0)
{
}

CMethodAction::~CMethodAction()
{
    if (m_ptrFailedPro)
    {
        delete m_ptrFailedPro;
        m_ptrFailedPro = NULL;
    }
}

bool CMethodAction::execute()
{
    LOGINFO("动作: [%s]-[%s]-[%s] 开始执行!",
        m_objAction.getNodeSeq().description().c_str(),
        m_objAction.getNodeFunc().description().c_str(),
        m_objAction.description().c_str());
   
    m_nStartTime = kbd_public::getUTCTimeSec();

    //初始化节点状态
    m_objAction.resetBeginStart();

    //开始执行
    bool bRet = startExecuteNode();

    m_nStopTime = kbd_public::getUTCTimeSec();

    updateActionEvent();//一个动作结束后 才记录
    alarmEvent();

    LOGINFO("动作: [%s]-[%s]-[%s] 结束执行 状态[%s]!",
        m_objAction.getNodeSeq().description().c_str(),
        m_objAction.getNodeFunc().description().c_str(),
        m_objAction.description().c_str(),
        (bRet ? ("成功") : ("失败")));

    return bRet;
}

bool CMethodAction::startExecuteNode()
{
    //变更状态为 正在执行
    changeStateToStart();

    //发送动作执行指令
    bool bRet = sendMessageToOpt();
    if (!bRet)
    {
        //失败,发送指令属于链路出错,不走重试流程, 变更状态为 执行失败
        changeStateToFailed(
            SActionErrorInfo(enumCode_ERRO_ACTION_SEND_FAILED,
                I18N("发送操作指令错误!")));

        return false;
    }

    //处理执行结果
    bRet = executeResult(m_objAction.ctrlTimeOut());

    m_objAction.resetOptResult("");

    return bRet;
}

//执行结果 一定要在 一定时间内返回,如果没有执行结果,那么就按超时处理
bool CMethodAction::executeResult(uint64 nWaitTime)
{
    SOptResult result
        = m_objAction.getOptResult(nWaitTime);

    //成功
    if (result.resultCode == OPT_RESPONSE_TYPE_SUCCESS)
    {
        return doSuccessPro();
    }
    //失败
    else if (result.resultCode == OPT_RESPONSE_TYPE_FAILED)
    {
        //std::string desc = result.resultDesc;
        return doFailedPro(
            SActionErrorInfo(
                enumCode_ERRO_ACTION_OPT_FAILED,
                result.resultDesc));
    }

    return doResultTimeOutPro(nWaitTime);
}

//超时也是属于执行失败
bool CMethodAction::doResultTimeOutPro(
    uint64 timeOut)
{
    boost::format formater(I18N("动作执行超时 超时时间:[%d]s"));
    std::string desc = (
        formater
        % timeOut
        ).str();

    LOGINFO(desc.c_str());

    return doFailedPro(SActionErrorInfo(
        enumCode_ERRO_ACTION_TIMEOUT,
        desc));
}

bool CMethodAction::doSuccessPro()
{
    changeStateToSuccess();
    return true;
}

//重试
bool CMethodAction::doFailedPro(const SActionErrorInfo& erroInfo)
{
    //如果没有创建失败 流程 那就先创建
    if (!m_ptrFailedPro)
    {
        m_ptrFailedPro = new CMethodFailedAction(*this, m_objAction);
    }

    return m_ptrFailedPro->doFailedPro(erroInfo);
}

bool CMethodAction::sendMessageToOpt()
{
    CMbCommunicateInfo& mb
        = m_objAction.getNodeSeq().getMbCmmInfo();

    if (mb.sendActionToOpt(m_objAction))
    {
        m_objAction.resetOptResult(m_objAction.keyIdTag());
        return true;
    }

    return false;
}

void CMethodAction::changeStateToStart()
{
    m_objAction.updateState(SEQ_RUNNING_STATUS);
    updateSeqRunning(false);
    notifyStateToHmi();
    m_strDescribe = "";
}

void CMethodAction::changeStateToStop(const SActionErrorInfo& erroInfo)
{
    m_objAction.updateState(SEQ_STOP_STATUS);
    updateSeqRunning();
    notifyStateToHmi(erroInfo);
    m_strDescribe = (erroInfo.erroStr);
}

void CMethodAction::changeStateToFailed(const SActionErrorInfo& erroInfo)
{
    m_objAction.updateState(SEQ_FAILED_STATUS);
    updateSeqRunning();
    notifyStateToHmi(erroInfo);
    m_strDescribe = (erroInfo.erroStr);
}

void CMethodAction::changeStateToSkip(const SActionErrorInfo& erroInfo)
{
    m_objAction.updateState(SEQ_SKIP_STATUS);
    updateSeqRunning();
    notifyStateToHmi(erroInfo);
    m_strDescribe = (erroInfo.erroStr);
}

void CMethodAction::changeStateToSuccess()
{
    m_objAction.updateState(SEQ_SUCCESS_STATUS);
    updateSeqRunning();
    notifyStateToHmi();
    m_strDescribe = I18N("执行成功");
}

void CMethodAction::notifyStateToHmi()
{
    CMbCommunicateInfo& mb
        = m_objAction.getNodeSeq().getMbCmmInfo();

    mb.nodeStatusToHmi(m_objAction);
}

void CMethodAction::notifyStateToHmi(
    const SActionErrorInfo& erroInfo)
{
    CMbCommunicateInfo& mb
        = m_objAction.getNodeSeq().getMbCmmInfo();

    mb.nodeStatusToHmi(m_objAction, erroInfo);
}

bool CMethodAction::updateSeqRunning(bool onlyState)
{
    SSeqCtrlRunning info;
    memset(&info, 0, sizeof(info));
    CNodeSeq& seq = m_objAction.getNodeSeq();
    CNodeFunc& func = m_objAction.getNodeFunc();

    SNodeSeqActor actor = seq.getSeqActor();

    strcpy(info.seq_name, seq.nodeName().c_str());
    strcpy(info.func_name, func.nodeName().c_str());
    strcpy(info.action_name, m_objAction.nodeName().c_str());
    strcpy(info.node_desc, m_objAction.description().c_str());
    info.action_no = m_objAction.actionNo();
    info.func_no = func.funcNo();
    info.node_type = 2;
    info.status = m_objAction.getState();
    info.checked = m_objAction.checkStatus();
    info.start_time = m_nStartTime;
    info.user_id = actor.user_id;
    info.user_groupid = actor.user_grounp_id;
    strcpy(info.host_name, actor.host_name.c_str());
    strcpy(info.user_name, actor.user_name.c_str());
    info.timeflag = m_objAction.timeFlag();
    info.relation = func.relation();
    info.delay_time = m_objAction.delayTime();
    info.fail_strage = m_objAction.failStrage();
    info.isses = seq.isSecExe();
    strcpy(info.key_id_tag, m_objAction.keyIdTag().c_str());
    info.targetvalue = m_objAction.targetValue();
    info.location_id = m_objAction.locationId();
    info.seq_type = seq.seqType();

    CModuleDbAccessMngr& access = seq.getDbAccess();
    return access.updateSeqRunningRecord(info, onlyState);
}

bool CMethodAction::alarmEvent()
{
    CModuleAlarmCreater& obj = m_objAction.getNodeSeq().getAlarmCreater();
    return obj.actionExecute(m_objAction);
}

bool CMethodAction::updateActionEvent()
{
    CDbSaveCtrl db;

    CNodeSeq& seq = m_objAction.getNodeSeq();
    CNodeFunc& func = m_objAction.getNodeFunc();

    SSeqCtrlActionEvent info;
    info.seq_name = seq.nodeName();
    info.time = seq.getStartTime();//执行时间
    BOOST_ASSERT(info.time != 0);
    info.func_name = func.nodeName();
    info.action_no = m_objAction.actionNo();
    info.action_name = m_objAction.nodeName();
    info.action_desc = m_objAction.description();
    info.status = CNode::getStateStr(m_objAction.getState());
    info.starttime = m_nStartTime;
    info.stoptime = m_nStopTime;
    info.key_id_tag = m_objAction.keyIdTag();
    info.targetvalue = m_objAction.targetValue();
    info.location_id = m_objAction.locationId();
    info.discribe = m_strDescribe;

    bool bRet = db.updateActionEvent(info);
    return bRet;
}