#include "StdAfx.h"
#include ".\BattleGroundTimeInfoParser.h"

//------------------------------------------------------------------------------ 
void BattleGroundTimeInfoParser::Release()
{
    Unload();
}

BOOL BattleGroundTimeInfoParser::LoadScript(eSCRIPT_CODE scriptCode, BOOL bReload)
{
    __UNUSED(bReload);
    switch (scriptCode)
    {
    case SCRIPT_BATTLE_GROUND_TIME_INFO:
        return _Load(false);
    }

    return false;
}
//------------------------------------------------------------------------------ 
void BattleGroundTimeInfoParser::Unload()
{
}
bool BattleGroundTimeInfoParser::_Load(bool reload)
{
    __UNUSED(reload);

    // open time event specification
    //        -10             -5                Open       
    //----------|--------------|-----------------|----------|

    if (!FlowControl::FCAssert(time_node_array_ == NULL && open_time_table_.empty()))
    {
        return false;
    }

    const int row_count = GetRowSize();
    number_of_time_nodes_ = \
        (row_count * kOpenTimeMaxCount * kEventTimeModeCounts) + (row_count * kOpenTimeMaxCount);

    const size_t buffer_size = sizeof(*time_node_array_) * number_of_time_nodes_;
    time_node_array_ = reinterpret_cast<BattleGroundTimeNode*>(::malloc(buffer_size));
    ZeroMemory(time_node_array_, buffer_size);

    TCHAR field_name[64] = {0,};

    BattleGroundTimeNode* time_node_it = time_node_array_;
    for (int row = 0; row < row_count; ++row) //day..
    {
        for(int col = 0; col < kOpenTimeMaxCount; ++col) // ¿äÀϺ° ½Ã°£
        {
            // day_flag setting
            const uint16_t day_flag = GetDataWORD("DayFlag", row);

            //StartTime
            //ACmTmFmt, HHMM´ÜÀ§·Î ÀúÀåµÈ ½Ã°£°ªÀ» minute´ÜÀ§·Î º¯È¯ÇÏ¿© ÀúÀåÇÑ´Ù.
            _sntprintf(field_name, _countof(field_name), "StartTime%d", col + 1);
            BattleGroundTimeNode::AcmTmFmt start_time = GetDataWORD(field_name, row);
            start_time = ((start_time / 100) * 60) + (start_time % 100);

            if (start_time == 0) // »ç¿ë ÇÏÁö ¾ÊÀº ½Ã°£..
            {
                continue;
            }

            for (int i = ns_func::eCOUNTDOWN_5MINUTES; i < ns_func::eTIMEMODE_MAX; ++i) 
            {
                BattleGroundTimeNode* const time_node = time_node_it++;

                //DayFlag
                time_node->day_flag = day_flag;

                //StringCode
                DWORD string_code = 0;
                GetData(row, string_code, "StartTimeStringCode%d", i);

                _SetTimeInfo(time_node, start_time,
                             static_cast<const ns_func::eBATTLEGROUND_TIMEMODE>(i),string_code);

                open_time_table_.insert(OpenTimeTable::value_type(time_node->day_flag, time_node));
            }
        }
    }

    return true;
}

void BattleGroundTimeInfoParser::_SetTimeInfo(BattleGroundTimeNode* time_node,
                                              const BattleGroundTimeNode::AcmTmFmt input_open_time,
                                              const ns_func::eBATTLEGROUND_TIMEMODE time_mode,
                                              const DWORD string_code)
{
    int start_time = 0;
    int end_time = 0;
    uint16_t day_flag = time_node->day_flag;

    switch (time_mode)
    {
    case ns_func::eCOUNTDOWN_5MINUTES:
        {
            start_time = input_open_time - 5;
            end_time = input_open_time;
        };
        break;
    case ns_func::eOPENED:
        {
            start_time = input_open_time;
            end_time = input_open_time + 1;
        }
        break;
    default:
        ASSERT(!"ÒâÍâµÄʱ¼äģʽ");
        start_time = end_time = 0;
        break;
    } //end 'switch'

    if (start_time < 0)
    {
        start_time += k24hours;
        end_time += k24hours;

        day_flag -= 1;
        if (day_flag < 1)
            day_flag = 7;
    }
    
    else if (start_time >= k24hours)
    {
        start_time -= k24hours;
        end_time -= k24hours;

        day_flag += 1;
        if (day_flag > 7)
            day_flag = 1;
    }

    time_node->time_mode = time_mode;   // ¸ðµå
    time_node->day_flag = day_flag; // ³¯Â¥
    time_node->start_time = static_cast<BattleGroundTimeNode::AcmTmFmt>(start_time); // ½ÃÀ۽ð£
    time_node->end_time = static_cast<BattleGroundTimeNode::AcmTmFmt>(end_time); // Á¾·á½Ã°£
    time_node->string_code = string_code; // ½ºÆ®¸µÄÚµå
}

bool BattleGroundTimeInfoParser::GetCurrentTimeNode(const util::TimeInfoPerFrame& time_info, 
                                                    uint16_t day_flag,
                                                    ns_func::BattleGroundTimeNode* result_node) const
{
    const util::TimeInfoPerFrame::AcmTmFmt cur_time = time_info.acm_time_;
    OpenTimeTable::_Paircc ranges = open_time_table_.equal_range(day_flag);
    for ( ; ranges.first != ranges.second; ++ranges.first)
    {
        const BattleGroundTimeNode* const time_node = ranges.first->second;
        if (time_node->IsInRange(cur_time))
        {
            *result_node = *time_node;
            return true;
        }
    }
    ZeroMemory(result_node, sizeof(*result_node));
    return false;
}

bool BattleGroundTimeInfoParser::GetLatestEventTimeNode( const util::TimeInfoPerFrame& time_info, 
                                                         ns_func::BattleGroundTimeNode* result_node,
                                                         const ns_func::eBATTLEGROUND_TIMEMODE& time_mode)
{
    uint16_t cur_day = time_info.system_time.wDayOfWeek + 1;

    //¹«ÇÑ·çÇÁ ¹æÁö, ¸îÀÏ Å½»öÇß´ÂÁö üũ
    BYTE day_count = 0;
    uint16_t day_flag = cur_day;
    while (day_count < 7)
    {
        OpenTimeTable::_Paircc ranges = open_time_table_.equal_range(day_flag);
        for ( ; ranges.first != ranges.second; ++ranges.first)
        {
            const BattleGroundTimeNode* const time_node = ranges.first->second;
            // °ú°Å ½Ã°£ÀÇ ³ëµå´Â °É·¯³½´Ù.
            if ((day_flag == cur_day) && (time_info.acm_time_ > time_node->start_time))
            {
                continue;
            }
            if ((time_node->time_mode == time_mode))
            {
                *result_node = *time_node;
                return true;
            }
        }

        ++day_flag;
        ++day_count;
        if (day_flag >= 8) 
        {
            // Åä -> ÀÏ
            day_flag = 1;
        }
    }
    return false;
}