#include "stdafx.h"
#include "NxFileSystemTool.h"
#include "NxFileSystemToolDlg.h"
#include "NewFolderDlg.h"
#include "ExportBrowseFolder.h"
#include "WorkDialog.h"
#include "BuildDivisionPacking.h"
#include "BuildDivisionPackingCapacity.h"
#include "LogWnd.h"
#include "SundriesFunc.h"
#include "SHFolderDialog.h"

#include <list>

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

#pragma warning(disable:4311)

// 응용 프로그램 정보에 사용되는 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()



// CNxFileSystemToolDlg 대화 상자


CNxFileSystemToolDlg::CNxFileSystemToolDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CNxFileSystemToolDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

	m_iOverwriteType = -1;
}

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

	DDX_Control(pDX, IDC_FILE_LIST, m_FileList);
	DDX_Control(pDX, IDC_NAVI , m_Edit);
}

BEGIN_MESSAGE_MAP(CNxFileSystemToolDlg, CDialog)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	//}}AFX_MSG_MAP
	ON_WM_SIZE()
	ON_COMMAND(ID_LOADSYSTEM, OnLoadsystem)
	ON_COMMAND(ID_NEWSYSTEM, OnNewsystem)
	ON_COMMAND(ID_FILESYSTEM_CLOSE, OnFilesystemClose)
	ON_COMMAND(ID_INSERT_FILE, OnInsertFile)
	ON_MESSAGE(WM_COMPLETE_MSG, OnCompleteMsg)
	ON_MESSAGE(WM_COMPLETE_OPTIMIZE, OnComplete_Optimize)
	ON_MESSAGE(WM_COMPLETE_EXPORT, OnComplete_Export)
	ON_COMMAND(ID_NEW_FOLDER, OnNewFolder)
	ON_COMMAND(ID_REMOVE, OnRemove)
	ON_NOTIFY(NM_DBLCLK, IDC_FILE_LIST, OnNMDblclkFileList)
	ON_NOTIFY(LVN_ENDLABELEDIT, IDC_FILE_LIST, OnLvnEndlabeleditFileList)
	ON_COMMAND(ID_IPAC_EXIT, OnIpacExit)
	ON_COMMAND(ID_OPTIMIZE, OnOptimize)
	ON_COMMAND(ID_RENAME, OnRename)
	ON_COMMAND(ID_EXPORT, OnExport)
	ON_COMMAND(ID_ABOUT, OnAbout)
	ON_BN_CLICKED(IDC_BUTTON1, OnBnClickedButton1)
	ON_COMMAND(ID_MENU_DIV_PACKING, &CNxFileSystemToolDlg::OnMenuDivPacking)
	ON_COMMAND(ID_MENU_DIV_PACKING_CAPACITY, &CNxFileSystemToolDlg::OnMenuDivPackingCapacity)
	ON_COMMAND(ID_PATCH, &CNxFileSystemToolDlg::OnPatch)
	ON_MESSAGE(WM_COMPLETE_PATCH, OnCompletePatch)
	ON_COMMAND(ID_COMPARE, &CNxFileSystemToolDlg::OnCompare)
	ON_COMMAND(ID_INSERT_FOLDER, &CNxFileSystemToolDlg::OnInsertFolder)
END_MESSAGE_MAP()


// CNxFileSystemToolDlg 메시지 처리기


BOOL 
CNxFileSystemToolDlg::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_FileList.DragAcceptFiles();
	m_FileList.SetExtendedStyle(LVS_EX_FULLROWSELECT);

	RECT Rect;
	m_FileList.GetWindowRect(&Rect);

	const int COLUMN_WIDTH_GAB = 4;
	const int SIZECOLUMN_WIDTH = 300;
	const int SIZECOLUMN_WIDTH2 = 80;

	m_FileList.InsertColumn(0,_T("이름"),LVCFMT_LEFT,SIZECOLUMN_WIDTH);
	m_FileList.InsertColumn(1,_T("크기"),LVCFMT_LEFT,SIZECOLUMN_WIDTH2);
	m_FileList.InsertColumn(2,_T("원본크기"),LVCFMT_LEFT,SIZECOLUMN_WIDTH2);
	m_FileList.InsertColumn(3,_T("설명"),LVCFMT_LEFT,SIZECOLUMN_WIDTH);

	m_ImageList.Create(IDB_FILE_LIST_ICON,16,2,RGB(0,255,0));
	m_FileList.SetImageList(&m_ImageList,LVSIL_SMALL);
	
	m_bWorking = false;	// 작업중인지 아닌지.. 초기화

	m_FileList.SetFocus();

//	LogWnd::CreateLog();


	return TRUE;  // 컨트롤에 대한 포커스를 설정하지 않을 경우 TRUE를 반환합니다.
}

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

// 대화 상자에 최소화 단추를 추가할 경우 아이콘을 그리려면 
// 아래 코드가 필요합니다. 문서/뷰 모델을 사용하는 MFC 응용 프로그램의 경우에는
// 프레임워크에서 이 작업을 자동으로 수행합니다.

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

BOOL
CNxFileSystemToolDlg::PreTranslateMessage(MSG* pMsg)
{

	switch(pMsg->wParam)
	{
		case VK_ESCAPE:
			pMsg->wParam=NULL; // ESC 는 무시한다.
			break;
		case VK_RETURN:
			pMsg->wParam=NULL; // 엔터도 무시한다.
			break;
	}

	switch(pMsg->message)
	{
	case WM_DROPFILES:
		if(pMsg->hwnd == m_FileList.GetSafeHwnd()) 
			DropFile((HDROP)pMsg->wParam);
		break;
	case WM_KEYDOWN:
		if(pMsg->hwnd == m_FileList.GetSafeHwnd() && pMsg->wParam == VK_DELETE) 
			OnRemove();
		break;
	}


	return CDialog::PreTranslateMessage(pMsg);
}

void 
CNxFileSystemToolDlg::OnSize(UINT nType, int cx, int cy)
{
	CDialog::OnSize(nType, cx, cy);

	const int SIZECOLUMN_WIDTH = 300;
	const int SIZECOLUMN_WIDTH2 = 60;

	CRect rt;
	// TODO: 여기에 메시지 처리기 코드를 추가합니다.
	if (m_FileList.GetSafeHwnd() != NULL )
	{
		m_FileList.SetWindowPos(NULL,10,35,cx-22,cy-48,SWP_NOZORDER);
		//Client 영역의 크기를 구한다. 
		m_FileList.GetClientRect(&rt);

	}
}

static int
CALLBACK FileListItemSortFunc(LPARAM lParam1,LPARAM lParam2,LPARAM /*lParamSort*/)
{
	SNxFileInfo* pFH1 = (SNxFileInfo*)lParam1;
	SNxFileInfo* pFH2 = (SNxFileInfo*)lParam2;

	CString strItem1;
	if(pFH1->nFileType == NFS_DIR)
	{
		strItem1.Format(_T("!%s"),pFH1->szFileName);
	}
	else
	{
		strItem1 = pFH1->szFileName;
	}

	CString strItem2;
	if(pFH2->nFileType == NFS_DIR)
	{
		strItem2.Format(_T("!%s"),pFH2->szFileName);
	}
	else
	{
		strItem2 = pFH2->szFileName;
	}

	return _tcscmp(strItem1,strItem2);
}
void
CNxFileSystemToolDlg::UpdateFileList()
{
	m_FileList.DeleteAllItems();

	int i;
	CString strFileSize;
	CString OriFileSize;

	std::vector< SPackingFileInfo * > vecFileInfo;
	std::vector< std::string > vecDirList;
		 
	g_FileSystem.GetFileInfoListCurDir( vecFileInfo );
	g_FileSystem.GetDirListCurDir( vecDirList );
	m_vecFileInfo.resize( vecFileInfo.size() + vecDirList.size() );
	for( i = 0; i < ( int )vecFileInfo.size(); i++ )
	{
		_GetFullFileName( m_vecFileInfo[ i ].szFileName, _countof(m_vecFileInfo[ i ].szFileName), vecFileInfo[ i ]->szFileName );
		m_vecFileInfo[ i ].dwCompressSize = vecFileInfo[ i ]->dwCompressSize;
		m_vecFileInfo[ i ].dwOriginalSize = vecFileInfo[ i ]->dwOriginalSize;
		m_vecFileInfo[ i ].nFileType = NFS_FILE;
	}
	for( i = 0; i < ( int )vecDirList.size(); i++ )
	{
		strcpy_s( m_vecFileInfo[ vecFileInfo.size() + i ].szFileName, _MAX_PATH, vecDirList[ i ].c_str() );
		m_vecFileInfo[ vecFileInfo.size() + i ].nFileType = NFS_DIR;
	}
	for( i = 0; i < ( int )m_vecFileInfo.size(); i++ )
	{
		m_FileList.InsertItem( i, m_vecFileInfo[ i ].szFileName, 1 );
		m_FileList.SetItemData( i, ( DWORD )( &m_vecFileInfo[ i ] ) );

		if( m_vecFileInfo[ i ].nFileType == NFS_FILE )
		{
			strFileSize.Format(_T("%dKB"),( m_vecFileInfo[ i ].dwCompressSize + 999 ) / 1000 );
			m_FileList.SetItemText(i,1,LPCTSTR(strFileSize));

			OriFileSize.Format(_T("%dKB"),( m_vecFileInfo[ i ].dwOriginalSize + 999 ) / 1000 );
			m_FileList.SetItemText(i,2,LPCTSTR(OriFileSize));
		}
	}
	m_FileList.SortItems(FileListItemSortFunc,NULL);

	this->SetDlgItemText(IDC_NAVI,g_FileSystem.GetCurDir());
}


void
CNxFileSystemToolDlg::OnLoadsystem()
{
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다."));
		return ;
	}

	CFileDialog Dlg(TRUE,_T(".pak"),NULL,OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,_T("파일(*.pak)|*.pak||"),NULL);
	if(Dlg.DoModal() == IDCANCEL) return;

	if(!g_FileSystem.OpenFileSystem(LPCTSTR(Dlg.GetPathName()))) 
	{
		// 파일 시스템 쓰기로 안열리면 읽기로라도 연다..
		if( !g_FileSystem.OpenFileSystem(LPCTSTR(Dlg.GetPathName()), true )) 
		{
			AfxMessageBox(_T("파일시스템을 열지 못하였거나 잘못된 파일 입니다."));
			return;
		}
	}

	m_strPath = Dlg.GetPathName();

	UpdateFileList();
}


void 
CNxFileSystemToolDlg::OnNewsystem()
{
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다."));
		return ;
	}

	CFileDialog Dlg(FALSE,_T(".Nfs"),_T("NewSystem.pak"),OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,_T("파일(*.pak)|*.pak||"),NULL);
	if(Dlg.DoModal() == IDCANCEL) return;

	if(!g_FileSystem.NewFileSystem(LPCTSTR(Dlg.GetPathName()))) 
	{
		AfxMessageBox(_T("새로운 파일시스템 생성에 실패 하였습니다."));
		return;
	}
	if(!g_FileSystem.OpenFileSystem(LPCTSTR(Dlg.GetPathName()))) 
	{
		AfxMessageBox(_T("새파일 시스템을 생성하였지만 로드하지 못하였습니다."));
		return;
	}

	m_strPath = Dlg.GetPathName();
	UpdateFileList();
}

void 
CNxFileSystemToolDlg::OnFilesystemClose()
{
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다."));
		return ;
	}

	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	g_FileSystem.CloseFileSystem();

	m_strPath.Empty();

	UpdateFileList();
}

BOOL 
CNxFileSystemToolDlg::DestroyWindow()
{
	// TODO: 여기에 특수화된 코드를 추가 및/또는 기본 클래스를 호출합니다.
	SAFE_DELETE (g_pAddThread);

	return CDialog::DestroyWindow();
}


LRESULT 
CNxFileSystemToolDlg::OnCompleteMsg(WPARAM wParam, LPARAM lParam)
{
	SAFE_DELETE (g_pAddThread);
	m_bWorking = false;
	::PostMessage(g_pWorking->GetSafeHwnd(),WM_DESTROY,0,0);
	SAFE_DELETE(g_pWorking);
	UpdateFileList();
	return TRUE;
}

void CNxFileSystemToolDlg::OnInsertFile()
{
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다."));
		return;
	}

	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	if(!m_FileList.GetItemCount())
	{
		AfxMessageBox(_T("파일시스템이 생성되어 있지 않습니다."));
		return;
	}

	CFileDialog Dlg(TRUE);
	if(Dlg.DoModal() == IDCANCEL) 
		return;

	TCHAR strName[_MAX_FNAME];


	g_FileSystem.GetNameOnly(strName,Dlg.GetPathName().GetBuffer());
/*	if(g_FileSystem.CheckNameExist(strName))
	{
		if(AfxMessageBox(_T("동일한 이름의 파일이 이미 존재합니다.\n\n모든 파일을 새로운 파일로 덮어쓰시려면 '예' 를\n\n모든 기존의 파일을 보존하시려면 '아니오' 를 눌러주십시오!   "),MB_YESNO) == IDNO) return;

		g_FileSystem.Remove(strName);
	}*/

	// 안내 박스.. 띄우기..
	DrawWorking();

	AddFileInfo add;
	add.FileName = LPCTSTR( Dlg.GetPathName() );
	add.FilePath = g_FileSystem.GetCurDir();

	g_AddFileList.push_back(add);

	// 파일 추가 쓰레스 시작!
	g_pAddThread = new CFileImportThread(this->GetSafeHwnd());
	g_pAddThread->Start();
	m_bWorking = true;
}

void CNxFileSystemToolDlg::OnInsertFolder()
{
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다."));
		return;
	}

	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	if(!m_FileList.GetItemCount())
	{
		AfxMessageBox(_T("파일시스템이 생성되어 있지 않습니다."));
		return;
	}

	CString strSelectedPath;
	if( !CSHFolderDialog::BrowseForFolder( strSelectedPath, _T("Choose a Folder:"), m_hWnd, 0, 0, NULL ) == IDOK )
	{
		return;
	}

	SearchFolderAndAddFile( strSelectedPath.GetBuffer() );

	// 안내 박스.. 띄우기..
	DrawWorking();

	// 파일 추가 쓰레스 시작!
	g_pAddThread = new CFileImportThread(this->GetSafeHwnd());
	g_pAddThread->Start();
	m_bWorking = true;
}

void CNxFileSystemToolDlg::SearchFolderAndAddFile( const char *szFolderName )
{
	char acCommonBuffer[1024];
	sprintf(acCommonBuffer, szFolderName);
	strcat(acCommonBuffer, "/*.*");

	HANDLE hSearchFile;
	WIN32_FIND_DATA wfd;
	BOOL bResult = TRUE;

	// 폴더안에 있는 파일을 찾아 순회한다.
	hSearchFile = FindFirstFile(acCommonBuffer, &wfd);
	if (hSearchFile == INVALID_HANDLE_VALUE)
		return;

	std::string strSubFolder;
	std::string::size_type szLength;
	if( m_strRootFolder.length() == 0 )
	{
		std::string strTemp = szFolderName;
		szLength = strTemp.rfind( "\\" );
		strTemp.erase( szLength );
		m_strRootFolder = strTemp;
	}

	std::string strFolderName = szFolderName;
	strFolderName.erase( 0, m_strRootFolder.length() );
	strSubFolder = strFolderName + "\\";

	// 뭔가 찾았다면,
	while (bResult)
	{
		// 파일 순서는 항상 영어이름 순이다. 폴더와 파일 구분 없다.
		if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
		{
			// 모든 폴더에는 항상 . 과 .. 폴더가 있다. 이건 그냥 넘기고, 다른 폴더라면,
			if (wfd.cFileName[0] != '.')
			{
				// 재귀호출로 처리한다.
				sprintf(acCommonBuffer, "%s\\%s", szFolderName, wfd.cFileName);
				SearchFolderAndAddFile(acCommonBuffer);
			}
		}
		else
		{
			if (_stricmp(wfd.cFileName, "Thumbs.db"))
			{
				// 파일명 조합
				sprintf(acCommonBuffer, "%s\\%s", szFolderName, wfd.cFileName);

				// 파일 크기가 0이 아닌 경우에만 추가한다. 파일크기 0은 의미없는 파일이다.
				HANDLE hFile = CreateFile(acCommonBuffer, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
				if (GetFileSize(hFile, NULL) != 0)
				{
					AddFileInfo add;
					add.FileName = acCommonBuffer;
					add.FilePath = strSubFolder;

					g_AddFileList.push_back(add);
				}
				CloseHandle(hFile);
			}
		}

		bResult = FindNextFile(hSearchFile, &wfd);
	}
	FindClose(hSearchFile);
}

void CNxFileSystemToolDlg::OnNewFolder()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다."));
		return;
	}

	if(!m_FileList.GetItemCount())
	{
		AfxMessageBox(_T("파일시스템이 생성되어 있지 않습니다."));
		return;
	}

	CNewFolderDlg Dlg;
	if(Dlg.DoModal() == IDCANCEL) return;
	if(Dlg.m_strFolderName.IsEmpty()) return;

//	g_FileSystem.AddDirWithChange(LPCTSTR(Dlg.m_strFolderName));

	UpdateFileList();
}

void 
CNxFileSystemToolDlg::OnRemove()
{
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다."));
		return;
	}

	
	if(!m_FileList.GetItemCount())
	{
		AfxMessageBox(_T("파일시스템이 생성되어 있지 않습니다."));
		return;
	}

	if(!m_FileList.GetSelectedCount()) return;

	if(AfxMessageBox(_T("선택된 파일 혹은 폴더를 삭제하시겠습니까?"), MB_YESNO) == IDYES)
	{
		CStringArray strRemove;

		POSITION Pos = m_FileList.GetFirstSelectedItemPosition();
		while(Pos)
		{
			int iItem = m_FileList.GetNextSelectedItem(Pos);
			SNxFileInfo* NxFileInfo = (SNxFileInfo*)m_FileList.GetItemData(iItem);

			strRemove.Add(NxFileInfo->szFileName);
		}

		for(int i=0;i<strRemove.GetSize();i++) g_FileSystem.Remove(strRemove[i]);

		UpdateFileList();
	}
}

void 
CNxFileSystemToolDlg::OnNMDblclkFileList(NMHDR *pNMHDR, LRESULT *pResult)
{
	
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다."));
		return;
	}


	if(m_FileList.GetSelectedCount() != 1) return;

	NMITEMACTIVATE* pNMItemActivate = (NMITEMACTIVATE*)pNMHDR;
	if(pNMItemActivate->iItem >= 0)
	{
		SNxFileInfo *pFH = ( SNxFileInfo * )m_FileList.GetItemData(pNMItemActivate->iItem);

		if( pFH->nFileType == NFS_DIR)
		{
			g_FileSystem.ChangeDir(pFH->szFileName);

			UpdateFileList();
		}
	}

	*pResult = 0;
}

void 
CNxFileSystemToolDlg::OnLvnEndlabeleditFileList(NMHDR *pNMHDR, LRESULT *pResult)
{
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다."));
		return;
	}


	NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
	if(!pDispInfo->item.pszText) return;

	SNxFileInfo *pFH = ( SNxFileInfo * )m_FileList.GetItemData(pDispInfo->item.iItem);
	if(!g_FileSystem.Rename(pFH->szFileName,pDispInfo->item.pszText))
	{
		AfxMessageBox(_T("선택된 파일 혹은 폴더의 이름을 변경할수 없습니다!"));
		return;
	}

	m_FileList.SetItemText(pDispInfo->item.iItem,0,pDispInfo->item.pszText);
	*pResult = 0;
}


void
CNxFileSystemToolDlg::DropFile(HDROP hDrop)
{
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다."));
		return;
	}


	g_AddFileList.clear();

	if(!m_FileList.GetItemCount())
	{
		AfxMessageBox(_T("파일시스템이 생성되어 있지 않습니다."));
		return;
	}

	if ( AfxMessageBox(_T("드래그한 파일및 폴더를 파일시스템에 저장하시겠습니까?") , MB_YESNO) == IDNO )
		return;

	// 안내 박스.. 띄우기..
	DrawWorking();


	/* 
	UINT DragQueryFile( HDROP hDrop, UINT iFile, LPTSTR lpszFile, UINT cch );

	iFile의 값이 0xFFFFFFFF일 경우에는 리턴값으로 몇 개의 파일이 드롭되었는지를 정수형으로 반환
	또, iFile값이 0과 드롭된 전체 파일수사이의 값이고, lpszFile이 NULL인 경우에는 null을 포함하지 
	않는 필요한 캐릭터 크기를 리턴

	hDrop	 : 드롭파일 지시자
	iFile    : 파일 쿼리에 대한 인덱스를 나타내며, 이 값에 의해 필요한 쿼리가 변합니다.
	lpszFile : 패스명을 받아드릴 버퍼(스트링형)
	cch		 : 버퍼의 크기

	*/

	int iCount = DragQueryFile(hDrop,0xFFFFFFFF,NULL,0);	// 파일의 갯수를 구한다.

	TCHAR strPath[_MAX_PATH];

	for(int i=0;i<iCount;i++)
	{
		DragQueryFile(hDrop,i,strPath,_MAX_PATH);

		FILE* bFile = _tfopen(strPath, _T("rb"));			// 파일이 아니면 bFile 이 NULL 될것이다

		if(bFile)	// 즉, 파일이면 일단 닫고!
			fclose(bFile);

		TCHAR strName[_MAX_FNAME];
		g_FileSystem.GetNameOnly(strName,strPath);	// 경로명 다 빼고 파일이름만 얻어낸다.

		if(bFile)
		{
			// 같은 이름의 파일이 존재할경우..
/*			if(g_FileSystem.CheckNameExist(strName))	
			{
				if(m_iOverwriteType < 0) 
					m_iOverwriteType = AfxMessageBox(_T("동일한 이름의 파일이 이미 존재합니다.\n\n 모든 파일을 새로운 파일로 덮어쓰시려면 '예' 를\n\n  모든 기존의 파일을 보존하시려면 '아니오' 를 눌러주십시오!") ,MB_YESNO);
				
				if(m_iOverwriteType == IDNO) 
					continue;

				g_FileSystem.Remove(strName);
			}*/

            // 파일 추가..	
			AddFileInfo add;
			add.FileName = strPath;
			add.FilePath = g_FileSystem.GetCurDir();
			g_AddFileList.push_back(add);
			
		}
		else
		{
			if(!DropFolder(strPath))
			{
				CString strError;
				strError.Format(_T("폴더를 추가하는데 실패하였습니다.\n\n%s"),strPath);
				AfxMessageBox(strError);
			}
		}
	}

	m_iOverwriteType = -1;

	DragFinish(hDrop);
	// 파일 추가 쓰레스 시작!
	g_pAddThread = new CFileImportThread(this->GetSafeHwnd());
	g_pAddThread->Start();
	m_bWorking = true;
}

BOOL
CNxFileSystemToolDlg::DropFolder(const TCHAR* strPath)
{
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다."));
		return FALSE;
	}

	char *pFindPtr = strstr( ( char * )strPath, ".svn" );
	if( pFindPtr )
	{
		if( _stricmp( pFindPtr, ".svn" ) == 0 )
		{
			return FALSE;
		}
	}
	
	TCHAR strOldPath[_MAX_PATH];
	GetCurrentDirectory(_MAX_PATH,strOldPath);	// 현재 이 프로그램이 실행중인 디렉토리를 알아낸다.
	SetCurrentDirectory(strPath);				// 드롭할 폴더로 이동.?? 

	TCHAR strName[_MAX_FNAME];
	g_FileSystem.GetNameOnly(strName,strPath);

/*	if(!g_FileSystem.CheckNameExist(strName))
	{
		g_FileSystem.AddDir(strName);
	}*/

	if(!g_FileSystem.ChangeDir(strName))
		return FALSE;

	CFileFind FileFind;
	if(FileFind.FindFile())
	{
		for(BOOL bNext=TRUE;bNext;)
		{
			bNext = FileFind.FindNextFile();
			CString strP = FileFind.GetFilePath();
			CString strN = FileFind.GetFileName();
			if(strN == "." || strN == "..") continue;

			if(FileFind.IsDirectory())
			{
				DropFolder(LPCTSTR(strP));
			}
			else
			{
/*				if(g_FileSystem.CheckNameExist(strN))
				{
					if(m_iOverwriteType < 0)
						m_iOverwriteType = AfxMessageBox(_T("동일한 이름의 파일이 이미 존재합니다.\n\n모든 파일을 새로운 파일로 덮어쓰시려면 '예' 를\n\n모든 기존의 파일을 보존하시려면 '아니오' 를 눌러주십시오!"),MB_YESNO);
					
					if(m_iOverwriteType == IDNO) 
						continue;

					g_FileSystem.Remove(strN);
				}*/
				
				// 파일 추가..
				AddFileInfo add;
				add.FileName = strP;
				add.FilePath = g_FileSystem.GetCurDir();
				g_AddFileList.push_back(add);
			}
		}
	}

	FileFind.Close();

	g_FileSystem.ChangeDir(_T(".."));

	SetCurrentDirectory(strOldPath);

	return TRUE;
}
void
CNxFileSystemToolDlg::OnIpacExit()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다.\n\n조금만 기다려주시면 안될까요..? \n\n흑흑..."));
		return;
	}

	PostQuitMessage(0);
}

void 
CNxFileSystemToolDlg::OnOptimize()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다.\n\n조금만 기다려주시면 안될까요..? \n\n흑흑..."));
		return;
	}
	
	if(!m_FileList.GetItemCount())
	{
		AfxMessageBox(_T("파일시스템이 생성되어 있지 않습니다."));
		return;
	}
	// 안내 박스.. 띄우기..
	DrawWorking();

	// 파일 추가 쓰레스 시작!
	g_pOptimizeThread = new COptimizeThread(this->GetSafeHwnd() , m_strPath);
	//OptimizeThread->Start();
	g_pOptimizeThread->Run();
	m_bWorking = true;
	
}

LRESULT		
CNxFileSystemToolDlg::OnComplete_Optimize(WPARAM wParam, LPARAM lParam)
{
	SAFE_DELETE (g_pOptimizeThread);
	g_FileSystem.ChangeDir(_T("/"));
	m_bWorking = false;
	::PostMessage(g_pWorking->GetSafeHwnd(),WM_DESTROY,0,0);
	SAFE_DELETE(g_pWorking);
	AfxMessageBox(_T("최적화 작업을 성공했습니다.\n\n오래기달렷슈~"));
	UpdateFileList();

	return TRUE;
}

LRESULT
CNxFileSystemToolDlg::OnComplete_Export(WPARAM wParam, LPARAM lParam)
{

	SAFE_DELETE (g_pExportThread);
	::PostMessage(g_pWorking->GetSafeHwnd(),WM_DESTROY,0,0);
	SAFE_DELETE(g_pWorking);
	AfxMessageBox(_T("파일 추출 작업이 완료 되었습니다."));
	UpdateFileList();
	m_bWorking = false;
	return TRUE;
}


void 
CNxFileSystemToolDlg::OnRename()
{
	;
}


using namespace std;
typedef list<SNxFileInfo>		 		CValueFileHandleList;
typedef list<SNxFileInfo>::iterator	 CValueFileHandleList_It;

void
CNxFileSystemToolDlg::OnExport()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	if ( m_bWorking )
	{
		AfxMessageBox(_T("아직 작업이 진행중입니다."));
		return;
	}

	if(!m_FileList.GetItemCount())
	{
		AfxMessageBox(_T("파일시스템이 생성되어 있지 않습니다."));
		return;
	}

	if(!m_FileList.GetSelectedCount()) 
		return;

	if ( AfxMessageBox(_T("선택된 파일 혹은 폴더를 외부로 추출하시겠습니까?"), MB_YESNO) == IDNO)
		return;

	TCHAR strOldPath[_MAX_PATH]= { 0 , };
//	GetCurrentDirectory(_MAX_PATH,strOldPath);	// 현재 디렉토리를 알아낸다.

	if ( ExportBrowseFolder(GetSafeHwnd(),strOldPath) == FALSE )
		return;

	CString	CurPath;
	CString ExportPath;

	CurPath = strOldPath;
	ExportPath = CurPath + _T("\\Exports");

	// 선택한 경로 + Exports 폴더 만들기
	CreateDirectory(ExportPath,NULL);

	// 익스포트 할 폴더로 이동
	SetCurrentDirectory(ExportPath);	
	
	// 안내 박스.. 띄우기..
	DrawWorking();

	g_ExportList.clear();

	POSITION Pos = m_FileList.GetFirstSelectedItemPosition();

	CValueFileHandleList OriginalValue;

	while(Pos)
	{
		int iItem = m_FileList.GetNextSelectedItem(Pos);
		SNxFileInfo *pFH = ( SNxFileInfo * )m_FileList.GetItemData(iItem);
		
		if( *(pFH->szFileName) == _T('.') )
			continue;
		
		SNxFileInfo FH = *pFH;	// Value Copy
		OriginalValue.push_back(FH);
	}

	CValueFileHandleList_It tempit=OriginalValue.begin();

	for(tempit ; tempit!=OriginalValue.end() ; ++tempit )
	{
		SNxFileInfo FH = (SNxFileInfo)(*tempit);

		ExportInfo add;
		add.FileType = FH.nFileType;
		add.Name = FH.szFileName;
		add.FilePath = g_FileSystem.GetCurDir();		
		g_ExportList.push_back(add);

		if ( FH.nFileType == NFS_DIR )
		{
			tstring name = FH.szFileName;
			FolderExport(name);
			g_FileSystem.ChangeDir(_T(".."));
		}
	}

	// 파일 로그를 남겨 보아요~
	ExportInfoList_It Export_It = g_ExportList.begin();
	//@Log.LogInfo(L"###### 타입 0 번이면 폴더 1번이면 파일 ######");
	for (Export_It ; Export_It != g_ExportList.end() ; ++Export_It )
	{
		tstring name = (*Export_It).Name;
		tstring FilePath = (*Export_It).FilePath;
		int FileType = (*Export_It).FileType;
		//@Log.LogInfo(L"이름:[%s]    ,     경로:[%s]   , 파일타입: [%d] ",name.c_str(),FilePath.c_str(),FileType);
	}

	// 목록을 다 뽑았으니 쓰레드를 시작해볼까!!
	g_pExportThread = new CFileExportThread(this->GetSafeHwnd() , ExportPath);
	g_pExportThread->Start();
	m_bWorking = true;
	
	OriginalValue.clear();

}

void CNxFileSystemToolDlg::FolderExport(tstring FolderName)
{
	if ( g_FileSystem.ChangeDir(FolderName.c_str()) == FALSE)
	{
		return;
	}
	
	std::vector< SPackingFileInfo * > vecFileInfo;
	std::vector< std::string > vecDirList;

	g_FileSystem.GetDirListCurDir( vecDirList );
	g_FileSystem.GetFileInfoListCurDir( vecFileInfo );

	int i;
	for( i = 0; i < ( int )vecFileInfo.size(); i++ )
	{
		if( vecFileInfo[ i ]->dwCompressSize > 0 )
		{
			ExportInfo add;
			add.FileType = NFS_FILE;
			add.Name = vecFileInfo[ i ]->szFileName;
			add.FilePath = g_FileSystem.GetCurDir();
			g_ExportList.push_back(add);
		}
	}

	for( i = 0; i < ( int )vecDirList.size(); i++ )
	{
		if( _stricmp( vecDirList[ i ].c_str(), "." ) == 0 )
		{
			continue;
		}
		if( _stricmp( vecDirList[ i ].c_str(), ".." ) == 0 )
		{
			continue;
		}
		FolderExport( vecDirList[ i ].c_str() );
	}
	g_FileSystem.ChangeDir( ".." );
}

void
CNxFileSystemToolDlg::OnAbout()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	CAboutDlg dlgAbout;
	dlgAbout.DoModal();
}

void 
CNxFileSystemToolDlg::OnBnClickedButton1()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	CString Path;
	this->GetDlgItemText(IDC_NAVI,Path);
    if( g_FileSystem.ChangeDir((LPTSTR)(LPCTSTR)Path) )
	{
		UpdateFileList();
	}

}

void CNxFileSystemToolDlg::OnMenuDivPacking()
{
	// TODO: Add your command handler code here
	BuildDivisionPacking dlg;
	dlg.DoModal();
}

void CNxFileSystemToolDlg::OnMenuDivPackingCapacity()
{
	// TODO: Add your command handler code here
	BuildDivisionPackingCapacity dlg;
	dlg.DoModal();
}


void CNxFileSystemToolDlg::OnPatch()
{
	// TODO: Add your command handler code here
	if(!m_FileList.GetItemCount())
	{
		AfxMessageBox(_T("파일시스템이 생성되어 있지 않습니다.\n원본패킹파일을 로드해주세요."));
		return;
	}

	CFileDialog Dlg(TRUE,_T(".pak"),NULL,OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,_T("파일(*.pak)|*.pak||"),NULL);
	if(Dlg.DoModal() == IDCANCEL) return;

	DrawWorking();

	// 파일 패치 쓰레드 시작!
	g_pPatchThread = new PatchThread(this->GetSafeHwnd(), std::string(LPCTSTR(Dlg.GetPathName())));
	g_pPatchThread->Start();
	m_bWorking = true;


}

LRESULT CNxFileSystemToolDlg::OnCompletePatch(WPARAM wParam, LPARAM lParam)
{
	m_bWorking = false;
	SAFE_DELETE(g_pPatchThread);
	//AfxMessageBox(_T("패치 완료!!"));
	
	if ( g_pWorking )
	{
		::PostMessage(g_pWorking->GetSafeHwnd(),WM_DESTROY,0,0);
		SAFE_DELETE(g_pWorking);
	}

	g_FileSystem.ChangeDir(_T("/"));
	UpdateFileList();

	return 0;
}
void CNxFileSystemToolDlg::OnCompare()
{
	char szFileList[ 10000 ];
	TCHAR szFilter[] = _T( "DragonNest Packing File (*.pak)|*.pak|All Files (*.*)|*.*||" );
	CFileDialog FileDlg( TRUE, _T("pak"), _T("*.pak"), OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_ALLOWMULTISELECT | OFN_ENABLESIZING , szFilter, this );
	memset( szFileList, 0, 10000 );
	FileDlg.GetOFN().lpstrFile = szFileList;
	FileDlg.GetOFN().nMaxFile = 10000;
	FileDlg.m_ofn.lpstrTitle = "Open Source File";

	if( FileDlg.DoModal() != IDOK )
	{
		return;
	}

	std::vector< std::string > vecSour, vecDest;
	POSITION Pos = FileDlg.GetStartPosition();
	while( Pos )
	{
		CString szFileName = FileDlg.GetNextPathName( Pos );
		vecSour.push_back( szFileName.GetBuffer() );
	}

	FileDlg.m_ofn.lpstrTitle = "Open Destination File";
	if( FileDlg.DoModal() != IDOK )
	{
		return;
	}

	Pos = FileDlg.GetStartPosition();
	while( Pos )
	{
		CString szFileName = FileDlg.GetNextPathName( Pos );
		vecDest.push_back( szFileName.GetBuffer() );
	}

	std::vector< SPackingFileInfo > vecSourFileInfo, vecDestFileInfo;
	int i, j;
	for( i = 0; i < ( int )vecSour.size(); i++ )
	{
		CEtPackingFile FileSystem;
		if( !FileSystem.OpenFileSystem( vecSour[ i ].c_str(), true ) )
		{
			continue;
		}
		int nFileCount = FileSystem.GetFileCount();
		for( j = 0; j < nFileCount; j++ )
		{
			SPackingFileInfo *pFileInfo = FileSystem.GetFileInfo( j );
			if( pFileInfo->dwCompressSize == 0 )
			{
				continue;
			}
			vecSourFileInfo.push_back( *pFileInfo );
		}
		FileSystem.CloseFileSystem();
	}

	for( i = 0; i < ( int )vecDest.size(); i++ )
	{
		CEtPackingFile FileSystem;
		if( !FileSystem.OpenFileSystem( vecDest[ i ].c_str(), true ) )
		{
			continue;
		}
		int nFileCount = FileSystem.GetFileCount();
		for( j = 0; j < nFileCount; j++ )
		{
			SPackingFileInfo *pFileInfo = FileSystem.GetFileInfo( j );
			if( pFileInfo->dwCompressSize == 0 )
			{
				continue;
			}
			vecDestFileInfo.push_back( *pFileInfo );
		}
		FileSystem.CloseFileSystem();
	}

	std::vector< char > vecCheckField;
	std::vector< SPackingFileInfo > vecSourExist, vecDestExist, vecDiff;

	vecCheckField.resize( vecDestFileInfo.size() );
	memset( &vecCheckField[ 0 ], 0, vecCheckField.size() );
	for( i = 0; i < ( int )vecSourFileInfo.size(); i++ )
	{
		for( j = 0; j < ( int )vecDestFileInfo.size(); j++ )
		{
			if( _stricmp( vecSourFileInfo[ i ].szFileName, vecDestFileInfo[ j ].szFileName ) == 0 )
			{
				vecCheckField[ j ] = 1;
				if( vecSourFileInfo[ i ].dwChecksum != vecDestFileInfo[ j ].dwChecksum )
				{
					vecDiff.push_back( vecSourFileInfo[ i ] );
				}
				break;
			}
		}
		if( j == ( int )vecDestFileInfo.size() )
		{
			vecSourExist.push_back( vecSourFileInfo[ i ] );
		}
	}
	for( i = 0; i < ( int )vecCheckField.size(); i++ )
	{
		if( vecCheckField[ i ] == 0 )
		{
			vecDestExist.push_back( vecDestFileInfo[ i ] );
		}
	}

	if( vecDestExist.size() + vecSourExist.size() + vecDiff.size() == 0 )
	{
		MessageBox( "File Is Identical" );
		return;
	}

	MessageBox( "File Is Different" );
	return;
}