#include "stdafx.h"

#ifdef _NA_008012_20150204_SUN_RANKING_SYSTEM

#include "SunRankingPlayer.h"
#include "SunRankingGradeManager.h"
#include "SunRankingParser.h"
#include "SunRankingManager.h"
#include "ServerOptionParserEx.h"
#include "StatueManager.h"
#include "PacketStruct_DW.h"

//////////////////////////////////////////////////////////////////////////
// Compare to Ranking
struct CompareRankingObject 
{
    eSUN_RANKING_TYPE m_ranking_type;
    eSUN_RANKING_GRADE_TYPE m_ranking_grade;

    CompareRankingObject()
    {
        m_ranking_type = eSUN_RANKING_TYPE_END;
        m_ranking_grade = eSUN_RANKING_GRADE_NONE;
    }

    CompareRankingObject(eSUN_RANKING_TYPE ranking_type, eSUN_RANKING_GRADE_TYPE grade)
    {
        m_ranking_type = ranking_type;
        m_ranking_grade = grade;
    }

    bool operator < (const CompareRankingObject& object) const
    {
        const eSUN_RANKING_GRADE_TYPE high_boundary = eSUN_RANKING_GRADE_3;
        const eSUN_RANKING_GRADE_TYPE row_boundary = eSUN_RANKING_GRADE_4;

        if (m_ranking_grade == eSUN_RANKING_GRADE_NONE)
        {
            return true;
        }

        if (object.m_ranking_grade == eSUN_RANKING_GRADE_NONE)
        {
            return false;
        }

        if (m_ranking_type == eSUN_RANKING_TYPE_BEST_OF_BEST
            || object.m_ranking_type  == eSUN_RANKING_TYPE_BEST_OF_BEST)
        {
            if (object.m_ranking_type  != eSUN_RANKING_TYPE_BEST_OF_BEST)
            {
                if (m_ranking_grade < high_boundary)
                {
                    return false;
                }
                else if (object.m_ranking_grade >= row_boundary)
                {
                    return false;
                }
            }

            if (m_ranking_type != eSUN_RANKING_TYPE_BEST_OF_BEST)
            {
                if (object.m_ranking_grade < high_boundary)
                {
                    return true;
                }
                else if (m_ranking_grade >= row_boundary)
                {
                    return true;
                }
            }
        }

        if (object.m_ranking_grade < m_ranking_grade)
        {
            return true;
        }
        else if (object.m_ranking_grade == m_ranking_grade && object.m_ranking_type < m_ranking_type)
        {
            return true;
        }

        return false;
    }

    bool operator > (const CompareRankingObject& object) const
    {
        return (object < *this);
    }
};

class CompareRanking
{
public:
    CompareRanking()
    {
        _GenerateCompare();
    }

    int GetCompareScore(eSUN_RANKING_TYPE ranking_type, 
        eSUN_RANKING_GRADE_TYPE ranking_grade)
    {
        CompareMap::const_iterator find_iter =
            m_compare_map.find(std::make_pair(ranking_type, ranking_grade));
        if (find_iter == m_compare_map.end())
        {
            return 0;
        }

        return find_iter->second;
    }

private:
    typedef std::map<std::pair<eSUN_RANKING_TYPE, eSUN_RANKING_GRADE_TYPE>, int> CompareMap;
    CompareMap m_compare_map;

    void _GenerateCompare()
    {
        for (eSUN_RANKING_TYPE type = eSUN_RANKING_TYPE_START;
            type < eSUN_RANKING_TYPE_END; ++type)
        {
            for (eSUN_RANKING_GRADE_TYPE grade = eSUN_RANKING_GRADE_START;
                grade < eSUN_RANKING_GRADE_END; ++grade)
            {
                m_compare_map.insert(std::make_pair(std::make_pair(type, grade), 
                    _GetCompareScore(type, grade)));
            }
        }
    }

    int _GetCompareScore(eSUN_RANKING_TYPE ranking_type, 
        eSUN_RANKING_GRADE_TYPE ranking_grade)
    {
        int score = 0;
        CompareRankingObject target(ranking_type, ranking_grade);
        for (eSUN_RANKING_TYPE type = eSUN_RANKING_TYPE_START;
            type < eSUN_RANKING_TYPE_END; ++type)
        {
            for (eSUN_RANKING_GRADE_TYPE grade = eSUN_RANKING_GRADE_START;
                grade < eSUN_RANKING_GRADE_END; ++grade)
            {
                CompareRankingObject compare_object(type, grade);
                if (target > compare_object)
                {
                    ++score;
                }
            }
        }
        return score;
    }
};
// Compare to Ranking
//////////////////////////////////////////////////////////////////////////

SunRankingGradeManager::SunRankingGradeManager() : grade_initialization(FALSE)
{
    if (g_pGameServer->GetMode() == eSERVER_DEV)
    {
        m_update_timer_.SetTimer(DEV_UPDATE_TIME);
    }
    else
    {
        m_update_timer_.SetTimer(UPDATE_TIME);
    }

    Initialize();

    m_last_settle_day = 0;
}

SunRankingGradeManager::~SunRankingGradeManager()
{
}

void SunRankingGradeManager::Initialize()
{
    SetState(eSUN_RANKING_STATE_INIT);

    for (eLOAD_KIND kind = eLOAD_KIND_START; kind < eLOAD_KIND_END; ++kind)
    {
        m_load_complete[kind] = false;
    }
    m_sun_ranking_grades.clear();
}

void SunRankingGradeManager::Update()
{
    if (m_update_timer_.IsExpired())
    {
        switch (m_sun_ranking_state)
        {
        case eSUN_RANKING_STATE_INIT:
            if (g_pGameServer->IsConnected(GAME_DBPROXY) == TRUE)
            {
                {
                    MSG_DG_SUN_RANKING_SELECT_SYN msg;
                    g_pGameServer->SendToServer(GAME_DBPROXY, &msg, sizeof(msg));
                }
                {
                    MSG_DG_SUN_RANKING_GRADE_SELECT_SYN msg;
                    g_pGameServer->SendToServer(GAME_DBPROXY, &msg, sizeof(msg));
                }
                {
                    MSG_DG_STATUE_SELECT_SYN msg;
                    g_pGameServer->SendToServer(GAME_DBPROXY, &msg, sizeof(msg));
                }

                SetState(eSUN_RANKING_STATE_LOAD);

                m_load_complete[eLOAD_KIND_GRADE_SELECT] = false;
                m_load_complete[eLOAD_KIND_RANKING_SELECT] = false;

                m_reload_timer.SetTimer(RELOAD_TIME);
            }
            break;
        case eSUN_RANKING_STATE_LOAD:
            {
                if (IsLoadComplete(eLOAD_KIND_GRADE_SELECT) && IsLoadComplete(eLOAD_KIND_RANKING_SELECT))
                {
                    SetState(eSUN_RANKING_STATE_RUN);
                }
                else
                {
                    // 로드가 완료되지 않았고 로드 대기 시간이 지났다면 재요청한다
                    if (m_reload_timer.IsExpired()) 
                    {
                        if (IsLoadComplete(eLOAD_KIND_RANKING_SELECT) == false)
                        {
                            MSG_DG_SUN_RANKING_SELECT_SYN msg;
                            g_pGameServer->SendToServer(GAME_DBPROXY, &msg, sizeof(msg));

                            SUNLOG(eCRITICAL_LOG, "[SunRanking] - Reload Ranking");
                        }
                        if (IsLoadComplete(eLOAD_KIND_GRADE_SELECT) == false)
                        {
                            MSG_DG_SUN_RANKING_GRADE_SELECT_SYN msg;
                            g_pGameServer->SendToServer(GAME_DBPROXY, &msg, sizeof(msg));

                            SUNLOG(eCRITICAL_LOG, "[SunRanking] - Reload Grade");
                        }
                    }
                }
            }
            break;
        case eSUN_RANKING_STATE_RUN:
            if (_IsSettleTime() == true)
            {
                //Settle();
                //바로 Settle상태로 돌리지 않고, DBP에게 요청 후, DBP의 시작 통지를 받아서 Settle()이 동작하도록 하자.
                //각 채널의 FieldServer 정산 상태 동기화를 위함
                if (IsSettleChannel() == true)
                {
                    MSG_DG_SUN_RANKING_SETTLE_START_SYN msg;
                    g_pGameServer->SendToServer(GAME_DBPROXY, &msg, sizeof(msg));
                }
                return;
            }
            break;
        case eSUN_RANKING_STATE_SETTLE_WAIT:
            {
            }
            break;
        case eSUN_RANKING_STATE_SEND_MEMO:
            {
                if (IsLoadComplete(eLOAD_KIND_GRADE_SELECT))
                {
                    m_load_complete[eLOAD_KIND_GRADE_SELECT] = false;
                    Settle_SendMemo();
                    //메모를 보내기 위한 정보가 필요하므로 ReUse()를 메모 전달 이후에 한다
                    ReUse();
                }
            }
            break;
        default:
            break;
        }
    }
}

void SunRankingGradeManager::SetGradeInfo( SunRankingGradeInfo& grade_info )
{
    SunRankingGrades::iterator find_iter = m_sun_ranking_grades.find(grade_info.char_guid);
    if (find_iter == m_sun_ranking_grades.end())
    {
        SunRankingGradeInfos infos;
        eSUN_RANKING_TYPE ranking_type = 
            static_cast<eSUN_RANKING_TYPE>(grade_info.ranking_type);
        infos.insert(std::make_pair(ranking_type, grade_info));
        m_sun_ranking_grades.insert(std::make_pair(grade_info.char_guid, infos));
    }
    else
    {
        SunRankingGradeInfos& infos = find_iter->second;
        eSUN_RANKING_TYPE ranking_type = 
            static_cast<eSUN_RANKING_TYPE>(grade_info.ranking_type);
        SunRankingGradeInfos::iterator cur_iter = infos.find(ranking_type);
        if (cur_iter != infos.end())
        {
            infos.erase(cur_iter);
        }
        infos.insert(std::make_pair(ranking_type, grade_info));
    }
}

bool SunRankingGradeManager::_IsSettleTime()
{
    if (GetState() != eSUN_RANKING_STATE_RUN)
    {
        return false;
    }

    time_t t;
    util::TimeSync::time(&t);
    struct tm* cur_time_struct = localtime(&t);
    if (cur_time_struct == NULL)
    {
        return false;
    }

    if (SunRankingParser::Instance()->GetSettleDateType() == eSUN_RANKING_SETTLE_MONTH
        && SunRankingParser::Instance()->GetSettleDateDay() != cur_time_struct->tm_mday)
    {
        return false;
    }

    if (SunRankingParser::Instance()->GetSettleDateType() == eSUN_RANKING_SETTLE_WEEK
        && SunRankingParser::Instance()->GetSettleDateDay() != cur_time_struct->tm_wday)
    {
        return false;
    }

    if (SunRankingParser::Instance()->GetSettleDateTime() !=
        cur_time_struct->tm_hour * 100 + cur_time_struct->tm_min)
    {
        return false;
    }

    if (m_last_settle_day == cur_time_struct->tm_mday)
    {
        return false;
    }
    m_last_settle_day = cur_time_struct->tm_mday;

    return true;
}

bool SunRankingGradeManager::GetGradeInfo( CHARGUID char_guid, SunRankingGradeInfos& infos )
{
    SunRankingGrades::iterator find_iter = m_sun_ranking_grades.find(char_guid);
    if (find_iter == m_sun_ranking_grades.end())
    {
        return false;
    }

    infos = find_iter->second;

    return true;
}

void SunRankingGradeManager::GetTopGrade( CHARGUID char_guid, eSUN_RANKING_GRADE_TYPE& top_grade, eSUN_RANKING_TYPE& top_ranking_type )
{
    SunRankingGradeInfos infos;
    if (GetGradeInfo(char_guid, infos) == false)
    {
        top_grade = eSUN_RANKING_GRADE_NONE;
        top_ranking_type = eSUN_RANKING_TYPE_END;
        return;
    }

    eSUN_RANKING_GRADE_TYPE grade = eSUN_RANKING_GRADE_NONE;
    eSUN_RANKING_TYPE ranking_type = eSUN_RANKING_TYPE_END;

    SunRankingGradeInfos::iterator cur_iter = infos.begin();
    for (; cur_iter != infos.end(); ++cur_iter)
    {
        SunRankingGradeInfo& info = cur_iter->second;
        eSUN_RANKING_GRADE_TYPE iter_grade = 
            static_cast<eSUN_RANKING_GRADE_TYPE>(info.grade);
        eSUN_RANKING_TYPE iter_ranking_type = 
            static_cast<eSUN_RANKING_TYPE>(info.ranking_type);
        static CompareRanking compare_ranking;
        if (compare_ranking.GetCompareScore(iter_ranking_type, iter_grade)
            > compare_ranking.GetCompareScore(ranking_type, grade))
        {
            grade = iter_grade;
            ranking_type = iter_ranking_type;
        }
    }
    top_grade = grade;
    top_ranking_type = ranking_type;

    if (top_grade >= eSUN_RANKING_GRADE_4)
    {
        top_grade = eSUN_RANKING_GRADE_NONE;
    }
}

eSUN_RANKING_GRADE_TYPE SunRankingGradeManager::GetGrade( const CHARGUID& char_guid, 
                                                          const eSUN_RANKING_TYPE& ranking_type )
{
    SunRankingGrades::iterator find_iter = m_sun_ranking_grades.find(char_guid);
    if (find_iter == m_sun_ranking_grades.end()) {
        return eSUN_RANKING_GRADE_NONE;
    }

    SunRankingGradeInfos grade_infos = find_iter->second;
    SunRankingGradeInfos::iterator grade_itr = grade_infos.find(ranking_type);
    if (grade_itr == grade_infos.end()) {
        return eSUN_RANKING_GRADE_NONE;
    }

    SunRankingGradeInfo grade_info = grade_itr->second;
    return (eSUN_RANKING_GRADE_TYPE)grade_info.grade;
}

void SunRankingGradeManager::ReUse()
{
    Initialize();

    SunRankingManager::Instance()->Release();
    SunRankingManager::Instance()->Initialize();
}

void SunRankingGradeManager::Settle_SendMemo()
{
    SunRankingGrades::iterator cur_iter = m_sun_ranking_grades.begin();
    SunRankingGrades::iterator end_iter = m_sun_ranking_grades.end();
    MSG_AG_EVENT_SYSTEMMEMO_SEND_CMD cmd_msg;
    cmd_msg.Clear();
    const int max_system_memo_size = 20;    // MAX_SYSTEM_MEMO_LIST 는 패킷 크기가 너무 크다
    for (; cur_iter != end_iter; ++cur_iter)
    {
        SunRankingGradeInfos& infos = cur_iter->second;

        SunRankingGradeInfos::iterator infos_cur_iter = infos.begin();
        SunRankingGradeInfos::iterator infos_end_iter = infos.end();
        for (; infos_cur_iter != infos_end_iter; ++infos_cur_iter)
        {
            SunRankingGradeInfo& grade_info = infos_cur_iter->second;

            if (grade_info.ranking_type < eSUN_RANKING_TYPE_START || grade_info.ranking_type >= eSUN_RANKING_TYPE_END)
            {
                continue;
            }

            if (grade_info.grade >= eSUN_RANKING_GRADE_4)
            {
                continue;
            }

            int rank = 0;
            eSUN_RANKING_TYPE rank_type = static_cast<eSUN_RANKING_TYPE>(grade_info.ranking_type);
            SunRankingManager::Instance()->GetRanking(rank_type, grade_info.char_guid, rank);

            BasicSystemMemoInfo& memo = cmd_msg.system_memo_info_[cmd_msg.system_memo_list_num_];
            memo.recv_user_guid_ = grade_info.char_guid;
            memo.system_memo_type_ = SYSMEMO_SUN_RANKING_SETTLE_RESULT;
            _sntprintf(memo.system_memo_contents_, MAX_MEMO_LENGTH, "%d|%d|%d|", 
                SYSMEMO_SUN_RANKING_SETTLE_RESULT, grade_info.ranking_type, rank);

            if (cmd_msg.system_memo_list_num_ == max_system_memo_size)
            {
                g_pGameServer->SendToServer(AGENT_SERVER, &cmd_msg, cmd_msg.GetSize());
                cmd_msg.Clear();
            }
            else
            {
                ++cmd_msg.system_memo_list_num_;
            }
        }
    }

    if (cmd_msg.system_memo_list_num_ != 0)
    {
        g_pGameServer->SendToServer(AGENT_SERVER, &cmd_msg, cmd_msg.GetSize());
    }
}

bool SunRankingGradeManager::IsSettleChannel()
{
    BYTE channel_id = ServerOptionParserEx::Instance()->GetServerOption().sun_ranking_settle_channel;

    if (g_pGameServer->GetKey().GetChannelID() == channel_id 
        && g_pGameServer->GetServerType() == FIELD_SERVER)
    {
        return true;
    }
    return false;
}

void SunRankingGradeManager::Settle_StartForGM()
{
    if (GetState() != eSUN_RANKING_STATE_RUN)
    {
        return;
    }

    MSG_DG_SUN_RANKING_SETTLE_START_SYN msg;
    g_pGameServer->SendToServer(GAME_DBPROXY, &msg, sizeof(msg));
}

void SunRankingGradeManager::SetState( eSUN_RANKING_STATE state )
{
    m_sun_ranking_state = state;

    static const int MAX_RANKING_STATE_STR = 64;
    static const char ranking_state_str[eSUN_RANKING_STATE_MAX][MAX_RANKING_STATE_STR] = {
        "eSUN_RANKING_STATE_INIT",
        "eSUN_RANKING_STATE_LOAD",
        "eSUN_RANKING_STATE_RUN",
        "eSUN_RANKING_STATE_SETTLE_WAIT",
        "eSUN_RANKING_STATE_SEND_MEMO"
    };

    SUNLOG(eCRITICAL_LOG, "[SunRanking] - State : %s", ranking_state_str[state]);
}

void SunRankingGradeManager::Settle()
{
    if (GetState() != eSUN_RANKING_STATE_RUN)
    {
        return;
    }

    SetState(eSUN_RANKING_STATE_SETTLE_WAIT);

    if (IsSettleChannel() != true)
    {
        return;
    }

    MSG_DG_SUN_RANKING_SETTLE_SYN msg;
    SunRankingParser::Instance()->GetBoundary(msg.grade_boundary);
    SunRankingManager::Instance()->GetTopRankerEquipmentScore(msg.statue_char_equip_score, msg.statue_char_guid);
    g_pGameServer->SendToServer(GAME_DBPROXY, &msg, sizeof(msg));
}

void SunRankingGradeManager::Settle_Complete()
{
#ifdef _NA_008679_20160202_REWORK_BATTLEGROUND
    // 이전 등급자 리스트 지우기전에, 등급자들 저장
    std::vector<CHARGUID> grade_char_list;
    ;{
        SunRankingGrades::iterator itr = m_sun_ranking_grades.begin();
        while (itr != m_sun_ranking_grades.end())
        {
            CHARGUID guid = itr->first;
            grade_char_list.push_back(guid);

            ++itr;
        }
    };
    

    if (IsSettleChannel() == true)
    {
        SetState(eSUN_RANKING_STATE_SEND_MEMO);
    }
    else
    {
        ReUse();
    }

    // 전 등급자들 1. 장착중인 칭호 갱신 2. 칭호 리스트 갱신
    ;{
        std::vector<CHARGUID>::iterator itr = grade_char_list.begin();
        for(;itr != grade_char_list.end(); ++itr)
        {
            CHARGUID guid = *itr;
            Player* player = PlayerManager::Instance()->FindPlayerByCharKey(guid);
            if (player == NULL) {
                continue;
            }

            player->GetHonorManager()->UpdateRankingTitle();
        }
    ;}
    
#else
    if (IsSettleChannel() == true)
    {
        SetState(eSUN_RANKING_STATE_SEND_MEMO);
    }
    else
    {
        ReUse();
    }
#endif //_NA_008679_20160202_REWORK_BATTLEGROUND
    
}

void SunRankingGradeManager::Display()
{
    static const int MAX_RANKING_STATE_STR = 64;
    static const char ranking_state_str[eSUN_RANKING_STATE_MAX][MAX_RANKING_STATE_STR] = {
        "eSUN_RANKING_STATE_INIT",
        "eSUN_RANKING_STATE_LOAD",
        "eSUN_RANKING_STATE_RUN",
        "eSUN_RANKING_STATE_SETTLE_WAIT",
        "eSUN_RANKING_STATE_SEND_MEMO"
    };

    SUNLOG(eCRITICAL_LOG, "[SunRanking] - State : %s", ranking_state_str[m_sun_ranking_state]);
    SUNLOG(eCRITICAL_LOG, "[SunRanking] - Grades Count : %d", m_sun_ranking_grades.size());

    if (m_sun_ranking_state == eSUN_RANKING_STATE_LOAD)
    {
        SUNLOG(eCRITICAL_LOG, "[SunRanking] - Ranking Load State : %d",
            m_load_complete[eLOAD_KIND_RANKING_SELECT]);
        SUNLOG(eCRITICAL_LOG, "[SunRanking] - Grade Load State : %d",
            m_load_complete[eLOAD_KIND_GRADE_SELECT]);
    }
}

void SunRankingGradeManager::SetLoadComplete( eLOAD_KIND load_kind )
{
    m_load_complete[load_kind] = true;
}

bool SunRankingGradeManager::IsLoadComplete( eLOAD_KIND load_kind )
{
    return m_load_complete[load_kind];
}

VOID SunRankingGradeManager::SetAllGradeInfos( SunRankingGradeInfo* infos, INT data_count )
{
    for (int i = 0; i < data_count; ++i)
    {
        SunRankingGradeManager::Instance()->SetGradeInfo(infos[i]);
    }

#ifdef _NA_008679_20160202_REWORK_BATTLEGROUND
    if (grade_initialization == TRUE)
    {
        // 등급자들 칭호 리스트 갱신
        SunRankingGrades::iterator itr = m_sun_ranking_grades.begin();
        for(; itr != m_sun_ranking_grades.end(); ++itr)
        {
            CHARGUID guid = itr->first;
            Player* player = PlayerManager::Instance()->FindPlayerByCharKey(guid);
            if (player == NULL) {
                continue;
            }

            player->GetHonorManager()->UpdateRankingTitle();
        }
    }
#endif //_NA_008679_20160202_REWORK_BATTLEGROUND

    if (grade_initialization == FALSE) {
        grade_initialization = TRUE;
    }
}

#endif // _NA_008012_20150204_SUN_RANKING_SYSTEM