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

#include "stdafx.h"
#include "ItemUpgradeSimulator.h"
#include "ItemUpgradeSimulatorDlg.h"

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

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CItemUpgradeSimulatorDlg ´ëÈ­ »óÀÚ



CItemUpgradeSimulatorDlg::CItemUpgradeSimulatorDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CItemUpgradeSimulatorDlg::IDD, pParent)
    , m_szItemName(_T(""))
    , m_nGemType(0)
    , m_nMineralType(0)
{
    m_simData.m_dwUsedMoney     = 0LL;
    m_simData.m_dwSacrificeItem = 0L;
    m_simData.m_dwUsedMineral   = 0L;
    
    memset(m_simData.m_dwSucceededUpgrade, 0, sizeof(m_simData.m_dwSucceededUpgrade));
    memset(m_simData.m_dwFailedUpgrade, 0, sizeof(m_simData.m_dwFailedUpgrade));

    memset(m_simData.m_dwUsedGems, 0, sizeof(m_simData.m_dwUsedGems));

    m_simData.m_usPrototypeID   = 0;
    m_simData.m_lpMineral       = 0;

    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CItemUpgradeSimulatorDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);

    DDX_Text(pDX, IDC_ITEM_SACRIFICE,   m_simData.m_dwSacrificeItem);
    DDX_Text(pDX, IDC_TOTAL_MINERAL,    m_simData.m_dwUsedMineral);    
    DDX_Text(pDX, IDC_TOTAL_USEDMONEY,  m_simData.m_dwUsedMoney);

    DDX_Text(pDX, IDC_ITEMNAME, m_szItemName);

    DDX_Radio(pDX, IDC_MINERAL_SILVIN,  m_nMineralType);
    DDX_Radio(pDX, IDC_GEM_RUBY,        m_nGemType);

    DDX_Control(pDX, IDC_CURRENT_ITEM,  m_ResultList);
    DDX_Control(pDX, IDC_GEM_USED,      m_GemUsedList);
    DDX_Control(pDX, IDC_UPGRADE_LOG,   m_UpgradeResultList);
}

BEGIN_MESSAGE_MAP(CItemUpgradeSimulatorDlg, CDialog)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	//}}AFX_MSG_MAP
    ON_BN_CLICKED(IDC_START, OnBnClickedStart)
END_MESSAGE_MAP()


// CItemUpgradeSimulatorDlg ¸Þ½ÃÁö 󸮱â

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

	// ½Ã½ºÅÛ ¸Þ´º¿¡ "Á¤º¸..." ¸Þ´º Ç׸ñÀ» Ãß°¡ÇÕ´Ï´Ù.

	// IDM_ABOUTBOX´Â ½Ã½ºÅÛ ¸í·É ¹üÀ§¿¡ ÀÖ¾î¾ß ÇÕ´Ï´Ù.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		CString strAboutMenu;
		strAboutMenu.LoadString(IDS_ABOUTBOX);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

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

	// TODO: ¿©±â¿¡ Ãß°¡ ÃʱâÈ­ ÀÛ¾÷À» Ãß°¡ÇÕ´Ï´Ù.

    m_ResultList.InsertColumn(0, _T(""), LVCFMT_LEFT, 80);
    m_ResultList.InsertColumn(1, _T(""), LVCFMT_LEFT, 150);

    m_GemUsedList.InsertColumn(0, _T(""), LVCFMT_LEFT, 80);
    m_GemUsedList.InsertColumn(1, _T(""), LVCFMT_LEFT, 50);

    m_UpgradeResultList.InsertColumn(0, _T(""), LVCFMT_LEFT, 50);
    m_UpgradeResultList.InsertColumn(1, _T(""), LVCFMT_LEFT, 120);

	return TRUE;  // ÄÁÆ®·Ñ¿¡ ´ëÇÑ Æ÷Ä¿½º¸¦ ¼³Á¤ÇÏÁö ¾ÊÀ» °æ¿ì TRUE¸¦ ¹ÝȯÇÕ´Ï´Ù.
}

void CItemUpgradeSimulatorDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	CDialog::OnSysCommand(nID, lParam);
}

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

void CItemUpgradeSimulatorDlg::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 CItemUpgradeSimulatorDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

const TCHAR* GradeToString(Item::EquipType::Grade eGrade)
{
    const TCHAR* szGradeString = _T("Unknown");

    switch(eGrade)
    {
    case Item::EquipType::AAA_GRADE:    szGradeString = _T("AAA");  break;
    case Item::EquipType::AA_GRADE:     szGradeString = _T("AA");   break;
    case Item::EquipType::A_GRADE:      szGradeString = _T("A");    break;
    case Item::EquipType::B_GRADE:      szGradeString = _T("B");    break;
    case Item::EquipType::C_GRADE:      szGradeString = _T("C");    break;
    case Item::EquipType::D_GRADE:      szGradeString = _T("D");    break;
    case Item::EquipType::F_GRADE:      szGradeString = _T("F");    break;
    case Item::EquipType::X_GRADE:      szGradeString = _T("X");    break;
    };

    return szGradeString;
}

namespace Item
{
    const int MAX_EQUIP_TYPE = 6;
    const int MAX_TYPE_NUM   = 2;

    using namespace Attribute;

    Type aryExceptAttr[MAX_EQUIP_TYPE][Item::MAX_GEM_KIND][MAX_TYPE_NUM] =
    {
        //	·çºñ				            ¿¡¸Þ¶öµå		»çÆÄÀ̾î			´ÙÀ̾Ƹóµå				ºí·¢¹®
        { { ARMOR, NONE },               { MAX_HP, NONE }, { HP_REGEN, NONE }, { MAGIC_RESIST, NONE }, { EVADE, NONE } },    // ¾Æ¸Ó
        { { MIN_DAMAGE,  MAX_DAMAGE },   { MAX_MP, NONE }, { MP_REGEN, NONE }, { CRITICAL, NONE     }, { HIT_RATE, NONE } }, // ´ë°Å
        { { MIN_DAMAGE,  MAX_DAMAGE },   { MAX_MP, NONE }, { MP_REGEN, NONE }, { CRITICAL, NONE     }, { HIT_RATE, NONE } }, // ÇѼչ«±â
        { { MIN_DAMAGE,  MAX_DAMAGE },   { MAX_MP, NONE }, { MP_REGEN, NONE }, { CRITICAL, NONE     }, { HIT_RATE, NONE } }, // ¾ç¼Õ¹«±â
        { { MAGIC_POWER, MAX_DAMAGE },   { MAX_MP, NONE }, { MP_REGEN, NONE }, { CRITICAL, NONE     }, { HIT_RATE, NONE } }, // ½ºÅÂÇÁ
        { { MAX_HP,  NONE},              { MAX_MP, NONE }, { MP_REGEN, NONE }, { BLOCK, NONE        }, { HP_REGEN, NONE } }, // ¹æÆÐ
    };
}


Item::Attribute::Type GetSacrificePos(Item::CEquipment& item, Item::CEquipment& sacrifice, Item::CItem& gem)
{
    short usEquipAttr[Item::Attribute::MAX_ATTRIBUTE_NUM];
    short usSacrificeAttr[Item::Attribute::MAX_ATTRIBUTE_NUM];

    item.GetAttribute(usEquipAttr, Item::Attribute::MAX_ATTRIBUTE_NUM);
    sacrifice.GetAttribute(usSacrificeAttr, Item::Attribute::MAX_ATTRIBUTE_NUM);

    int nGemIndex = gem.GetPrototypeID() - 1911;
    int nType = 0;

    Item::CItemType::ArrayType arrayType = static_cast<Item::CItemType::ArrayType>(
        Item::CItemType::GetEquipType(item.GetItemInfo().m_DetailData.m_dwFlags));

    switch(arrayType)
    {
    case Item::CItemType::ARMOUR_TYPE:      nType = 0;  break;
    case Item::CItemType::DAGGER_TYPE:		nType = 1;  break;
    case Item::CItemType::ONEHANDED_TYPE:	nType = 2;  break;
    case Item::CItemType::LONGRANGE_TYPE:   nType = 2;  break;
    case Item::CItemType::TWOHANDED_TYPE:	nType = 3;  break;
    case Item::CItemType::STAFF_TYPE:		nType = 4;  break;
    case Item::CItemType::SHIELD_TYPE:		nType = 5;  break;
    }

    int nMinValue = INT_MAX;
    int nMinIndex = Item::Attribute::MAX_ATTRIBUTE_NUM;

    int nIndex = 0;
    for (nIndex = 0; nIndex < Item::Attribute::MAX_ATTRIBUTE_NUM; ++nIndex)
    {
        // Àü·«1. ÇöÀç ¾ÆÀÌÅÛÀÇ ¼Ó¼ºº¸´Ù ³ôÀº ¼Ó¼ºÀ» °ñ¶ó ÇÕ¼ºÇÑ´Ù.
        if (nIndex != Item::aryExceptAttr[nType][nGemIndex][0] &&
            nIndex != Item::aryExceptAttr[nType][nGemIndex][1] &&
            item.CanOptionGraft(arrayType, static_cast<Item::Attribute::Type>(nIndex)))
        {
            if (usEquipAttr[nIndex] <= usSacrificeAttr[nIndex])
            {
                // Èñ»ý¹°ÀÇ ¿É¼ÇÀÌ ´õ Å©´Ù.
                break;
            }
            else if (usEquipAttr[nIndex] < nMinValue)
            {
                nMinValue = usEquipAttr[nIndex];
                nMinIndex = nIndex;
            }
        }
    }

    if (nIndex == Item::Attribute::MAX_ATTRIBUTE_NUM &&
        nMinIndex != Item::Attribute::MAX_ATTRIBUTE_NUM)
    {
        nIndex = nMinIndex;
    }

    ASSERT(nIndex != Item::Attribute::MAX_ATTRIBUTE_NUM);
    return static_cast<Item::Attribute::Type>(nIndex);
}

Item::CEquipment* CreateResultItem(SimulateData& simData, 
                                   Item::EquipType::Grade eGrade, Item::CItem& Gem)
{
    Item::CItem* lpItem = Item::CItemFactory::GetInstance().CreateItem(simData.m_usPrototypeID);
    Item::CEquipment* lpEquipment = Item::CEquipment::DowncastToEquipment(lpItem);

    DWORD dwUsedGold = 0;
	unsigned char cMaxDurOut = 0;

    if (0 != lpEquipment)
    {
        // C±×·¹ÀÌµå ¾ÆÀÌÅÛÀ¸·Î »Ì´Â´Ù.
        lpEquipment->AddRandomOption(Item::EquipType::C_GRADE, 0);

        while(eGrade < lpEquipment->GetItemGrade().m_eItemGrade)
        {
            // 10Á¦·Ã¿¡ ¼º°øÇÒ¶§±îÁö Á¦·ÃÀ» ÇÑ´Ù.
            while (lpEquipment->GetUpgradeLevel() < 10)
            {
                dwUsedGold = 0;
                simData.m_lpMineral->SetNumOrDurability(UCHAR_MAX);
                
                unsigned char cUpgradeLevel = lpEquipment->GetUpgradeLevel();

                if (Item::CEquipment::S_SUCCESS == 
                    lpEquipment->UpgradeItem(*simData.m_lpMineral, ULONG_MAX, dwUsedGold, cMaxDurOut))
                {
                    // ¼º°ø ·Î±×
                    if (cUpgradeLevel < lpEquipment->GetUpgradeLevel())
                    {
                        ++simData.m_dwSucceededUpgrade[lpEquipment->GetUpgradeLevel() - 1];
                    }
                    else
                    {
                        ++simData.m_dwFailedUpgrade[lpEquipment->GetUpgradeLevel()];
                    }
                }
                else
                {
                    // ½ÇÆÐ ·Î±×
                    
                }

                simData.m_dwUsedMoney += dwUsedGold;
                simData.m_dwUsedMineral += (UCHAR_MAX - simData.m_lpMineral->GetNumOrDurability());
            }

            // 10Á¦·Ã ¿Ï¼º ÈÄ¿¡ º¸¼®À» 5°³ ¹Ú´Â´Ù.
            for (int nGemInstallCount = 0; nGemInstallCount < 5; ++nGemInstallCount)
            {
                Gem.SetNumOrDurability(UCHAR_MAX);
                
                if (Item::CEquipment::S_SUCCESS == 
                    lpEquipment->InstallSocket(Gem))
                {
                    simData.m_dwUsedGems[Gem.GetPrototypeID() - 1911] += 
                        (UCHAR_MAX - Gem.GetNumOrDurability());
                }
                else
                {


                }
            }

            if (eGrade < lpEquipment->GetItemGrade().m_eItemGrade)
            {
                // ¹æ¾î±¸ÀÌ¸é ´ÙÀ̾Æ, ¾Æ´Ï¸é ·çºñ¸¦ »ç¿ëÇØ, Èñ»ý¹°À» ¸¸µç´Ù.
                unsigned short usSacrificedItemGem = 
                    (lpEquipment->GetItemInfo().m_DetailData.m_dwFlags & Item::DetailData::ARMOR)
                    ? 1914 : 1911;

                Item::CItem* lpGem = &Gem;

                if (Gem.GetPrototypeID() != usSacrificedItemGem)
                {
                    lpGem = Item::CItemFactory::GetInstance().CreateItem(usSacrificedItemGem);
                }

                if (0 != lpGem)
                {
                    Item::CEquipment* lpSacrifice = 
                        CreateResultItem(simData, lpEquipment->GetItemGrade().m_eItemGrade, *lpGem);

                    if (0 != lpSacrifice)
                    {
                        dwUsedGold = 0;

                        if (Item::CEquipment::S_SUCCESS == 
                            lpEquipment->OptionGraft(lpSacrifice, true, 
                            GetSacrificePos(*lpEquipment, *lpSacrifice, Gem), ULONG_MAX, dwUsedGold))
                        {
                            ++simData.m_dwSacrificeItem;
                            simData.m_dwUsedMoney += dwUsedGold;
                        }
                        else
                        {
                            

                        }

                        DELETE_ITEM(lpSacrifice);
                    }

                    if (lpGem != &Gem)
                    {
                        DELETE_ITEM(lpGem);
                    }
                }
            }
        }
    }
    else
    {
        DELETE_ITEM(lpItem);
    }

    return lpEquipment;
}

void CItemUpgradeSimulatorDlg::OnBnClickedStart()
{
    // TODO: ¿©±â¿¡ ÄÁÆ®·Ñ ¾Ë¸² 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.
    UpdateData(TRUE);
    
    const Item::ItemInfo* lpItemInfo = 
        Item::CItemMgr::GetInstance().GetItemInfoFromItemName(m_szItemName);

    if (0 != lpItemInfo)
    {
        m_simData.m_dwUsedMoney     = 0LL;
        m_simData.m_dwSacrificeItem = 0L;        
        m_simData.m_dwUsedMineral   = 0L;

        memset(m_simData.m_dwSucceededUpgrade, 0, sizeof(m_simData.m_dwSucceededUpgrade));
        memset(m_simData.m_dwFailedUpgrade, 0, sizeof(m_simData.m_dwFailedUpgrade));

        memset(m_simData.m_dwUsedGems, 0, sizeof(m_simData.m_dwUsedGems));

        m_simData.m_usPrototypeID   = lpItemInfo->m_usProtoTypeID;

        m_simData.m_lpMineral   = Item::CItemFactory::GetInstance().CreateItem(m_nMineralType + 2001);
        Item::CItem* lpGem      = Item::CItemFactory::GetInstance().CreateItem(m_nGemType + 1911);

        if (0 != m_simData.m_lpMineral && 0 != lpGem)
        {
            Item::CEquipment* lpEquipment = 
                CreateResultItem(m_simData, Item::EquipType::AAA_GRADE, *lpGem);

            if (0 != lpEquipment)
            {
                // ¼Ó¼º °ªÀ» ¾ò¾î¿Í¼­ ¸®½ºÆ®¹Ú½º¿¡ Ãß°¡ÇÑ´Ù.

                CString szText;                       
                int nCount = 0;

                Item::Grade::GradeInfo gradeInfo = lpEquipment->GetItemGrade();

                szText.SetString(GradeToString(gradeInfo.m_eItemGrade));
                for(nCount = 0; nCount < gradeInfo.m_cPlus; ++nCount) { szText.Append(_T("+")); }

                m_ResultList.DeleteAllItems();
                m_ResultList.InsertItem(0, "Grade");
                m_ResultList.SetItemText(0, 1, szText);

                short Attributes[Item::Attribute::MAX_ATTRIBUTE_NUM];
                lpEquipment->GetAttribute(Attributes, Item::Attribute::MAX_ATTRIBUTE_NUM);

                int nInsertIndex = 1;
                for(nCount = 0; nCount < Item::Attribute::MAX_ATTRIBUTE_NUM; ++nCount)
                {
                    if (0 != Attributes[nCount])
                    {
                        szText.Format("%d (%s)", Attributes[nCount], 
                            GradeToString(gradeInfo.m_aryAttributeGrade[nCount]));

                        m_ResultList.InsertItem(nInsertIndex, 
                            Item::Attribute::Attributes[nCount].GetTypeName());

                        m_ResultList.SetItemText(nInsertIndex, 1, szText);

                        ++nInsertIndex;
                    }
                }

                m_GemUsedList.DeleteAllItems();
                
                const TCHAR* szGemText[] = 
                { _T("·çºñ"), _T("¿¡¸Þ¶öµå"), _T("»çÆÄÀ̾î"), _T("´ÙÀ̾Ƹóµå"), _T("ºí·¢¹®") };

                for(nCount = 0; nCount < Item::MAX_GEM_KIND; ++nCount)
                {
                    m_GemUsedList.InsertItem(nCount, szGemText[nCount]);
                    szText.Format("%d", m_simData.m_dwUsedGems[nCount]);
                    m_GemUsedList.SetItemText(nCount, 1, szText);
                }
               
                m_UpgradeResultList.DeleteAllItems();

                for(nCount = 0; nCount < 10; ++nCount)
                {
                    szText.Format(_T("%d´Ü°è"), nCount);
                    m_UpgradeResultList.InsertItem(nCount, szText);

                    szText.Format(_T("(%d¼º°ø/%d½ÇÆÐ)"), 
                        m_simData.m_dwSucceededUpgrade[nCount],
                        m_simData.m_dwFailedUpgrade[nCount]);

                    m_UpgradeResultList.SetItemText(nCount, 1, szText);
                }

                DELETE_ITEM(lpEquipment);
            }
        }
        else
        {
            DELETE_ITEM(m_simData.m_lpMineral);
            DELETE_ITEM(lpGem);
        }
    }

    UpdateData(FALSE);
}