// MainFrm.cpp : implementation of the CMainFrame class
//

#include "stdafx.h"
#include "CAP.h"

#include "MainFrm.h"

#include "EpdProcessor.h"
#include "TpmChess.h"

#include <iostream>

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CMainFrame

IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWnd)

BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
	//{{AFX_MSG_MAP(CMainFrame)
	ON_WM_CREATE()
	ON_COMMAND(ID_TEST_RUN_TEST_1, OnTestRunTest1)
	ON_COMMAND(ID_TEST_RUN_TEST_2, OnTestRunTest2)
	ON_COMMAND(ID_TEST_RUN_TEST_3, OnTestRunTest3)
	ON_COMMAND(ID_TEST_RUN_TEST_4, OnTestRunTest4)
	ON_COMMAND(ID_TEST_RUN_TEST_5, OnTestRunTest5)
	ON_COMMAND(ID_TEST_RUN_TEST_6, OnTestRunTest6)
	ON_COMMAND(ID_TEST_RUN_TEST_7, OnTestRunTest7)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

static UINT indicators[] =
{
	ID_SEPARATOR,           // status line indicator
	ID_INDICATOR_CAPS,
	ID_INDICATOR_NUM,
	ID_INDICATOR_SCRL,
};

/////////////////////////////////////////////////////////////////////////////
// CMainFrame construction/destruction

CMainFrame::CMainFrame()
{
	// TODO: add member initialization code here
	
}

CMainFrame::~CMainFrame()
{
}

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	if (!m_wndToolBar.Create(this) ||
		!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
	{
		TRACE0("Failed to create toolbar\n");
		return -1;      // fail to create
	}

	if (!m_wndStatusBar.Create(this) ||
		!m_wndStatusBar.SetIndicators(indicators,
		  sizeof(indicators)/sizeof(UINT)))
	{
		TRACE0("Failed to create status bar\n");
		return -1;      // fail to create
	}

	// TODO: Remove this if you don't want tool tips or a resizeable toolbar
	m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
		CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);

	// TODO: Delete these three lines if you don't want the toolbar to
	//  be dockable
	m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
	EnableDocking(CBRS_ALIGN_ANY);
	DockControlBar(&m_wndToolBar);

	return 0;
}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CMDIFrameWnd::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CMainFrame diagnostics

#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
	CMDIFrameWnd::AssertValid();
}

void CMainFrame::Dump(CDumpContext& dc) const
{
	CMDIFrameWnd::Dump(dc);
}

#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CMainFrame message handlers

void CMainFrame::OnTestRunTest1() 
{
	EpdBinary		EpdBin;

	EPD				EpdString = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq -";
	EpdBin = EpdString;
	EpdString = EpdBin.GetEpd();

	EpdProcessor	EpdProc;

	EpdProc.GenerateOutputOpcodes(false);
	EpdProc.SetOutputOpcodeTypes(false,false,false);

	CString	csFilePath;

	CString sFilter("Text Files (*.txt)|*.txt|All Files (*.*)|*.*||");

	CFileDialog InDlg(TRUE, NULL, NULL, 0, sFilter);
	InDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST 
					| OFN_READONLY | OFN_HIDEREADONLY;
	InDlg.m_ofn.lpstrInitialDir = csFilePath;

	CFileDialog OutDlg(FALSE, NULL, NULL, 0, sFilter);
	OutDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST;
	OutDlg.m_ofn.lpstrInitialDir = csFilePath;

	if (InDlg.DoModal() == IDOK)
	{
		const CString csInputPath(InDlg.GetPathName());

		if (OutDlg.DoModal() == IDOK)
		{
			const CString csOutputPath(OutDlg.GetPathName());

			CStdioFile	csfInput;
			CStdioFile	csfOutput;
			BOOL		bInputOpen;
			BOOL		bOutputOpen;
			CString		csBuffer;
			CString		csOutBuffer;
			BOOL		bGotData;
			bool		bEpdNext;
			CString		csTest;
			CString		csError;
			CString		csNull;
			EPD			epd;
			PV			pv;
			EPD			Result;
			EPD_VECTOR	ResultVector;
			int			nInputEpds = 0;
			int			nErrorEpds = 0;
			int			nOutputEpds = 0;
			int			nInputPvs = 0;
			int			nModifyPvs = 0;
			int			nErrorPvs = 0;
			int			nLineNumber = 1;
			DWORD		dwStart;
			DWORD		dwStop;
			float		fSeconds;
			bool		bEpdValid;
			int			nPvValid;
			std::string	EpdErrorMsg;
			std::string PvErrorMsg;

			dwStart = GetTickCount();

			bInputOpen = csfInput.Open(csInputPath, CFile::modeRead | CFile::shareDenyWrite);
			bOutputOpen = csfOutput.Open(csOutputPath, CFile::modeCreate | CFile::modeWrite);

			if (bInputOpen && bOutputOpen)
			{
				CWaitCursor wc;

				bGotData = csfInput.ReadString(csBuffer);
				nLineNumber++;

				bEpdNext = true;
				csError = "#Error";
				csNull	= "(null)";

				while (bGotData)
				{
					csTest = csBuffer.Mid(0, csError.GetLength());

					if (csTest != csError)
					{
						if (bEpdNext)
						{
							epd = csBuffer;

							bEpdNext = false;
								
							bEpdValid = EpdProc.SetEpd(epd);

							csOutBuffer = csBuffer;
							csOutBuffer += "\n";
							csfOutput.WriteString(csOutBuffer);

							if (!bEpdValid)
							{
								nErrorEpds++;

								EpdErrorMsg = "*** EPD ERROR *** ";
								EpdErrorMsg += EpdProc.GetEpdError();

								csOutBuffer = EpdErrorMsg.c_str();
								csOutBuffer += "\n\n";
								csfOutput.WriteString(csOutBuffer);
							}

							nInputEpds++;
						}
						else
						{
							csTest = csBuffer.Mid(0, csNull.GetLength());

							if (csTest != csNull)
							{
								pv = csBuffer;
								nInputPvs++;
							}
							else
							{
								pv = "";
							}

							bEpdNext = true;
						
							if (bEpdValid)
							{
								csOutBuffer = "PV In:  ";
								csOutBuffer += pv.c_str();
								csOutBuffer += "\n";
								csfOutput.WriteString(csOutBuffer);

								nPvValid = EpdProc.SetPv(pv);

								if (nPvValid <= EPD_STATUS_WARNING)
								{
									if (nPvValid == EPD_STATUS_WARNING)
									{
										nModifyPvs++;

										pv = EpdProc.GetPv();

										csOutBuffer = "PV Out: ";
										csOutBuffer += pv.c_str();
										csOutBuffer += "\n\n";
										csfOutput.WriteString(csOutBuffer);
									}

									Result = EpdProc.GetEpd(0);
									ResultVector = EpdProc.GetEpdVector();

									EPD_VECTOR::iterator	i;

									i = ResultVector.begin();

									while (i != ResultVector.end())
									{
										csOutBuffer = i->c_str();
										csOutBuffer += "\n";
										csfOutput.WriteString(csOutBuffer);

										nOutputEpds++;

										i++;
									}

									csOutBuffer = "\n";
									csfOutput.WriteString(csOutBuffer);
								}
								else
								{
									nErrorPvs++;

									PvErrorMsg = "*** PV ERROR *** ";
									PvErrorMsg += EpdProc.GetPvError();

									csOutBuffer = PvErrorMsg.c_str();
									csOutBuffer += "\n\n";
									csfOutput.WriteString(csOutBuffer);
								}
							}
						}
					}
					
					bGotData = csfInput.ReadString(csBuffer);
					nLineNumber++;
				}

				dwStop = GetTickCount();

				fSeconds = (float) (dwStop - dwStart);
				fSeconds /= 1000.0;

				CString	csFormat;

				csFormat.Format("Input EPDs:   %7d\n", nInputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Error EPDs:   %7d\n", nErrorEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Input PVs:    %7d\n", nInputPvs);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Modified PVs: %7d\n", nModifyPvs);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Error PVs:    %7d\n", nErrorPvs);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Output EPDs:  %7d\n", nOutputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Seconds:      %7.2f\n", fSeconds);
				csfOutput.WriteString(csFormat);

				csfInput.Close();
				csfOutput.Close();
			}
		}
	}
}

void CMainFrame::OnTestRunTest2() 
{
	EpdProcessor		EpdProc;
	SAN_LIST			LegalMoves;
	SAN_LIST::iterator	pSan;
	SAN					San;
	
	EpdProc.GenerateOutputOpcodes(false);
	EpdProc.SetOutputOpcodeTypes(false,false,false);

	CString	csFilePath;

	CString sFilter("Text Files (*.txt)|*.txt|All Files (*.*)|*.*||");

	CFileDialog InDlg(TRUE, NULL, NULL, 0, sFilter);
	InDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST 
					| OFN_READONLY | OFN_HIDEREADONLY;
	InDlg.m_ofn.lpstrInitialDir = csFilePath;

	CFileDialog OutDlg(FALSE, NULL, NULL, 0, sFilter);
	OutDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST;
	OutDlg.m_ofn.lpstrInitialDir = csFilePath;

	if (InDlg.DoModal() == IDOK)
	{
		const CString csInputPath(InDlg.GetPathName());

		if (OutDlg.DoModal() == IDOK)
		{
			const CString csOutputPath(OutDlg.GetPathName());

			CStdioFile	csfInput;
			CStdioFile	csfOutput;
			BOOL		bInputOpen;
			BOOL		bOutputOpen;
			CString		csBuffer;
			CString		csOutBuffer;
			BOOL		bGotData;
			CString		csTest;
			CString		csError;
			CString		csNull;
			EPD			epd;
			PV			pv;
			EPD			Result;
			EPD_VECTOR	ResultVector;
			int			nInputEpds = 0;
			int			nErrorEpds = 0;
			int			nOutputEpds = 0;
			int			nInputPvs = 0;
			int			nErrorPvs = 0;
			int			nLineNumber = 1;
			DWORD		dwStart;
			DWORD		dwStop;
			float		fSeconds;
			bool		bEpdValid;
			std::string	EpdErrorMsg;
			std::string PvErrorMsg;
			EPD_LIST			LegalEpds;
			EPD_LIST::iterator	pEpd;
			EPD					Epd;

			dwStart = GetTickCount();

			bInputOpen = csfInput.Open(csInputPath, CFile::modeRead | CFile::shareDenyWrite);
			bOutputOpen = csfOutput.Open(csOutputPath, CFile::modeCreate | CFile::modeWrite);

			if (bInputOpen && bOutputOpen)
			{
				CWaitCursor wc;

				bGotData = csfInput.ReadString(csBuffer);
				nLineNumber++;

				while (bGotData)
				{
					csBuffer.TrimRight();

					if (!csBuffer.IsEmpty())
					{
						nInputEpds++;

						Epd.erase();			// fix Microsoft bug
						Epd = csBuffer;

						bEpdValid = EpdProc.SetEpd(Epd);

						if (bEpdValid)
						{
							LegalEpds = EpdProc.GetLegalEpdList();

							pEpd = LegalEpds.begin();

							while (pEpd != LegalEpds.end())
							{
								Epd.erase();	// fix Microsoft bug
								Epd = *pEpd;

								csOutBuffer = Epd.c_str();
								csOutBuffer += "\n";

								csfOutput.WriteString(csOutBuffer);

								nOutputEpds++;
								pEpd++;
							}
						}
						else
						{
							std::string ErrorMsg;

							ErrorMsg = "Epd Error: ";
							ErrorMsg += EpdProc.GetEpdError();
							csOutBuffer = ErrorMsg.c_str();
							csOutBuffer += "  ";
							csOutBuffer += Epd.c_str();
							csOutBuffer += "\n";								
							csfOutput.WriteString(csOutBuffer);

							nErrorEpds++;
						}
					}

					bGotData = csfInput.ReadString(csBuffer);
				}

				dwStop = GetTickCount();

				fSeconds = (float) (dwStop - dwStart);
				fSeconds /= 1000.0;

				CString	csFormat;

				csFormat.Format("Input EPDs:  %7d\n", nInputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Error EPDs:  %7d\n", nErrorEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Output EPDs: %7d\n", nOutputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Seconds:     %7.2f\n", fSeconds);
				csfOutput.WriteString(csFormat);

				csfInput.Close();
				csfOutput.Close();
			}
		}
	}
}

void CMainFrame::OnTestRunTest3() 
{
	EpdProcessor	EpdProc;

	EpdProc.GenerateOutputOpcodes(false);
	EpdProc.SetOutputOpcodeTypes(false,false,false);

	CString	csFilePath;

	CString sFilter("Text Files (*.txt)|*.txt|All Files (*.*)|*.*||");

	CFileDialog InDlg(TRUE, NULL, NULL, 0, sFilter);
	InDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST 
					| OFN_READONLY | OFN_HIDEREADONLY;
	InDlg.m_ofn.lpstrInitialDir = csFilePath;

	CFileDialog OutDlg(FALSE, NULL, NULL, 0, sFilter);
	OutDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST;
	OutDlg.m_ofn.lpstrInitialDir = csFilePath;

	if (InDlg.DoModal() == IDOK)
	{
		const CString csInputPath(InDlg.GetPathName());

		if (OutDlg.DoModal() == IDOK)
		{
			const CString csOutputPath(OutDlg.GetPathName());

			CStdioFile	csfInput;
			CStdioFile	csfOutput;
			BOOL		bInputOpen;
			BOOL		bOutputOpen;
			CString		csBuffer;
			CString		csOutBuffer;
			BOOL		bGotData;
			bool		bEpdNext;
			CString		csTest;
			CString		csError;
			CString		csNull;
			EPD			epd;
			PV			pv;
			EPD			Result;
			EPD_VECTOR	ResultVector;
			int			nInputEpds = 0;
			int			nErrorEpds = 0;
			int			nOutputEpds = 0;
			int			nLineNumber = 1;
			DWORD		dwStart;
			DWORD		dwStop;
			float		fSeconds;
			bool		bEpdValid;
			std::string	EpdErrorMsg;
			EPD_LIST			LegalEpds;
			EPD_LIST::iterator	pEpd;
			EPD					Epd;

			dwStart = GetTickCount();

			bInputOpen = csfInput.Open(csInputPath, CFile::modeRead | CFile::shareDenyWrite);
			bOutputOpen = csfOutput.Open(csOutputPath, CFile::modeCreate | CFile::modeWrite);

			if (bInputOpen && bOutputOpen)
			{
				CWaitCursor wc;

				bGotData = csfInput.ReadString(csBuffer);
				nLineNumber++;

				bEpdNext = true;
				csError = "#Error";
				csNull	= "(null)";

				while (bGotData)
				{
					csTest = csBuffer.Mid(0, csError.GetLength());

					if (csTest != csError)
					{
						if (bEpdNext)
						{
							epd = csBuffer;

							bEpdNext = false;
								
							bEpdValid = EpdProc.SetEpd(epd);

							csOutBuffer = "Epd In: ";
							csOutBuffer += epd.c_str();
							csOutBuffer += "\n";
							csfOutput.WriteString(csOutBuffer);

							if (!bEpdValid)
							{
								nErrorEpds++;

								EpdErrorMsg = "*** EPD ERROR *** ";
								EpdErrorMsg += EpdProc.GetEpdError();

								csOutBuffer = EpdErrorMsg.c_str();
								csOutBuffer += "\n\n";
								csfOutput.WriteString(csOutBuffer);
							}

							nInputEpds++;
						}
						else
						{
							bEpdNext = true;
						
							if (bEpdValid)
							{
								LegalEpds = EpdProc.GetLegalEpdList();

								if (LegalEpds.size() == 0)
								{
									if (EpdProc.IsStalemate())
									{
										csOutBuffer = "Stalemate!\n\n";
										csfOutput.WriteString(csOutBuffer);
									}
									else
									{
										csOutBuffer = "Checkmate!\n\n";
										csfOutput.WriteString(csOutBuffer);
									}
								}
								else
								{
									pEpd = LegalEpds.begin();

									while (pEpd != LegalEpds.end())
									{
										Epd = *pEpd;

										nOutputEpds++;
										csOutBuffer = Epd.c_str();
										csOutBuffer += "\n";
										csfOutput.WriteString(csOutBuffer);

										pEpd++;
									}

									csOutBuffer = "\n";
									csfOutput.WriteString(csOutBuffer);
								}
							}
						}
					}
					
					bGotData = csfInput.ReadString(csBuffer);
					nLineNumber++;
				}

				dwStop = GetTickCount();

				fSeconds = (float) (dwStop - dwStart);
				fSeconds /= 1000.0;

				CString	csFormat;

				csFormat.Format("Input EPDs:   %7d\n", nInputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Error EPDs:   %7d\n", nErrorEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Output EPDs:  %7d\n", nOutputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Seconds:      %7.2f\n", fSeconds);
				csfOutput.WriteString(csFormat);

				csfInput.Close();
				csfOutput.Close();
			}
		}
	}
}

void CMainFrame::OnTestRunTest4() 
{
	CString	csFilePath;

	CString sFilter("Text Files (*.txt)|*.txt|All Files (*.*)|*.*||");

	CFileDialog InDlg(TRUE, NULL, NULL, 0, sFilter);
	InDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST 
					| OFN_READONLY | OFN_HIDEREADONLY;
	InDlg.m_ofn.lpstrInitialDir = csFilePath;

	CFileDialog OutDlg(FALSE, NULL, NULL, 0, sFilter);
	OutDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST;
	OutDlg.m_ofn.lpstrInitialDir = csFilePath;

	if (InDlg.DoModal() == IDOK)
	{
		const CString csInputPath(InDlg.GetPathName());

		if (OutDlg.DoModal() == IDOK)
		{
			const CString csOutputPath(OutDlg.GetPathName());

			CStdioFile	csfInput;
			CStdioFile	csfOutput;
			BOOL		bInputOpen;
			BOOL		bOutputOpen;
			CString		csBuffer;
			CString		csOutBuffer;
			BOOL		bGotData;
			bool		bEpdNext;
			CString		csTest;
			CString		csError;
			CString		csNull;
			PV			pv;
			EPD			Result;
			EPD_VECTOR	ResultVector;
			int			nInputEpds = 0;
			int			nErrorEpds = 0;
			int			nOutputEpds = 0;
			int			nLineNumber = 1;
			DWORD		dwStart;
			DWORD		dwStop;
			float		fSeconds;
			std::string	EpdErrorMsg;
			EPD_LIST			LegalEpds;
			EPD_LIST::iterator	pEpd;
			EPD					Epd;
			EPD					EpdOut;
			EpdBinary			EpdBin;
			EpdBinary			EpdBinOut;
			EPD_BINARY_LIST		LegalBinaryEpds;
			EPD_BINARY_LIST::iterator	pEpdBinary;
			EpdProcessor		EpdProc;

			dwStart = GetTickCount();

			bInputOpen = csfInput.Open(csInputPath, CFile::modeRead | CFile::shareDenyWrite);
			bOutputOpen = csfOutput.Open(csOutputPath, CFile::modeCreate | CFile::modeWrite);

			if (bInputOpen && bOutputOpen)
			{
				CWaitCursor wc;

				bGotData = csfInput.ReadString(csBuffer);
				nLineNumber++;

				bEpdNext = true;
				csError = "#Error";
				csNull	= "(null)";

				while (bGotData)
				{
					csTest = csBuffer.Mid(0, csError.GetLength());

					if (csTest != csError)
					{
						if (bEpdNext)
						{
							Epd.erase();
							Epd = csBuffer;

							bEpdNext = false;

							csOutBuffer = "Epd In:  ";
							csOutBuffer += Epd.c_str();
							csOutBuffer += "\n";
							csfOutput.WriteString(csOutBuffer);

							nInputEpds++;
						}
						else
						{
							bEpdNext = true;

							EpdProc.SetEpd(Epd);

							LegalEpds = EpdProc.GetLegalEpdList();
							LegalBinaryEpds = EpdProc.GetLegalEpdBinaryList();

							pEpd = LegalEpds.begin();
							pEpdBinary = LegalBinaryEpds.begin();

							while ((pEpd != LegalEpds.end()) &&
								   (pEpdBinary != LegalBinaryEpds.end()))
							{
								Epd.erase();	// fix Microsoft bug
								Epd = *pEpd;
								EpdBin = *pEpdBinary;

								EpdOut = EpdBin.GetEpd();
								
								if (Epd != EpdOut)
								{
									csOutBuffer = "Text:    ";
									csOutBuffer += Epd.c_str();
									csOutBuffer += "\n";
									csfOutput.WriteString(csOutBuffer);
									csOutBuffer = "Binary:  ";
									csOutBuffer += EpdOut.c_str();
									csOutBuffer += "\n";
									csfOutput.WriteString(csOutBuffer);
									nErrorEpds++;
								}
								else
								{
									nOutputEpds++;
								}

								pEpd++;
								pEpdBinary++;
							}
						}
					}
					
					bGotData = csfInput.ReadString(csBuffer);
					nLineNumber++;
				}

				dwStop = GetTickCount();

				fSeconds = (float) (dwStop - dwStart);
				fSeconds /= 1000.0;

				CString	csFormat;

				csFormat.Format("Input EPDs:   %7d\n", nInputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Error EPDs:   %7d\n", nErrorEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Output EPDs:  %7d\n", nOutputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Seconds:      %7.2f\n", fSeconds);
				csfOutput.WriteString(csFormat);

				csfInput.Close();
				csfOutput.Close();
			}
		}
	}
}

void CMainFrame::OnTestRunTest5() 
{
	EpdBinary		EpdBin;

	EPD				EpdString = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq -";
	EpdBin = EpdString;
	EpdString = EpdBin.GetEpd();

	EpdProcessor	EpdProc;

	EpdProc.GenerateOutputOpcodes(false);
	EpdProc.SetOutputOpcodeTypes(false,false,false);

	CString	csFilePath;

	CString sFilter("Text Files (*.txt)|*.txt|All Files (*.*)|*.*||");

	CFileDialog InDlg(TRUE, NULL, NULL, 0, sFilter);
	InDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST 
					| OFN_READONLY | OFN_HIDEREADONLY;
	InDlg.m_ofn.lpstrInitialDir = csFilePath;

	CFileDialog OutDlg(FALSE, NULL, NULL, 0, sFilter);
	OutDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST;
	OutDlg.m_ofn.lpstrInitialDir = csFilePath;

	if (InDlg.DoModal() == IDOK)
	{
		const CString csInputPath(InDlg.GetPathName());

		if (OutDlg.DoModal() == IDOK)
		{
			const CString csOutputPath(OutDlg.GetPathName());

			CStdioFile	csfInput;
			CStdioFile	csfOutput;
			BOOL		bInputOpen;
			BOOL		bOutputOpen;
			CString		csBuffer;
			CString		csOutBuffer;
			BOOL		bGotData;
			bool		bEpdNext;
			CString		csTest;
			CString		csError;
			CString		csNull;
			EPD			epd;
			PV			pv;
			EPD			Result;
			EpdBinary	BinaryResult;
			EPD			BinaryResultEpd;
			EPD_VECTOR	ResultVector;
			EPD_BINARY_VECTOR	BinaryResultVector;
			int			nInputEpds = 0;
			int			nErrorEpds = 0;
			int			nErrorConversions = 0;
			int			nOutputEpds = 0;
			int			nInputPvs = 0;
			int			nModifyPvs = 0;
			int			nErrorPvs = 0;
			int			nLineNumber = 1;
			DWORD		dwStart;
			DWORD		dwStop;
			float		fSeconds;
			bool		bEpdValid;
			int			nPvValid;
			std::string	EpdErrorMsg;
			std::string PvErrorMsg;
			char		cFormat[64];

			dwStart = GetTickCount();

			bInputOpen = csfInput.Open(csInputPath, CFile::modeRead | CFile::shareDenyWrite);
			bOutputOpen = csfOutput.Open(csOutputPath, CFile::modeCreate | CFile::modeWrite);

			if (bInputOpen && bOutputOpen)
			{
				CWaitCursor wc;

				bGotData = csfInput.ReadString(csBuffer);
				nLineNumber++;

				bEpdNext = true;
				csError = "#Error";
				csNull	= "(null)";

				while (bGotData)
				{
					csTest = csBuffer.Mid(0, csError.GetLength());

					if (csTest != csError)
					{
						if (bEpdNext)
						{
							epd = csBuffer;

							bEpdNext = false;
								
							bEpdValid = EpdProc.SetEpd(epd);

							if (!bEpdValid)
							{
								nErrorEpds++;

								sprintf(cFormat, "Line# %8d:", nLineNumber);
								EpdErrorMsg = cFormat;
								EpdErrorMsg += " *** EPD ERROR *** ";
								EpdErrorMsg += EpdProc.GetEpdError();

								csOutBuffer = EpdErrorMsg.c_str();
								csOutBuffer += "\n";
								csfOutput.WriteString(csOutBuffer);

								csOutBuffer = epd.c_str();
								csOutBuffer += "\n\n";
								csfOutput.WriteString(csOutBuffer);
							}

							nInputEpds++;
						}
						else
						{
							csTest = csBuffer.Mid(0, csNull.GetLength());

							if (csTest != csNull)
							{
								pv = csBuffer;
								nInputPvs++;
							}
							else
							{
								pv = "";
							}

							bEpdNext = true;
						
							if (bEpdValid)
							{
								nPvValid = EpdProc.SetPv(pv);

								if (nPvValid <= EPD_STATUS_WARNING)
								{
									if (nPvValid == EPD_STATUS_WARNING)
									{
										nModifyPvs++;

										sprintf(cFormat, "Line# %8d:", nLineNumber);
										EpdErrorMsg = cFormat;
										EpdErrorMsg += " *** PV MODIFIED *** ";

										csOutBuffer = EpdErrorMsg.c_str();
										csOutBuffer += "\n";
										csfOutput.WriteString(csOutBuffer);

										csOutBuffer = epd.c_str();
										csOutBuffer += "\n";
										csfOutput.WriteString(csOutBuffer);

										csOutBuffer = "PV In:  ";
										csOutBuffer += pv.c_str();
										csOutBuffer += "\n";
										csfOutput.WriteString(csOutBuffer);

										pv = EpdProc.GetPv();

										csOutBuffer = "PV Out: ";
										csOutBuffer += pv.c_str();
										csOutBuffer += "\n\n";
										csfOutput.WriteString(csOutBuffer);
									}
								}
								else
								{
									nErrorPvs++;

									sprintf(cFormat, "Line# %8d:", nLineNumber);
									EpdErrorMsg = cFormat;
									EpdErrorMsg += " *** PV ERROR *** ";
									EpdErrorMsg += EpdProc.GetPvError();

									csOutBuffer = EpdErrorMsg.c_str();
									csOutBuffer += "\n";
									csfOutput.WriteString(csOutBuffer);

									csOutBuffer = epd.c_str();
									csOutBuffer += "\n";
									csfOutput.WriteString(csOutBuffer);

									csOutBuffer = pv.c_str();
									csOutBuffer += "\n\n";
									csfOutput.WriteString(csOutBuffer);
								}
							}
						}
					}
					
					bGotData = csfInput.ReadString(csBuffer);
					nLineNumber++;
				}

				dwStop = GetTickCount();

				fSeconds = (float) (dwStop - dwStart);
				fSeconds /= 1000.0;

				CString	csFormat;

				csFormat.Format("Input EPDs:        %7d\n", nInputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Error EPDs:        %7d\n", nErrorEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Input PVs:         %7d\n", nInputPvs);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Modified PVs:      %7d\n", nModifyPvs);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Error PVs:         %7d\n", nErrorPvs);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Output EPDs:       %7d\n", nOutputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Conversion Errors: %7d\n", nErrorConversions);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Seconds:           %7.2f\n", fSeconds);
				csfOutput.WriteString(csFormat);

				csfInput.Close();
				csfOutput.Close();
			}
		}
	}
}

void CMainFrame::OnTestRunTest6() 
{
	EpdProcessor		EpdProc;
	SAN_LIST			LegalMoves;
	SAN_LIST::iterator	pSan;
	SAN					San;
	
	EpdProc.GenerateOutputOpcodes(false);
	EpdProc.SetOutputOpcodeTypes(false,false,false);

	CString	csFilePath;

	CString sFilter("Text Files (*.txt)|*.txt|All Files (*.*)|*.*||");

	CFileDialog InDlg(TRUE, NULL, NULL, 0, sFilter);
	InDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST 
					| OFN_READONLY | OFN_HIDEREADONLY;
	InDlg.m_ofn.lpstrInitialDir = csFilePath;

	CFileDialog OutDlg(FALSE, NULL, NULL, 0, sFilter);
	OutDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST;
	OutDlg.m_ofn.lpstrInitialDir = csFilePath;

	if (InDlg.DoModal() == IDOK)
	{
		const CString csInputPath(InDlg.GetPathName());

		if (OutDlg.DoModal() == IDOK)
		{
			const CString csOutputPath(OutDlg.GetPathName());

			CStdioFile	csfInput;
			CStdioFile	csfOutput;
			BOOL		bInputOpen;
			BOOL		bOutputOpen;
			CString		csBuffer;
			CString		csOutBuffer;
			BOOL		bGotData;
			CString		csTest;
			CString		csError;
			CString		csNull;
			PV			pv;
			EPD			Result;
			EPD_VECTOR	ResultVector;
			int			nInputEpds = 0;
			int			nErrorEpds = 0;
			int			nMateEpds = 0;
			int			nOutputEpds = 0;
			int			nInputPvs = 0;
			int			nErrorPvs = 0;
			int			nLineNumber = 1;
			DWORD		dwStart;
			DWORD		dwStop;
			float		fSeconds;
			bool		bEpdValid;
			std::string	EpdErrorMsg;
			std::string PvErrorMsg;
			EPD_LIST			LegalEpds;
			EPD_LIST::iterator	pEpd;
			EPD					Epd;
			EPD_BINARY_LIST				LegalEpdsBinary;
			EPD_BINARY_LIST::iterator	pEpdBinary;
			EpdBinary					EpdBin;

			dwStart = GetTickCount();

			bInputOpen = csfInput.Open(csInputPath, CFile::modeRead | CFile::shareDenyWrite);
			bOutputOpen = csfOutput.Open(csOutputPath, CFile::modeCreate | CFile::modeWrite);

			if (bInputOpen && bOutputOpen)
			{
				CWaitCursor wc;

				bGotData = csfInput.ReadString(csBuffer);
				nLineNumber++;

				while (bGotData)
				{
					csBuffer.TrimRight();

					if (!csBuffer.IsEmpty())
					{
						nInputEpds++;

						Epd.erase();			// fix Microsoft bug
						Epd = csBuffer;

						bEpdValid = EpdProc.SetEpd(Epd);

						if (bEpdValid)
						{
							LegalEpds = EpdProc.GetLegalEpdList();
							LegalEpdsBinary = EpdProc.GetLegalEpdBinaryList();

							if ((LegalEpds.size() == 0) &&
								(LegalEpdsBinary.size() == 0))
							{
								nMateEpds++;
							}
							else if (LegalEpds.size() != LegalEpdsBinary.size())
							{
								nErrorEpds++;
							}
							else
							{
								pEpd = LegalEpds.begin();
								pEpdBinary = LegalEpdsBinary.begin();

								while ((pEpd != LegalEpds.end()) &&
									   (pEpdBinary != LegalEpdsBinary.end()))
								{
									Epd.erase();	// fix Microsoft bug
									Epd = *pEpd;

									EpdBin = *pEpdBinary;

									/*

									EpdProcessor	EpdTestProc;

									if (!EpdTestProc.SetEpd(Epd))
									{
										csOutBuffer = Epd.c_str();
										csOutBuffer += "\n";
										csfOutput.WriteString(csOutBuffer);

										csOutBuffer = EpdTestProc.GetEpdError().c_str();
										csOutBuffer += "\n";
										csfOutput.WriteString(csOutBuffer);
									}

									*/

									csOutBuffer = Epd.c_str();
									csOutBuffer += "\n";

									csfOutput.WriteString(csOutBuffer);

									if (Epd != EpdBin.GetEpd())
									{
										csOutBuffer = "Error: ";
										csOutBuffer += EpdBin.GetEpd().c_str();
										csOutBuffer += "\n";
										
										csfOutput.WriteString(csOutBuffer);
										nErrorEpds++;
									}

									nOutputEpds++;
									pEpd++;
									pEpdBinary++;
								}
							}

							
						}
						else
						{
							std::string ErrorMsg;

							ErrorMsg = "Epd Error: ";
							ErrorMsg += EpdProc.GetEpdError();
							csOutBuffer = ErrorMsg.c_str();
							csOutBuffer += "  ";
							csOutBuffer += Epd.c_str();
							csOutBuffer += "\n";								
							csfOutput.WriteString(csOutBuffer);

							nErrorEpds++;
						}
					}

					bGotData = csfInput.ReadString(csBuffer);
				}

				dwStop = GetTickCount();

				fSeconds = (float) (dwStop - dwStart);
				fSeconds /= 1000.0;

				CString	csFormat;

				csFormat.Format("Input EPDs:  %7d\n", nInputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Error EPDs:  %7d\n", nErrorEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Output EPDs: %7d\n", nOutputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Mate EPDs:   %7d\n", nMateEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Seconds:     %7.2f\n", fSeconds);
				csfOutput.WriteString(csFormat);

				csfInput.Close();
				csfOutput.Close();
			}
		}
	}
}

void CMainFrame::OnTestRunTest7() 
{
	EpdProcessor		EpdProc;
	SAN_LIST			LegalMoves;
	SAN_LIST::iterator	pSan;
	SAN					San;
	
	EpdProc.GenerateOutputOpcodes(false);
	EpdProc.SetOutputOpcodeTypes(false,false,false);

	CString	csFilePath;

	CString sFilter("Text Files (*.txt)|*.txt|All Files (*.*)|*.*||");

	CFileDialog InDlg(TRUE, NULL, NULL, 0, sFilter);
	InDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST 
					| OFN_READONLY | OFN_HIDEREADONLY;
	InDlg.m_ofn.lpstrInitialDir = csFilePath;

	CFileDialog OutDlg(FALSE, NULL, NULL, 0, sFilter);
	OutDlg.m_ofn.Flags |= OFN_PATHMUSTEXIST;
	OutDlg.m_ofn.lpstrInitialDir = csFilePath;

	if (InDlg.DoModal() == IDOK)
	{
		const CString csInputPath(InDlg.GetPathName());

		if (OutDlg.DoModal() == IDOK)
		{
			const CString csOutputPath(OutDlg.GetPathName());

			CStdioFile	csfInput;
			CStdioFile	csfOutput;
			BOOL		bInputOpen;
			BOOL		bOutputOpen;
			CString		csBuffer;
			CString		csOutBuffer;
			BOOL		bGotData;
			CString		csTest;
			CString		csError;
			CString		csNull;
			PV			pv;
			EPD			Result;
			EPD_VECTOR	ResultVector;
			int			nInputEpds = 0;
			int			nErrorEpds = 0;
			int			nMateEpds = 0;
			int			nOutputEpds = 0;
			int			nInputPvs = 0;
			int			nErrorPvs = 0;
			int			nLineNumber = 1;
			DWORD		dwStart;
			DWORD		dwStop;
			float		fSeconds;
			bool		bEpdValid;
			int			nPvValid;
			std::string	EpdErrorMsg;
			std::string PvErrorMsg;
			EPD_LIST			LegalEpds;
			SAN_LIST			LegalSans;
			EPD_LIST::iterator	pEpd;
			EPD					Epd;
			SAN					San;
			EPD_BINARY_LIST				LegalEpdsBinary;
			EPD_BINARY_LIST::iterator	pEpdBinary;
			SAN_LIST::iterator			pSan;
			EpdBinary					EpdBin;

			dwStart = GetTickCount();

			bInputOpen = csfInput.Open(csInputPath, CFile::modeRead | CFile::shareDenyWrite);
			bOutputOpen = csfOutput.Open(csOutputPath, CFile::modeCreate | CFile::modeWrite);

			if (bInputOpen && bOutputOpen)
			{
				CWaitCursor wc;

				bGotData = csfInput.ReadString(csBuffer);
				nLineNumber++;

				while (bGotData)
				{
					csBuffer.TrimRight();

					if (!csBuffer.IsEmpty())
					{
						nInputEpds++;

						Epd.erase();			// fix Microsoft bug
						Epd = csBuffer;

						bEpdValid = EpdProc.SetEpd(Epd);

						if (bEpdValid)
						{
							LegalSans = EpdProc.GetLegalSanList();

							if (LegalSans.size() == 0)
							{
								nMateEpds++;
							}
							else
							{
								pSan = LegalSans.begin();

								while (pSan != LegalSans.end())
								{
									San = *pSan;

									nPvValid = EpdProc.SetPv(San);

									if (nPvValid != EPD_STATUS_SUCCESS)
									{
										csOutBuffer = Epd.c_str();
										csOutBuffer += "\n";
										csfOutput.WriteString(csOutBuffer);

										csOutBuffer = San.c_str();
										csOutBuffer += "\n";
										csfOutput.WriteString(csOutBuffer);

										csOutBuffer = EpdProc.GetPvError().c_str();
										csOutBuffer += "\n";
										csfOutput.WriteString(csOutBuffer);

										nErrorEpds++;
									}
									else
									{
										nOutputEpds++;
									}

									pSan++;
								}
							}							
						}
						else
						{
							std::string ErrorMsg;

							ErrorMsg = "Epd Error: ";
							ErrorMsg += EpdProc.GetEpdError();
							csOutBuffer = ErrorMsg.c_str();
							csOutBuffer += "  ";
							csOutBuffer += Epd.c_str();
							csOutBuffer += "\n";								
							csfOutput.WriteString(csOutBuffer);

							nErrorEpds++;
						}
					}

					bGotData = csfInput.ReadString(csBuffer);
				}

				dwStop = GetTickCount();

				fSeconds = (float) (dwStop - dwStart);
				fSeconds /= 1000.0;

				CString	csFormat;

				csFormat.Format("Input EPDs:  %7d\n", nInputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Error EPDs:  %7d\n", nErrorEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Output EPDs: %7d\n", nOutputEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Mate EPDs:   %7d\n", nMateEpds);
				csfOutput.WriteString(csFormat);

				csFormat.Format("Seconds:     %7.2f\n", fSeconds);
				csfOutput.WriteString(csFormat);

				csfInput.Close();
				csfOutput.Close();
			}
		}
	}
}