#include "pub_logger_api/logger.h"

#include "CRecoverNodeContainer.h"
#include "PredifineForSeqServer.h"

CRecoverNodeContainer::CRecoverNodeContainer()
{
}

CRecoverNodeContainer::~CRecoverNodeContainer()
{
    clearData();
}

bool CRecoverNodeContainer::isEmpty() const
{
    return m_mapRecoverNodeSeq.begin() == m_mapRecoverNodeSeq.end();
}

void CRecoverNodeContainer::clearData()
{
    clearAllNode();
    clearSeqInfo();
    clearFuncInfo();
    clearActionInfo();
}

void CRecoverNodeContainer::pushData(SSeqCtrlRunning* data)
{
    if (data->node_type == 0)
    {
        m_vecSeqInfo.push_back(data);
    }
    else if (data->node_type == 1)
    {
        m_vecFuncInfo.push_back(data);
    }
    else if (data->node_type == 2)
    {
        m_vecActionInfo.push_back(data);
    }
    else
    {
        delete data;
        data = NULL;
    }
}

void CRecoverNodeContainer::createModel()
{
    LOGINFO("创建顺控运行表结构");
    createSeqNode();
    createFuncNode();
    createActionNode();
    LOGINFO("结束创建顺控运行表结构");
}

void CRecoverNodeContainer::clearAllNode()
{
    recoverSeqMap::iterator iter = m_mapRecoverNodeSeq.begin();
    for (; iter != m_mapRecoverNodeSeq.end(); ++iter)
    {
        delete iter->second;
        iter->second = NULL;
    }
    m_mapRecoverNodeSeq.clear();
}

void CRecoverNodeContainer::clearSeqInfo()
{
    std::vector<SSeqCtrlRunning*>::iterator iter;

    iter = m_vecSeqInfo.begin();
    for (; iter != m_vecSeqInfo.end(); ++iter)
    {
        delete *iter;
        *iter = NULL;
    }
    m_vecSeqInfo.clear();
}

void CRecoverNodeContainer::clearFuncInfo()
{
    std::vector<SSeqCtrlRunning*>::iterator iter;

    iter = m_vecFuncInfo.begin();
    for (; iter != m_vecFuncInfo.end(); ++iter)
    {
        delete *iter;
        *iter = NULL;
    }
    m_vecFuncInfo.clear();
}

void CRecoverNodeContainer::clearActionInfo()
{
    std::vector<SSeqCtrlRunning*>::iterator iter;

    iter = m_vecActionInfo.begin();
    for (; iter != m_vecActionInfo.end(); ++iter)
    {
        delete *iter;
        *iter = NULL;
    }
    m_vecActionInfo.clear();
}

void CRecoverNodeContainer::createSeqNode()
{
    std::vector<SSeqCtrlRunning*>::iterator iter = m_vecSeqInfo.begin();
    for (; iter != m_vecSeqInfo.end(); ++iter)
    {
        if ((*iter)->status == SEQ_RUNNING_STATUS
            || (*iter)->status == SEQ_PAUSE_STATUS
            || (*iter)->status == SEQ_SUCCESS_STATUS
            || (*iter)->status == SEQ_STOP_STATUS
            || (*iter)->status == SEQ_FAILED_STATUS
            || (*iter)->status == SEQ_TRIGGERED_STATUS)
        {
            CRecoverNodeSeq* seq = new CRecoverNodeSeq(*iter);
            m_mapRecoverNodeSeq.insert(std::make_pair(seq->nodeName(), seq));
        }
        else
        {
            delete *iter;
            *iter = NULL;
        }
    }

    //把数据移交给 节点管理
    m_vecSeqInfo.clear();
}

void CRecoverNodeContainer::createFuncNode()
{
    std::vector<SSeqCtrlRunning*>::iterator iter = m_vecFuncInfo.begin();
    for (; iter != m_vecFuncInfo.end(); ++iter)
    {
        CRecoverNodeFunc* func = new CRecoverNodeFunc(*iter);

        CRecoverIterator seqNodeIter(*this, func->seqName());
        if (seqNodeIter.hasNext())
        {
            CRecoverNode& seq = seqNodeIter.getNext();
            seq.addChild(func);
        }
        else
        {
            delete func;
            func = NULL;
        }
    }

    //把数据移交给 节点管理
    m_vecFuncInfo.clear();
}

void CRecoverNodeContainer::createActionNode()
{
    std::vector<SSeqCtrlRunning*>::iterator iter = m_vecActionInfo.begin();
    for (; iter != m_vecActionInfo.end(); ++iter)
    {
        CRecoverNodeAction* action = new CRecoverNodeAction(*iter);

        CRecoverIterator seqNodeIter(*this, action->seqName());
        if (seqNodeIter.hasNext())
        {
            CRecoverNode& seq = seqNodeIter.getNext();
            CRecoverIterator funcNodeIter(seq, action->funcName());
            if (funcNodeIter.hasNext())
            {
                CRecoverNode& func = funcNodeIter.getNext();
                func.addChild(action);
            }
            else
            {
                delete action;
                action = NULL;
            }
        }
        else
        {
            delete action;
            action = NULL;
        }
    }

    //把数据移交给 节点管理
    m_vecActionInfo.clear();
}