// RebalanceViewerDlg.cpp : ±¸Çö ÆÄÀÏ
//

#include "stdafx.h"
#include "RebalanceViewer.h"
#include "RebalanceViewerDlg.h"
#include ".\rebalanceviewerdlg.h"

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

#include <Item/RebalanceConvert/RebalanceItem.h>
#include <Item/RebalanceConvert/OldItemConstants.h>
#include <Item/RebalanceConvert/OldItemMgr.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CRebalanceViewerDlg ´ëÈ­ »óÀÚ



CRebalanceViewerDlg::CRebalanceViewerDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CRebalanceViewerDlg::IDD, pParent)
    , m_szItemName(_T(""))
    , m_CriticalPercentage(0.0f)
    , m_MinDamage(0)
    , m_MaxDamage(0)
    , m_OffRevision(0)
    , m_Defence(0)
    , m_DefenceRevision(0)
    , m_MagicResist(0)
    , m_BlockingPercentage(0.0f)
    , m_MaxHP(0)
    , m_MaxMP(0)
    , m_HPRegen(0)
    , m_MPRegen(0)
    , m_UpgradeLevel(0)
    , m_bForceOverStore(FALSE)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CRebalanceViewerDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    DDX_Text(pDX, IDC_ITEM_NAME, m_szItemName);
    DDX_Text(pDX, IDC_OUTPUT_ITEM_INFO, m_szOutputData);

    DDX_Text(pDX, IDC_CRI_PERCENT, m_CriticalPercentage);
    DDV_MinMaxFloat(pDX, m_CriticalPercentage, 0.0f, 4096.0f);

    DDX_Text(pDX, IDC_BLOCKING_PERCENTAGE, m_BlockingPercentage);
    DDV_MinMaxFloat(pDX, m_BlockingPercentage, 0.0f, 4096.0f);

    DDX_Text(pDX, IDC_MIN_DAMAGE, m_MinDamage);
    DDV_MinMaxShort(pDX, m_MinDamage, 0, 4096);

    DDX_Text(pDX, IDC_MAX_DAMAGE, m_MaxDamage);
    DDV_MinMaxShort(pDX, m_MaxDamage, 0, 4096);

    DDX_Text(pDX, IDC_OFFENCE_REVISION, m_OffRevision);
    DDV_MinMaxShort(pDX, m_OffRevision, 0, 4096);

    DDX_Text(pDX, IDC_DEFENCE, m_Defence);
    DDV_MinMaxShort(pDX, m_Defence, 0, 4096);

    DDX_Text(pDX, IDC_DEFENCE_REVISION, m_DefenceRevision);
    DDV_MinMaxShort(pDX, m_DefenceRevision, 0, 4096);

    DDX_Text(pDX, IDC_MAGIC_REGISTANCE, m_MagicResist);
    DDV_MinMaxShort(pDX, m_MagicResist, 0, 4096);

    DDX_Text(pDX, IDC_MAX_HP, m_MaxHP);
    DDV_MinMaxShort(pDX, m_MaxHP, 0, 10000);

    DDX_Text(pDX, IDC_MAX_MP, m_MaxMP);
    DDV_MinMaxShort(pDX, m_MaxMP, 0, 10000);

    DDX_Text(pDX, IDC_HP_REGEN_AMOUNT, m_HPRegen);
    DDV_MinMaxShort(pDX, m_HPRegen, 0, 4096);

    DDX_Text(pDX, IDC_MP_REGEN_AMOUNT, m_MPRegen);
    DDV_MinMaxShort(pDX, m_MPRegen, 0, 4096);

    DDX_Text(pDX, IDC_UPGRADE_LEVEL, m_UpgradeLevel);
    DDV_MinMaxShort(pDX, m_UpgradeLevel, 0, 12);

    DDX_Control(pDX, IDC_SELECT_TYPE, m_SelectType);
    DDX_Check(pDX, IDC_FORCE_OVER_STORE, m_bForceOverStore);
}

BEGIN_MESSAGE_MAP(CRebalanceViewerDlg, CDialog)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	//}}AFX_MSG_MAP
    ON_BN_CLICKED(IDC_CONVERT, OnBnClickedConvert)
END_MESSAGE_MAP()


// CRebalanceViewerDlg ¸Þ½ÃÁö 󸮱â

BOOL CRebalanceViewerDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// ÀÌ ´ëÈ­ »óÀÚÀÇ ¾ÆÀÌÄÜÀ» ¼³Á¤ÇÕ´Ï´Ù. ÀÀ¿ë ÇÁ·Î±×·¥ÀÇ ÁÖ Ã¢ÀÌ ´ëÈ­ »óÀÚ°¡ ¾Æ´Ò °æ¿ì¿¡´Â
	// ÇÁ·¹ÀÓ¿öÅ©°¡ ÀÌ ÀÛ¾÷À» ÀÚµ¿À¸·Î ¼öÇàÇÕ´Ï´Ù.
	SetIcon(m_hIcon, TRUE);			// Å« ¾ÆÀÌÄÜÀ» ¼³Á¤ÇÕ´Ï´Ù.
	SetIcon(m_hIcon, FALSE);		// ÀÛÀº ¾ÆÀÌÄÜÀ» ¼³Á¤ÇÕ´Ï´Ù.

	// TODO: ¿©±â¿¡ Ãß°¡ ÃʱâÈ­ ÀÛ¾÷À» Ãß°¡ÇÕ´Ï´Ù.
	
    if(!Item::CItemMgr::GetInstance().LoadItemProtoType("./NewItemScript.txt"))
    {
        AfxMessageBox("NewItemScript.txt load failed");
    }

    if(!OldItem::CItemMgr::GetInstance().LoadItemProtoType("./OldItemScript.txt"))
    {
        AfxMessageBox("OldItemScript.txt load failed");
    }

    m_SelectType.InsertString(0, "QA");
    m_SelectType.InsertString(1, "Dev");
    m_SelectType.SetCurSel(0);
	return TRUE;  // ÄÁÆ®·Ñ¿¡ ´ëÇÑ Æ÷Ä¿½º¸¦ ¼³Á¤ÇÏÁö ¾ÊÀ» °æ¿ì TRUE¸¦ ¹ÝȯÇÕ´Ï´Ù.
}

// ´ëÈ­ »óÀÚ¿¡ ÃÖ¼ÒÈ­ ´ÜÃ߸¦ Ãß°¡ÇÒ °æ¿ì ¾ÆÀÌÄÜÀ» ±×¸®·Á¸é 
// ¾Æ·¡ Äڵ尡 ÇÊ¿äÇÕ´Ï´Ù. ¹®¼­/ºä ¸ðµ¨À» »ç¿ëÇÏ´Â MFC ÀÀ¿ë ÇÁ·Î±×·¥ÀÇ °æ¿ì¿¡´Â
// ÇÁ·¹ÀÓ¿öÅ©¿¡¼­ ÀÌ ÀÛ¾÷À» ÀÚµ¿À¸·Î ¼öÇàÇÕ´Ï´Ù.

void CRebalanceViewerDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // ±×¸®±â¸¦ À§ÇÑ µð¹ÙÀ̽º ÄÁÅؽºÆ®

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// Ŭ¶óÀ̾ðÆ® »ç°¢Çü¿¡¼­ ¾ÆÀÌÄÜÀ» °¡¿îµ¥¿¡ ¸ÂÃä´Ï´Ù.
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// ¾ÆÀÌÄÜÀ» ±×¸³´Ï´Ù.
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

// »ç¿ëÀÚ°¡ ÃÖ¼ÒÈ­µÈ âÀ» ²ô´Â µ¿¾È¿¡ Ä¿¼­°¡ Ç¥½ÃµÇµµ·Ï ½Ã½ºÅÛ¿¡¼­
//  ÀÌ ÇÔ¼ö¸¦ È£ÃâÇÕ´Ï´Ù. 
HCURSOR CRebalanceViewerDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

void CRebalanceViewerDlg::OnBnClickedConvert()
{
    // TODO: ¿©±â¿¡ ÄÁÆ®·Ñ ¾Ë¸² 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.

    UpdateData(true);

    // ¾ÆÀÌÅÛ ¸¸µé±â

    // ÀÏ´Ü ¾ÆÀÌÅÛÀ» »ý¼ºÇÏ°í, ¼Ó¼ºÀ» ³Ö´Â´Ù.

    m_szOutputData = "";

    const OldItem::ItemInfo* lpOldItemInfo = 
        OldItem::CItemMgr::GetInstance().GetItemInfoFromItemName(m_szItemName);

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

    if(0 == lpOldItemInfo || 0 == lpNewItemInfo)
    {
        AfxMessageBox("¾ÆÀÌÅÛ Á¤º¸°¡ ¾ø½À´Ï´Ù!");
        return;
    }

    int nIndex = m_SelectType.GetCurSel();

    char szItemData[Item::MAX_ITEM_SIZE];

    Item::ItemData* lpItemData = reinterpret_cast<Item::ItemData*>(szItemData);
    OldItem::EquipmentInfo* lpEquipmentInfo = reinterpret_cast<OldItem::EquipmentInfo*>(lpItemData + 1);
    OldItem::ItemAttribute* lpAttribute = reinterpret_cast<OldItem::ItemAttribute*>(lpEquipmentInfo + 1);

    lpItemData->m_dwUID             = 0;                                //  ¾ÆÀÌÅÛ UID
    lpItemData->m_usProtoTypeID     = lpOldItemInfo->m_usProtoTypeID;   //  ¾ÆÀÌÅÛ Á¾·ù ID
    lpItemData->m_ItemPos           = Item::ItemPos();                  //  ¾ÆÀÌÅÛ À§Ä¡
    lpItemData->m_cItemSize         = 0;                                //  ¾ÆÀÌÅÛ ±¸Á¶Ã¼ Å©±â
    lpItemData->m_cNumOrDurability  = 0;                                //  °³¼ö ȤÀº ³»±¸µµ

    lpEquipmentInfo->m_cRuneSocket          = 0;
    lpEquipmentInfo->m_cDiffMaterialType    = m_UpgradeLevel;

    lpEquipmentInfo->m_cDiffMaxSocket       = 0;
    lpEquipmentInfo->m_cReserved            = 0;

    lpEquipmentInfo->m_cSocketNum           = 0;
    lpEquipmentInfo->m_cAttributeNum        = 0;

    lpEquipmentInfo->m_cDiffMaxDurability   = 0;
    lpEquipmentInfo->m_cReserved2           = 0;

    OldItem::ItemAttribute* lpAttributePos = lpAttribute;


    // »óÁ¡°ªº¸´Ù ÀÛÀº °ªÀÌ ÀÖÀ¸¸é »óÁ¡°ªÀ¸·Î ÅëÀÏ.

    if(m_bForceOverStore)
    {
        const unsigned short* usOldAttr = lpOldItemInfo->m_EquipAttribute.m_usAttributeValue;

        m_CriticalPercentage    = max(m_CriticalPercentage, float(usOldAttr[OldItem::Attribute::CRITICAL_PERCENTAGE]));
        m_BlockingPercentage    = max(m_BlockingPercentage, float(usOldAttr[OldItem::Attribute::BLOCKING_PERCENTAGE]));

        m_MinDamage             = max(m_MinDamage,          short(usOldAttr[OldItem::Attribute::MIN_DAMAGE]));
        m_MaxDamage             = max(m_MaxDamage,          short(usOldAttr[OldItem::Attribute::MAX_DAMAGE]));
        m_OffRevision           = max(m_OffRevision,        short(usOldAttr[OldItem::Attribute::OFFENCE_REVISION]));
        m_Defence               = max(m_Defence,            short(usOldAttr[OldItem::Attribute::DEFENCE]));
        m_DefenceRevision       = max(m_DefenceRevision,    short(usOldAttr[OldItem::Attribute::DEFENCE_REVISION]));
        m_MagicResist           = max(m_MagicResist,        short(usOldAttr[OldItem::Attribute::MAGIC_RESISTANCE]));        
        m_MaxHP                 = max(m_MaxHP,              short(usOldAttr[OldItem::Attribute::MAX_HP]));
        m_MaxMP                 = max(m_MaxMP,              short(usOldAttr[OldItem::Attribute::MAX_MP]));
        m_HPRegen               = max(m_HPRegen,            short(usOldAttr[OldItem::Attribute::HP_REGEN_AMOUNT]));
        m_MPRegen               = max(m_MPRegen,            short(usOldAttr[OldItem::Attribute::MP_REGEN_AMOUNT]));
    }

    short usGetValue[OldItem::Attribute::MAX_ATTRIBUTE_NUM] = { 0, };
    
    usGetValue[OldItem::Attribute::MIN_DAMAGE]          = m_MinDamage;
    usGetValue[OldItem::Attribute::MAX_DAMAGE]          = m_MaxDamage;
    usGetValue[OldItem::Attribute::OFFENCE_REVISION]    = m_OffRevision;
    usGetValue[OldItem::Attribute::DEFENCE]             = m_Defence;
    usGetValue[OldItem::Attribute::DEFENCE_REVISION]    = m_DefenceRevision;
    usGetValue[OldItem::Attribute::MAGIC_RESISTANCE]    = m_MagicResist;

    usGetValue[OldItem::Attribute::HP_REGEN_AMOUNT]     = m_HPRegen;
    usGetValue[OldItem::Attribute::MP_REGEN_AMOUNT]     = m_MPRegen;

    if(0 == nIndex) 
    {
        // QA·Î ¼±ÅÃ
        usGetValue[OldItem::Attribute::CRITICAL_PERCENTAGE] = static_cast<short>(m_CriticalPercentage * 2);
        usGetValue[OldItem::Attribute::BLOCKING_PERCENTAGE] = static_cast<short>(m_BlockingPercentage * 2);

        usGetValue[OldItem::Attribute::MAX_HP]     = m_MaxHP / 50;
        usGetValue[OldItem::Attribute::MAX_MP]     = m_MaxMP / 50;
    }
    else if(1 == nIndex)
    {
        // °³¹ßÆÀÀ¸·Î ¼±ÅÃ
        usGetValue[OldItem::Attribute::CRITICAL_PERCENTAGE] = static_cast<short>(m_CriticalPercentage);
        usGetValue[OldItem::Attribute::BLOCKING_PERCENTAGE] = static_cast<short>(m_BlockingPercentage);

        usGetValue[OldItem::Attribute::MAX_HP]     = m_MaxHP;
        usGetValue[OldItem::Attribute::MAX_MP]     = m_MaxMP;
    }

    for(short usAttrCount = 0; usAttrCount < OldItem::Attribute::MAX_ATTRIBUTE_NUM; ++usAttrCount)
    {
        short usValue = usGetValue[usAttrCount] - 
            lpOldItemInfo->m_EquipAttribute.m_usAttributeValue[usAttrCount];

        if(0 != usValue)
        {
            lpAttributePos->m_cType     = usAttrCount;
            lpAttributePos->m_usValue   = usValue;

            ++lpAttributePos;
        }
    }

    size_t nAttrNum = lpAttributePos - lpAttribute;
    
    lpEquipmentInfo->m_cAttributeNum = static_cast<unsigned char>(nAttrNum);

    lpItemData->m_cItemSize = static_cast<unsigned char>(sizeof(OldItem::ItemData) + 
        sizeof(OldItem::EquipmentInfo) + sizeof(OldItem::ItemAttribute) * nAttrNum); 

    char szDataOut[Item::MAX_ITEM_SIZE];
    unsigned long dwItemDataSize = Item::MAX_ITEM_SIZE;

    Item::Grade::GradeInfo convertedGradeInfo;

    if(RebalanceLib::ConvertRebalanceItem(0, 0, lpItemData, 
        *lpNewItemInfo, *lpOldItemInfo, szDataOut, dwItemDataSize, convertedGradeInfo))
    {
        size_t nItemDataSize = static_cast<size_t>(dwItemDataSize);

        Item::CItem* lpNewItem = 
            Item::CItemFactory::GetInstance().CreateItem(szDataOut, nItemDataSize);

        Item::CEquipment* lpNewEquip = Item::CEquipment::DowncastToEquipment(lpNewItem);

        if(0 != lpNewEquip)
        {
            // Ç¥½Ã Ç׸ñ - ¾ÆÀÌÅÛ À̸§ / Á¾·ùID / Option

            const char* szPlus = "++++++++++++++++++++++++++++++++++++++++++++++";

            m_szOutputData.Format("%6d : %s : Grade(%s", 
                lpNewEquip->GetPrototypeID(), 
                lpNewEquip->GetItemInfo().m_SpriteData.m_szName, 
                RebalanceLib::GetGradeString(convertedGradeInfo.m_eItemGrade));
            
            m_szOutputData.Append(szPlus, convertedGradeInfo.m_cPlus);
            m_szOutputData.Append(")\r\n\r\n");
            
            short usNewAttribute[Item::Attribute::MAX_ATTRIBUTE_NUM] = { 0, };
            lpNewEquip->GetAttribute(usNewAttribute, Item::Attribute::MAX_ATTRIBUTE_NUM);
            
            usNewAttribute[Item::Attribute::MAX_HP] *= 50;
            usNewAttribute[Item::Attribute::MAX_MP] *= 50;

            for(short usAttrCount = 0; usAttrCount < Item::Attribute::MAX_ATTRIBUTE_NUM; ++usAttrCount)
            {
                if(0 != usNewAttribute[usAttrCount])
                {
                    m_szOutputData.AppendFormat("%20s:%10u\r\n", 
                        Item::Attribute::Attributes[usAttrCount].GetTypeName(), usNewAttribute[usAttrCount]);
                }
            }
        }
    }
    else
    {
        AfxMessageBox("Convert failed!");
    }

    UpdateData(false);
}