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

#include "stdafx.h"
#include "GameLogAnalyzer.h"
#include "GameLogAnalyzerDlg.h"
#include "CharacterInfoDlg.h"
#include "ItemInfoSheet.h"
#include "SearchClass.h"
#include <RylGameLibrary/Log/ParseLog.h>
#include <set>
#include <string>

#include "GlobalFunctions.h"
#include "Clipboard.h"
#include ".\gameloganalyzerdlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// ÀÀ¿ë ÇÁ·Î±×·¥ Á¤º¸¿¡ »ç¿ëµÇ´Â CAboutDlg ´ëÈ­ »óÀÚÀÔ´Ï´Ù.

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// ´ëÈ­ »óÀÚ µ¥ÀÌÅÍ
	enum { IDD = IDD_ABOUTBOX };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV Áö¿ø

// ±¸Çö
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
END_MESSAGE_MAP()


// CGameLogAnalyzerDlg ´ëÈ­ »óÀÚ



CGameLogAnalyzerDlg::CGameLogAnalyzerDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CGameLogAnalyzerDlg::IDD, pParent)
	, m_SearchValue(_T(""))	
	, m_FileName(_T(""))
	, m_Page(_T(""))
	, m_bShowUID(TRUE)
	, m_bShowCID(TRUE)
	, m_bShowTime(TRUE)
	, m_bShowPosition(FALSE)
	, m_bSearchInResult(FALSE)
	, m_XPos(_T("0"))
	, m_YPos(_T("0"))
	, m_ZPos(_T("0"))
	, m_Radius(_T("0"))
	, m_dwGoPageIndex(1)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

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

	DDX_Control(pDX, IDC_SEARCH_TYPE_COMBO, m_ctrlSearchTypeCb);
	DDX_Control(pDX, IDC_VIEW_NUM_COMBO, m_ListNum);
	DDX_Text(pDX, IDC_READFILENAME, m_FileName);
	DDX_Text(pDX, IDC_SEARCH_VALUE_EDIT, m_SearchValue);	
	DDX_Text(pDX, IDC_EDIT1, m_Page);
	DDX_Check(pDX, IDC_SHOW_UID, m_bShowUID);
	DDX_Check(pDX, IDC_CHECK2, m_bShowCID);
	DDX_Check(pDX, IDC_CHECK3, m_bShowTime);
	DDX_Check(pDX, IDC_CHECK4, m_bShowPosition);
	DDX_Check(pDX, IDC_CHECK5, m_bSearchInResult);
	DDX_Control(pDX, IDC_DATETIMEPICKER2, m_SearchStartDate);
	DDX_Control(pDX, IDC_DATETIMEPICKER3, m_SearchStopDate);
	DDX_Text(pDX, IDC_EDIT2, m_XPos);
	DDX_Text(pDX, IDC_EDIT3, m_YPos);
	DDX_Text(pDX, IDC_EDIT4, m_ZPos);
	DDX_Text(pDX, IDC_EDIT5, m_Radius);
	DDX_Control(pDX, IDC_RESULT_LIST, m_ListBox);
	DDX_Text(pDX, IDC_GOPAGE_EDIT, m_dwGoPageIndex);
	DDV_MinMaxUInt(pDX, m_dwGoPageIndex, 1, UINT_MAX);
	DDX_Control(pDX, IDC_CATEGORY_TYPE_CB, m_ctrlCategoryTypeCb);
}

BEGIN_MESSAGE_MAP(CGameLogAnalyzerDlg, CDialog)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	//}}AFX_MSG_MAP
	ON_BN_CLICKED(IDC_READ_FILE_SELECT_BUTTON, OnBnClickedFileSelect)
	ON_BN_CLICKED(IDC_SEARCH_BUTTON, OnBnClickedSearch)
	ON_LBN_DBLCLK(IDC_RESULT_LIST, OnLbnDblclkResultList)
	ON_BN_CLICKED(IDC_PREV_BUTTON, OnBnClickedPrevButton)
	ON_BN_CLICKED(IDC_NEXT_BUTTON, OnBnClickedNextButton)
	ON_BN_CLICKED(IDC_BUTTON2, OnBnPositionResetClicked)
	ON_BN_CLICKED(IDC_BUTTON3, OnBnTimeResetClicked)
	ON_WM_CLOSE()
	ON_CBN_SELCHANGE(IDC_CATEGORY_TYPE_CB, OnCbnSelchangeCategoryTypeCombo)
    ON_BN_CLICKED(IDC_EXTRACTMULTIFILE, OnBnClickedExtractmultifile)
	ON_WM_CONTEXTMENU()
	ON_COMMAND(ID_RESULT_EXPORTTOFILE, OnResultExporttofile)
	ON_BN_CLICKED(IDC_GOPAGE_BTN, OnBnClickedGopageBtn)
	ON_BN_CLICKED(IDC_DEFAULT_BTN, OnBnClickedDefaultBtn)
    ON_BN_CLICKED(IDC_CONVERT_TO_TEXT, OnBnClickedConvertToText)
	ON_COMMAND(ID_RESULT_EXPORTTOCLIPBOARD, OnResultExportToClipboard)
END_MESSAGE_MAP()


// CGameLogAnalyzerDlg ¸Þ½ÃÁö 󸮱â

BOOL CGameLogAnalyzerDlg::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: ¿©±â¿¡ Ãß°¡ ÃʱâÈ­ ÀÛ¾÷À» Ãß°¡ÇÕ´Ï´Ù.

	SetDlgItemText(IDC_LOGFILENAME_STATIC, GetMyINIString("STRING_FOR_LOCALIZE", "LOG_FILE_NAME"));
	SetDlgItemText(IDC_READ_FILE_SELECT_BUTTON, GetMyINIString("STRING_FOR_LOCALIZE", "FILE_SELECT"));
	SetDlgItemText(IDC_SEARCHTIME_STATIC, GetMyINIString("STRING_FOR_LOCALIZE", "SEARCH_TIME"));
	SetDlgItemText(IDC_SEARCHCOORDINATES_STATIC, GetMyINIString("STRING_FOR_LOCALIZE", "SEARCH_COORDINATES"));
	SetDlgItemText(IDC_SEARCHTYPE_STATIC, GetMyINIString("STRING_FOR_LOCALIZE", "SEARCH_TYPE"));
	SetDlgItemText(IDC_SEARCHCONDITION_STATIC, GetMyINIString("STRING_FOR_LOCALIZE", "SEARCH_CONDITION"));
	SetDlgItemText(IDC_SEARCHVALUE_STATIC, GetMyINIString("STRING_FOR_LOCALIZE", "SEARCH_VALUE"));
	SetDlgItemText(IDC_EXTRACTMULTIFILE, GetMyINIString("STRING_FOR_LOCALIZE", "EXTRACT_MULTIFILE"));
	SetDlgItemText(IDC_SEARCH_BUTTON, GetMyINIString("STRING_FOR_LOCALIZE", "SEARCH"));
	SetDlgItemText(IDC_CHECK5, GetMyINIString("STRING_FOR_LOCALIZE", "SEARCH_IN_RESULT"));
	SetDlgItemText(IDC_SEARCHSTARTDATE_STATIC, GetMyINIString("STRING_FOR_LOCALIZE", "SEARCH_START_DATE"));
	SetDlgItemText(IDC_SEARCHENDDATE_STATIC, GetMyINIString("STRING_FOR_LOCALIZE", "SEARCH_END_DATE"));
	SetDlgItemText(IDC_BUTTON3, GetMyINIString("STRING_FOR_LOCALIZE", "RESET_TIME"));
	SetDlgItemText(IDC_BUTTON2, GetMyINIString("STRING_FOR_LOCALIZE", "RESET_CORORDINATES"));
	SetDlgItemText(IDC_RADIUS_STATIC, GetMyINIString("STRING_FOR_LOCALIZE", "RADIUS"));
    SetDlgItemText(IDC_CONVERT_TO_TEXT, GetMyINIString("STRING_FOR_LOCALIZE", "CONVERT_TO_TEXT"));
	
	m_LogAnalyzer.Initialize(m_hWnd, m_ctrlSearchTypeCb, m_ctrlCategoryTypeCb);
	for(int nIdx = 0; nIdx < m_ctrlCategoryTypeCb.GetCount(); ++nIdx)
	{
		m_ctrlCategoryTypeCb.SetCheck(nIdx, false);
	}
	m_ctrlCategoryTypeCb.SetCheck(0, true);	// ±âº» ¼±ÅÃÀº ALL

	m_ListNum.InsertString(0, "5000");
	m_ListNum.InsertString(1, "1000");
	m_ListNum.InsertString(2, "500");
	m_ListNum.InsertString(3, "100");
	m_ListNum.SetCurSel(0);

	m_SearchStartDate.SetFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_001"));
	m_SearchStopDate.SetFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_001"));

	CTime startTime(2002, 10, 21, 0, 0, 0);
	m_SearchStartDate.SetTime(&startTime);

	return TRUE;
}

void CGameLogAnalyzerDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

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

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

void CGameLogAnalyzerDlg::OnBnClickedFileSelect()
{
	if (!m_LogAnalyzer.Open())
		MessageBox(GetMyINIString("STRING_FOR_LOCALIZE", "ERR_002"));
	
	m_ListBox.ResetContent();
	m_FileName = m_LogAnalyzer.GetFileName();

	UpdateData(false);
}

void CGameLogAnalyzerDlg::OnCbnSelchangeCategoryTypeCombo()
{
	/*
	UpdateData(true);

	CTime startTime, stopTime;
	m_SearchStartDate.GetTime(startTime);	m_SearchStopDate.GetTime(stopTime);

	if (!m_LogAnalyzer.Category(m_ctrlCategoryTypeCb, startTime, stopTime,
		CRegion(m_Radius, m_XPos, m_YPos, m_ZPos), m_bSearchInResult))
	{
		MessageBox(GetMyINIString("STRING_FOR_LOCALIZE", "ERR_005"));
		return;
	}

	m_LogAnalyzer.SetShowMode(m_bShowUID, m_bShowCID, m_bShowTime, m_bShowPosition);
	
	CString ShowNum;
	m_ListNum.GetLBText(m_ListNum.GetCurSel(), ShowNum);
	m_LogAnalyzer.Show(m_ListBox, atoi(ShowNum), m_Page);
	
	m_ListBox.SetFocus();
	
	UpdateData(false);
	*/
}

void CGameLogAnalyzerDlg::OnBnClickedSearch()
{
	UpdateData(true);

	CString	SearchType;
	m_ctrlSearchTypeCb.GetLBText(m_ctrlSearchTypeCb.GetCurSel(), SearchType);

	CTime startTime, stopTime;
	m_SearchStartDate.GetTime(startTime);
	m_SearchStopDate.GetTime(stopTime);

	if (!m_LogAnalyzer.Search(m_ctrlCategoryTypeCb, 
		SearchType, m_SearchValue, startTime, stopTime,
		CRegion(m_Radius, m_XPos, m_YPos, m_ZPos), m_bSearchInResult))
	{
		MessageBox(GetMyINIString("STRING_FOR_LOCALIZE", "ERR_005"));
		return;
	}

	m_LogAnalyzer.SetShowMode(m_bShowUID, m_bShowCID, m_bShowTime, m_bShowPosition);

	CString ShowNum;
	m_ListNum.GetLBText(m_ListNum.GetCurSel(), ShowNum);
	m_LogAnalyzer.Show(m_ListBox, atoi(ShowNum), m_Page);

	UpdateData(false);
}

void CGameLogAnalyzerDlg::OnLbnDblclkResultList()
{
	UpdateData(true);

	int nSel = m_ListBox.GetCurSel();
	if(nSel < 0)
	{
		return;
	}
	
	if(false == m_LogAnalyzer.ShowDetail(nSel))
	{
		MessageBox(GetMyINIString("STRING_FOR_LOCALIZE", "ERR_006"));
	}

	UpdateData(FALSE);
}

void CGameLogAnalyzerDlg::OnBnClickedGopageBtn()
{
	UpdateData(true);

	if(m_dwGoPageIndex > 0)
	{
		m_LogAnalyzer.SetShowMode(m_bShowUID, m_bShowCID, m_bShowTime, m_bShowPosition);
	
		CString ShowNum;
		m_ListNum.GetLBText(m_ListNum.GetCurSel(), ShowNum);
		m_LogAnalyzer.MovePage(m_ListBox, atoi(ShowNum), m_Page, m_dwGoPageIndex);

		UpdateData(false);
	}
}

void CGameLogAnalyzerDlg::OnBnClickedPrevButton()
{
	UpdateData(true);

	m_LogAnalyzer.SetShowMode(m_bShowUID, m_bShowCID, m_bShowTime, m_bShowPosition);

	CString ShowNum;
	m_ListNum.GetLBText(m_ListNum.GetCurSel(), ShowNum);
	m_LogAnalyzer.Prev(m_ListBox, atoi(ShowNum), m_Page);

	UpdateData(false);
}

void CGameLogAnalyzerDlg::OnBnClickedNextButton()
{
	UpdateData(true);

	m_LogAnalyzer.SetShowMode(m_bShowUID, m_bShowCID, m_bShowTime, m_bShowPosition);

	CString ShowNum;
	m_ListNum.GetLBText(m_ListNum.GetCurSel(), ShowNum);
	m_LogAnalyzer.Next(m_ListBox, atoi(ShowNum), m_Page);

	UpdateData(false);
}


void CGameLogAnalyzerDlg::OnBnPositionResetClicked()
{
	m_XPos = "0";
	m_YPos = "0";
	m_ZPos = "0";
	m_Radius = "0";

	UpdateData(false);
}

void CGameLogAnalyzerDlg::OnBnTimeResetClicked()
{
	CTime startTime(2002, 10, 21, 0, 0, 0), stopTime;
	m_SearchStartDate.SetTime(&startTime);	
	m_SearchStopDate.SetTime(&CTime::GetCurrentTime());
}

void CGameLogAnalyzerDlg::OnClose()
{
	CDialog::OnClose();
}

void WriteLog(CParseLog::LogPtrArray& ResultArray, CFile& writeFile)
{    
    CParseLog::LogPtrArray::iterator first  = ResultArray.begin();
    CParseLog::LogPtrArray::iterator last   = ResultArray.end();

    for(; first != last; ++first)
    {
        GAMELOG::sLogBase* lpLogBase = *first;
        writeFile.Write(lpLogBase, lpLogBase->GetSize());
    }
}

void CGameLogAnalyzerDlg::OnBnClickedExtractmultifile()
{
	UpdateData(true);

	OPENFILENAME openfile;
	OPENFILENAME savefile;

	char szOpenFileName[MAX_PATH * MAX_PATH] = "";
	char szSaveFileName[MAX_PATH] = "";
	
	memset(&openfile, 0, sizeof(OPENFILENAME));
	memset(&savefile, 0, sizeof(OPENFILENAME));

	openfile.lStructSize	= sizeof(OPENFILENAME);
	openfile.hwndOwner		= m_hWnd;	
	openfile.lpstrFilter	= "Log and ziped files\0*.log;*.zip\0All files\0*.*\0";
	openfile.lpstrFile		= szOpenFileName;
	openfile.nMaxFile		= MAX_PATH * MAX_PATH;
	openfile.Flags			= OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT | OFN_LONGNAMES | OFN_EXPLORER;

	savefile.lStructSize    = sizeof(OPENFILENAME);
	savefile.hwndOwner      = m_hWnd;
	savefile.lpstrFilter    = "Log FIles\0*.log\0";
	savefile.lpstrFile      = szSaveFileName;
	savefile.nMaxFile		= MAX_PATH;
	savefile.Flags          = OFN_SHOWHELP | OFN_LONGNAMES | OFN_EXPLORER;

	CParseLog               ParseLog;
	CParseLog::LogPtrArray  ResultArray;

	CString	SearchType;
	CTime	startTime, stopTime;

	UpdateData();

	m_ctrlSearchTypeCb.GetLBText(m_ctrlSearchTypeCb.GetCurSel(), SearchType);    
	m_SearchStartDate.GetTime(startTime);	
	m_SearchStopDate.GetTime(stopTime);

	if(GetOpenFileName(&openfile))
	{
		if(GetSaveFileName(&savefile))
		{
			CFile writeData;
			CFileException fileException;

			strncat(szSaveFileName, ".log", MAX_PATH);

			if (!writeData.Open(szSaveFileName, 
				CFile::modeCreate | CFile::modeReadWrite, &fileException))
			{
				TRACE("Can't open file %s, error = %u\n", szSaveFileName, fileException.m_cause );
			}

			const char* szAnalyzeFileName = szOpenFileName;
            
			if(*(szAnalyzeFileName + strlen(szAnalyzeFileName) + 1) == 0)
			{
				// ÆÄÀÏÀÌ ÇÑ°³
				ParseLog.LoadFile(szAnalyzeFileName);

				// °Ë»öÇÑ ÈÄ, °Ë»ö °á°ú¸¦ ÆÄÀÏ·Î ÀúÀå.
				if(CLogAnalyzer::Search(ParseLog, ResultArray, 
					m_ctrlCategoryTypeCb, SearchType, m_SearchValue, 
					startTime, stopTime, CRegion(m_Radius, m_XPos, m_YPos, m_ZPos), false))
				{
					WriteLog(ResultArray, writeData);
					ResultArray.clear();
				}
			}
			else
			{
				// ÆÄÀÏÀÌ ¿©·¯°³.                
                std::string szPath(szOpenFileName);
                std::set<std::string> AnalyzeFileSet;

				for (;;)
				{
					szAnalyzeFileName = szAnalyzeFileName + strlen(szAnalyzeFileName) + 1;

					if(*szAnalyzeFileName == 0)
					{
						break;
					}

					AnalyzeFileSet.insert(szAnalyzeFileName);
				}

				std::set<std::string>::iterator 
                    pos = AnalyzeFileSet.begin(),
                    end = AnalyzeFileSet.end();

                std::string szPathName;
                szPathName.reserve(MAX_PATH * 2);

				for(;pos != end; ++pos)
				{
                    szPathName.assign(szPath);
                    szPathName.append("\\");
                    szPathName.append(*pos);

					ParseLog.LoadFile(szPathName.c_str());

					// °Ë»öÇÑ ÈÄ, °Ë»ö °á°ú¸¦ ÆÄÀÏ·Î ÀúÀå.
					if(CLogAnalyzer::Search(ParseLog, ResultArray, 
						m_ctrlCategoryTypeCb, SearchType, m_SearchValue, 
						startTime, stopTime, CRegion(m_Radius, m_XPos, m_YPos, m_ZPos), false))
					{
						WriteLog(ResultArray, writeData);
						ResultArray.clear();
					}
				}
			}

			MessageBox(GetMyINIString("STRING_FOR_LOCALIZE", "ERR_007"));
		}
	}
}

void CGameLogAnalyzerDlg::OnOK()
{
	//CDialog::OnOK();
}

void CGameLogAnalyzerDlg::OnCancel()
{
	CDialog::OnCancel();
}

void CGameLogAnalyzerDlg::OnContextMenu(CWnd* pWnd, CPoint point)
{
	if(pWnd->GetSafeHwnd() == m_ListBox.GetSafeHwnd() 
		&& m_ListBox.GetSelCount() != 0)
	{
		CMenu muTemp, *pContextMenu;
		muTemp.LoadMenu(IDR_RESULT_LISTBOX);
		pContextMenu = muTemp.GetSubMenu(0);
		pContextMenu->TrackPopupMenu(TPM_LEFTALIGN, point.x, point.y, this);
	}
}

void CGameLogAnalyzerDlg::OnResultExporttofile()
{
	// ´ÙÀ̾ó·Î±× ¿­¾î Ãâ·Â ÆÄÀÏ À̸§ ¹Þ±â.
		
    OPENFILENAME    OpenFile;	
    char	        szFileNameBuffer[MAX_PATH];
    char	        szFileTitle[MAX_PATH];

    memset(&OpenFile, 0, sizeof(OPENFILENAME));

    OpenFile.lStructSize        = sizeof(OPENFILENAME); 
    OpenFile.hwndOwner          = NULL; 
    OpenFile.lpstrFilter        = "LogFIle\0*.log\0";    
    OpenFile.nMaxFile           = MAX_PATH;
    OpenFile.nMaxFileTitle      = MAX_PATH; 
    OpenFile.lpstrInitialDir    = (LPSTR)NULL; 
    OpenFile.Flags              = OFN_SHOWHELP | OFN_OVERWRITEPROMPT; 
    OpenFile.lpstrFile          = szFileNameBuffer;
    OpenFile.lpstrFileTitle     = szFileTitle; 
    
	ZeroMemory(szFileNameBuffer, MAX_PATH);
	ZeroMemory(szFileTitle, MAX_PATH);    
    
    if(GetSaveFileName(&OpenFile))
    {
        if(0 == strstr(szFileNameBuffer, ".log"))
        {
            strncat(szFileNameBuffer, ".log", MAX_PATH);
        }

        CFile WriteFile(szFileNameBuffer, CFile::modeWrite | CFile::modeCreate);

	    CString ShowNum;
	    m_ListNum.GetLBText(m_ListNum.GetCurSel(), ShowNum);

        int     nItemNum = atoi(ShowNum);
        LPINT   lpItemIndex = new INT[nItemNum];

        nItemNum = m_ListBox.GetSelItems(nItemNum, lpItemIndex);

        if(LB_ERR != nItemNum)
        {
            LPINT begin = lpItemIndex;
            LPINT end   = lpItemIndex + nItemNum;

            CString Result;            

            for(;begin != end; ++begin)
            {            
                m_ListBox.GetText(*begin, Result);
                Result += "\r\n";
                WriteFile.Write(Result, Result.GetLength());
            }
        }

        WriteFile.Close();
        delete [] lpItemIndex;

		char szPath[MAX_PATH];
		char szFileNameWithPath[MAX_PATH];

		UINT nResult = GetWindowsDirectory(szPath, MAX_PATH);
		if(0 != nResult && nResult <= MAX_PATH)
		{
			_snprintf(szFileNameWithPath, MAX_PATH, "%s\\NotePad.exe %s", szPath, szFileNameBuffer);
			WinExec(szFileNameWithPath, SW_SHOW);
		}
    }
}

BOOL CGameLogAnalyzerDlg::PreTranslateMessage(MSG* pMsg)
{
	if((WM_KEYDOWN == pMsg->message) && (VK_RETURN == pMsg->wParam))
	{
		if(GetFocus() == GetDlgItem(IDC_SEARCH_VALUE_EDIT)->GetFocus())
		{
			OnBnClickedSearch();
		}
		else if(GetFocus() == GetDlgItem(IDC_GOPAGE_EDIT)->GetFocus())
		{
			OnBnClickedGopageBtn();
		}
	}

	return CDialog::PreTranslateMessage(pMsg);
}

void CGameLogAnalyzerDlg::OnBnClickedDefaultBtn()
{
	CString strALL;
	for(int nIndex = 0; nIndex < m_ctrlCategoryTypeCb.GetCount(); ++nIndex)
	{
		m_ctrlCategoryTypeCb.GetLBText(nIndex, strALL);
		if (!strALL.Compare(_T("ALL")))
		{
			m_ctrlCategoryTypeCb.SetCheck(nIndex, true);
		}
		else
		{
			m_ctrlCategoryTypeCb.SetCheck(nIndex, false);
		}
	}	
}
void CGameLogAnalyzerDlg::OnBnClickedConvertToText()
{
    // TODO: ¿©±â¿¡ ÄÁÆ®·Ñ ¾Ë¸² 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.

    // ´ÙÀ̾ó·Î±× ¿­¾î Ãâ·Â ÆÄÀÏ À̸§ ¹Þ±â.

    OPENFILENAME    OpenFile;	
    char	        szFileNameBuffer[MAX_PATH];
    char	        szFileTitle[MAX_PATH];

    memset(&OpenFile, 0, sizeof(OPENFILENAME));

    OpenFile.lStructSize        = sizeof(OPENFILENAME); 
    OpenFile.hwndOwner          = NULL; 
    OpenFile.lpstrFilter        = "LogFIle\0*.log\0";    
    OpenFile.nMaxFile           = MAX_PATH;
    OpenFile.nMaxFileTitle      = MAX_PATH; 
    OpenFile.lpstrInitialDir    = (LPSTR)NULL; 
    OpenFile.Flags              = OFN_SHOWHELP | OFN_OVERWRITEPROMPT; 
    OpenFile.lpstrFile          = szFileNameBuffer;
    OpenFile.lpstrFileTitle     = szFileTitle; 

    ZeroMemory(szFileNameBuffer, MAX_PATH);
    ZeroMemory(szFileTitle, MAX_PATH);    

    if(GetSaveFileName(&OpenFile))
    {
        if(0 == strstr(szFileNameBuffer, ".log"))
        {
            strncat(szFileNameBuffer, ".log", MAX_PATH);
        }

        m_LogAnalyzer.WriteTextLog(szFileNameBuffer);
    }

    MessageBox("Convert Success", "Convert");
}

void CGameLogAnalyzerDlg::OnResultExportToClipboard()
{
	// TODO: ¿©±â¿¡ ¸í·É 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.

	CString ShowNum;	
	m_ListNum.GetLBText(m_ListNum.GetCurSel(), ShowNum);

    int     nItemNum = atoi(ShowNum);
    LPINT   lpItemIndex = new INT[nItemNum];

	if (0 != lpItemIndex)
	{
		nItemNum = m_ListBox.GetSelItems(nItemNum, lpItemIndex);

		if(LB_ERR != nItemNum)
		{
			LPINT begin = lpItemIndex;
			LPINT end   = lpItemIndex + nItemNum;

			CString TotalResult;
			CString Result;

			for(;begin != end; ++begin)
			{            
				m_ListBox.GetText(*begin, Result);
				TotalResult += Result;
				TotalResult += "\r\n";
			}

			CClipboard::SetText(TotalResult);
		}

		delete [] lpItemIndex;
	}
}