// SkillRebalanceConverter.cpp : ÄÜ¼Ö ÀÀ¿ë ÇÁ·Î±×·¥¿¡ ´ëÇÑ ÁøÀÔÁ¡À» Á¤ÀÇÇÕ´Ï´Ù.
//

#include "stdafx.h"

#pragma warning(disable:4800)

#include <winsock2.h>
#include <windows.h>

#include <DB/DBComponent.h>
#include <DB/GameDBComponent.h>

#include <map>
#include <boost/pool/pool_alloc.hpp>
#include <Item/ItemMgr.h>
#include <Item/Item.h>
#include <Item/ItemContainer.h>
#include <Item/ItemFactory.h>
#include <Item/ItemStructure.h>

#include <Skill/SkillMgr.h>

#include <Log/ServerLog.h>

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

#include "ItemSerialMgr.h"
#include "3DArrayChecker.h"


#pragma pack(1)

struct SkillData
{
    unsigned long   m_dwCID;
    SKILL           m_skill;
};

struct CharData
{
    unsigned long   m_dwCID;
    INVEN           m_Inventory;
    EXTRA           m_Extra;
    EXCHANGE        m_Exchange;
};

struct StoreData
{
    unsigned long   m_dwUID;
    STORE           m_store1;
    STORE           m_store2;
};

#pragma pack()

struct SkillBookData
{
    enum { MAX_SKILL_LOCKCOUNT = 5 };
    unsigned long   m_dwSkillBookNum[MAX_SKILL_LOCKCOUNT];
};

typedef std::map<unsigned long, SkillBookData, std::less<unsigned long>, 
    boost::fast_pool_allocator<std::pair<unsigned long, SkillBookData> > >  SkillBookMap;
/*
typedef std::map<unsigned long, SkillBookData> SkillBookMap;
*/
bool ProcessCharData(CDBComponent& readDB, CDBComponent& writeDB, 
                     SkillBookMap& skillBookMap, bool bDelCharHistory, bool bWriteDB);

bool ProcessStoreData(CDBComponent& readDB, CDBComponent& writeDB, 
                      SkillBookMap& skillBookMap, bool bWriteDB);

bool ReadSkillData(CDBComponent& readDB, SkillBookMap& cidSkillBookMap, bool bReadDelCharHistory);

bool RemoveSkills(unsigned long dwKey, const char* szContainerName, SkillBookMap& skillBookMap,
                  const char* szInputData, unsigned long dwInputDataSize, 
                  char* szResultData, unsigned long& dwResultDataSize);

unsigned long InsertSkillBookTicket(unsigned long dwKey, const char* szContainerName, 
                                    C3DArrayChecker& arrayChecker, SkillBookMap& skillBookMap, 
                                    char* szData, unsigned long& dwDataSize_InOut, unsigned long dwMaxDataSize);

bool InsertToTempInven(CDBComponent& readDB, unsigned long dwCID, SkillBookMap& cidBookMap);
bool InsertToCharDelTempInven(CDBComponent& writeDB, unsigned long dwCID, SkillBookMap& cidBookMap);

void WriteSkillClear(CDBComponent& writeDB, bool bDelCharHistory);
void WriteBackCharacterData(CDBComponent& writeDB, CharData& originalData, CharData& newData);
void WriteBackStoreData(CDBComponent& writeDB, StoreData& originalData, StoreData& newData);
void WriteBackCharDelHistoryData(CDBComponent& writeDB, CharData& originalData, CharData& newData);

void AddCharGold(CDBComponent& writeDB, unsigned long dwGold, unsigned long dwCID, bool bCharDelHistory);
void AddStoreGold(CDBComponent& writeDB, unsigned long dwGold, unsigned long dwUID);

namespace DBComponent
{
namespace GameDB
{

bool UpdateDelHistoryInven(CDBComponent& DBComponent, unsigned long CharID_In, LPINVEN lpInven_In);
bool UpdateDelHistoryExtra(CDBComponent& DBComponent, unsigned long CharID_In, LPEXTRA lpExtra_In);
bool UpdateDelHistoryExchange(CDBComponent& DBComponent, unsigned long CharID_In, LPEXCHANGE lpExchange_In);

}
}


void PrintUsage()
{
    printf("Usage : SkillRebalanceConverter DBServerName DBName DBAccount DBPassword "
        "ServerGroup(GroupNum) ConvertDelHistroy(0/1) DBWrite(0/1)\n");
}

CServerLog g_GoldLog("GoldLog.log");

int _tmain(int argc, _TCHAR* argv[])
{
    if(argc != 8)
    {
        PrintUsage();
        return -1;
    }

    int     nGroupNum           = atoi(argv[5]);    
    bool    bConvertDelHistory  = (0 == strcmp("1", argv[6]));
    bool    bWriteDB            = (0 == strcmp("1", argv[7]));

    CDBComponent readDB;
    if(!readDB.Connect(argv[1], argv[2], argv[3], argv[4]))
    {
        printf("Open readDB failed\n");
        return -1;
    }

    CDBComponent writeDB;
    if(!writeDB.Connect(argv[1], argv[2], argv[3], argv[4]))
    {
        printf("Open writeDB failed\n");
        return -1;
    }

    if(!Item::CItemMgr::GetInstance().LoadItemProtoType("./NewItemScript.txt"))
    {
        printf("ItemScript load failed\n");
        return -1;
    }

    if(!CSkillMgr::GetInstance().LoadSkillsFromFile("./NewSkillScript.txt"))
    {
        printf("SkillScript load failed\n");
        return -1;
    }

    SERVER_ID serverID;
    serverID.sID.Type       = CServerSetup::AdminToolServer;
    serverID.sID.Group      = nGroupNum;
    serverID.sID.Channel    = 1;
    serverID.sID.ID         = SERVER_ID::ADMIN_TOOL_ZONE;

    CItemSerialMgr itemSerialMgr;

    if(!itemSerialMgr.LoadItemSerial(readDB, serverID.dwID))
    {
        printf("AdminTool serial setting failed\n");
        return -1;
    }

    Item::CItemFactory::GetInstance().SetItemUID(itemSerialMgr.GetItemSerial());
    
    /*
    1. ±âÁ¸ ½ºÅ³À» Àоî Ä«¿îÆÃÇÏ°í ¸®¼ÂÇÑ´Ù
    4´Ü°è/3´Ü°è/2´Ü°è/1´Ü°è °³¼ö Ä«¿îÆÃ

    2. ±âÁ¸ ½ºÅ³ºÏÀ» Àо Container¿¡ SerializeÇÑ ÈÄ iterator ·Î µ¹¸é¼­ Á¦°ÅÇÑ´Ù
    4´Ü°è/3´Ü°è/2´Ü°è/1´Ü°è °³¼ö Ä«¿îÆÃ

    3. ºó°ø°£À» °Ë»öÇؼ­, 3/4´Ü°è ½ºÅ³¿¡ ´ëÇؼ­ º¸»ó ¾ÆÀÌÅÛÀ» ³Ö¾îÁØ´Ù
    4. ºó°ø°£ÀÌ ¾øÀ¸¸é Àӽà Àκ¥Å丮¿¡ ³Ö¾î ÁØ´Ù.

    5. ´Ù½Ã SerializeÇؼ­ DB¿¡ ÀúÀåÇÑ´Ù.


    6. 1/2´Ü°è ½ºÅ³ºÏ¿¡ ´ëÇÑ º¸»ó ±Ý¾×À» DB¿¡ °»½ÅÇÑ´Ù.
    */

    SkillBookMap    m_cidBookMap;
    SkillBookMap    m_uidBookMap;

    /*
    SkillBookData data;
    memset(&data, 0, sizeof(SkillBookData));
    data.m_dwSkillBookNum[2] = 10;
    data.m_dwSkillBookNum[3] = 10;
    m_cidBookMap.insert(std::make_pair(277715, data));

    InsertToTempInven(writeDB, 277715, m_cidBookMap);
    */

    // Á¦°Å ¼º°øÇßÀ¸¸é, Àκ¥Å丮¿¡ ½ºÅ³ºÏ ±³È¯±ÇÀ» ³Ö¾îÁØ´Ù.
    if(bConvertDelHistory)
    {
        printf("Convert CharDelHistory\n");
        INFLOG0(g_Log, "Convert CharDelHistory");

        if(!ReadSkillData(readDB, m_cidBookMap, true))
        {
            printf("Skill data read failed\n");
            return -1;
        }

        if(!ProcessCharData(readDB, writeDB, m_cidBookMap, true, bWriteDB))
        {
            printf("CharDelHistory : Character data convert failed\n");
            return -1;
        }

        SkillBookMap::iterator pos = m_cidBookMap.begin();
        SkillBookMap::iterator end = m_cidBookMap.end();

        for(; pos != end; ++pos)
        {
            unsigned long dwCID = pos->first;
            SkillBookData& skillBookData = pos->second;

            ERRLOG5(g_Log, "CID:%10u / 0:%u / 1:%u / 2:%u / 3:%u / CharDelHistory : ´ÙÀ½ ½ºÅ³À» ij¸¯ÅÍ¿¡ Áö±ÞÇÏÁö ¸øÇß½À´Ï´Ù",
                dwCID, skillBookData.m_dwSkillBookNum[0], skillBookData.m_dwSkillBookNum[1],
                skillBookData.m_dwSkillBookNum[2], skillBookData.m_dwSkillBookNum[3]);
        }

        m_cidBookMap.clear();

        WriteSkillClear(writeDB, true);
    }

    printf("Read SkillData\n");
    INFLOG0(g_Log, "Read SkillData");

    if(!ReadSkillData(readDB, m_cidBookMap, false))
    {
        printf("Skill data read failed\n");
        return -1;
    }

    printf("Convert CharData\n");
    INFLOG0(g_Log, "Convert CharData");

    if(!ProcessCharData(readDB, writeDB, m_cidBookMap, false, bWriteDB))
    {
        printf("Character data convert failed\n");
        return -1;
    }

    printf("Convert StoreData\n");
    INFLOG0(g_Log, "Convert Store");

    if(!ProcessStoreData(readDB, writeDB, m_uidBookMap, bWriteDB))
    {
        printf("Store data convert failed\n");
        return -1;
    }

    SkillBookMap::iterator pos = m_cidBookMap.begin();
    SkillBookMap::iterator end = m_cidBookMap.end();

    for(; pos != end; ++pos)
    {
        unsigned long dwCID = pos->first;
        SkillBookData& skillBookData = pos->second;

        ERRLOG5(g_Log, "CID:%10u / 0:%u / 1:%u / 2:%u / 3:%u / ´ÙÀ½ ½ºÅ³À» ij¸¯ÅÍ¿¡ Áö±ÞÇÏÁö ¸øÇß½À´Ï´Ù",
            dwCID, skillBookData.m_dwSkillBookNum[0], skillBookData.m_dwSkillBookNum[1],
            skillBookData.m_dwSkillBookNum[2], skillBookData.m_dwSkillBookNum[3]);
    }

    m_cidBookMap.clear();

    pos = m_uidBookMap.begin();
    end = m_uidBookMap.end();

    for(; pos != end; ++pos)
    {
        unsigned long dwUID = pos->first;
        SkillBookData& skillBookData = pos->second;

        ERRLOG5(g_Log, "UID:%10u / 0:%u / 1:%u / 2:%u / 3:%u / ´ÙÀ½ ½ºÅ³À» â°í¿¡ Áö±ÞÇÏÁö ¸øÇß½À´Ï´Ù",
            dwUID, skillBookData.m_dwSkillBookNum[0], skillBookData.m_dwSkillBookNum[1],
            skillBookData.m_dwSkillBookNum[2], skillBookData.m_dwSkillBookNum[3]);
    }

    m_uidBookMap.clear();


    printf("Clear Skill\n");
    INFLOG0(g_Log, "Clear Skill");

    if(bWriteDB)
    {
        // ½ºÅ³À» ÃʱâÈ­ÇÑ´Ù.
        WriteSkillClear(writeDB, false);

        printf("Clear Skill Complete\n");
        INFLOG0(g_Log, "Clear Skill Complete");

        // ¾ÆÀÌÅÛ ½Ã¸®¾óÀ» ÀúÀåÇÑ´Ù.
        itemSerialMgr.SetItemSerial(Item::CItemFactory::GetInstance().GetItemUID());

        if(!itemSerialMgr.SaveItemSerial(writeDB, serverID.dwID))
        {
            printf("AdminTool serial save failed\n");
        }
    }

    printf("Convert Complete\n");
    INFLOG0(g_Log, "Convent Complete");
    return 0;
}



bool ProcessCharData(CDBComponent& readDB, CDBComponent& writeDB, SkillBookMap& skillBookMap, 
                     bool bDelCharHistory, bool bWriteDB)
{
    const char* szQuery = bDelCharHistory ? 
        "Select UID, Inventory, Extra from CharDelHistory..DelCharItem" :
        "Select a.UID, a.Inventory, a.Extra, b.Exchange from CharItem a join CharItemEX b on a.UID = b.UID";

    const int MAX_CHAR_DATA = 1024;
    CharData* lpCharData = new CharData[MAX_CHAR_DATA];

    if(0 == lpCharData)
    {
        printf("Memory allocation failed : CharData\n");
        return false;
    }

    memset(lpCharData, 0, sizeof(CharData) * MAX_CHAR_DATA);

    // ij¸¯ÅÍ Àκ¥ µÚÁ®¼­ ½ºÅ³ºÏ Á¦°ÅÇÏ°í, Ä«¿îÆÃÇϱâ.
    if(!readDB.ExecuteQuery(szQuery))    
    {
        printf("DBQuery failed : %s : %s\n", szQuery, readDB.GetErrorString());
        return false;
    }

    int nCount = 0;
    int nGetRowNum = 0;
    while(readDB.GetData((void**)lpCharData, sizeof(CharData), MAX_CHAR_DATA, &nGetRowNum))
    {
        if(0 == nGetRowNum)
        {
            break;
        }

        CharData* lpCharDataPos = lpCharData;
        CharData* lpCharDataEnd = lpCharData + nGetRowNum;

        for(; lpCharDataPos != lpCharDataEnd; ++lpCharDataPos, ++nCount)
        {
            unsigned long dwCID = lpCharDataPos->m_dwCID;

            CharData resultData;
            memset(&resultData, 0, sizeof(CharData));

            resultData.m_dwCID = dwCID;

            // Àκ¥Å丮¿¡¼­ Á¦°Å
            if(sizeof(unsigned long) <= lpCharDataPos->m_Inventory.dwSize)
            {
                lpCharDataPos->m_Inventory.dwSize -= sizeof(unsigned long);
            }

            resultData.m_Inventory.dwSize = INVEN::MAX_INVEN_SIZE;

            RemoveSkills(dwCID, "Inventory", skillBookMap, 
                lpCharDataPos->m_Inventory.Data, lpCharDataPos->m_Inventory.dwSize, 
                resultData.m_Inventory.Data, resultData.m_Inventory.dwSize);


            // ±³È¯Ã¢¿¡¼­ Á¦°Å
            if(sizeof(unsigned long) <= lpCharDataPos->m_Exchange.dwSize)
            {
                lpCharDataPos->m_Exchange.dwSize -= sizeof(unsigned long);
            }

            resultData.m_Exchange.dwSize = EXCHANGE::MAX_EXCHANGE_SIZE;

            RemoveSkills(dwCID, "Exchange", skillBookMap, 
                lpCharDataPos->m_Exchange.Data, lpCharDataPos->m_Exchange.dwSize, 
                resultData.m_Exchange.Data, resultData.m_Exchange.dwSize);

            // Extra¿¡¼­ Á¦°Å
            if(sizeof(unsigned long) <= lpCharDataPos->m_Extra.dwSize)
            {
                lpCharDataPos->m_Extra.dwSize -= sizeof(unsigned long);
            }

            resultData.m_Extra.dwSize = EXTRA::MAX_EXTRA_SIZE;

            RemoveSkills(dwCID, "Extra", skillBookMap, 
                lpCharDataPos->m_Extra.Data, lpCharDataPos->m_Extra.dwSize, 
                resultData.m_Extra.Data, resultData.m_Extra.dwSize);

            // Á¦°Å ¼º°øÇßÀ¸¸é, Àκ¥Å丮¿¡ ½ºÅ³ºÏ ±³È¯±ÇÀ» ³Ö¾îÁØ´Ù.
            C3DItemArrayChecker<6, 6, 3> invenArrayChecker(TakeType::TS_INVEN);

            unsigned long dwGold = 
                InsertSkillBookTicket(dwCID, "Inventory", invenArrayChecker, skillBookMap, 
                resultData.m_Inventory.Data, resultData.m_Inventory.dwSize, INVEN::MAX_INVEN_SIZE);

            // Á¦°Å ¼º°øÇßÀ¸¸é, ´Ù½Ã DB¿¡ ±â·Ï
            if(bWriteDB)
            {
                if(0 < dwGold)
                {
                    AddCharGold(writeDB, dwGold, dwCID, bDelCharHistory);
                }

                // ij¸¯ÅÍ µ¥ÀÌÅÍ DB¿¡ ±â·Ï
                if(bDelCharHistory)
                {
                    InsertToCharDelTempInven(writeDB, dwCID, skillBookMap);
                    WriteBackCharDelHistoryData(writeDB, *lpCharDataPos, resultData);
                }
                else
                {
                    // Àӽà Àκ¥Å丮¿¡ µ¥ÀÌÅÍ »ðÀÔ.
                    InsertToTempInven(writeDB, dwCID, skillBookMap);
                    WriteBackCharacterData(writeDB, *lpCharDataPos, resultData);
                }                
            }

            if(0 == (nCount % 1000))
            {
                printf(".");
            }
        }

        memset(lpCharData, 0, sizeof(CharData) * MAX_CHAR_DATA);
    }

    printf("\n");

    delete [] lpCharData;
    return true;
}



bool ProcessStoreData(CDBComponent& readDB, CDBComponent& writeDB, SkillBookMap& skillBookMap, bool bWriteDB)
{

    if(!readDB.ExecuteQuery(
        "Select a.UID, a.Store, b.Store from ItemStore1 a join ItemStore2 b on a.UID = b.UID"))
    {
        printf("Store query failed : %s\n", readDB.GetErrorString());
        return false;
    }

    const int MAX_STORE_DATA_NUM = 1024;
    StoreData* lpStoreData = new StoreData[MAX_STORE_DATA_NUM];

    if(0 == lpStoreData)
    {
        printf("Store memory allocation failed\n");
        return false;
    }

    int nCount = 0;

    int nGetRowNum = 0;
    while(readDB.GetData((void**)lpStoreData, sizeof(StoreData), MAX_STORE_DATA_NUM, &nGetRowNum))
    {
        if(0 == nGetRowNum)
        {
            break;
        }

        StoreData* lpStoreDataPos = lpStoreData;
        StoreData* lpStoreDataEnd = lpStoreData + nGetRowNum;

        for(; lpStoreDataPos != lpStoreDataEnd; ++lpStoreDataPos, ++nCount)
        {
            unsigned long dwUID = lpStoreDataPos->m_dwUID;

            StoreData resultData;
            memset(&resultData, 0, sizeof(StoreData));

            if(sizeof(unsigned long) <= lpStoreDataPos->m_store1.dwSize) { lpStoreDataPos->m_store1.dwSize -= sizeof(unsigned long); }
            if(sizeof(unsigned long) <= lpStoreDataPos->m_store2.dwSize) { lpStoreDataPos->m_store2.dwSize -= sizeof(unsigned long); }

            resultData.m_store1.dwSize = STORE::MAX_STORE_SIZE;
            resultData.m_store2.dwSize = STORE::MAX_STORE_SIZE;

            // â°í 1 ½ºÅ³ºÏ Àо Á¦°Å
            RemoveSkills(dwUID, "Store1", skillBookMap, 
                lpStoreDataPos->m_store1.Data, lpStoreDataPos->m_store1.dwSize, 
                resultData.m_store1.Data, resultData.m_store1.dwSize);

            // â°í 2 ½ºÅ³ºÏ Àо Á¦°Å
            RemoveSkills(dwUID, "Store2", skillBookMap, 
                lpStoreDataPos->m_store2.Data, lpStoreDataPos->m_store2.dwSize, 
                resultData.m_store2.Data, resultData.m_store2.dwSize);

            // Á¦°Å ¼º°øÇßÀ¸¸é, â°í¿¡ ½ºÅ³ºÏ ±³È¯±ÇÀ» ³Ö¾îÁØ´Ù.
            C3DItemArrayChecker<8, 12, 4> storeArrayChecker(TakeType::TS_DEPOSIT);

            unsigned long dwStoreGold = 
                InsertSkillBookTicket(dwUID, "store1", storeArrayChecker, skillBookMap, 
                resultData.m_store1.Data, resultData.m_store1.dwSize, STORE::MAX_STORE_SIZE);

            // â°í 1/2ÅÇ¿¡ ¾ÆÀÌÅÛÀÌ ²ËÂ÷¼­ ¸ø³ÖÀº °æ¿ì°¡ »ý±æ ¼ö ÀÖ´Ù. À̶§´Â â°í 3/4ÅÇ¿¡ ³Ö´Â´Ù.
            InsertSkillBookTicket(dwUID, "store2", storeArrayChecker, skillBookMap, 
                resultData.m_store2.Data, resultData.m_store2.dwSize, STORE::MAX_STORE_SIZE);

            // Á¦°Å ¼º°øÇßÀ¸¸é, ´Ù½Ã DB¿¡ ±â·Ï
            if(bWriteDB)
            {
                if(0 < dwStoreGold)
                {
                    AddStoreGold(writeDB, dwStoreGold, dwUID);                    
                }

                // â°í µ¥ÀÌÅÍ DB¿¡ ±â·Ï
                WriteBackStoreData(writeDB, *lpStoreDataPos, resultData);
            }

            if(0 == (nCount % 1000))
            {
                printf(".");
            }
        }

        memset(lpStoreData, 0, sizeof(StoreData) * MAX_STORE_DATA_NUM);
    }

    printf("\n");

    delete [] lpStoreData;
    return true;
}

bool RemoveSkills(unsigned long dwKey, const char* szContainerName, 
                  SkillBookMap& skillBookMap,
                  const char* szInputData, unsigned long dwInputDataSize, 
                  char* szResultData, unsigned long& dwResultDataSize)
{
    if(dwResultDataSize < dwInputDataSize)
    {        
        ERRLOG4(g_Log, "Key:%10u / ResultData:%10u / InputData:%10u / %s : ResultBuffer is too small", 
            dwKey, dwResultDataSize, dwInputDataSize, szContainerName);

        return false;
    }

    const char* szPos = szInputData;
    const char* szEnd = szInputData + dwInputDataSize;
   
    char* szResultPos = szResultData;

    for(; szPos < szEnd; )
    {
        const Item::ItemData* lpItemData = reinterpret_cast<const Item::ItemData*>(szPos);

        const Item::ItemInfo* lpItemInfo = 
            Item::CItemMgr::GetInstance().GetItemInfo(lpItemData->m_usProtoTypeID);

        if(0 == lpItemInfo)
        {
            ERRLOG4(g_Log, "Key:%10u / Serial:0x%016I64X / ProtoType:%6d / %s : Script has not this item", 
                dwKey, lpItemData->m_dwUID, lpItemData->m_usProtoTypeID, szContainerName);
        }
        else if(Item::ItemType::SKILLBOOK == lpItemInfo->m_DetailData.m_cItemType)
        {
            // ±³È¯±Ç ¹è¿­¿¡ Ä«¿îÆÃÇÏ°í, ¾ÆÀÌÅÛÀ» º¹»çÇÏÁö ¾Ê´Â´Ù.
            SkillBookMap::iterator pos = skillBookMap.find(dwKey);
            SkillBookMap::iterator end = skillBookMap.end();

            if(pos != end)
            {
                pos->second.m_dwSkillBookNum[lpItemInfo->m_UseItemInfo.m_usSkill_LockCount] += 
                    lpItemData->m_cNumOrDurability;
            }
            else            
            {
                SkillBookData bookData;
                memset(&bookData, 0, sizeof(SkillBookData));

                bookData.m_dwSkillBookNum[lpItemInfo->m_UseItemInfo.m_usSkill_LockCount] += 
                    lpItemData->m_cNumOrDurability;

                skillBookMap.insert(std::make_pair(dwKey, bookData));
            }
        }
        else
        {
            // ±×³É ¾ÆÀÌÅÛÀ» º¹»çÇÑ´Ù.
            memcpy(szResultPos, lpItemData, lpItemData->m_cItemSize);
            szResultPos += lpItemData->m_cItemSize;
        }

        szPos += lpItemData->m_cItemSize;
    }

    dwResultDataSize = static_cast<unsigned long>(szResultPos - szResultData);
    return true;
}


unsigned long InsertSkillBookTicket(unsigned long dwKey, const char* szContainerName, C3DArrayChecker& arrayChecker, 
                                    SkillBookMap& skillBookMap, 
                                    char* szData, unsigned long& dwDataSize_InOut, unsigned long dwMaxDataSize)
{
    unsigned long dwGold = 0;

    if(dwMaxDataSize < dwDataSize_InOut + sizeof(Item::ItemData) * 2)
    {
        ERRLOG2(g_Log, "Key:%10u / %s : give skillbook failed - data overflow", dwKey, szContainerName);
        return 0;
    }

    SkillBookMap::iterator pos = skillBookMap.find(dwKey);
    SkillBookMap::iterator end = skillBookMap.end();
    
    if(pos != end)
    {
        SkillBookData& bookData = pos->second;

        dwGold = bookData.m_dwSkillBookNum[0] * 1000 + bookData.m_dwSkillBookNum[1] * 10000;

        bookData.m_dwSkillBookNum[0] = 0;
        bookData.m_dwSkillBookNum[1] = 0;
        
        unsigned long dw3rdBookNum = bookData.m_dwSkillBookNum[2];
        unsigned long dw4thBookNum = bookData.m_dwSkillBookNum[3];

        if(0 < dw3rdBookNum || 0 < dw4thBookNum)
        {
            const char* szDataPos = szData;
            const char* szDataEnd = szData + dwDataSize_InOut;

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

                const Item::ItemInfo* lpItemInfo = 
                    Item::CItemMgr::GetInstance().GetItemInfo(lpItemData->m_usProtoTypeID);

                if(0 != lpItemInfo)
                {
                    arrayChecker.Set(lpItemData->m_ItemPos, 
                        lpItemInfo->m_DetailData.m_cXSize, lpItemInfo->m_DetailData.m_cYSize);
                }
                else
                {
                    ERRLOG4(g_Log, "Key:%10u / Serial:0x%016I64X / ProtoType:%6d / %s : Script has not this item", 
                        dwKey, lpItemData->m_dwUID, lpItemData->m_usProtoTypeID, szContainerName);
                }

                szDataPos += lpItemData->m_cItemSize;
            }

            if(0 < dw3rdBookNum)
            {
                Item::ItemData thirdSkillBook;
                memset(&thirdSkillBook, 0, sizeof(Item::ItemData));
                
                thirdSkillBook.m_dwUID              = Item::CItemFactory::GetInstance().GetItemUID() + 1;
                thirdSkillBook.m_usProtoTypeID      = 3401;
                thirdSkillBook.m_cItemSize          = sizeof(Item::ItemData);
                thirdSkillBook.m_cNumOrDurability   = static_cast<unsigned char>(dw3rdBookNum);
                
                if(arrayChecker.FindEmptyPos(thirdSkillBook.m_ItemPos, 1, 1))
                {
                    Item::CItemFactory::GetInstance().SetItemUID(thirdSkillBook.m_dwUID);
                    memcpy(szData + dwDataSize_InOut, &thirdSkillBook, sizeof(Item::ItemData));
                    dwDataSize_InOut += sizeof(Item::ItemData);

                    arrayChecker.Set(thirdSkillBook.m_ItemPos, 1, 1);

                    bookData.m_dwSkillBookNum[2] = 0;
                }
                else
                {
                    DETLOG3(g_Log, "Key:%10u / 3rdBookNum:%10u / %s : ºó °ø°£ÀÌ ¾ø¾î¼­ 3´Ü°è ½ºÅ³ºÏ ±³È¯±ÇÀ» Àӽà Àκ¥¿¡ ³Ö½À´Ï´Ù.", 
                        dwKey, dw3rdBookNum, szContainerName);
                }
            }

            if(0 < dw4thBookNum)
            {
                Item::ItemData forthSkillBook;
                memset(&forthSkillBook, 0, sizeof(Item::ItemData));

                forthSkillBook.m_dwUID              = Item::CItemFactory::GetInstance().GetItemUID() + 1;
                forthSkillBook.m_usProtoTypeID      = 3402;
                forthSkillBook.m_cItemSize          = sizeof(Item::ItemData);
                forthSkillBook.m_cNumOrDurability   = static_cast<unsigned char>(dw4thBookNum);

                if(arrayChecker.FindEmptyPos(forthSkillBook.m_ItemPos, 1, 1))
                {
                    Item::CItemFactory::GetInstance().SetItemUID(forthSkillBook.m_dwUID);
                    memcpy(szData + dwDataSize_InOut, &forthSkillBook, sizeof(Item::ItemData));
                    dwDataSize_InOut += sizeof(Item::ItemData);

                    arrayChecker.Set(forthSkillBook.m_ItemPos, 1, 1);

                    bookData.m_dwSkillBookNum[3] = 0;
                }
                else
                {
                    DETLOG3(g_Log, "Key:%10u / 4thBookNum:%10u / %s : ºó °ø°£ÀÌ ¾ø¾î¼­ 4´Ü°è ½ºÅ³ºÏ ±³È¯±ÇÀ» Àӽà Àκ¥¿¡ ³Ö½À´Ï´Ù.", 
                        dwKey, dw4thBookNum, szContainerName);
                }
            }
        }

        if(0 == bookData.m_dwSkillBookNum[0] && 0 == bookData.m_dwSkillBookNum[1] &&
            0 == bookData.m_dwSkillBookNum[2] && 0 == bookData.m_dwSkillBookNum[3])
        {
            // Á¦´ë·Î ´Ù Áö±ÞÇßÀ¸¸é ¸Ê¿¡¼­ Áö¿î´Ù.
            skillBookMap.erase(pos);   
        }
    }

    return dwGold;
}



bool InsertToTempInven(CDBComponent& writeDB, unsigned long dwCID, SkillBookMap& cidBookMap)
{
    SkillBookMap::iterator pos = cidBookMap.find(dwCID);
    SkillBookMap::iterator end = cidBookMap.end();

    if(pos != end)
    {
        // ¾ÆÁ÷ ½ºÅ³ºÏ Áö±ÞÀÌ ³¡³ªÁö ¾Ê¾Ò´Ù. Àӽà Àκ¥¿¡ ³Ö¾îÁØ´Ù.
        SkillBookData& bookData = pos->second;

        unsigned long dw3rdBookNum = bookData.m_dwSkillBookNum[2];
        unsigned long dw4thBookNum = bookData.m_dwSkillBookNum[3];

        TEMPINVEN tempInven;
        memset(&tempInven, 0, sizeof(TEMPINVEN));

        if(!DBComponent::GameDB::GetTempInven(writeDB, dwCID, &tempInven))
        {
            printf("Read temp inventory faild : CID:%10u / %s\n", dwCID, writeDB.GetErrorString());
            ERRLOG2(g_Log, "CID:%10u / Read temp inventory failed : %s", dwCID, writeDB.GetErrorString());
            return false;
        }

        const char* szDataPos = tempInven.Data;
        const char* szDataEnd = tempInven.Data + tempInven.dwSize;

        int nCount = 0;

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

            szDataPos += lpItemData->m_cItemSize;
            ++nCount;
        }
        
        if(0 < dw3rdBookNum)
        {
            Item::ItemData thirdSkillBook;
            memset(&thirdSkillBook, 0, sizeof(Item::ItemData));

            thirdSkillBook.m_dwUID              = Item::CItemFactory::GetInstance().GetItemUID() + 1;
            thirdSkillBook.m_usProtoTypeID      = 3401;
            thirdSkillBook.m_cItemSize          = sizeof(Item::ItemData);
            thirdSkillBook.m_cNumOrDurability   = static_cast<unsigned char>(dw3rdBookNum);

            thirdSkillBook.m_ItemPos = Item::ItemPos(TakeType::TS_TEMPINVEN, nCount);
            ++nCount;

            if(tempInven.dwSize + sizeof(Item::ItemData) < TEMPINVEN::MAX_TEMPINVEN_SIZE)
            {
                Item::CItemFactory::GetInstance().SetItemUID(thirdSkillBook.m_dwUID);
                memcpy(tempInven.Data + tempInven.dwSize, &thirdSkillBook, sizeof(Item::ItemData));
                tempInven.dwSize += sizeof(Item::ItemData);

                DETLOG2(g_Log, "CID:%10u / 3rdBookNum:%10u / 3´Ü°è ½ºÅ³ºÏ ±³È¯±ÇÀ» Àӽà Àκ¥¿¡ ³Ö½À´Ï´Ù.", dwCID, dw3rdBookNum);
            }
            else
            {
                ERRLOG2(g_Log, "CID:%10u / Num:%d / Insert 3rdBook to tempinven failed - not enough space", dwCID, dw3rdBookNum);
            }
        }

        if(0 < dw4thBookNum)
        {
            Item::ItemData forthSkillBook;
            memset(&forthSkillBook, 0, sizeof(Item::ItemData));

            forthSkillBook.m_dwUID              = Item::CItemFactory::GetInstance().GetItemUID() + 1;
            forthSkillBook.m_usProtoTypeID      = 3402;
            forthSkillBook.m_cItemSize          = sizeof(Item::ItemData);
            forthSkillBook.m_cNumOrDurability   = static_cast<unsigned char>(dw4thBookNum);

            forthSkillBook.m_ItemPos = Item::ItemPos(TakeType::TS_TEMPINVEN, nCount);
            ++nCount;

            if(tempInven.dwSize + sizeof(Item::ItemData) < TEMPINVEN::MAX_TEMPINVEN_SIZE)
            {
                Item::CItemFactory::GetInstance().SetItemUID(forthSkillBook.m_dwUID);
                memcpy(tempInven.Data + tempInven.dwSize, &forthSkillBook, sizeof(Item::ItemData));
                tempInven.dwSize += sizeof(Item::ItemData);

                DETLOG2(g_Log, "CID:%10u / 4thBookNum:%10u / 4´Ü°è ½ºÅ³ºÏ ±³È¯±ÇÀ» Àӽà Àκ¥¿¡ ³Ö½À´Ï´Ù.", dwCID, dw4thBookNum);
            }
            else
            {
                ERRLOG2(g_Log, "CID:%10u / Num:%d / Insert 3rdBook to tempinven failed - not enough space",
                    dwCID, dw3rdBookNum);
            }
        }

        if(!DBComponent::GameDB::UpdateTempInven(writeDB, dwCID, &tempInven))
        {
            printf("Write temp inventory faild : CID:%10u / %s\n", dwCID, writeDB.GetErrorString());
            ERRLOG2(g_Log, "CID:%10u / Write temp inventory failed : %s", dwCID, writeDB.GetErrorString());
            return false;
        }

        cidBookMap.erase(pos);
    }

    return true;
}

bool InsertToCharDelTempInven(CDBComponent& writeDB, unsigned long dwCID, SkillBookMap& cidBookMap)
{
    SkillBookMap::iterator pos = cidBookMap.find(dwCID);
    SkillBookMap::iterator end = cidBookMap.end();

    if(pos != end)
    {
        // ¾ÆÁ÷ ½ºÅ³ºÏ Áö±ÞÀÌ ³¡³ªÁö ¾Ê¾Ò´Ù. Àӽà Àκ¥¿¡ ³Ö¾îÁØ´Ù.
        SkillBookData& bookData = pos->second;

        unsigned long dw3rdBookNum = bookData.m_dwSkillBookNum[2];
        unsigned long dw4thBookNum = bookData.m_dwSkillBookNum[3];

        TEMPINVEN tempInven;
        memset(&tempInven, 0, sizeof(TEMPINVEN));

        _snprintf(writeDB.GetQueryBuffer(), CDBComponent::MAX_QUERY_LENGTH, 
            "SELECT TempInven FROM CharDelHistory..DelCharItemEx WHERE UID = %d", dwCID);

        if(!writeDB.ExecuteQueryGetData(writeDB.GetQueryBuffer(), &tempInven))
        {
            printf("Read temp inventory faild : CID:%10u / %s\n", dwCID, writeDB.GetErrorString());
            ERRLOG2(g_Log, "CID:%10u / Read temp inventory failed : %s", dwCID, writeDB.GetErrorString());
            return false;
        }

        if(sizeof(unsigned long) <= tempInven.dwSize)
        {
            tempInven.dwSize -= sizeof(unsigned long);
        }

        const char* szDataPos = tempInven.Data;
        const char* szDataEnd = tempInven.Data + tempInven.dwSize;

        int nCount = 0;

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

            szDataPos += lpItemData->m_cItemSize;
            ++nCount;
        }

        if(0 < dw3rdBookNum)
        {
            Item::ItemData thirdSkillBook;
            memset(&thirdSkillBook, 0, sizeof(Item::ItemData));

            thirdSkillBook.m_dwUID              = Item::CItemFactory::GetInstance().GetItemUID() + 1;
            thirdSkillBook.m_usProtoTypeID      = 3401;
            thirdSkillBook.m_cItemSize          = sizeof(Item::ItemData);
            thirdSkillBook.m_cNumOrDurability   = static_cast<unsigned char>(dw3rdBookNum);

            thirdSkillBook.m_ItemPos = Item::ItemPos(TakeType::TS_TEMPINVEN, nCount);
            ++nCount;

            if(tempInven.dwSize + sizeof(Item::ItemData) < TEMPINVEN::MAX_TEMPINVEN_SIZE)
            {
                Item::CItemFactory::GetInstance().SetItemUID(thirdSkillBook.m_dwUID);
                memcpy(tempInven.Data + tempInven.dwSize, &thirdSkillBook, sizeof(Item::ItemData));
                tempInven.dwSize += sizeof(Item::ItemData);

                DETLOG2(g_Log, "CID:%10u / 3rdBookNum:%10u / 3´Ü°è ½ºÅ³ºÏ ±³È¯±ÇÀ» Àӽà Àκ¥¿¡ ³Ö½À´Ï´Ù.", dwCID, dw3rdBookNum);
            }
            else
            {
                ERRLOG2(g_Log, "CID:%10u / Num:%d / Insert 3rdBook to tempinven failed - not enough space", dwCID, dw3rdBookNum);
            }
        }

        if(0 < dw4thBookNum)
        {
            Item::ItemData forthSkillBook;
            memset(&forthSkillBook, 0, sizeof(Item::ItemData));

            forthSkillBook.m_dwUID              = Item::CItemFactory::GetInstance().GetItemUID() + 1;
            forthSkillBook.m_usProtoTypeID      = 3402;
            forthSkillBook.m_cItemSize          = sizeof(Item::ItemData);
            forthSkillBook.m_cNumOrDurability   = static_cast<unsigned char>(dw4thBookNum);

            forthSkillBook.m_ItemPos = Item::ItemPos(TakeType::TS_TEMPINVEN, nCount);
            ++nCount;

            if(tempInven.dwSize + sizeof(Item::ItemData) < TEMPINVEN::MAX_TEMPINVEN_SIZE)
            {
                Item::CItemFactory::GetInstance().SetItemUID(forthSkillBook.m_dwUID);
                memcpy(tempInven.Data + tempInven.dwSize, &forthSkillBook, sizeof(Item::ItemData));
                tempInven.dwSize += sizeof(Item::ItemData);

                DETLOG2(g_Log, "CID:%10u / 4thBookNum:%10u / 4´Ü°è ½ºÅ³ºÏ ±³È¯±ÇÀ» Àӽà Àκ¥¿¡ ³Ö½À´Ï´Ù.", dwCID, dw4thBookNum);
            }
            else
            {
                ERRLOG2(g_Log, "CID:%10u / Num:%d / Insert 3rdBook to tempinven failed - not enough space",
                    dwCID, dw3rdBookNum);
            }
        }

        _snprintf(writeDB.GetQueryBuffer(), CDBComponent::MAX_QUERY_LENGTH, 
            "SELECT TempInven FROM CharDelHistory..DelCharItemEx WHERE UID = %d", dwCID);

        tempInven.dwSize += sizeof(unsigned long);
        if (!writeDB.ExecuteQuery(writeDB.GetQueryBuffer(), OleDB::Rowset_Update) ||
            !writeDB.SetBinaryData(1, (OleDB::LPSET_BINARY)&tempInven)) 
        {
            printf("Write temp inventory faild : CID:%10u / %s\n", dwCID, writeDB.GetErrorString());
            ERRLOG2(g_Log, "CID:%10u / Write temp inventory failed : %s", dwCID, writeDB.GetErrorString());
            return false;
        }

        cidBookMap.erase(pos);
    }

    return true;
}


bool ReadSkillData(CDBComponent& readDB, SkillBookMap& cidSkillBookMap, bool bReadCharDelHistory)
{
    const int MAX_SKILL_DATA = 1024;
    SkillData* lpSkillData = new SkillData[MAX_SKILL_DATA];

    if(0 == lpSkillData)
    {
        printf("ReadSkillData : Memory allocation failed\n");
        return false;
    }

    const char* szQuery = bReadCharDelHistory ? 
        "select UID, Skill From CharDelHistory..DelCharSkill" : 
        "select UID, SKill From CharSkill";

    if(!readDB.ExecuteQuery(szQuery))
    {
        printf("ReadSkillData : Query failed : %s : %s\n", szQuery, readDB.GetErrorString());
        return false;
    }

    int nCount = 0;
    int nGetRowNum = 0;

    memset(lpSkillData, 0, sizeof(SkillData) * MAX_SKILL_DATA);
    while(readDB.GetData((void**)lpSkillData, sizeof(SkillData), MAX_SKILL_DATA, &nGetRowNum))
    {
        if(0 == nGetRowNum)
        {
            break;
        }

        SkillData* lpSkillPos = lpSkillData;
        SkillData* lpSkillEnd = lpSkillData + nGetRowNum;

        for(; lpSkillPos != lpSkillEnd; ++lpSkillPos, ++nCount)
        {
            unsigned long dwCID = lpSkillPos->m_dwCID;
            SKILL& skill = lpSkillPos->m_skill;

            SkillBookData bookData;
            memset(&bookData, 0, sizeof(SkillBookData));

            for(int nSkillCount = 0; nSkillCount < skill.wSlotNum; ++nSkillCount)
            {
                SKILLSLOT& skillSlot = skill.SSlot[nSkillCount];

                if(skillSlot.SKILLINFO.cLockCount < CSkillMgr::MAX_SKILL_LOCKCOUNT &&
                    skillSlot.SKILLINFO.cSkillLevel <= CSkillMgr::MAX_SKILL_LEVEL &&
                    0 != CSkillMgr::GetInstance().GetSkillProtoType(skillSlot.SKILLINFO.wSkill))
                {
                    // ½ºÅ³ÀÇ Á¾·ù¿¡ °ü°è ¾øÀÌ Áö±Þ                    
                    for(int nLockCount = 0; nLockCount < skillSlot.SKILLINFO.cLockCount; ++nLockCount)
                    {
                        bookData.m_dwSkillBookNum[nLockCount] += CSkillMgr::MAX_SKILL_LEVEL;
                    }

                    bookData.m_dwSkillBookNum[skillSlot.SKILLINFO.cLockCount] += 
                        skillSlot.SKILLINFO.cSkillLevel;
                }
                else
                {
                    ERRLOG4(g_Log, "CID:%10u / Skill_ID:0x%04X / LockCount:%6d / Level:%6d / ¾Ë ¼ö ¾ø´Â ½ºÅ³ÀÔ´Ï´Ù",
                        dwCID, skillSlot.SKILLINFO.wSkill, skillSlot.SKILLINFO.cLockCount, skillSlot.SKILLINFO.cSkillLevel);
                }
            }

            cidSkillBookMap.insert(std::make_pair(dwCID, bookData));

            if(0 == (nCount % 1000))
            {
                printf(".");
            }
        }
        
        memset(lpSkillData, 0, sizeof(SkillData) * MAX_SKILL_DATA);
    }

    printf("\n");

    delete [] lpSkillData;
    return true;
}


// º¯°æµÈ Á¡À» DB¿¡ ±â·ÏÇÑ´Ù.
void WriteBackCharacterData(CDBComponent& writeDB, CharData& originalData, CharData& newData)
{
    unsigned long dwCID = originalData.m_dwCID;

    // Àκ¥Å丮 ±â·Ï
    if((newData.m_Inventory.dwSize != originalData.m_Inventory.dwSize ||
        0 != memcmp(newData.m_Inventory.Data, originalData.m_Inventory.Data, newData.m_Inventory.dwSize)) &&
        !DBComponent::GameDB::UpdateInven(writeDB, dwCID, &newData.m_Inventory))
    {
        ERRLOG1(g_Log, "CID:%10u / Àκ¥Å丮 ±â·Ï¿¡ ½ÇÆÐÇß½À´Ï´Ù.", dwCID);
    }

    // ±³È¯Ã¢ ±â·Ï
    if((newData.m_Exchange.dwSize != originalData.m_Exchange.dwSize ||
        0 != memcmp(newData.m_Exchange.Data, originalData.m_Exchange.Data, newData.m_Exchange.dwSize)) &&
        !DBComponent::GameDB::UpdateExchange(writeDB, dwCID, &newData.m_Exchange))
    {
        ERRLOG1(g_Log, "CID:%10u / Exchange ±â·Ï¿¡ ½ÇÆÐÇß½À´Ï´Ù.", dwCID);
    }

    // Extra ±â·Ï
    if((newData.m_Extra.dwSize != originalData.m_Extra.dwSize ||
        0 != memcmp(newData.m_Extra.Data, originalData.m_Extra.Data, newData.m_Extra.dwSize)) &&
        !DBComponent::GameDB::UpdateExtra(writeDB, dwCID, &newData.m_Extra))
    {
        ERRLOG1(g_Log, "CID:%10u / Extra ±â·Ï¿¡ ½ÇÆÐÇß½À´Ï´Ù.", dwCID);
    }
}

void WriteBackCharDelHistoryData(CDBComponent& writeDB, CharData& originalData, CharData& newData)
{
    unsigned long dwCID = originalData.m_dwCID;

    // Àκ¥Å丮 ±â·Ï
    if((newData.m_Inventory.dwSize != originalData.m_Inventory.dwSize ||
        0 != memcmp(newData.m_Inventory.Data, originalData.m_Inventory.Data, newData.m_Inventory.dwSize)) &&
        !DBComponent::GameDB::UpdateDelHistoryInven(writeDB, dwCID, &newData.m_Inventory))
    {
        ERRLOG1(g_Log, "CID:%10u / DelHistory Àκ¥Å丮 ±â·Ï¿¡ ½ÇÆÐÇß½À´Ï´Ù.", dwCID);
    }

    // ±³È¯Ã¢ ±â·Ï
    if((newData.m_Exchange.dwSize != originalData.m_Exchange.dwSize ||
        0 != memcmp(newData.m_Exchange.Data, originalData.m_Exchange.Data, newData.m_Exchange.dwSize)) &&
        !DBComponent::GameDB::UpdateDelHistoryExchange(writeDB, dwCID, &newData.m_Exchange))
    {
        ERRLOG1(g_Log, "CID:%10u / DelHistory Exchange ±â·Ï¿¡ ½ÇÆÐÇß½À´Ï´Ù.", dwCID);
    }

    // Extra ±â·Ï
    if((newData.m_Extra.dwSize != originalData.m_Extra.dwSize ||
        0 != memcmp(newData.m_Extra.Data, originalData.m_Extra.Data, newData.m_Extra.dwSize)) &&
        !DBComponent::GameDB::UpdateDelHistoryExtra(writeDB, dwCID, &newData.m_Extra))
    {
        ERRLOG1(g_Log, "CID:%10u / DelHistory Extra ±â·Ï¿¡ ½ÇÆÐÇß½À´Ï´Ù.", dwCID);
    }
}

void WriteBackStoreData(CDBComponent& writeDB, StoreData& originalData, StoreData& newData)
{
    unsigned long dwUID = originalData.m_dwUID;

    if((newData.m_store1.dwSize != originalData.m_store1.dwSize || 
        0 != memcmp(newData.m_store1.Data, originalData.m_store1.Data, newData.m_store1.dwSize)) &&
        !DBComponent::GameDB::UpdateItemStore1(writeDB, dwUID, &newData.m_store1))
    {
        ERRLOG1(g_Log, "UID:%10u / â°í 1 ±â·Ï¿¡ ½ÇÆÐÇß½À´Ï´Ù.", dwUID);
    }

    if((newData.m_store2.dwSize != originalData.m_store2.dwSize || 
        0 != memcmp(newData.m_store2.Data, originalData.m_store2.Data, newData.m_store2.dwSize)) &&
        !DBComponent::GameDB::UpdateItemStore2(writeDB, dwUID, &newData.m_store2))
    {
        ERRLOG1(g_Log, "UID:%10u / â°í 2 ±â·Ï¿¡ ½ÇÆÐÇß½À´Ï´Ù.", dwUID);
    }
}



void WriteSkillClear(CDBComponent& writeDB, bool bDelCharHistory)
{
    const int MAX_QUERY = 4;

    const char* szQuery[MAX_QUERY] = 
    {
        "Update CharSkill_1 set Skill = NULL",
        "Update CharSkill_2 set Skill = NULL",
        "Update CharSkill_3 set Skill = NULL",
        "Update CharSkill_4 set Skill = NULL"
    };
    
    const char* szQuickSlotQuery = "Update CharItem set Quick = NULL";

    if(bDelCharHistory)
    {
        szQuery[0] = "Update CharDelHistory..DelCharSkill_1 set Skill = NULL";
        szQuery[1] = "Update CharDelHistory..DelCharSkill_2 set Skill = NULL";
        szQuery[2] = "Update CharDelHistory..DelCharSkill_3 set Skill = NULL";
        szQuery[3] = "Update CharDelHistory..DelCharSkill_4 set Skill = NULL";

        szQuickSlotQuery = "Update CharDelHistory..DelCharItem set Quick = NULL";
    }

    for(int nCount = 0; nCount < MAX_QUERY; ++nCount)
    {
        if(!writeDB.ExecuteQuery(szQuery[nCount]))
        { 
            printf("Query failed : %s : %s\n", szQuery[nCount], writeDB.GetErrorString());
            ERRLOG2(g_Log, "Query failed : %s : %s\n", szQuery[nCount], writeDB.GetErrorString());
            break;
        }
    }

    if(!writeDB.ExecuteQuery(szQuickSlotQuery))
    { 
        printf("Query failed : %s : %s\n", szQuickSlotQuery, writeDB.GetErrorString());
        ERRLOG2(g_Log, "Query failed : %s : %s\n", szQuickSlotQuery, writeDB.GetErrorString());        
    }
}

void AddCharGold(CDBComponent& writeDB, unsigned long dwGold, unsigned long dwCID, bool bCharDelHistory)
{
    unsigned long dwOldGold = 0;
    unsigned long dwNewGold = 0;

    if(bCharDelHistory)
    {
        unsigned long dwIndex = (dwCID % 4) + 1;

        const int MAX_QUERY_LEN = 1024;
        char szGetQuery[MAX_QUERY_LEN];
        char szUpdateQuery[MAX_QUERY_LEN];

        _snprintf(szGetQuery, MAX_QUERY_LEN, "select Gold from CharDelHistory..DelCharInfo_%u where UID = %d",
            dwIndex, dwCID);

        if(!writeDB.ExecuteQueryGetData(szGetQuery, &dwOldGold))
        {
            ERRLOG2(g_Log, "CID:%10u / Gold:%10u / CharDelHistory : µ·À» ³Ö¾îÁÖ±â À§ÇØ Ä³¸¯ÅÍ µ¥ÀÌÅÍ Àоî¿À±â ½ÇÆÐ", dwCID, dwGold);
        }
        else
        {
            if(dwOldGold < ULONG_MAX - dwGold)
            {
                dwNewGold = dwOldGold + dwGold;
            }
            else
            {
                dwNewGold = ULONG_MAX;                    
            }

            _snprintf(szUpdateQuery, MAX_QUERY_LEN, "UPDATE CharDelHistory..DelCharInfo_%u SET Gold = %d where UID = %d",
                dwIndex, dwNewGold, dwCID);

            if(!writeDB.ExecuteQuery(szUpdateQuery))
            {
                dwNewGold = 0;
                ERRLOG2(g_Log, "CID:%10u / Gold:%10u / µ·À» ³Ö¾îÁÖ±â À§ÇØ Ä³¸¯ÅÍ µ¥ÀÌÅÍ ÀúÀåÇϱ⠽ÇÆÐ", dwCID, dwGold);
            }
        }
    }
    else
    {
        const int MAX_EQUIP_VIEW = 15;

        CHAR_INFOST     charInfoST;
        unsigned short  usEquipView[MAX_EQUIP_VIEW];

        memset(&charInfoST, 0, sizeof(CHAR_INFOST));
        memset(usEquipView, 0, sizeof(unsigned short) * MAX_EQUIP_VIEW);

        if(!DBComponent::GameDB::GetCharInfo(writeDB, dwCID, 
            &charInfoST, usEquipView, MAX_EQUIP_VIEW))
        {
            ERRLOG2(g_Log, "CID:%10u / Gold:%10u / µ·À» ³Ö¾îÁÖ±â À§ÇØ Ä³¸¯ÅÍ µ¥ÀÌÅÍ Àоî¿À±â ½ÇÆÐ", dwCID, dwGold);
        }
        else
        {
            dwOldGold = charInfoST.Gold;

            if(charInfoST.Gold < ULONG_MAX - dwGold)
            {
                charInfoST.Gold += dwGold;
            }
            else
            {
                charInfoST.Gold = ULONG_MAX;                    
            }

            if(!DBComponent::GameDB::UpdateCharInfo(writeDB, dwCID, 
                &charInfoST, usEquipView, MAX_EQUIP_VIEW))
            {
                ERRLOG2(g_Log, "CID:%10u / Gold:%10u / µ·À» ³Ö¾îÁÖ±â À§ÇØ Ä³¸¯ÅÍ µ¥ÀÌÅÍ ÀúÀåÇϱ⠽ÇÆÐ", dwCID, dwGold);
            }
            else
            {
                dwNewGold = charInfoST.Gold;
            }
        }
    }

    if(0 != dwNewGold && 0 != dwGold)
    {
        DETLOG4(g_GoldLog, "CID:%10u / OldGold:%10u / NewGold:%10u / GetGold:%10u / ij¸¯ÅÍ¿¡ µ·À» Áö±ÞÇß½À´Ï´Ù.", 
            dwCID, dwOldGold, dwNewGold, dwGold);
    }
}


void AddStoreGold(CDBComponent& writeDB, unsigned long dwGold, unsigned long dwUID)
{
    STORE_INFO storeInfo;
    memset(&storeInfo, 0, sizeof(STORE_INFO));

    unsigned long dwOldGold = 0;
    unsigned long dwNewGold = 0;

    if(!DBComponent::GameDB::GetItemStoreInfo(writeDB, dwUID, &storeInfo))
    {
        ERRLOG2(g_Log, "UID:%10u / Gold:%10u / µ· ´õÇϱ⠽ÇÆÐ : â°í Á¤º¸ Àб⠽ÇÆÐ", dwUID, dwGold);
    }
    else
    {
        dwOldGold = storeInfo.Gold;

        if(storeInfo.Gold < ULONG_MAX - dwGold)
        {
            storeInfo.Gold += dwGold;
        }
        else
        {
            storeInfo.Gold = ULONG_MAX;
        }

        if(!DBComponent::GameDB::SetItemStoreInfo(writeDB, dwUID, &storeInfo))
        {
            ERRLOG2(g_Log, "UID:%10u / Gold:%10u / µ· ´õÈ÷±â ½ÇÆÐ : â°í Á¤º¸ ÀúÀå ½ÇÆÐ", dwUID, dwGold);
        }
        else
        {
            dwNewGold = storeInfo.Gold;
        }
    }

    if(0 != dwNewGold && 0 != dwGold)
    {
        DETLOG4(g_GoldLog, "UID:%10u / OldGold:%10u / NewGold:%10u / GetGold:%10u / â°í¿¡ µ·À» Áö±ÞÇß½À´Ï´Ù.", 
            dwUID, dwOldGold, dwNewGold, dwGold);
    }
}




///////////////////////////////////////////////////////////////////////////////////////////////
//
// UpdateInven [ public ]
// - Àκ¥ ¾÷µ¥ÀÌÆ®
//
// Parameter :
//	1st : ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	2st : Àκ¥ µ¥ÀÌÅÍ[Out]
//
// Return :
//	»ý¼º ¼º°ø ½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool DBComponent::GameDB::UpdateDelHistoryInven(CDBComponent& DBComponent, unsigned long CharID_In, LPINVEN lpInven_In)
{
    _snprintf(DBComponent.GetQueryBuffer(), CDBComponent::MAX_QUERY_LENGTH, 
        "SELECT Inventory FROM CharDelHistory..DelCharItem WHERE UID = %d", CharID_In );

    lpInven_In->dwSize += sizeof(unsigned long);
    if (DBComponent.ExecuteQuery(DBComponent.GetQueryBuffer(), OleDB::Rowset_Update)) {
        if (DBComponent.SetBinaryData(1, (OleDB::LPSET_BINARY)lpInven_In)) {
            lpInven_In->dwSize -= sizeof(unsigned long);
            return true;
        }
    }

    SERLOG3(g_Log, "CID:%10u %s %s", CharID_In, DBComponent.GetErrorString(), DBComponent.GetQueryBuffer());
    lpInven_In->dwSize -= sizeof(unsigned long);
    return false;
}

///////////////////////////////////////////////////////////////////////////////////////////////
//
// UpdateExtra [ public ]
// - Àκ¥ Äü ½½·Ô
//
// Parameter :
//	1st : ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	2st : Äü[Out]
//
// Return :
//	»ý¼º ¼º°ø ½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool DBComponent::GameDB::UpdateDelHistoryExtra(CDBComponent& DBComponent, unsigned long CharID_In, LPEXTRA lpExtra_In)
{
    _snprintf(DBComponent.GetQueryBuffer(), CDBComponent::MAX_QUERY_LENGTH, 
        "SELECT Extra FROM CharDelHistory..DelCharItem WHERE UID = %d", CharID_In );

    lpExtra_In->dwSize += sizeof(unsigned long);
    if (DBComponent.ExecuteQuery(DBComponent.GetQueryBuffer(), OleDB::Rowset_Update)) {
        if (DBComponent.SetBinaryData(1, (OleDB::LPSET_BINARY)lpExtra_In)) {
            lpExtra_In->dwSize -= sizeof(unsigned long);
            return true;
        }
    }

    ERRLOG3(g_Log, "CID:%10u %s %s", CharID_In, DBComponent.GetErrorString(), DBComponent.GetQueryBuffer());
    lpExtra_In->dwSize -= sizeof(unsigned long);
    return false;
}

///////////////////////////////////////////////////////////////////////////////////////////////
//
// UpdateExchange [ public ]
// - ±³È¯ ¾÷µ¥ÀÌÆ®
//
// Parameter :
//	1st : ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	2st : ±³È¯[In]
//
// Return :
//	»ý¼º ¼º°ø ½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool DBComponent::GameDB::UpdateDelHistoryExchange(CDBComponent& DBComponent, unsigned long CharID_In, LPEXCHANGE lpExchange_In)
{
    _snprintf(DBComponent.GetQueryBuffer(), CDBComponent::MAX_QUERY_LENGTH, 
        "SELECT Exchange FROM CharDelHistory..DelCharItemEx WHERE UID = %d", CharID_In );

    lpExchange_In->dwSize += sizeof(unsigned long);
    if (DBComponent.ExecuteQuery(DBComponent.GetQueryBuffer(), OleDB::Rowset_Update)) {
        if (DBComponent.SetBinaryData(1, (OleDB::LPSET_BINARY)lpExchange_In)) {
            lpExchange_In->dwSize -= sizeof(unsigned long);
            return true;
        }
    }

    ERRLOG3(g_Log, "CID:%10u %s %s", CharID_In, DBComponent.GetErrorString(), DBComponent.GetQueryBuffer());
    lpExchange_In->dwSize -= sizeof(unsigned long);
    return false;
}