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

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

#include <Item/Container/DepositContainer.h>
#include <Item/Container/ContainerConstant.h>
#include <Character/ModifyCharacter.h>
#include <Utility/Math/Math.h>

// CCharItemStorePage 대화 상자입니다.

IMPLEMENT_DYNAMIC(CCharItemStorePage, CPropertyPage)
CCharItemStorePage::CCharItemStorePage()
	: CPropertyPage(CCharItemStorePage::IDD)
	, m_dwStoreGold(0)
	, m_strStorePass(_T("0000"))
	, m_dwDocKey(0)
	, m_lpStorePageInfo(NULL)
	, m_bSortListAsc(false)
{
}

CCharItemStorePage::~CCharItemStorePage()
{
}

void CCharItemStorePage::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);

	DDX_Control(pDX, IDC_ITEMSTORETAB, m_ctrlItemStoreTab);
	DDX_Control(pDX, IDC_ITEMSTORELIST, m_ctrlItemStoreItemList);

	DDX_Text(pDX, IDC_STORE_GOLD, m_dwStoreGold);
	DDX_Text(pDX, IDC_STORE_PASS, m_strStorePass);
	DDX_Control(pDX, IDC_TABNUM_CB, m_ctrlTabNumCb);
}

BEGIN_MESSAGE_MAP(CCharItemStorePage, CPropertyPage)
	ON_WM_CONTEXTMENU()

	ON_NOTIFY(NM_CLICK, CHAR_STORE_ITEM, OnStoreGridClick)
	ON_NOTIFY(NM_DBLCLK, IDC_ITEMSTORELIST, OnNMDblclkItemstorelist)
	ON_NOTIFY(TCN_SELCHANGE, IDC_ITEMSTORETAB, OnTcnSelchangeItemstoretab)
	
	ON_COMMAND(ID_STOREITEM_EDIT, OnStoreitemUpdate)
	ON_COMMAND(ID_STOREITEM_REMOVE, OnStoreitemRemove)
	ON_COMMAND(ID_STORE_COPY, OnStoreCopy)
	
	ON_BN_CLICKED(IDC_STORERESET, OnBnClickedStoreResetBtn)
	ON_BN_CLICKED(IDC_STOREPASS_EDIT, OnBnClickedStorePassEdit)
	ON_BN_CLICKED(IDC_STOREGOLD_UPDATE, OnBnClickedStoregoldUpdate)
	ON_NOTIFY(LVN_COLUMNCLICK, IDC_ITEMSTORELIST, OnLvnColumnclickItemstorelist)
	ON_BN_CLICKED(IDC_STOREPAGE_STORECLIP_BTN, OnBnClickedStorepageStoreclipBtn)
	ON_BN_CLICKED(IDC_TABEDIT_BTN, OnBnClickedTabeditBtn)
END_MESSAGE_MAP()


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

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

	CRect rcGrid;
    rcGrid.left = 19; rcGrid.top = 49; rcGrid.right = 264; rcGrid.bottom = 414;
    m_ctrlItemStoreGrid.Create(rcGrid, this, CHAR_STORE_ITEM, WS_CHILD|WS_BORDER|WS_TABSTOP|WS_VISIBLE);	

	InitializeItemGrid(m_ctrlItemStoreGrid, 12, 8, FALSE, FALSE,
		RGB(0, 0, 0), RGB(215, 247, 255), RGB(172, 172, 172));
	m_ctrlItemStoreGrid.EnableSelection(FALSE);
	
	m_ctrlItemStoreTab.InsertItem( 0, _T("1"), 0);
	m_ctrlItemStoreTab.InsertItem( 1, _T("2"), 0);
	m_ctrlItemStoreTab.InsertItem( 2, _T("3"), 0);
	m_ctrlItemStoreTab.InsertItem( 3, _T("4"), 0);
	
	m_ctrlItemStoreItemList.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_FLATSB);

	m_ctrlItemStoreItemList.InsertColumn(0, GetLocalString("SERIAL"), LVCFMT_LEFT, 120);
	m_ctrlItemStoreItemList.InsertColumn(1, GetLocalString("ITEM_NAME"), LVCFMT_LEFT, 117);
	m_ctrlItemStoreItemList.InsertColumn(2, GetLocalString("ITEM_TYPE"), LVCFMT_LEFT, 80);
	m_ctrlItemStoreItemList.InsertColumn(3, GetLocalString("POS"), LVCFMT_LEFT, 47);
	m_ctrlItemStoreItemList.InsertColumn(4, GetLocalString("QTY"), LVCFMT_LEFT, 47);

	CString strTab;
	for (int nIndex = 0; nIndex < 4; ++nIndex)
	{
		strTab.Format("%d", nIndex + 1);
		m_ctrlTabNumCb.AddString(strTab);
	}

	SetUIString(this->m_hWnd, IDC_STOREPAGE_01, "IDC_STOREPAGE_01");
	SetUIString(this->m_hWnd, IDC_STOREPAGE_02, "IDC_STOREPAGE_02");
	SetUIString(this->m_hWnd, IDC_STOREPAGE_03, "IDC_STOREPAGE_03");
	SetUIString(this->m_hWnd, IDC_STOREPAGE_04, "IDC_STOREPAGE_04");
	SetUIString(this->m_hWnd, IDC_STOREPAGE_05, "IDC_STOREPAGE_05");
	SetUIString(this->m_hWnd, IDC_STORERESET, "IDC_STORERESET");
	SetUIString(this->m_hWnd, IDC_STOREPAGE_STORECLIP_BTN, "IDC_STOREPAGE_STORECLIP_BTN");
	SetUIString(this->m_hWnd, IDC_STOREGOLD_UPDATE, "IDC_STOREGOLD_UPDATE");
	SetUIString(this->m_hWnd, IDC_STOREPASS_EDIT, "IDC_STOREPASS_EDIT");

	return TRUE;
}

bool CCharItemStorePage::SetStorePageData(unsigned int dwDocKey, CModifyCharacter* lpModifyCharacter)
{
	if((0 != dwDocKey) && (NULL != lpModifyCharacter))
	{
		m_lpStorePageInfo	= lpModifyCharacter;
		m_dwDocKey			= dwDocKey;

		GetDlgItem(IDC_STORERESET)->EnableWindow(true);
		GetDlgItem(IDC_STOREGOLD_UPDATE)->EnableWindow(true);
		GetDlgItem(IDC_STOREPASS_EDIT)->EnableWindow(true);
		GetDlgItem(IDC_STOREPAGE_STORECLIP_BTN)->EnableWindow(true);

		return true;
	}
	else
		return false;
}

void CCharItemStorePage::SetStorePage(CModifyCharacter* lpModifyCharacter)
{
	m_ctrlItemStoreItemList.DeleteAllItems();
	m_ctrlItemStoreGrid.DeleteAllItems();

	InitializeItemGrid(m_ctrlItemStoreGrid, 12, 8, FALSE, FALSE, 
		RGB(0, 0, 0), RGB(215, 247, 255), RGB(172, 172, 172));
	m_ctrlItemStoreGrid.EnableSelection(false);
	
	if(NULL == lpModifyCharacter)
	{
		return;
	}

	Item::CDepositContainer& DepositContainer = lpModifyCharacter->GetDeposit();
	Item::CItemContainer* ItemContainer = DepositContainer.GetTab(m_ctrlItemStoreTab.GetCurSel());
	
	Item::CItemContainer::iterator Itr = ItemContainer->begin();
	Item::CItem* StoreItem = NULL;
		
	unsigned long dwTabFlag = DepositContainer.GetTabFlag();
	unsigned int  nUseTabNum = 0;


	// 사용중인 탭과 사용중이지 않은 탭 캡션 셋팅
	TCHAR szText[255];

	TCITEM stTabItem;
	stTabItem.mask = TCIF_TEXT;
	stTabItem.pszText = szText;
	stTabItem.cchTextMax = 255;
	
	for (char cTab = 0; cTab < ContainerConstant::MAX_DEPOSIT_TAB; ++cTab)
	{
		if (0 == (dwTabFlag & (1 << cTab)))
		{	
			_sntprintf(szText, 255, _T("Not use"));
			m_ctrlItemStoreTab.SetItem((int)cTab, &stTabItem);
		}
		else
		{
			_sntprintf(szText, 255, _T("%d"), (int)cTab + 1);
			m_ctrlItemStoreTab.SetItem((int)cTab, &stTabItem);

			++nUseTabNum;
		}
	}

	while(Itr != ItemContainer->end())
	{
		StoreItem = (*Itr);
		if(NULL != StoreItem)
		{
			StoreGridSet(StoreItem);
		}
		++Itr;
	}

	//	사용가능 한 탭에 있는 아이템 정보 리스트 컨트롤에 셋팅
	for(int StoreTab = 0; StoreTab < ContainerConstant::MAX_DEPOSIT_TAB; StoreTab++)
	{
		ItemContainer = DepositContainer.GetTab(StoreTab);
		Itr			  = ItemContainer->begin();
		StoreItem	  = NULL;
		
		while(Itr != ItemContainer->end())
		{
			StoreItem = (*Itr);
			if(NULL != StoreItem)
			{
				CString	serial(_T("0x"));
				CString	quantity;
				CString	realItemPos;

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

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

				const Item::ItemInfo& ItemInfo = StoreItem->GetItemInfo();

				m_ctrlItemStoreItemList.InsertItem(0, serial);
				m_ctrlItemStoreItemList.SetItemText(0, 1, (LPCTSTR)ItemInfo.m_SpriteData.m_szName);
				m_ctrlItemStoreItemList.SetItemText(0, 2, (LPCTSTR)StoreItem->GetItemTypeName());
				m_ctrlItemStoreItemList.SetItemText(0, 3, realItemPos);
				m_ctrlItemStoreItemList.SetItemText(0, 4, quantity);

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

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

	m_dwStoreGold = DepositContainer.GetGold();
	
	char szPassword[10];
	sprintf(szPassword, "%s", DepositContainer.GetPassword());
	szPassword[4] = 0;

	m_strStorePass.Format(_T("%s"), CONV_CLISTR(szPassword));

	m_ctrlTabNumCb.SetCurSel(nUseTabNum - 1);

	UpdateData(false);
}

void CCharItemStorePage::StoreGridSet(Item::CItem* StoreItem)
{
	Item::ItemPos ItemPos = StoreItem->GetPos();
	const Item::ItemInfo& ItemInfo = StoreItem->GetItemInfo();
	
	CString ItemToolTip;		// 그리드에 채울 아이템 툴팁
	CString	serial(_T("0x"));	// 아이템 시리얼 포맷팅 용
	
	// 아이템 좌표 정보
	unsigned int	itemX		= ItemPos.GetXIndex();
	unsigned int	itemY		= ItemPos.GetYIndex();
	unsigned int	itemSizeX	= ItemInfo.m_DetailData.m_cXSize;
	unsigned int	itemSizeY	= ItemInfo.m_DetailData.m_cYSize;
	
	ItemToolTip.Format(GetLocalString("FORMAT_002"),
		ItemInfo.m_SpriteData.m_szName, StoreItem->GetUID());

	m_ctrlItemStoreGrid.SetItemText(itemY, itemX, ItemToolTip);

	// 해당 아이템 크기에 따라 그리드 배경색 칠하기
	for (int X = itemX; X < (int)(itemX + itemSizeX); X++)
	{
		for(int Y = itemY; Y < (int)(itemY + itemSizeY); Y++)
		{
			m_ctrlItemStoreGrid.SetItemBkColour(Y, X,
				GetItemTypeColor(Item::ItemType::Type(ItemInfo.m_DetailData.m_cItemType)));
		}
	}

	m_ctrlItemStoreGrid.Invalidate(TRUE);
}

//	그리드 클릭시 이벤트 처리
void CCharItemStorePage::OnStoreGridClick(NMHDR *pNotifyStruct, LRESULT* /*pResult*/)
{
    NM_GRIDVIEW* pItem = (NM_GRIDVIEW*) pNotifyStruct;
	
	if(g_bItemGrab)
	{	
		CPoint selItemCoordinate, selItemSize;

		g_stMyItemInfo.m_stItemInfo.m_cTakePos  = TakeType::TS_DEPOSIT;	// 창고에 드랍

		g_stMyItemInfo.m_stItemInfo.m_cXPos	= pItem->iColumn;		//	좌표와 탭 정보를 전역 아이템 변수에 셋팅
		g_stMyItemInfo.m_stItemInfo.m_cYPos	= pItem->iRow;
		g_stMyItemInfo.m_stItemInfo.m_cZPos	= m_ctrlItemStoreTab.GetCurSel();
		
		// 드랍 가능 여부 판별용 그리드 좌표 정보 셋팅
		selItemCoordinate.x			= 	g_stMyItemInfo.m_stItemInfo.m_cXPos;		
		selItemCoordinate.y			= 	g_stMyItemInfo.m_stItemInfo.m_cYPos;
		
		//	드랍 가능 여부 판별용  아이템 크기 정보 셋팅
		selItemSize.x = g_stMyItemInfo.m_SizeX;
		selItemSize.y = g_stMyItemInfo.m_SizeY;

		if(NULL != m_lpStorePageInfo && NULL != m_dwDocKey)
		{
			if(IsEnableItemDrop(selItemCoordinate, selItemSize))
			{
				//	아이템 생성 
				CPacketMgr::GetInstance()->SendCreateItem(m_lpStorePageInfo->GetServerGroup(),
					m_lpStorePageInfo->GetCID(), m_lpStorePageInfo->GetUID(), m_dwDocKey, g_stMyItemInfo.m_stItemInfo);

				//	아이템 이동 모드라면 아이템 집은 상태 해제
				if(g_stMyItemInfo.m_nModeIndex == g_stMyItemInfo.CREATE_SINGLE)
				{
					g_bItemGrab	= FALSE;
				}
			}
			else
			{
				Report(GetLocalString("MSG_0120"), CAUTION);
			}
		}
		else
		{
			Report(GetLocalString("MSG_0121"), CAUTION);
		}
	}
}

//	해당 좌표의 그리드에 현재 집혀있는 아이템을 놓을 수 있는 지 판별하는 함수
BOOL CCharItemStorePage::IsEnableItemDrop(CPoint selGridCoordinates, CPoint selItemSize)
{
	int nIsEnableCell = 0;		// 비어있는 셀의 개수
	
	// 그리드 검색시 8 X 12 의 그리드 셀을 벗어나지 않도록 초기화
	int maxGridSearchColumn = (selGridCoordinates.x + selItemSize.x > 7) ? 8 : selGridCoordinates.x + selItemSize.x;
	int maxGridSearchRow = (selGridCoordinates.y + selItemSize.y > 11) ? 12 : 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_ctrlItemStoreGrid.GetItemBkColour(nRow, nColumn))
			{
				nIsEnableCell++;
			}
		}
	}
	// 아이템 크기 만큼의 빈 셀이 있으면 TRUE 리턴, 아니면 FALSE 리턴
	if(nIsEnableCell == (selItemSize.x * selItemSize.y))
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

void CCharItemStorePage::OnTcnSelchangeItemstoretab(NMHDR *pNMHDR, LRESULT *pResult)
{
	//	창고 탭이 바뀔때 마다 탭에 맞는 아이템으로 지긋히 셋팅

	if(NULL == m_lpStorePageInfo)
	{
		return;
	}
	
	m_ctrlItemStoreGrid.DeleteAllItems();							// 그리드 완전히 지우기
	InitializeItemGrid( m_ctrlItemStoreGrid, 12, 8, FALSE, FALSE,
	RGB(0, 0, 0), RGB(215, 247, 255), RGB(172, 172, 172));			// 새 그리드 그리기

	if(NULL != m_lpStorePageInfo)
	{
		Item::CDepositContainer&			DepositContainer	= m_lpStorePageInfo->GetDeposit();
		Item::CItemContainer*				ItemContainer		= DepositContainer.GetTab( m_ctrlItemStoreTab.GetCurSel() );
		Item::CItemContainer::iterator		Itr					= ItemContainer->begin( );
		Item::CItem*						StoreItem			= NULL;
		
		while(Itr != ItemContainer->end())
		{		
			StoreItem = (*Itr);

			if(NULL != StoreItem)
			{	
				StoreGridSet(StoreItem);
			}

			++Itr;
		}
	}

	*pResult = 0;
}

void CCharItemStorePage::OnContextMenu(CWnd* pWnd, CPoint point)
{
	if((pWnd->GetSafeHwnd() == m_ctrlItemStoreItemList.GetSafeHwnd()) 
		&& (m_ctrlItemStoreItemList.GetSelectedCount() == 1))
	{
		CMenu muTemp, *pContextMenu;
		muTemp.LoadMenu(IDR_CONTEXTMENU);
		pContextMenu = muTemp.GetSubMenu(7);
		pContextMenu->ModifyMenu(0, MF_STRING | MF_BYPOSITION, ID_STOREITEM_EDIT,   GetLocalString("MENU_024"));
		pContextMenu->ModifyMenu(1, MF_STRING | MF_BYPOSITION, ID_STOREITEM_REMOVE, 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);
	}
}

void CCharItemStorePage::OnStoreitemUpdate()
{ 
	unsigned __int64 i64ItemSerial = 0;
	TCHAR szItemName[255] = _T("Item Name");
	TCHAR szTmp[50];
	unsigned char cTakeType;

	UpdateData(true);	
	
	cTakeType = TakeType::TS_DEPOSIT;
	int iSelIndex = m_ctrlItemStoreItemList.GetNextItem(-1, LVIS_SELECTED);
	
	if(-1 != iSelIndex)
	{
		m_ctrlItemStoreItemList.GetItemText(iSelIndex, 0, szTmp, sizeof(szTmp));
		m_ctrlItemStoreItemList.GetItemText(iSelIndex, 1, szItemName, sizeof(szItemName));
		i64ItemSerial = Math::Convert::StrToHex64(szTmp);	//__ttoi64(szTmp);
	}

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

		g_stMyItemInfo.m_dwItemSerial = i64ItemSerial;
		CopyMemory( g_stMyItemInfo.m_szItemName, szItemName, sizeof(szItemName));
		g_stMyItemInfo.m_cTakeType = cTakeType;
		g_stMyItemInfo.m_lpModifyCharInfo = m_lpStorePageInfo;
		g_stMyItemInfo.m_dwDocKey = m_dwDocKey;

		Item::CItem* lpItem = g_stMyItemInfo.m_lpModifyCharInfo->UIDbyItem(i64ItemSerial, cTakeType);

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

void CCharItemStorePage::OnStoreitemRemove()
{
	int					Index;
	unsigned __int64	i64ItemSerial = 0;
	TCHAR				szItemName[255] = _T("Item Name");
	TCHAR				szTmp[50];
	unsigned char		cTakeType;

	UpdateData(TRUE);
	
	cTakeType = TakeType::TS_DEPOSIT;
	Index = m_ctrlItemStoreItemList.GetNextItem(-1, LVIS_SELECTED);

	if(-1 != Index)
	{
		m_ctrlItemStoreItemList.GetItemText(Index, 0, szTmp, sizeof(szTmp));
		m_ctrlItemStoreItemList.GetItemText(Index, 1, szItemName, sizeof(szItemName));
		i64ItemSerial = Math::Convert::StrToHex64( szTmp );//__ttoi64( szTmp );
	}

	if( (NULL != m_lpStorePageInfo) && (i64ItemSerial != 0) && (NULL != m_dwDocKey) )
	{
		g_stMyItemInfo.m_nModeIndex			= MyItemInfo::REMOVE;	// 삭제모드의 아이템 변수임을 명시

		g_stMyItemInfo.m_dwItemSerial		= i64ItemSerial;		// 아이템 수정 정보 변수에 시리얼 셋팅
		CopyMemory(g_stMyItemInfo.m_szItemName, szItemName, sizeof(szItemName));	// 아이템 이름 셋팅
		g_stMyItemInfo.m_cTakeType			= cTakeType;				// 아이템 위치 셋팅

		g_stMyItemInfo.m_lpModifyCharInfo	= m_lpStorePageInfo;		// 아이템 소유자 정보 셋팅
		g_stMyItemInfo.m_dwDocKey			= m_dwDocKey;				// 현재 다큐먼트 키 셋팅

		Item::CItem*		lpItem			= m_lpStorePageInfo->UIDbyItem( i64ItemSerial, cTakeType );
		Item::ItemPos		stItemPos		= lpItem->GetPos();
		
		CPacketMgr::GetInstance()->SendRemoveItem(m_lpStorePageInfo->GetServerGroup(),
			m_lpStorePageInfo->GetCID(), m_lpStorePageInfo->GetUID(), m_dwDocKey, i64ItemSerial,
			lpItem->GetPrototypeID(), stItemPos);
	}	
}

void CCharItemStorePage::OnNMDblclkItemstorelist(NMHDR *pNMHDR, LRESULT *pResult)
{
	if(m_ctrlItemStoreItemList.GetSelectedCount() == 1)
	{
		OnStoreitemUpdate();
	}

	*pResult = 0;
}

void CCharItemStorePage::OnBnClickedStoreResetBtn()
{
	CPacketMgr::GetInstance()->SendItemContainerReset(m_lpStorePageInfo->GetServerGroup(),
		m_lpStorePageInfo->GetUID(), m_lpStorePageInfo->GetCID(), m_dwDocKey, TakeType::TS_DEPOSIT);
}

void CCharItemStorePage::OnBnClickedStorePassEdit()
{
	UpdateData(true);

	if(m_strStorePass.GetLength() < PktAdminMgr::PktDepositPasswd::PASSWORD_LENGTH + 1)
	{
		CPacketMgr::GetInstance()->SendPktDepositPwd(m_lpStorePageInfo->GetUID(), m_lpStorePageInfo->GetCID(),
			m_lpStorePageInfo->GetServerGroup(), m_dwDocKey, m_strStorePass.GetBuffer());
	}
	else
	{
		AfxMessageBox(GetLocalString("MSG_0122"));
	}
}

void CCharItemStorePage::OnStoreCopy()
{	// 중복코드 ㅋㅋㅋ ㅡ.ㅡ;
	__int64			ItemUID;
	TCHAR			szTmp[256];
	unsigned char	cTakeType = TakeType::TS_DEPOSIT;

	int Index = m_ctrlItemStoreItemList.GetNextItem(-1, LVIS_SELECTED);
	
	if( -1 < Index )
	{
		m_ctrlItemStoreItemList.GetItemText(Index, 0, szTmp, sizeof(szTmp));
		ItemUID = Math::Convert::StrToHex64(szTmp);
	}
	else
	{
		return;
	}
	
	PktAdminMgr::CreateItemInfo MkStoreInfo;
	Item::CItem* lpItem = m_lpStorePageInfo->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_lpStorePageInfo->GetServerGroup(),
		CONV_CLISTR(m_lpStorePageInfo->GetName()), szItemName, StoreBuffer);
}

void CCharItemStorePage::PostNcDestroy()
{	
	m_ctrlItemStoreGrid.DestroyWindow();

	CPropertyPage::PostNcDestroy();
}

void CCharItemStorePage::OnBnClickedStoregoldUpdate()
{
	UpdateData(true);

	if(m_dwStoreGold < ULONG_MAX)
	{
		CPacketMgr::GetInstance()->SendStoreGoldUpdate(
			m_lpStorePageInfo->GetUID(), m_lpStorePageInfo->GetCID(),
			m_lpStorePageInfo->GetServerGroup(), m_dwDocKey, m_dwStoreGold);
	}
	else
	{
		AfxMessageBox(GetLocalString("MSG_0123"));
	}
}

void CCharItemStorePage::OnLvnColumnclickItemstorelist(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;
	}

	SortListWndItem(&m_ctrlItemStoreItemList, m_iSortListItem);
	
	*pResult = 0;
}

void CCharItemStorePage::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 CCharItemStorePage::OnBnClickedStorepageStoreclipBtn()
{
	ClippingListCtrl(m_ctrlItemStoreItemList, 5, true);
}

void CCharItemStorePage::OnBnClickedTabeditBtn()
{
	unsigned long dwTabFlag = m_lpStorePageInfo->GetDeposit().GetTabFlag();
	unsigned int nUseTabNum = 0;

	for (char cTab = 0; cTab < ContainerConstant::MAX_DEPOSIT_TAB; ++cTab)
	{
		if(0 != (dwTabFlag & (1 << cTab)))
		{
			++nUseTabNum;
		}
	}

	if ((int)nUseTabNum < (m_ctrlTabNumCb.GetCurSel() + 1))
	{
		CPacketMgr::GetInstance()->SendPktStoreTabEdit(m_dwDocKey,
			m_lpStorePageInfo->GetServerGroup(), m_lpStorePageInfo->GetCID(),
			(unsigned int)(m_ctrlTabNumCb.GetCurSel() + 1));	
	}
	else
	{
		Report(GetLocalString("ADDED_STRING_038"), CAUTION);
	}
}