// CharInventoryPage.cpp : 구현 파일입니다.
//

#include "stdafx.h"
#include "AdminToolClient.h"
#include "ListCtrlSortClass.h"
#include "CharInventoryPage.h"
#include "GridControlFactory.h"
#include "ItemManageDlg.h"
#include "GlobalFunctions.h"
#include "PacketManager.h"

#include <stdlib.h>
#include <Utility/Math/Math.h>
#include <Item/Item.h>
#include <Item/Container/ItemContainer.h>
#include <Character/ModifyCharacter.h>
#include <Network/Protocol/Ryl_AdminMgrProtocol.h>

// CCharInventoryPage 대화 상자입니다.

IMPLEMENT_DYNAMIC(CCharInventoryPage, CPropertyPage)
CCharInventoryPage::CCharInventoryPage()
	: CPropertyPage(CCharInventoryPage::IDD)
	, m_lpInventoryPageInfo( NULL )
	, m_dwInventoryGold(0)
	, m_dwDocKey(0)
	, m_InInventoryList(false)
	, m_InEquipList(false)
	, m_bSortListAsc(false)
{
}

CCharInventoryPage::~CCharInventoryPage()
{	
}

void CCharInventoryPage::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_INVENTORYTAB, m_ctrlInventoryTab);
	DDX_Control(pDX, IDC_EQUIPITEMLIST, m_ctrlEquipItemList);
	DDX_Control(pDX, IDC_INVENTORYITEMLIST, m_ctrlInventoryItemList);
	DDX_Text(pDX, IDC_INVENTORY_GOLD, m_dwInventoryGold);
}

BEGIN_MESSAGE_MAP(CCharInventoryPage, CPropertyPage)
	ON_WM_CONTEXTMENU()
	ON_NOTIFY(NM_CLICK, MSG_INVENTORY_GRID, OnInventoryGridClick)
	ON_NOTIFY(NM_DBLCLK, MSG_INVENTORY_GRID, OnInventoryGridDblClick)
	ON_NOTIFY(TCN_SELCHANGE, IDC_INVENTORYTAB, OnTcnSelchangeInventorytab)
	ON_BN_CLICKED(IDC_ITEMMAKE, OnBnClickedItemmake)
	ON_NOTIFY(NM_DBLCLK, IDC_EQUIPITEMLIST, OnNMDblclkEquipitemlist)
	ON_NOTIFY(NM_DBLCLK, IDC_INVENTORYITEMLIST, OnNMDblclkInventoryitemlist)
	ON_COMMAND(ID_INVENITEMEDIT, OnUpdateItem)
	ON_COMMAND(ID_INVENITEMREMOVE, OnRemoveItem)
	ON_BN_CLICKED(IDC_EQUIP_RESET, OnBnClickedEquipReset)
	ON_BN_CLICKED(IDC_INVEN_RESET, OnBnClickedInvenReset)
	ON_BN_CLICKED(IDC_INVENGOLD_UPDATE, OnBnClickedInvenGoldUpdate)
	ON_COMMAND(ID_STORE_COPY, OnStoreCopy)
	ON_NOTIFY(LVN_COLUMNCLICK, IDC_EQUIPITEMLIST, OnLvnColumnclickitemlist)
	ON_NOTIFY(LVN_COLUMNCLICK, IDC_INVENTORYITEMLIST, OnLvnColumnclickitemlist)
	ON_BN_CLICKED(IDC_INVENPAGE_EQUIPCLIP_BTN, OnBnClickedInvenpageEguipclipBtn)
	ON_BN_CLICKED(IDC_INVENPAGE_INVENCLIP_BTN, OnBnClickedInvenpageInvenclipBtn)
END_MESSAGE_MAP()


// CCharInventoryPage 메시지 처리기입니다.

BOOL CCharInventoryPage::OnInitDialog()
{
	CPropertyPage::OnInitDialog();

	CRect rcGrid;
    rcGrid.left = 23; rcGrid.top = 55; rcGrid.right = 209; rcGrid.bottom = 240;
    m_ctrlInventoryGrid.Create(rcGrid, this, MSG_INVENTORY_GRID, WS_CHILD | WS_BORDER | WS_TABSTOP | WS_VISIBLE);
	InitializeItemGrid(m_ctrlInventoryGrid, 6, 6, FALSE, FALSE, 
		RGB(0, 0, 0), RGB(215, 247, 255), RGB(172, 172, 172));
	
	m_ctrlInventoryGrid.EnableSelection( FALSE );

	m_ctrlInventoryTab.InsertItem(0, _T("Ⅰ"), 0);
	m_ctrlInventoryTab.InsertItem(1, _T("Ⅱ"), 0);
	m_ctrlInventoryTab.InsertItem(2, _T("Ⅲ"), 0);
	m_ctrlInventoryTab.InsertItem(3, _T("Ⅳ"), 0);
	
	m_ctrlEquipItemList.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_FLATSB);
	m_ctrlInventoryItemList.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_FLATSB);
	
	m_ctrlEquipItemList.InsertColumn(0, GetLocalString("SERIAL"), LVCFMT_LEFT, 130);
	m_ctrlEquipItemList.InsertColumn(1, GetLocalString("ITEM_NAME"), LVCFMT_LEFT, 123);
	m_ctrlEquipItemList.InsertColumn(2, GetLocalString("ITEM_TYPE"), LVCFMT_LEFT, 85);
	m_ctrlEquipItemList.InsertColumn(3, GetLocalString("POS"), LVCFMT_LEFT, 50);
	m_ctrlEquipItemList.InsertColumn(4, GetLocalString("QTY"), LVCFMT_LEFT, 50);
	
	m_ctrlInventoryItemList.InsertColumn(0, GetLocalString("SERIAL"), LVCFMT_LEFT, 130);
	m_ctrlInventoryItemList.InsertColumn(1, GetLocalString("ITEM_NAME"), LVCFMT_LEFT, 123);
	m_ctrlInventoryItemList.InsertColumn(2, GetLocalString("ITEM_TYPE"), LVCFMT_LEFT, 85);
	m_ctrlInventoryItemList.InsertColumn(3, GetLocalString("POS"), LVCFMT_LEFT, 50);
	m_ctrlInventoryItemList.InsertColumn(4, GetLocalString("QTY"), LVCFMT_LEFT, 50);

	SetUIString(this->m_hWnd, IDC_INVENPAGE_01, "IDC_INVENPAGE_01");
	SetUIString(this->m_hWnd, IDC_INVENPAGE_02, "IDC_INVENPAGE_02");
	SetUIString(this->m_hWnd, IDC_INVENPAGE_03, "IDC_INVENPAGE_03");
	SetUIString(this->m_hWnd, IDC_INVENPAGE_04, "IDC_INVENPAGE_04");
	SetUIString(this->m_hWnd, IDC_INVENGOLD_UPDATE, "IDC_INVENGOLD_UPDATE");
	SetUIString(this->m_hWnd, IDC_EQUIP_RESET, "IDC_EQUIP_RESET");
	SetUIString(this->m_hWnd, IDC_INVENPAGE_EQUIPCLIP_BTN, "IDC_INVENPAGE_EQUIPCLIP_BTN");
	SetUIString(this->m_hWnd, IDC_INVEN_RESET, "IDC_INVEN_RESET");
	SetUIString(this->m_hWnd, IDC_INVENPAGE_INVENCLIP_BTN, "IDC_INVENPAGE_INVENCLIP_BTN");

	return TRUE;
}

bool CCharInventoryPage::SetInventoryPageData(unsigned int dwDocKey, CModifyCharacter*  lpModifyCharInfo)
{
	if((0 != dwDocKey) && (NULL != lpModifyCharInfo))
	{
		m_lpInventoryPageInfo	= lpModifyCharInfo;
		m_dwDocKey				= dwDocKey;

		GetDlgItem(IDC_INVENGOLD_UPDATE)->EnableWindow(true);
		GetDlgItem(IDC_EQUIP_RESET)->EnableWindow(true);
		GetDlgItem(IDC_INVEN_RESET)->EnableWindow(true);
		GetDlgItem(IDC_INVENPAGE_EQUIPCLIP_BTN)->EnableWindow(true);
		GetDlgItem(IDC_INVENPAGE_INVENCLIP_BTN)->EnableWindow(true);
		
		return true;
	}
	else
	{
		return false;
	}
}

// 인벤토리 페이지 셋팅
void CCharInventoryPage::SetInventoryPage(CModifyCharacter* lpModifyCharInfo)
{
	SetEquip(lpModifyCharInfo);
	SetInventoryItem(lpModifyCharInfo);
}

//	장비 아이템을 리스트 컨트롤에 셋팅
void CCharInventoryPage::SetEquip(CModifyCharacter* lpModifyCharacter)
{
	m_ctrlEquipItemList.DeleteAllItems();

	if(NULL == lpModifyCharacter)	return;

	Item::CEquipmentsContainer&		Equip	= lpModifyCharacter->GetEquipments();
	Item::CItemContainer::iterator	Itr		= Equip.begin();

	while(Itr != Equip.end())
	{
		Item::CItem* lpEquipItem = (*Itr);
		if(NULL != lpEquipItem)
		{
			CString			serial(_T("0x"));
			CString			quantity;
			CString			realItemPos;
			Item::ItemPos	ItemPos = lpEquipItem->GetPos();

			quantity.Format(_T("%d"), lpEquipItem->GetNumOrDurability());
			realItemPos.Format(_T("X:%d Y:%d Z:%d"), ItemPos.GetXIndex(), ItemPos.GetYIndex(), ItemPos.GetZIndex());
			serial.AppendFormat(_T("%016I64X"), lpEquipItem->GetUID());			

			const Item::ItemInfo& ItemInfo = lpEquipItem->GetItemInfo( );
			
			m_ctrlEquipItemList.InsertItem(0, serial);
			m_ctrlEquipItemList.SetItemText(0, 1, (LPCTSTR)ItemInfo.m_SpriteData.m_szName);
			m_ctrlEquipItemList.SetItemText(0, 2, (LPCTSTR)lpEquipItem->GetItemTypeName());
			m_ctrlEquipItemList.SetItemText(0, 3, realItemPos);
			m_ctrlEquipItemList.SetItemText(0, 4, quantity);

			// 중복 시리얼 아이템 체크
			std::pair<CModifyCharacter::ModifyCharItemSerialInfo::iterator, bool> returnPair
				= lpModifyCharacter->m_ModifyCharItemSerialInfo.insert(lpEquipItem->GetUID());

			if(!returnPair.second)
			{
				lpModifyCharacter->m_OverlapSerialInfo.push_back(lpEquipItem->GetUID());
				lpModifyCharacter->SetOwnCopyItemState(true);
			}
		}
		++Itr;
	}
}

//	인벤토리 아이템을 리스트 컨트롤과 그리드에 셋팅
void CCharInventoryPage::SetInventoryItem(CModifyCharacter* lpModifyCharacter)
{
	m_ctrlInventoryGrid.DeleteAllItems();
	m_ctrlInventoryItemList.DeleteAllItems();

	InitializeItemGrid(m_ctrlInventoryGrid,
		6, 6, FALSE, FALSE, RGB(0, 0, 0), RGB(215, 247, 255), RGB(172, 172, 172));

	if (NULL == lpModifyCharacter)
	{
		return;
	}

	Item::CArrayContainer& Inventory = lpModifyCharacter->GetInventory();
	Item::CArrayContainer::iterator	Itr = Inventory.begin();	
	Item::CItem* InventoryItem = NULL;
	
	m_dwInventoryGold = lpModifyCharacter->GetGold();

	while(Itr != Inventory.end())
	{		
		InventoryItem = (*Itr);

		if (NULL != InventoryItem)
		{
			CString strItemSerial(_T("0x")), strQty, strItemPos;

			Item::ItemPos ItemPos = InventoryItem->GetPos();

			strQty.Format(_T("%d"), InventoryItem->GetNumOrDurability());
			strItemPos.Format(_T("X:%d Y:%d Z:%d"),
				ItemPos.GetXIndex(), ItemPos.GetYIndex(), ItemPos.GetZIndex());
			strItemSerial.AppendFormat(_T("%016I64X"), InventoryItem->GetUID());

			const Item::ItemInfo& ItemInfo = InventoryItem->GetItemInfo();
			
			m_ctrlInventoryItemList.InsertItem(0, strItemSerial);
			m_ctrlInventoryItemList.SetItemText(0, 1, (LPCTSTR)ItemInfo.m_SpriteData.m_szName);
			m_ctrlInventoryItemList.SetItemText(0, 2, (LPCTSTR)InventoryItem->GetItemTypeName());
			m_ctrlInventoryItemList.SetItemText(0, 3, strItemPos);
			m_ctrlInventoryItemList.SetItemText(0, 4, strQty);
			
			InventoryGridSet(InventoryItem, m_ctrlInventoryTab.GetCurSel());

			std::pair<CModifyCharacter::ModifyCharItemSerialInfo::iterator, bool> returnPair
				= lpModifyCharacter->m_ModifyCharItemSerialInfo.insert(InventoryItem->GetUID());

			if(!returnPair.second)
			{
				lpModifyCharacter->m_OverlapSerialInfo.push_back(InventoryItem->GetUID());
				lpModifyCharacter->SetOwnCopyItemState(true);
			}
		}

		++Itr;
	}

	UpdateData(false);
}

void CCharInventoryPage::InventoryGridSet(Item::CItem* InventoryItem, unsigned int nTab)
{
	Item::ItemPos ItemPos = InventoryItem->GetPos();
	const Item::ItemInfo& ItemInfo = InventoryItem->GetItemInfo();
	
	if (nTab == ItemPos.GetZIndex())
	{
		CString strItemToolTip;
		
		unsigned int nItemPosX = ItemPos.GetXIndex();
		unsigned int nItemPosY = ItemPos.GetYIndex();

		unsigned int nItemSizeX = ItemInfo.m_DetailData.m_cXSize;
		unsigned int nItemSizeY = ItemInfo.m_DetailData.m_cYSize;
		
		strItemToolTip.Format(GetLocalString("FORMAT_002"),
			ItemInfo.m_SpriteData.m_szName, InventoryItem->GetUID());

		m_ctrlInventoryGrid.SetItemText(nItemPosY, nItemPosX, strItemToolTip);

		for (unsigned int nPosX = nItemPosX; nPosX < (nItemPosX + nItemSizeX); nPosX++)
		{
			for (unsigned int nPosY = nItemPosY; nPosY < (nItemPosY + nItemSizeY); nPosY++)
			{
				m_ctrlInventoryGrid.SetItemBkColour(nPosY, nPosX,
					GetItemTypeColor(Item::ItemType::Type(ItemInfo.m_DetailData.m_cItemType)));
			}
		}
		m_ctrlInventoryGrid.Invalidate();
	}
}

void CCharInventoryPage::OnTcnSelchangeInventorytab(NMHDR *pNMHDR, LRESULT *pResult)
{
	if (NULL == m_lpInventoryPageInfo)
	{
		return;
	}

	m_ctrlInventoryGrid.DeleteAllItems();

	InitializeItemGrid(m_ctrlInventoryGrid,
		6, 6, FALSE, FALSE, RGB(0, 0, 0), RGB(215, 247, 255), RGB(172, 172, 172));

	if (NULL != m_lpInventoryPageInfo)
	{
		Item::CArrayContainer& Inventory = m_lpInventoryPageInfo->GetInventory();
		Item::CArrayContainer::iterator	Itr = Inventory.begin();
		Item::CItem* InventoryItem = NULL;
		
		while(Itr != Inventory.end())
		{		
			InventoryItem = (*Itr);
			
			if (NULL != InventoryItem)
			{
				Item::ItemPos Pos = InventoryItem->GetPos();

				if (Pos.GetZIndex() == m_ctrlInventoryTab.GetCurSel())
				{
					switch(m_ctrlInventoryTab.GetCurSel())
					{
					case 0:		InventoryGridSet(InventoryItem, 0);		break;
					case 1:		InventoryGridSet(InventoryItem, 1);		break;
					case 2:		InventoryGridSet(InventoryItem, 2);		break;
					case 3:		InventoryGridSet(InventoryItem, 3);		break;

					default:
						Report(GetLocalString("MSG_0116"), FAILED);	
						break;
					}
				}
			}
			++Itr;
		}
	}
	*pResult = 0;
}

//	인벤토리 정보 페이지의 컨텍스트 메뉴
void CCharInventoryPage::OnContextMenu(CWnd* pWnd, CPoint point)
{
	if (((pWnd->GetSafeHwnd() == m_ctrlEquipItemList.GetSafeHwnd()) && (m_ctrlEquipItemList.GetSelectedCount() == 1) ) || 
		((pWnd->GetSafeHwnd() == m_ctrlInventoryItemList.GetSafeHwnd()) && (m_ctrlInventoryItemList.GetSelectedCount() == 1)))
	{
		CMenu muTemp, *pContextMenu;
		muTemp.LoadMenu(IDR_CONTEXTMENU);
		pContextMenu = muTemp.GetSubMenu(6);
		pContextMenu->ModifyMenu(0, MF_STRING | MF_BYPOSITION, ID_INVENITEMEDIT,   GetLocalString("MENU_024"));
		pContextMenu->ModifyMenu(1, MF_STRING | MF_BYPOSITION, ID_INVENITEMREMOVE, GetLocalString("MENU_025"));
		pContextMenu->ModifyMenu(3, MF_STRING | MF_BYPOSITION, ID_STORE_COPY,	   GetLocalString("MENU_026"));
		pContextMenu->TrackPopupMenu(TPM_LEFTALIGN, point.x, point.y, this);

		if (pWnd->GetSafeHwnd() == m_ctrlEquipItemList.GetSafeHwnd())		m_InEquipList = true;

		if (pWnd->GetSafeHwnd() == m_ctrlInventoryItemList.GetSafeHwnd())	m_InInventoryList = true;
	}
}

//	그리드 더블 클릭시 이벤트 처리
void CCharInventoryPage::OnInventoryGridDblClick(NMHDR *pNotifyStruct, LRESULT* /*pResult*/)
{
    NM_GRIDVIEW* pItem = (NM_GRIDVIEW*) pNotifyStruct;

	m_ctrlInventoryGrid.Invalidate();
}

//	그리드 클릭시 이벤트 처리
void CCharInventoryPage::OnInventoryGridClick(NMHDR *pNotifyStruct, LRESULT* /*pResult*/)
{
    NM_GRIDVIEW* pItem = (NM_GRIDVIEW*) pNotifyStruct;
		
	if (true == g_bItemGrab)
	{	
		/* 2005-06-16 QA실 요청
		if (3 == m_ctrlInventoryTab.GetCurSel())
		{
			Report(GetLocalString("ADDED_STRING_059"), CAUTION);
			return;
		}
		*/

		g_stMyItemInfo.m_stItemInfo.m_cTakePos	= TakeType::TS_INVEN;
		g_stMyItemInfo.m_stItemInfo.m_cXPos		= pItem->iColumn;
		g_stMyItemInfo.m_stItemInfo.m_cYPos		= pItem->iRow;
		g_stMyItemInfo.m_stItemInfo.m_cZPos		= m_ctrlInventoryTab.GetCurSel();
		
		// 드랍 가능 여부 판별용 변수
		CPoint GrabbedItemPos, GrabbedItemSize;

		GrabbedItemPos.x = g_stMyItemInfo.m_stItemInfo.m_cXPos;		
		GrabbedItemPos.y = g_stMyItemInfo.m_stItemInfo.m_cYPos;
		GrabbedItemSize.x = g_stMyItemInfo.m_SizeX;
		GrabbedItemSize.y = g_stMyItemInfo.m_SizeY;

		if (NULL != m_lpInventoryPageInfo && NULL != m_dwDocKey)
		{
			if (TRUE == IsEnableItemDrop(GrabbedItemPos, GrabbedItemSize))
			{
				CPacketMgr::GetInstance()->SendCreateItem(m_lpInventoryPageInfo->GetServerGroup(),
					m_lpInventoryPageInfo->GetCID(), m_lpInventoryPageInfo->GetUID(),
					m_dwDocKey, g_stMyItemInfo.m_stItemInfo);

				if (g_stMyItemInfo.m_nModeIndex == g_stMyItemInfo.CREATE_SINGLE)
				{
					g_bItemGrab	= FALSE;
				}
			}
			else
			{
				Report(GetLocalString("MSG_0117"), CAUTION);
			}
		}
		else
		{
			Report(GetLocalString("MSG_0118"), CAUTION);
		}
	}
}

//	해당 좌표의 그리드에 현재 집혀있는 아이템을 놓을 수 있는 지 판별하는 함수
BOOL CCharInventoryPage::IsEnableItemDrop(CPoint selGridCoordinates, CPoint selItemSize)
{
	int nIsEnableCell = 0;		// 비어있는 셀의 개수
	
	// 그리드 검색시 6 X 6 의 그리드 셀을 벗어나지 않도록 초기화
	int maxGridSearchColumn =
		(selGridCoordinates.x + selItemSize.x > 5) ? 6 : selGridCoordinates.x + selItemSize.x;

	int maxGridSearchRow =
		(selGridCoordinates.y + selItemSize.y > 5) ? 6 : selGridCoordinates.y + selItemSize.y;
		
	// 그리드 검색
	for (int nColumn = selGridCoordinates.x; nColumn < maxGridSearchColumn; nColumn++)
	{
		for (int nRow = selGridCoordinates.y; nRow < maxGridSearchRow; nRow++)
		{
			COLORREF clrDefaultCellColor = RGB(215, 247, 255);
			
			// 디폴트 색상으로 채워져있는 그리드(비어있는 그리드)인지 확인
			if (4278190080 == m_ctrlInventoryGrid.GetItemBkColour(nRow, nColumn))
				nIsEnableCell++;
		}
	}
	// 아이템 크기 만큼의 빈 셀이 있으면 TRUE 리턴, 아니면 FALSE 리턴
	if (nIsEnableCell == (selItemSize.x * selItemSize.y))
		return TRUE;
	else
		return FALSE;
}

//	아이템 생성 버튼 클릭
void CCharInventoryPage::OnBnClickedItemmake()
{	
	CItemManageDlg dlg(CItemManageDlg::CREATE);
	dlg.DoModal();
}

//	아이템 수정
void CCharInventoryPage::OnUpdateItem()
{
	int Index;
	unsigned __int64 ItemID = 0;
	TCHAR szItemName[255];
	TCHAR szTmp[50];
	unsigned char cTakeType;

	UpdateData(true);
	
	if (true == m_InEquipList)
	{
		cTakeType = TakeType::TS_EQUIP;
		
		Index = m_ctrlEquipItemList.GetNextItem(-1, LVIS_SELECTED);
		if (-1 != Index)
		{
			m_ctrlEquipItemList.GetItemText(Index, 0, szTmp, sizeof(szTmp));
			m_ctrlEquipItemList.GetItemText(Index, 1, szItemName, sizeof(szItemName));
			ItemID = Math::Convert::StrToHex64(szTmp);
		}
	}
	else if (true == m_InInventoryList)
	{
		cTakeType = TakeType::TS_INVEN;
		
		Index = m_ctrlInventoryItemList.GetNextItem(-1, LVIS_SELECTED);
		if (-1 != Index)
		{
			m_ctrlInventoryItemList.GetItemText(Index, 0, szTmp, sizeof(szTmp));
			m_ctrlInventoryItemList.GetItemText(Index, 1, szItemName, sizeof(szItemName));
			ItemID = Math::Convert::StrToHex64(szTmp);

			const Item::ItemInfo *ItemInfo =
				Item::CItemMgr::GetInstance().GetItemInfoFromItemName(szItemName);

			if (NULL == ItemInfo)
			{
				Report(GetLocalString("ADDED_STRING_060"), FAILED);
				return;
			}
			/* 2005-06-16 QA실 요청
			else if(Item::ItemType::QUEST_ITEM == ItemInfo->m_DetailData.m_cItemType)
			{
				Report(GetLocalString("ADDED_STRING_061"), FAILED);
				return;
			}
			*/
		}
	}

	if ((NULL != m_lpInventoryPageInfo) && (ItemID != 0) && (NULL != m_dwDocKey))
	{
		g_stMyItemInfo.m_nModeIndex = MyItemInfo::EDIT;

		g_stMyItemInfo.m_dwItemSerial = ItemID;
		_tcscpy(g_stMyItemInfo.m_szItemName, szItemName);
		g_stMyItemInfo.m_cTakeType = cTakeType;
		g_stMyItemInfo.m_lpModifyCharInfo = m_lpInventoryPageInfo;
		g_stMyItemInfo.m_dwDocKey = m_dwDocKey;

		Item::CItem* lpItem = g_stMyItemInfo.m_lpModifyCharInfo->UIDbyItem(ItemID, cTakeType);
		//g_stMyItemInfo.m_stItemInfo = lpItem->GetItemInfo();

		CItemManageDlg dlg(CItemManageDlg::EDIT);
		dlg.DoModal();
	}

	m_InEquipList = m_InInventoryList = false;
}

//	아이템 삭제
void CCharInventoryPage::OnRemoveItem()
{
	int Index;
	unsigned __int64 ItemID = 0;
	TCHAR szItemName[256];
	TCHAR szTmp[50];
	unsigned char cTakeType;

	UpdateData(true);
	
	if (true == m_InEquipList)
	{
		cTakeType = TakeType::TS_EQUIP;

		Index = m_ctrlEquipItemList.GetNextItem(-1, LVIS_SELECTED);
		if(-1 != Index)
		{
			m_ctrlEquipItemList.GetItemText(Index, 0, szTmp, 50);
			m_ctrlEquipItemList.GetItemText(Index, 1, szItemName, 256);
			ItemID = Math::Convert::StrToHex64(szTmp);
		}
	}
	else if (true == m_InInventoryList)
	{
		cTakeType = TakeType::TS_INVEN;

		Index = m_ctrlInventoryItemList.GetNextItem(-1, LVIS_SELECTED);
		if (-1 != Index)
		{
			m_ctrlInventoryItemList.GetItemText(Index, 0, szTmp, 50);
			m_ctrlInventoryItemList.GetItemText(Index, 1, szItemName, 256);
			ItemID = Math::Convert::StrToHex64(szTmp);

			const Item::ItemInfo *ItemInfo =
				Item::CItemMgr::GetInstance().GetItemInfoFromItemName(szItemName);

			if (NULL == ItemInfo)
			{
				Report(GetLocalString("ADDED_STRING_060"), FAILED);
				return;
			}
			/* 2005-06-16 QA실 요청
			else if(Item::ItemType::QUEST_ITEM == ItemInfo->m_DetailData.m_cItemType)
			{
				Report(GetLocalString("ADDED_STRING_062"), FAILED);
				return;
			}
			*/
		}
	}

	if ((NULL != m_lpInventoryPageInfo) && (ItemID != 0) && (NULL != m_dwDocKey))
	{
		g_stMyItemInfo.m_nModeIndex = MyItemInfo::REMOVE;

		g_stMyItemInfo.m_dwItemSerial = ItemID;
		CopyMemory(g_stMyItemInfo.m_szItemName, szItemName, 256);
		g_stMyItemInfo.m_cTakeType = cTakeType;

		g_stMyItemInfo.m_lpModifyCharInfo = m_lpInventoryPageInfo;
		g_stMyItemInfo.m_dwDocKey = m_dwDocKey;

		Item::CItem* lpItem = m_lpInventoryPageInfo->UIDbyItem(ItemID, cTakeType);
		Item::ItemPos stItemPos	= lpItem->GetPos();

		CPacketMgr::GetInstance()->SendRemoveItem(
			m_lpInventoryPageInfo->GetServerGroup(), m_lpInventoryPageInfo->GetCID(),
			m_lpInventoryPageInfo->GetUID(), m_dwDocKey, ItemID, lpItem->GetPrototypeID(), stItemPos);
	}

	m_InEquipList = m_InInventoryList = false;
}

void CCharInventoryPage::PostNcDestroy()
{
	m_ctrlInventoryGrid.DestroyWindow();

	CPropertyPage::PostNcDestroy();
}

void CCharInventoryPage::OnNMDblclkEquipitemlist(NMHDR *pNMHDR, LRESULT *pResult)
{
	if(1 == m_ctrlEquipItemList.GetSelectedCount())
	{
		m_InEquipList = true;
		OnUpdateItem();
	}

	*pResult = 0;
}

void CCharInventoryPage::OnNMDblclkInventoryitemlist(NMHDR *pNMHDR, LRESULT *pResult)
{
	if(1 == m_ctrlInventoryItemList.GetSelectedCount())
	{
		m_InInventoryList = true;
		OnUpdateItem();
	}

	*pResult = 0;
}

void CCharInventoryPage::OnBnClickedEquipReset()
{
	CPacketMgr::GetInstance()->SendItemContainerReset(m_lpInventoryPageInfo->GetServerGroup(), 
		m_lpInventoryPageInfo->GetUID(), m_lpInventoryPageInfo->GetCID(), m_dwDocKey, TakeType::TS_EQUIP);	
}

void CCharInventoryPage::OnBnClickedInvenReset()
{
	CPacketMgr::GetInstance()->SendItemContainerReset(m_lpInventoryPageInfo->GetServerGroup(),
		m_lpInventoryPageInfo->GetUID(), m_lpInventoryPageInfo->GetCID(), m_dwDocKey, TakeType::TS_INVEN);
}

void CCharInventoryPage::OnBnClickedInvenGoldUpdate()
{
	UpdateData(true);
	
	CPacketMgr::GetInstance()->SendInvenGold(
		m_lpInventoryPageInfo->GetUID(), m_lpInventoryPageInfo->GetCID(),
		m_lpInventoryPageInfo->GetServerGroup(), m_dwDocKey, m_dwInventoryGold);
}

void CCharInventoryPage::OnStoreCopy()
{
	CListCtrl*		lpItemList;
	unsigned char	cTakeType;
	__int64			ItemUID;
	TCHAR			szTmp[256];

	if (true == m_InEquipList)
	{
		cTakeType = TakeType::TS_EQUIP;
		lpItemList = &m_ctrlEquipItemList;
	}
	else if (true == m_InInventoryList)
	{
		cTakeType = TakeType::TS_INVEN;
		lpItemList = &m_ctrlInventoryItemList;
	}
	else
	{
		return;
	}
	
	int Index = lpItemList->GetNextItem(-1, LVIS_SELECTED);
	if (-1 < Index)
	{
		lpItemList->GetItemText(Index, 0, szTmp, sizeof(szTmp));
		ItemUID = Math::Convert::StrToHex64( szTmp );
	}
	else
	{
		Report(GetLocalString("MSG_0119"), FAILED);
		return;
	}
	
	PktAdminMgr::CreateItemInfo  MkStoreInfo;
	
	Item::CItem* lpItem = m_lpInventoryPageInfo->UIDbyItem(ItemUID, cTakeType);
	if (NULL != lpItem)
	{		
		MkStoreInfo.m_cNumOrDurability = lpItem->GetNumOrDurability();
			
		Item::CEquipment* lpEquipment = Item::CEquipment::DowncastToEquipment(lpItem);
		if (NULL != lpEquipment)
		{
			for(int nIndex = 0; nIndex < Item::EquipmentInfo::MAX_RUNE_SOCKET_NUM; ++nIndex)
			{
				MkStoreInfo.m_usRuneSocket[nIndex] = lpEquipment->GetRuneSocket(nIndex);
			}
			MkStoreInfo.m_cMaxDurability    = lpEquipment->GetMaxNumOrDurability();
			MkStoreInfo.m_cCurrentSocketNum = lpEquipment->GetCurrentSocketNum();
			MkStoreInfo.m_cMaxSocketNum	    = lpEquipment->GetMaxSocketNum();
			MkStoreInfo.m_cUpgradeLevel	    = lpEquipment->GetUpgradeLevel();
			MkStoreInfo.m_cSeasonRecord		= lpEquipment->GetSeasonRecord();
			MkStoreInfo.m_cCoreLevel		= lpEquipment->GetCoreLevel();

			lpEquipment->GetAttribute(MkStoreInfo.m_usAttribute, sizeof(MkStoreInfo.m_usAttribute));
			lpEquipment->GetSocket(MkStoreInfo.m_cSocket, sizeof(MkStoreInfo.m_cSocket));			
		}
	}

	char StoreBuffer[PktAdminMgr::PktAdminStoreInsert::MAX_ITEM_INFO];
	TCHAR szItemName[64];
	unsigned long dwStoreBufferLength = 0;

	_tcsncpy(szItemName, CONV_CLISTR(lpItem->GetItemInfo().m_SpriteData.m_szName), 64);
	MkStoreInfo.AdminStore_Out(StoreBuffer, dwStoreBufferLength);

	CPacketMgr::GetInstance()->SendPktAdminStoreInsert(
		(unsigned char)m_lpInventoryPageInfo->GetServerGroup(),
		CONV_CLISTR(m_lpInventoryPageInfo->GetName()), szItemName, StoreBuffer);

	m_InEquipList = m_InInventoryList = false;
}

void CCharInventoryPage::OnLvnColumnclickitemlist(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
		
	if(pNMLV->iSubItem == m_iSortListItem)
	{
		m_bSortListAsc = !m_bSortListAsc;
	}
	else
	{
	    m_iSortListItem = pNMLV->iSubItem;
	    m_bSortListAsc  = true;
	}

	if(pNMLV->hdr.idFrom == IDC_EQUIPITEMLIST)
	{
		SortListWndItem(&m_ctrlEquipItemList, m_iSortListItem);
	}
	else if(pNMLV->hdr.idFrom == IDC_INVENTORYITEMLIST)
	{
		SortListWndItem(&m_ctrlInventoryItemList, m_iSortListItem);
	}

	*pResult = 0;
}

void CCharInventoryPage::SortListWndItem(CListCtrl* pListCtrl, const int iCol)
{
	CListCtrlSortClass SortClass(pListCtrl,iCol);

	switch(m_iSortListItem)
	{
	case SORT_TYPE::SERIAL:
		SortClass.Sort(m_bSortListAsc, CListCtrlSortClass::SortDataType::dtSTRINGNOCASE);
		break;
	case SORT_TYPE::NAME: 
		SortClass.Sort(m_bSortListAsc, CListCtrlSortClass::SortDataType::dtSTRINGNOCASE);
		break;
	case SORT_TYPE::TYPE: 
		SortClass.Sort(m_bSortListAsc, CListCtrlSortClass::SortDataType::dtSTRING);
		break;
	case SORT_TYPE::COORDINATE:
		SortClass.Sort(m_bSortListAsc, CListCtrlSortClass::SortDataType::dtSTRINGNOCASE);
		break;
	case SORT_TYPE::QUANTITY:
		SortClass.Sort(m_bSortListAsc, CListCtrlSortClass::SortDataType::dtINT);
		break;
	}
}

void CCharInventoryPage::OnBnClickedInvenpageEguipclipBtn()
{
	ClippingListCtrl(m_ctrlEquipItemList, 5, true);
}

void CCharInventoryPage::OnBnClickedInvenpageInvenclipBtn()
{
	ClippingListCtrl(m_ctrlInventoryItemList, 5, true);
}