
#include "stdafx.h"

#pragma warning(disable:4800)

#include <Item/ItemFactory.h>
#include <Item/ItemConstants.h>
#include <Item/ItemMgr.h>

#include <Log/GuildLog.h>
#include <Log/LogStruct.h>
#include <Log/LogCommands.h>

#include <Map/FieldMap/Cell.h>

#include <Utility/Math/Math.h>
#include <Community/Guild/GuildConstants.h>
#include <Network/Packet/PacketStruct/GuildPacket.h>

#include "CharacterInfoDlg.h"
#include "InfoDlg.h"
#include "ItemInfoDlg.h"
#include "LogItemContainer.h"
#include "GlobalFunctions.h"
#include "PrintLog.h"

using namespace GAMELOG;

inline const char* GetItemName(unsigned short usProtoTypeID)
{
    const Item::ItemInfo* lpItemInfo = Item::CItemMgr::GetInstance().GetItemInfo(usProtoTypeID);
    return (NULL != lpItemInfo) ? lpItemInfo->m_SpriteData.m_szName : NULL;
}

inline const char* GetGradeString(Item::EquipType::Grade eGrade)
{
    switch(eGrade)
    {
    case Item::EquipType::AAA_GRADE:    return "AAA";
    case Item::EquipType::AA_GRADE:     return "AA";
    case Item::EquipType::A_GRADE:      return "A";
    case Item::EquipType::B_GRADE:      return "B";
    case Item::EquipType::C_GRADE:      return "C";
    case Item::EquipType::D_GRADE:      return "D";
    case Item::EquipType::F_GRADE:      return "F";
    }

    return "Unknown";
}

void CreateMonsterItemInfo(CString& szResult, unsigned long dwIndex, unsigned long dwKindID);

/*
void DetailInfo::CharLogin(const sLogBase* lpLogBase){ }
void DetailInfo::CharLogout(const sLogBase* lpLogBase){ }
void DetailInfo::CharDBUpdate(const sLogBase* lpLogBase){ }
*/

void DetailInfo::ShowCharacterInfo(const sLogBase* lpLogBase)
{
	CCharacterInfoDlg* pCharInfoDlg = new CCharacterInfoDlg;

	pCharInfoDlg->Create(IDD_CHARACTERINFODLG, AfxGetMainWnd());
	pCharInfoDlg->ShowWindow(SW_SHOW);

	if(!pCharInfoDlg->Initialize(lpLogBase))
	{
		pCharInfoDlg->OnClose();
	}
}

void DetailInfo::GetMinItemInfo(CString& Result, const GAMELOG::sMinItemInfo& minItemInfo)
{
	Result.AppendFormat("\r\n"
		"UID             : 0x%016I64X\r\n"
		"ItemProtoTypeID : %5d\r\n"
        "Num(Durability) : %5d\r\n", 
        minItemInfo.m_dwItemUID, minItemInfo.m_usProtoTypeID, minItemInfo.m_cNowDurability);
}

CString DetailInfo::GetDetailItemInfo(const Item::CItem* lpItem)
{
    CString szItemInfo = "";
    CString szItemGradeInfo = "";

    Item::CEquipment* lpEquipment = Item::CEquipment::DowncastToEquipment(
        const_cast<Item::CItem*>(lpItem));

    if(0 != lpEquipment)
    {
        Item::Grade::GradeInfo gradeInfo = lpEquipment->GetItemGrade();

        szItemGradeInfo.Format("(%s", GetGradeString(gradeInfo.m_eItemGrade));
        szItemGradeInfo.Append("++++++++++++++++++++++++++++++++++++++", gradeInfo.m_cPlus);
        szItemGradeInfo.Append(")");
    }
    
    szItemInfo.Format(         
        "Name            : %18s%s\r\n"
        "UID             : 0x%016I64X\r\n"
        "ItemProtoTypeID : %5d\r\n",
        GetItemName(lpItem->GetPrototypeID()), 
        szItemGradeInfo, lpItem->GetUID(), lpItem->GetPrototypeID());

    if(0 != lpEquipment)
    {
        // 장비 정보를 출력. 내구도, 소켓, 속성.	
        class CLogEquipment : public Item::CEquipment
        {
        public:
            void LogEquipment(CString& szItemInfo)
            {
                int nCurrentSocketNum       = 0;
                int nCurrentAttributeNum    = 0;

                for(int nIndex = 0; 
                    nIndex < Item::EquipmentInfo::MAX_SOCKET_NUM; ++nIndex)
                {
                    if(0 != m_cSocket[nCurrentSocketNum])
                    {                        
                        szItemInfo.AppendFormat("GemID            : %5d\r\n", 
                            m_cSocket[nCurrentSocketNum] + Item::EtcItemID::GEM_START_ID - 1);

                        ++nCurrentSocketNum;
                    }
                }

                for(int nIndex = 0;
                    nIndex < Item::Attribute::MAX_ATTRIBUTE_NUM; ++nIndex)
                {
					short wAttributeValue = GetAttribute(static_cast<Item::Attribute::Type>(nIndex));
                    if(0 != wAttributeValue)
                    {
                        ++nCurrentAttributeNum;

						// edith 2009.09.09 장비중 HP, MP의 증가율은 x10 배임
						if(nIndex == Item::Attribute::MAX_HP || nIndex == Item::Attribute::MAX_MP)
						{
							wAttributeValue = wAttributeValue * 10;
						}

                        szItemInfo.AppendFormat("AttributeType   : %20s(%5d)\r\n",
							Item::Attribute::Attributes[nIndex].GetTypeName(), wAttributeValue);
                    }
                }

                szItemInfo.AppendFormat(                     
                    "Durablility     : %5d/%5d\r\n"
                    "Socket Nums     : %5d/%5d\r\n"
                    "Attribute Nums  : %5d/%5d\r\n"
                    "Upgrade Step    : %5d\r\n"
					"Season Record   : %5d\r\n"
					"Core Level      : %5d\r\n",					
                    m_ItemData.m_cNumOrDurability, GetMaxNumOrDurability(), 
                    nCurrentSocketNum, m_cMaxSocket, nCurrentAttributeNum, m_cMaxAttribute,
                    m_cUpgradeLevel, m_cSeasonRecord, m_cCoreLevel);
            }
        };

        static_cast<CLogEquipment*>(lpEquipment)->LogEquipment(szItemInfo);

    }
    else
    {
        // 기타 혹은 사용 아이템.
        // 개수 출력. 사용 아이템이면 스킬 아이디와 스킬 레벨 출력                                 
        szItemInfo.AppendFormat("Current number  : %5d\r\n", lpItem->GetNumOrDurability());

        Item::CUseItem* lpUseItem = Item::CUseItem::DowncastToUseItem(
            const_cast<Item::CItem*>(lpItem));

        if(NULL != lpUseItem)
        {                                     
            szItemInfo.AppendFormat("Skill ID        : 0x%04x	Skill Level : %5d",
                lpUseItem->GetItemInfo().m_UseItemInfo.m_usSkill_ID,
                lpUseItem->GetItemInfo().m_UseItemInfo.m_usSkill_LockCount);
        }
    }

    return szItemInfo;
}

void DetailInfo::ShowItemInfo(CString& Title, const Item::CItem* lpItem)
{
	CInfoDlg itemInfoDlg(Title, DetailInfo::GetDetailItemInfo(lpItem));
	itemInfoDlg.DoModal();
}

void DetailInfo::ExchangeItem(const sLogBase* lpLogBase)
{
	const GAMELOG::sExchangeItemLog* pExchangeItemLog = 
		static_cast<const GAMELOG::sExchangeItemLog*>(lpLogBase);

    CItemInfoDlg	            itemInfoDlg;
    Item::CLogArrayContainer    LogArrayContainer(itemInfoDlg.GetListBox(), itemInfoDlg.GetEditBox());
	
    if(LogArrayContainer.Initialize(0, 8, 4, 1))
    {
        if(LogArrayContainer.SerializeIn((char*)(&pExchangeItemLog[1]), pExchangeItemLog->m_usItemSize))
        {
            itemInfoDlg.Initialize(&LogArrayContainer);
	        itemInfoDlg.DoModal();
        }
    }
}

void DetailInfo::CharCreate(const sLogBase* lpLogBase){ }
void DetailInfo::CharDelete(const sLogBase* lpLogBase){ }

void DetailInfo::CharLevelUp(const sLogBase* lpLogBase){ }
void DetailInfo::CharBindPos(const sLogBase* lpLogBase){ }
void DetailInfo::CharDead(const sLogBase* lpLogBase){ }
void DetailInfo::CharRespawn(const sLogBase* lpLogBase){ }

void DetailInfo::MoveItem(const sLogBase* lpLogBase)
{
    CString Result;

	const sMoveItemLog* lpMoveItemLog = static_cast<const sMoveItemLog*>(lpLogBase);
	const TakeType&		takeType = lpMoveItemLog->m_takeType;

	char szSrc[MIN_BUFFER], szDst[MIN_BUFFER];

    SimpleInfo::PositionToString(szSrc, MIN_BUFFER, takeType.m_srcPos);
	SimpleInfo::PositionToString(szDst, MIN_BUFFER, takeType.m_dstPos);

    Result.AppendFormat("Item moved : %s->%s, %d(Num/Durability)", 
        szSrc, szDst, lpMoveItemLog->m_itemInfo.m_cNowDurability);

    GetMinItemInfo(Result, lpMoveItemLog->m_itemInfo);

    CInfoDlg itemInfoDlg("Item Move Info", Result);
	itemInfoDlg.DoModal();
}

void DetailInfo::SwapItem(const sLogBase* lpLogBase)
{

}

void DetailInfo::UseItem(const sLogBase* lpLogBase)
{

}

void DetailInfo::UseLottery(const sLogBase* lpLogBase)
{
}

void DetailInfo::SplitItem(const sLogBase* lpLogBase)
{

}

void DetailInfo::PickupItem(CString& Title, const sLogBase* lpLogBase)
{
	const sPickupItemLog* lpPickupItemLog = static_cast<const sPickupItemLog*>(lpLogBase);

	if(0 == lpLogBase->m_cErr)
	{
        size_t nItemSize = Item::MAX_ITEM_SIZE;

        Item::CItem* lpItem = Item::CItemFactory::GetInstance().CreateItem(
            (const char*)lpPickupItemLog + sizeof(sPickupItemLog), nItemSize);

        if(NULL != lpItem)
        {
            ShowItemInfo(Title, lpItem);
            DELETE_ITEM(lpItem)
        }
	}
}

void DetailInfo::DropItem(CString& Title, const sLogBase* lpLogBase)
{
	const sDropItemLog* lpDropItemLog = static_cast<const sDropItemLog*>(lpLogBase);

	if(0 == lpLogBase->m_cErr)
	{
        size_t nItemSize = Item::MAX_ITEM_SIZE;

        Item::CItem* lpItem = Item::CItemFactory::GetInstance().CreateItem(
            (const char*)lpDropItemLog + sizeof(sDropItemLog), nItemSize);

        if(NULL != lpItem)
        {
            ShowItemInfo(Title, lpItem);
            DELETE_ITEM(lpItem)
        }
	}
}


void DetailInfo::TradeItem(CString& Title, const sLogBase* lpLogBase)
{
	const sTradeItemLog* lpTradeItemLog = static_cast<const sTradeItemLog*>(lpLogBase);

	if(0 == lpLogBase->m_cErr)
	{
        size_t nItemSize = Item::MAX_ITEM_SIZE;

        Item::CItem* lpItem = Item::CItemFactory::GetInstance().CreateItem(
            (const char*)lpTradeItemLog + sizeof(sTradeItemLog), nItemSize);

        if(NULL != lpItem)
        {
            ShowItemInfo(Title, lpItem);
            DELETE_ITEM(lpItem)
        }
	}
}

void DetailInfo::HackDoubtItem(CString& Title, const sLogBase* lpLogBase)
{
	const sHockDoubtLog* lpDoubtItemLog = static_cast<const sHockDoubtLog*>(lpLogBase);

	if(0 == lpLogBase->m_cErr)
	{
		size_t nItemSize = Item::MAX_ITEM_SIZE;

		Item::CItem* lpItem = Item::CItemFactory::GetInstance().CreateItem(
			(const char*)lpDoubtItemLog + sizeof(sHockDoubtLog), nItemSize);

		if(NULL != lpItem)
		{
			ShowItemInfo(Title, lpItem);
			DELETE_ITEM(lpItem)
		}
	}
}

void DetailInfo::InstallSocketItem(const sLogBase* lpLogBase)
{

}

void DetailInfo::UpgradeItem(const sLogBase* lpLogBase)
{
    const sUpgradeItemLog* lpUpgradeItemLog = static_cast<const sUpgradeItemLog*>(lpLogBase);

    CString Result;

    if(0 == lpUpgradeItemLog->m_cErr)
    {
        size_t nMineralSize = Item::MAX_ITEM_SIZE;
        size_t nEquipSize = Item::MAX_ITEM_SIZE;

        if(0 != lpUpgradeItemLog->m_cMineralSize)
        {
            Item::CItem* lpMineral = Item::CItemFactory::GetInstance().CreateItem(
                (const char*)lpUpgradeItemLog + sizeof(sUpgradeItemLog), nMineralSize);

            if(NULL != lpMineral)
            {
                Result += GetDetailItemInfo(lpMineral);
                DELETE_ITEM(lpMineral);
            }
        }


        if(0 != lpUpgradeItemLog->m_cEquipSize)
        {
            Item::CItem* lpEquip = Item::CItemFactory::GetInstance().CreateItem(
                (const char*)lpUpgradeItemLog + sizeof(sUpgradeItemLog) + lpUpgradeItemLog->m_cMineralSize, nEquipSize);

            Item::CEquipment* lpEquipment = Item::CEquipment::DowncastToEquipment(lpEquip);

            if(NULL != lpEquipment)
            {
                Result += GetDetailItemInfo(lpEquipment);
                DELETE_ITEM(lpEquip);
            }            
        }


        CInfoDlg itemInfoDlg("Item Upgrade Info", Result);
        itemInfoDlg.DoModal();
    }
}


// 길드원 권한 설정
void DetailInfo::GuildRightsChange(const sLogBase* lpLogBase)
{
    CString Result;

    const sGuildLog* lpGuildLog = static_cast<const sGuildLog*>(lpLogBase);

    CString szRightsString[Guild::MAX_RIGHT_SIZE];

	szRightsString[GuildRight::PUT_STOREHOUSE]  = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_PUT_STOREHOUSE");
	szRightsString[GuildRight::GET_STOREHOUSE]  = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_GET_STOREHOUSE");
	szRightsString[GuildRight::USE_SAFE]        = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_USE_SAFE");
	szRightsString[GuildRight::INVITE_MEMBER]   = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_INVITE_MEMBER");
	szRightsString[GuildRight::PERMIT_JOIN]     = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_PERMIT_JOIN");
	szRightsString[GuildRight::CHANGE_PASSWORD] = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_CHANGE_PASSWORD");

	//szRightsString[GuildRight::SETUP_RELATION]  = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_SETUP_RELATION");
	//szRightsString[GuildRight::SETUP_RANK]      = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_SETUP_RANK");
	szRightsString[GuildRight::REGULATE_TEX]    = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_REGULATE_TEX");
	szRightsString[GuildRight::KICK_MEMBER]     = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_KICK_MEMBER");
	szRightsString[GuildRight::BOARD_ADMIN]     = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_BOARD_ADMIN");

	szRightsString[GuildRight::SETUP_MARK_N_LEVEL]  = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_SETUP_MARK_N_LEVEL");
	szRightsString[GuildRight::SETUP_MIDDLE]        = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_SETUP_MIDDLE");
	szRightsString[GuildRight::DIVIDE_GOLD]         = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_DIVIDE_GOLD");
	szRightsString[GuildRight::SETUP_POLICY]        = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_SETUP_POLICY");

    const char* szRights = reinterpret_cast<const char*>(lpGuildLog + 1);

    int nCountMax = min(lpGuildLog->m_usExtraDataSize, unsigned short(MAX_RIGHT_SIZE));
    for(int nCount = 0; nCount < nCountMax; ++nCount)
    {
        if(!szRightsString[nCount].IsEmpty())
        {
            Result.AppendFormat("%30s : %s\r\n", szRightsString[nCount], 
                GuildTitle(szRights[nCount]));
        }
    }

    CInfoDlg itemInfoDlg("Guild rights level changed", Result);
    itemInfoDlg.DoModal();
}

void DetailInfo::ItemAttachOption(const sLogBase* lpLogBase)
{
    const sItemAttachOption* lpItemAttach = static_cast<const sItemAttachOption*>(lpLogBase);

    if (0 == lpItemAttach->m_cErr &&
        0 != lpItemAttach->m_cOldItemLen &&
        0 != lpItemAttach->m_cUseItemLen &&
        0 != lpItemAttach->m_cNewItemLen)
    {
        const char* szOldItem = reinterpret_cast<const char*>(lpItemAttach + 1);
        const char* szUseItem = szOldItem + lpItemAttach->m_cOldItemLen;
        const char* szNewItem = szUseItem + lpItemAttach->m_cUseItemLen;

        size_t nItemLen = lpItemAttach->m_cOldItemLen;
        Item::CItem* lpOldItem = Item::CItemFactory::GetInstance().CreateItem(szOldItem, nItemLen);

        nItemLen = lpItemAttach->m_cUseItemLen;
        Item::CItem* lpUseItem = Item::CItemFactory::GetInstance().CreateItem(szUseItem, nItemLen);

        nItemLen = lpItemAttach->m_cNewItemLen;
        Item::CItem* lpNewItem = Item::CItemFactory::GetInstance().CreateItem(szNewItem, nItemLen);

        Item::CEquipment* lpOldEquipment = Item::CEquipment::DowncastToEquipment(lpOldItem);
        Item::CEquipment* lpUseEquipment = Item::CEquipment::DowncastToEquipment(lpUseItem);
        Item::CEquipment* lpNewEquipment = Item::CEquipment::DowncastToEquipment(lpNewItem);

        if(0 != lpOldEquipment && 0 != lpUseEquipment && 0 != lpNewEquipment)
        {
            const char* szAttributeName = 
                Item::Attribute::Attributes[lpItemAttach->m_cSelectedOptionIndex].GetTypeName();

            Item::Attribute::Type eAttrType =
                static_cast<Item::Attribute::Type>(lpItemAttach->m_cSelectedOptionIndex);

            CString szTitle;
            CString szResult;

            szTitle.Format("Item option attach : %s / UsedGold : %10u", 
                Item::Attribute::Attributes[eAttrType].GetTypeName(), 
                lpItemAttach->m_dwOldInvenGold - lpItemAttach->m_dwNewInvenGold);

            szResult = "[Old Item]\r\n" + GetDetailItemInfo(lpOldEquipment);
            szResult += "\r\n[Sacrifice Item]\r\n" + GetDetailItemInfo(lpUseEquipment);
            szResult += "\r\n[New Item]\r\n" + GetDetailItemInfo(lpNewEquipment);

            CInfoDlg infoDlg(szTitle, szResult);
            infoDlg.DoModal();
        }

        DELETE_ITEM(lpOldItem);
        DELETE_ITEM(lpUseItem);
        DELETE_ITEM(lpNewItem);
    }
}

void DetailInfo::ItemCompensation(const sLogBase* lpLogBase)
{
    const sItemCompensation* lpItemCompensation = static_cast<const sItemCompensation*>(lpLogBase);

    if (0 == lpItemCompensation->m_cErr &&
        0 != lpItemCompensation->m_cOldItemLen &&        
        0 != lpItemCompensation->m_cNewItemLen)
    {
        const char* szOldItem = reinterpret_cast<const char*>(lpItemCompensation + 1);        
        const char* szNewItem = szOldItem + lpItemCompensation->m_cOldItemLen;

        size_t nItemLen = lpItemCompensation->m_cOldItemLen;
        Item::CItem* lpOldItem = Item::CItemFactory::GetInstance().CreateItem(szOldItem, nItemLen);

        nItemLen = lpItemCompensation->m_cNewItemLen;
        Item::CItem* lpNewItem = Item::CItemFactory::GetInstance().CreateItem(szNewItem, nItemLen);

        Item::CEquipment* lpOldEquipment = Item::CEquipment::DowncastToEquipment(lpOldItem);
        Item::CEquipment* lpNewEquipment = Item::CEquipment::DowncastToEquipment(lpNewItem);

        if(0 != lpOldEquipment && 0 != lpNewEquipment)
        {
            long nGold = lpItemCompensation->m_dwOldInvenGold - lpItemCompensation->m_dwNewInvenGold;

            unsigned long dwGetGold  = nGold < 0 ? -nGold : 0;
            unsigned long dwUsedGold = 0 < nGold ? nGold : 0;

            CString szTitle;
            CString szResult;
            
            szTitle.Format("Item compension : GetGold : %10u / UsedGold : %10u", dwGetGold, dwUsedGold);

            szResult = "[Old Item]\r\n" + GetDetailItemInfo(lpOldEquipment);            
            szResult += "\r\n[New Item]\r\n" + GetDetailItemInfo(lpNewEquipment);

            CInfoDlg infoDlg(szTitle, szResult);
            infoDlg.DoModal();
        }

        DELETE_ITEM(lpOldItem);
        DELETE_ITEM(lpNewItem);
    }
}

void DetailInfo::UpgradeItemV2(const sLogBase* lpLogBase)
{
    const sUpgradeItemLogV2* lpUpgradeItemLogV2 = static_cast<const sUpgradeItemLogV2*>(lpLogBase);

    CString Result;

    if(0 == lpUpgradeItemLogV2->m_cErr)
    {
        size_t nMineralSize = Item::MAX_ITEM_SIZE;
        size_t nEquipSize = Item::MAX_ITEM_SIZE;

        unsigned char cUpgradeLevel = 0;

        if(0 != lpUpgradeItemLogV2->m_cMineralSize)
        {
            Item::CItem* lpMineral = Item::CItemFactory::GetInstance().CreateItem(
                (const char*)lpUpgradeItemLogV2 + sizeof(sUpgradeItemLogV2), nMineralSize);

            if(NULL != lpMineral)
            {
                Result += GetDetailItemInfo(lpMineral);
                DELETE_ITEM(lpMineral);
            }
        }

        if(0 != lpUpgradeItemLogV2->m_cEquipSize)
        {
            Item::CItem* lpEquip = Item::CItemFactory::GetInstance().CreateItem(
                (const char*)lpUpgradeItemLogV2 + sizeof(sUpgradeItemLogV2) + lpUpgradeItemLogV2->m_cMineralSize, nEquipSize);

            Item::CEquipment* lpEquipment = Item::CEquipment::DowncastToEquipment(lpEquip);

            if(NULL != lpEquipment)
            {
                cUpgradeLevel = lpEquipment->GetUpgradeLevel();

                Result += GetDetailItemInfo(lpEquipment);
                DELETE_ITEM(lpEquip);
            }            
        }

        CString szHeader;
        szHeader.Format("Item Upgrade %u to %u", 
            lpUpgradeItemLogV2->m_cLastUpgradeLevel, cUpgradeLevel);

        CInfoDlg itemInfoDlg(szHeader, Result);
        itemInfoDlg.DoModal();
    }
}

void DetailInfo::MonsterDead(const sLogBase* lpLogBase)
{
    const sMonsterDeadLog* lpMonsterDeadLog = 
        static_cast<const sMonsterDeadLog*>(lpLogBase);

    CString szResult;
    const unsigned long* lpdwItemIndexPos = reinterpret_cast<const unsigned long*>(lpMonsterDeadLog + 1);
    const unsigned long* lpdwItemIndexEnd = lpdwItemIndexPos + lpMonsterDeadLog->m_cDropItemNum;
    
    for(unsigned long dwIndex = 0; 
        lpdwItemIndexPos != lpdwItemIndexEnd; ++lpdwItemIndexPos, ++dwIndex)
    {
        CreateMonsterItemInfo(szResult, dwIndex, *lpdwItemIndexPos);
    }

    CInfoDlg itemInfoDlg("Monster Dead", szResult);
    itemInfoDlg.DoModal();
}


void CreateMonsterItemInfo(CString& szResult, unsigned long dwIndex, unsigned long dwKindID)
{
// TODO : 컴파일 에러가 나서 주석 처리해둡니다. 필요하신 분이 수정해주세요. (2005-01-26 by 로딘)
/*
	Item::CItemFactory& ItemFactory = Item::CItemFactory::GetInstance();

    // 몬스터가 떨군 것
    if (dwKindID & CCell::MONEY_BIT) 
    {
        // 돈
        unsigned long dwMoney = dwKindID & ~CCell::TYPE_CHECK_BIT;
        szResult.AppendFormat("%2u : %10u Gold Dropped\r\n\r\n", dwIndex, dwMoney);
    }		
    else if (dwKindID & CCell::EQUIP_BIT)
    {	
        const Item::ItemInfo* lpItemInfo = Item::CItemMgr::GetInstance().GetItemInfo(
            static_cast<unsigned short>(dwKindID & CCell::ITEM_PROTOTYPE_ID_BIT));

        if(0 != lpItemInfo)
        {
            // 장비
            Item::CItem* lpItem = ItemFactory.CreateTempItem(*lpItemInfo);
            Item::CEquipment* lpEquip = Item::CEquipment::DowncastToEquipment(lpItem);

            if (0 != lpEquip)
            {            
                lpEquip->AddRandomOption(static_cast<Item::EquipType::Grade>(
                    (dwKindID & ~(CCell::TYPE_CHECK_BIT | CCell::ITEM_PROTOTYPE_ID_BIT)) >> 16));
                lpEquip->SetNewEquip();
                lpEquip->SetUID(0LL);

                szResult.AppendFormat("%2u : Dropped equip info(ignore itemUID)\r\n", dwIndex);
                szResult += DetailInfo::GetDetailItemInfo(lpEquip);
                szResult.AppendFormat("\r\n\r\n");
            }
            else
            {
                szResult.AppendFormat("%2u : Item create failed - KindID(0x%08X)\r\n", dwIndex, dwKindID);
            }

            DELETE_ITEM(lpItem);
        }
        else
        {
            szResult.AppendFormat("%2u : Item create failed - KindID(0x%08X)\r\n", dwIndex, dwKindID);
        }
    }		
    else 
    {	
        // 기타 아이템
        const Item::ItemInfo* lpItemInfo = Item::CItemMgr::GetInstance().GetItemInfo(
            static_cast<unsigned short>(dwKindID));

        if(0 != lpItemInfo)
        {
            Item::CItem* lpItem = ItemFactory.CreateTempItem(*lpItemInfo);
            if (0 != lpItem) 
            {
                lpItem->SetNumOrDurability(1);

                szResult.AppendFormat("%2u : Dropped item info(ignore itemUID)\r\n", dwIndex);
                szResult += DetailInfo::GetDetailItemInfo(lpItem);
                szResult.AppendFormat("\r\n\r\n");
            }
            else
            {
                szResult.AppendFormat("%2u : Item create failed - KindID(0x%08X)\r\n", dwIndex, dwKindID);
            }

            DELETE_ITEM(lpItem);
        }
        else
        {
            szResult.AppendFormat("%2u : Item create failed - KindID(0x%08X)\r\n", dwIndex, dwKindID);
        }
    }
*/
}