// RenumberingItemSerial.cpp : 콘솔 응용 프로그램에 대한 진입점을 정의합니다.
//

#include "stdafx.h"
#include <RylDBLibrary/RylDBLibrary.h>
#include <RylDBLibrary/RylDBStoreCommand.h>
#include <RylDBLibrary/RylDBCharCommand.h>
#include <Item/RebalanceConvert/RebalanceItem.h>

#include <Network/Packet/PacketStruct/ServerInfo.h>
#include <Utility/Setup/ServerSetup.h>
#include <Log/ServerLog.h>

CServerLog g_ItemLog("RenumberItemUID");


class CDBRenumberingItemUID : 
    public IDBCharItemProcess,
    public IDBCharItemExProcess,
    public IDBStoreProcess
{
public:

    // SkillDataMap을 넣으면, 스킬북을 제거하고 컨버팅한다.
    CDBRenumberingItemUID(CDBItemSerialMgr& dbItemSerialMgr);

    virtual ConvertResult operator() (RylDBCommand::CCharItem& charItem_InOut);
    virtual ConvertResult operator() (RylDBCommand::CCharItemEx& charItemEx_InOut);

    virtual ConvertResult operator() (RylDBCommand::CUnifiedStore1& unifiedStore1_InOut);
    virtual ConvertResult operator() (RylDBCommand::CUnifiedStore2& unifiedStore2_InOut);

    bool RenumberingItemUID(unsigned long dwUID, unsigned long dwCID, 
        const char* szOriginalData, unsigned long dwOriginalSize,
        char* szChangedData, unsigned long& dwChangedSize_InOut, const char* szContainerName);

private:

    CDBItemSerialMgr& m_DBItemSerialMgr;
};

void PrintUsage()
{
    printf("RenumberingItemSerial DBAddress DBName DBAccount DBPassword ServerGroupNum(0~9)");
}

int _tmain(int argc, _TCHAR* argv[])
{
    // 전 캐릭을 다 돌면서 itemUID을 수정한다.
    // 필요한 것은 서버군 ID뿐이다.

    CoInitialize(0);

    int  nServerGroup = atoi(argv[5]);
        
    SERVER_ID serverID;

    serverID.sID.Type       = CServerSetup::AuthServer;
    serverID.sID.Group      = nServerGroup;
    serverID.sID.Channel    = 0;
    serverID.sID.ID         = 0;

    HRESULT hr = S_OK;

    ATL::CDataSource    dataSource;
    ATL::CSession       Session;    
    CDBItemSerialMgr    dbItemSerialMgr;

#define LOG_CONVERT0(str) { ERRLOG0(g_Log, (str)); printf(str "\n"); }
#define LOG_CONVERT1(str, arg1) { ERRLOG1(g_Log, (str), (arg1)); printf(str "\n", (arg1)); }
#define LOG_CONVERT2(str, arg1, arg2) { ERRLOG2(g_Log, (str), (arg1), (arg2)); printf(str "\n", (arg1), (arg2)); }

    if(FAILED(hr = CRylDBProcess::ConnectDB(dataSource, argv[1], argv[2], argv[3], argv[4])))
    {
        LOG_CONVERT1("Connect DB failed : hr:0x%08X", hr);
    }
    else if(FAILED(hr = Session.Open(dataSource)))
    {
        LOG_CONVERT1("Open session failed : hr:0x%08X", hr);
    }
    else if(FAILED(hr = dbItemSerialMgr.ClearAllSerialDB(Session)))
    {
        LOG_CONVERT1("Clear itemSerial failed : hr:0x%08X", hr);
    }
    else if(FAILED(hr = dbItemSerialMgr.LoadItemSerialDB(Session, serverID.dwID)))
    {   
        LOG_CONVERT1("Insert itemSerial failed : hr:0x%08X", hr);
    }
    else
    {
        if(FAILED(hr = dbItemSerialMgr.SaveItemSerialDB(Session, serverID.dwID)))
        {
            LOG_CONVERT1("ItemSerial save failed : hr:0x%08X", hr);
        }

        CRylDBProcess    rylDBProcess(Session);
        CConsoleCounter  consoleCounter(1000);

        CDBRenumberingItemUID renumberingItemUID(dbItemSerialMgr);

        // 통합 창고 아이템 시리얼 다시 매기기
        if(FAILED(hr = rylDBProcess.UnifiedStore1(renumberingItemUID, consoleCounter)))
        {
            LOG_CONVERT1("UnifiedStore1 process failed : hr:0x%08X", hr);
        }
        else if(FAILED(hr = rylDBProcess.UnifiedStore2(renumberingItemUID, consoleCounter)))
        {
            LOG_CONVERT1("UnifiedStore2 process failed : hr:0x%08X", hr);
        }
        // CharItem 아이템 시리얼 다시 매기기
        else if(FAILED(hr = rylDBProcess.CharItem(renumberingItemUID, consoleCounter)))
        {
            LOG_CONVERT1("CharItem process failed : hr:0x%08X", hr);
        }
        // CharItemEx 아이템 시리얼 다시 매기기
        else if(FAILED(hr = rylDBProcess.CharItemEx(renumberingItemUID, consoleCounter)))
        {
            LOG_CONVERT1("CharItemEx process failed : hr:0x%08X", hr);
        }
        // 최종 아이템 시리얼 저장.
        else if(FAILED(hr = dbItemSerialMgr.SaveItemSerialDB(Session, serverID.dwID)))
        {
            LOG_CONVERT1("ItemSerial save failed : hr:0x%08X", hr);
        }
    }

    INFLOG0(g_Log, "Convert Complete");

    Session.Close();
    dataSource.Close();
    
    CoUninitialize();
    return 0;
}


CDBRenumberingItemUID::CDBRenumberingItemUID(CDBItemSerialMgr& dbItemSerialMgr)
:   m_DBItemSerialMgr(dbItemSerialMgr)
{

}

ConvertResult CDBRenumberingItemUID::operator()(RylDBCommand::CCharItem& charItem_InOut)
{
    bool bChanged = false;

    const EQUIP& equip_In = charItem_InOut.GetEquip();
    const INVEN& inven_In = charItem_InOut.GetInven();
    const EXTRA& extra_In = charItem_InOut.GetExtra();

    EQUIP equip_Out;
    INVEN inven_Out;
    EXTRA extra_Out;

    memset(&equip_Out, 0, sizeof(EQUIP));
    memset(&inven_Out, 0, sizeof(INVEN));
    memset(&extra_Out, 0, sizeof(EXTRA));

    if (RenumberingItemUID(0, charItem_InOut.GetCID(), equip_In.Data, 
        equip_In.dwSize, equip_Out.Data, equip_Out.dwSize, "EQUIP") &&
        RenumberingItemUID(0, charItem_InOut.GetCID(), inven_In.Data, 
        inven_In.dwSize, inven_Out.Data, inven_Out.dwSize, "INVEN") &&        
        RenumberingItemUID(0, charItem_InOut.GetCID(), extra_In.Data, 
        extra_In.dwSize, extra_Out.Data, extra_Out.dwSize, "EXTRA"))
    {
        bChanged = true;

        charItem_InOut.SetEquip(equip_Out);
        charItem_InOut.SetInven(inven_Out);
        charItem_InOut.SetExtra(extra_Out);
    }
    
    return bChanged ? CONVERT_FORCE_WRITE : CONVERT_DO_NOT_WRITE;
}

ConvertResult CDBRenumberingItemUID::operator()(RylDBCommand::CCharItemEx& charItemEx_InOut)
{
    bool bChanged = false;

    const EXCHANGE&  exchange_In  = charItemEx_InOut.GetExchange();
    const TEMPINVEN& tempInven_In = charItemEx_InOut.GetTempInven();

    EXCHANGE  exchange_Out;
    TEMPINVEN tempInven_Out;

    memset(&exchange_Out,  0, sizeof(EXCHANGE));
    memset(&tempInven_Out, 0, sizeof(TEMPINVEN));

    if (RenumberingItemUID(0, charItemEx_InOut.GetCID(), exchange_In.Data, 
        exchange_In.dwSize, exchange_Out.Data, exchange_Out.dwSize, "EXCHANGE") &&
        RenumberingItemUID(0, charItemEx_InOut.GetCID(), tempInven_In.Data,
        tempInven_In.dwSize, tempInven_Out.Data, tempInven_Out.dwSize, "TEMPINVEN"))
    {
        bChanged = true;

        charItemEx_InOut.SetExchange(exchange_Out);
        charItemEx_InOut.SetTempInven(tempInven_Out);
    }

    return bChanged ? CONVERT_FORCE_WRITE : CONVERT_DO_NOT_WRITE;
}

ConvertResult CDBRenumberingItemUID::operator()(RylDBCommand::CUnifiedStore1& unifiedStore1_InOut)
{
    bool bChanged = false;

    const STORE& store_In = unifiedStore1_InOut.GetStore();

    STORE store_Out;
    memset(&store_Out, 0, sizeof(STORE));

    if (RenumberingItemUID(unifiedStore1_InOut.GetUID(), 0, store_In.Data,
        store_In.dwSize, store_Out.Data, store_Out.dwSize, "UnifiedStore1"))
    {
        bChanged = true;
        unifiedStore1_InOut.SetStore(store_Out);
    }

    return bChanged ? CONVERT_FORCE_WRITE : CONVERT_DO_NOT_WRITE;
}

ConvertResult CDBRenumberingItemUID::operator()(RylDBCommand::CUnifiedStore2& unifiedStore2_InOut)
{
    bool bChanged = false;

    const STORE& store_In = unifiedStore2_InOut.GetStore();

    STORE store_Out;
    memset(&store_Out, 0, sizeof(STORE));

    if (RenumberingItemUID(unifiedStore2_InOut.GetUID(), 0, store_In.Data,
        store_In.dwSize, store_Out.Data, store_Out.dwSize, "UnifiedStore2"))
    {
        bChanged = true;
        unifiedStore2_InOut.SetStore(store_Out);
    }

    return bChanged ? CONVERT_FORCE_WRITE : CONVERT_DO_NOT_WRITE;
}


bool CDBRenumberingItemUID::RenumberingItemUID(unsigned long dwUID, unsigned long dwCID, 
                                               const char* szOriginalData, unsigned long dwOriginalSize,
                                               char* szChangedData, unsigned long& dwChangedSize_InOut,
                                               const char* szContainerName)
{
    dwChangedSize_InOut = dwOriginalSize;

    if(0 != dwOriginalSize)
    {
        memcpy(szChangedData, szOriginalData, dwOriginalSize);        

        char* szDataPos = szChangedData;
        const char* szDataEnd = szChangedData + dwChangedSize_InOut;

        unsigned __int64 dwNewUID = 0LL;

        for(; szDataPos < szDataEnd; )
        {
            Item::ItemData* lpItemData = reinterpret_cast<Item::ItemData*>(szDataPos);

            dwNewUID = m_DBItemSerialMgr.GetNewItemSerial();

            INFLOG5(g_ItemLog, "[%s]/ UID:%10u / CID:%10u / OldItemSerial:0x%016I64X / "
                "NewItemSerial:0x%016I64X / Changed item serial",
                szContainerName, dwUID, dwCID, lpItemData->m_dwUID, dwNewUID);

            lpItemData->m_dwUID = dwNewUID;

            szDataPos += lpItemData->m_cItemSize;

            if(0 == lpItemData->m_cItemSize)
            {
                // 데이터가 이상합니다.

                INFLOG4(g_Log, "[%s]/ UID:%10u / CID:%10u / Invaild data size : %10u", 
                    szContainerName, dwUID, dwCID, dwOriginalSize);

                break;
            }
        }

        return true;
    }

    return false;    
}