#include "stdafx.h"

#include <Log/ServerLog.h>
#include <Utility/Resource/EnsureCleanup.h>
#include <Utility/Compress/MiniLZO/MiniLZOWrapper.h>
#include <Network/XORCrypt/XORCrypt.h>
#include "../Utility/TokenlizedFile.h"

#define DECODE_HEADER(Start_In, Length_In, PageVer_In, PageNum_In)  CXORCrypt::GetInstance().DecodeHeader((Start_In),(Length_In),(PageVer_In),(PageNum_In))
#define ENCODE_HEADER(Start_In, Length_In, PageVer_In, PageNum_In)  CXORCrypt::GetInstance().EncodeHeader((Start_In),(Length_In),(PageVer_In),(PageNum_In))
#define COMPRESS(In, In_len, Out, Out_len)      CMiniLZOCompress::Compress((In), (In_len), (Out), (Out_len))
#define DECOMPRESS(In, In_len, Out, Out_len)    CMiniLZOCompress::Decompress((In), (In_len), (Out), (Out_len))

#include <memory>
#include <algorithm>

#include "ItemMgr.h"
#include "ItemDataParser.h"



#ifdef _TEST_SERVER_
const char* Item::CItemMgr::ms_szItemScriptFileName = "TestItemScript.txt";
#else
const char* Item::CItemMgr::ms_szItemScriptFileName = "ItemScript.txt";
#endif


Item::CItemMgr Item::CItemMgr::ms_this;

using namespace Item;


class CParseDelimitedData
{
public:

    CParseDelimitedData(CTokenlizedFile& TokenlizedFile) : m_TokenlizedFile(TokenlizedFile) { }

    bool operator() (ItemDataParser::ParseDataArray& ParserArray, Item::ItemInfo& itemInfo)
    {
        for (ItemDataParser::ParseDataArray::iterator itr = ParserArray.begin();
            itr != ParserArray.end(); ++itr)
        {
            const char* szValue = m_TokenlizedFile.GetStringValue(itr->m_szColumnName);

            if (NULL == szValue)
            {
                ERRLOG2(g_Log, "µ¥ÀÌÅ͸¦ Àоî¿Ã ¼ö ¾ø½À´Ï´Ù. Line:%d, ColumnName:%d",
                    m_TokenlizedFile.GetCurrentLine(), itr->m_szColumnName);
                return false;
            }

            if (!itr->m_fnParseFunc(itemInfo, szValue))
            {
                ERRLOG2(g_Log, "¾Ë¸ÂÀº µ¥ÀÌÅÍ°¡ ¾Æ´Õ´Ï´Ù. Line:%d, ColumnName:%d",
                    m_TokenlizedFile.GetCurrentLine(), itr->m_szColumnName);
                return false;
            }
        }

        return true;
    }

private:

    CTokenlizedFile& m_TokenlizedFile;
};


CItemMgr::CItemMgr()
:	m_ItemInfoArray(NULL), m_nItemNum(0)
{

}

CItemMgr::~CItemMgr() 
{ 	
    DestoryItemInfo();
}

void CItemMgr::DestoryItemInfo()
{
    if (NULL != m_ItemInfoArray)
    {
        delete [] m_ItemInfoArray;
        m_ItemInfoArray = NULL;
    }

    m_nItemNum = 0;
}

bool CItemMgr::LoadItemProtoType(const char* szFileName)
{
    DestoryItemInfo();
    
    Item::ItemInfo  itemInfo;
	CTokenlizedFile TokenlizedFile;	// °´Ã¼ ¼Ò¸ê½Ã, ÀÚµ¿ Close.

	if (!TokenlizedFile.Open((NULL != szFileName) ? szFileName : ms_szItemScriptFileName))
    {
        ERRLOG0(g_Log, "¾ÆÀÌÅÛ ½ºÅ©¸³Æ® ÆÄÀÏ ·Îµù¿¡ ½ÇÆÐÇß½À´Ï´Ù.");
        return false;
    }
        
    if (!TokenlizedFile.ReadColumn())
    {
        ERRLOG0(g_Log, "¾ÆÀÌÅÛ ½ºÅ©¸³Æ® Ä÷³À» Àоî¿À´Â µ¥ ½ÇÆÐÇß½À´Ï´Ù.");
        return false;
    }

    ItemDataParser::ParseDataArray  DefaultItemData;
    ItemDataParser::ParseDataArray  EquipItemData;
    ItemDataParser::ParseDataArray  UseItemData;
    ItemDataParser::ParseDataArray  EtcItemData;

    ItemDataParser::SetDefaultData(DefaultItemData);
    ItemDataParser::SetEquipData(EquipItemData);
    ItemDataParser::SetUseItemData(UseItemData);
    ItemDataParser::SetEtcItemData(EtcItemData);

    Item::CItemType& ItemType = Item::CItemType::GetInstance();
         
    std::vector<Item::ItemInfo>     ItemInfoVector;

    CParseDelimitedData ParseData(TokenlizedFile);

    while(TokenlizedFile.ReadLine())
	{
        itemInfo.Initialize();

        if (!ParseData(DefaultItemData, itemInfo)) { return false; }
        
        if (ItemType.IsCorrectItemType(Item::CItemType::EQUIP_TYPE, 
            itemInfo.m_DetailData.m_cItemType))
        {
            // Àåºñ ¾ÆÀÌÅÛ.
            if (!ParseData(EquipItemData, itemInfo)) { return false; }
            ItemType.SetEquipTypeFlags(itemInfo);
        }        
        else if (ItemType.IsCorrectItemType(Item::CItemType::USE_ITEM_TYPE, 
            itemInfo.m_DetailData.m_cItemType))
        {
            // »ç¿ë ¾ÆÀÌÅÛ.
            if (!ParseData(UseItemData, itemInfo)) { return false; }
            ItemType.SetUseItemTypeFlags(itemInfo);
        }
        else
        {
            // ±âŸ ¾ÆÀÌÅÛ.
            if (!ParseData(EtcItemData, itemInfo))  { return false; }
            ItemType.SetEtcItemTypeFlags(itemInfo);
        }

        ItemInfoVector.push_back(itemInfo);
    }

    if (!TokenlizedFile.IsEOF())
    {
        ERRLOG0(g_Log, "¾ÆÀÌÅÛ ½ºÅ©¸³Æ® ÆÄÀÏÀ» ´Ù ÀÐÁö ¸øÇÏ°í Á¾·áÇÕ´Ï´Ù.");
        return false;
    }

    std::sort(ItemInfoVector.begin(), ItemInfoVector.end());

    for (std::vector<Item::ItemInfo>::iterator itr = ItemInfoVector.begin();
        itr != ItemInfoVector.end() - 1; ++itr)
    {
        if (itr->m_usProtoTypeID == (itr+1)->m_usProtoTypeID)
        {
            ERRLOG1(g_Log, "°ãÄ¡´Â ¾ÆÀÌÅÛ Á¾·ù ID°¡ ÀÖ½À´Ï´Ù. Á¾·ùID:%d", itr->m_usProtoTypeID);
            return false;
        }
    };

    m_nItemNum = ItemInfoVector.size();
    m_ItemInfoArray = new Item::ItemInfo[m_nItemNum];
    if (NULL == m_ItemInfoArray)
    {
        ERRLOG0(g_Log, "¾ÆÀÌÅÛ ½ºÅ©¸³Æ® ³»¿ëÀ» º¹»çÇÒ ¼ö ¾ø½À´Ï´Ù. ¸Þ¸ð¸®°¡ ºÎÁ·ÇÕ´Ï´Ù.");
        return false;
    }

    std::copy(ItemInfoVector.begin(), ItemInfoVector.end(), m_ItemInfoArray);
    return true;
}

const Item::ItemInfo* CItemMgr::GetItemInfo(unsigned short usProtoTypeID)
{
    Item::ItemInfo* lpFirst = m_ItemInfoArray;
    Item::ItemInfo* lpLast  = m_ItemInfoArray + m_nItemNum;
    Item::ItemInfo* lpMid   = NULL;

    size_t nCount   = m_nItemNum;
    size_t nCount2  = 0;

    for (; 0 < nCount; )
    {
        nCount2 = nCount / 2;
        lpMid = lpFirst + nCount2;

        if (lpMid->m_usProtoTypeID < usProtoTypeID)
        {
            lpFirst = ++lpMid, nCount -= nCount2 + 1;
        }
        else
        {
            nCount = nCount2;
        }
    }

    return (lpFirst != lpLast && !(usProtoTypeID < lpFirst->m_usProtoTypeID)) ? lpFirst : NULL;
}

const Item::ItemInfo* CItemMgr::GetItemInfoFromItemName(const char* szItemName)
{
    Item::ItemInfo* lpFirst = m_ItemInfoArray;
    Item::ItemInfo* lpLast  = m_ItemInfoArray + m_nItemNum;

    for (; lpFirst != lpLast; ++lpFirst)
    {
        if (0 == strcmp(lpFirst->m_SpriteData.m_szName, szItemName))
        {
            return lpFirst;
        }
    }

    return NULL;
}

const Item::ItemInfo* CItemMgr::GetItemInfoFromEquipName(const char* szEquipName)
{
    Item::ItemInfo* lpFirst = m_ItemInfoArray;
    Item::ItemInfo* lpLast  = m_ItemInfoArray + m_nItemNum;

    for (; lpFirst != lpLast; ++lpFirst)
    {
        if (0 == strcmp(lpFirst->m_StringData.m_szEquipModelName, szEquipName))
        {
            return lpFirst;
        }
    }

    return NULL;
}


const char* Item::CItemMgr::GetEquipName(const unsigned short usItemProtoTypeID)
{
	const Item::ItemInfo* pItemInfo = GetItemInfo(usItemProtoTypeID);

	if(pItemInfo)
	{
		return pItemInfo->m_StringData.m_szEquipModelName;
	}

	return NULL;
}


const unsigned short CItemMgr::GetItemIDFromSkillID(const unsigned short usSkill_ID, const unsigned short unSkill_LockCount)
{
    Item::ItemInfo* lpFirst = m_ItemInfoArray;
    Item::ItemInfo* lpLast  = m_ItemInfoArray + m_nItemNum;

    for (; lpFirst != lpLast; ++lpFirst)
    {
        if (lpFirst->m_UseItemInfo.m_usSkill_ID == usSkill_ID && 
			lpFirst->m_UseItemInfo.m_usSkill_LockCount == unSkill_LockCount)
        {
            return lpFirst->m_usProtoTypeID;
        }
    }

    return 0;
}


bool CItemMgr::LoadItemProtoTypeBinary(const char* szFileNameBinary)
{
	using namespace Item;
    
	HANDLE hFile = CreateFile((0 == szFileNameBinary) ? ms_szItemScriptFileName : szFileNameBinary,
        GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 
	if (hFile == INVALID_HANDLE_VALUE) { return false; } 

    CEnsureCloseHandle EnsureCloseHandle(hFile);

	DWORD dwRead            = 0;
	DWORD dwFileHighSize    = 0;
	DWORD dwFileSize        = GetFileSize(hFile, &dwFileHighSize);

    char* lpAllocated = new char[dwFileSize];
    CEnsureDeleteArray<char> EnsureFileInfo(lpAllocated);
	
	if (!ReadFile(hFile, lpAllocated, dwFileSize, &dwRead, NULL)) 
    {        
    	return false;
	}
    
	DWORD dwHeaderSize          = sizeof(DWORD) + *reinterpret_cast<DWORD*>(lpAllocated) + sizeof(DWORD);
    DWORD dwDecompressedSize    = *reinterpret_cast<DWORD*>(lpAllocated + dwHeaderSize - sizeof(DWORD));

    DestoryItemInfo();

    m_nItemNum = dwDecompressedSize/sizeof(Item::ItemInfo);
    m_ItemInfoArray = new Item::ItemInfo[m_nItemNum];
    if (NULL == m_ItemInfoArray)
    {
        ERRLOG0(g_Log, "¾ÆÀÌÅÛ ½ºÅ©¸³Æ® ³»¿ëÀ» ºÒ·¯¿Ã ¼ö ¾ø½À´Ï´Ù. ¸Þ¸ð¸®°¡ ºÎÁ·ÇÕ´Ï´Ù.");
        return false;
    }

    DECOMPRESS(lpAllocated + dwHeaderSize, dwFileSize - dwHeaderSize, 
        reinterpret_cast<char*>(m_ItemInfoArray), &dwDecompressedSize);

    DECODE_HEADER(reinterpret_cast<char*>(m_ItemInfoArray), dwDecompressedSize, 0, 2);
	return true;
}


bool CItemMgr::SaveItemProtoTypeBinary(const char* szFileNameBinary, const char* szTrashFile)
{
	HANDLE hFile = CreateFile((0 == szFileNameBinary) ? ms_szItemScriptFileName : szFileNameBinary,
		GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

	if (hFile == INVALID_HANDLE_VALUE) { return false; }
    
    CEnsureCloseHandle EnsureCloseSaveHandle(hFile);

    DWORD   nItemInfoSize       = static_cast<DWORD>(sizeof(Item::ItemInfo) * m_nItemNum);
    DWORD   nCompressedInfoSize = nItemInfoSize;
    
    char*   lpItemInfo          = new char[nItemInfoSize];
    char*   lpCompressedInfo    = new char[nItemInfoSize];

    CEnsureDeleteArray<char> EnsureDeleteItemInfo(lpItemInfo);
    CEnsureDeleteArray<char> EnsureDeleteCompressedInfo(lpCompressedInfo);

	if (0 == lpItemInfo || 0 == lpCompressedInfo)
    {
		return false;
	}

    memcpy(lpItemInfo, m_ItemInfoArray, nItemInfoSize);
    ENCODE_HEADER(lpItemInfo, nItemInfoSize, 0, 2);
    COMPRESS(lpItemInfo, nItemInfoSize, lpCompressedInfo, &nCompressedInfoSize);

	// ¾²·¹±â(´õ¹Ì) ÀÚ·á
	HANDLE hTrashFile = CreateFile(szTrashFile, GENERIC_READ, FILE_SHARE_READ, 
        NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

	if (hTrashFile == INVALID_HANDLE_VALUE) { return false; } 

    CEnsureCloseHandle EnsureCloseTrashHandle(hTrashFile);

	DWORD dwRead = 0;
    DWORD dwWritten = 0;
	DWORD dwFileHighSize = 0;
	DWORD dwTrashFileSize = GetFileSize(hTrashFile, &dwFileHighSize);

    char* lpTrashFileData = new char[dwTrashFileSize];
    CEnsureDeleteArray<char> EnsureDeleteTrashFile(lpTrashFileData);

	if (!ReadFile(hTrashFile, lpTrashFileData, dwTrashFileSize, &dwRead, NULL))
    {
		return false;
	}

    // Trash Fileµ¥ÀÌÅÍ
	WriteFile(hFile, &dwTrashFileSize, sizeof(DWORD), &dwWritten, 0);       // Trash ÆÄÀÏÀÇ Å©±â
	WriteFile(hFile, lpTrashFileData, dwTrashFileSize, &dwWritten, 0);      // Trash ÆÄÀÏ ³»¿ë

	// ¿Ã¹Ù¸¥ ÀÚ·á
	WriteFile(hFile, &nItemInfoSize, sizeof(DWORD), &dwWritten, 0);         // ¿øº» µ¥ÀÌÅÍ Å©±â
	WriteFile(hFile, lpCompressedInfo, nCompressedInfoSize, &dwWritten, 0); // ¾ÐÃàµÈ µ¥ÀÌÅÍ
	return true;
}