#include <printman/printman.hpp>
#include <common/assert.hpp>
#include <common/opendlg.hpp>
#include <common/gdata.hpp>
#include <common/crsctrl.hpp>
#include <common/diskinfo.hpp>

char MainFrame::szClassName[]="Aladin";
char MainFrame::szMenuName[]="mainMenu";

MainFrame::MainFrame(void)
{
  mQueryEndSessionHandler.setCallback(this,&MainFrame::queryEndSessionHandler);
  mPaintHandler.setCallback(this,&MainFrame::paintHandler);
	mDestroyHandler.setCallback(this,&MainFrame::destroyHandler);
	mCommandHandler.setCallback(this,&MainFrame::commandHandler);
	mSizeHandler.setCallback(this,&MainFrame::sizeHandler);
	mCreateHandler.setCallback(this,&MainFrame::createHandler);
	insertHandlers();
}

MainFrame::~MainFrame()
{
	destroy();
}

void MainFrame::insertHandlers(void)
{
	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
	insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
	insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
	insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
	insertHandler(VectorHandler::QueryEndSessionHandler,&mQueryEndSessionHandler);
}

void MainFrame::removeHandlers(void)
{
	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
	removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
	removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
	removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
	removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
	removeHandler(VectorHandler::QueryEndSessionHandler,&mQueryEndSessionHandler);
}

CallbackData::ReturnType MainFrame::createHandler(CallbackData &/*someCallbackData*/)
{
  GlobalData<int> statParts;

	createToolBar();
	mStatusBar=::new StatusBarEx(*this,StatusBarID);
	mStatusBar.disposition(PointerDisposition::Delete);
	statParts.size(2);
	*((int*)&statParts[0])=300;
	*((int*)&statParts[1])=400;
	mStatusBar->setParts(statParts);
	mStatusBar->setText("Ready");
	applyHistory(getFrameMenu());
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::destroyHandler(CallbackData &/*someCallbackData*/)
{
	removeHandlers();
	::PostQuitMessage(0);
	::WinHelp(*this,0,HELP_QUIT,0);
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::queryEndSessionHandler(CallbackData &someCallbackData)
{
   if(getClient().hasChildren())return (CallbackData::ReturnType)FALSE;
	 return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::sizeHandler(CallbackData &someCallbackData)
{
  Rect statusRect;
	Rect toolRect;
	Rect cRect;

  mToolBar.windowRect(toolRect);
	mStatusBar->windowRect(statusRect);
	cRect.right(someCallbackData.loWord());
	cRect.bottom(someCallbackData.hiWord());
	getClient().moveWindow(0,toolRect.bottom()-toolRect.top(),cRect.right(),cRect.bottom()-((statusRect.bottom()-statusRect.top())+(toolRect.bottom()-toolRect.top())));
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::paintHandler(CallbackData &/*someCallbackData*/)
{
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::commandHandler(CallbackData &someCallbackData)
{
	switch(someCallbackData.wmCommandID())
	{
	  case MenuCodeCompile :
		  handleCodeCompile();
			break;
		case MenuCodeCompileAndLoad :
		  handleCodeCompileAndLoad();
			break;
	  case MenuEditCut :
		  handleEditCut();
		  break;
		case MenuEditCopy :
		  handleEditCopy();
		  break;
		case MenuEditPaste :
		  handleEditPaste();
		  break;
		case MenuEditFind :
		  handleEditFind();
		  break;
	  case MenuCascade :
		  cascade();
			break;
		case MenuTile :
		  tile();
			break;
		case MenuArrange :
		  arrange();
			break;
		case MenuCloseAll :
		  closeAll();
			break;
		case MenuMinimizeAll :
		  minimizeAll();
			break;
		case MenuRestoreAll :
		  restoreAll();
			break;
	  case MenuFileNew :
		  handleFileNew();
			break;
		case MenuFileOpen :
		  handleFileOpen();
		  break;
	  case MenuFileSave :
		  handleFileSave();
			break;
		case MenuFilePrint :
		  handleFilePrint();
			break;
		case MenuFileSaveAs :
		  handleFileSaveAs();
			break;
		case MenuFileClose :
		  handleFileClose();
			break;
		case MenuFileQuit :
		  break;
		case MenuSettingsSerial :
		  handleCommunications();
		  break;
		case MenuHelpContents :
		  handleHelp();
		  break;
		case MenuHelpSearch :
		  handleHelp();
		  break;
		case MenuRegistration :
		  break;
		case MenuHelpAbout :
		  break;
	}
	if(someCallbackData.wParam()>=StartDynamicID)handleFileOpen(someCallbackData);
	return (CallbackData::ReturnType)FALSE;
}

// handlers

void MainFrame::handleCodeCompile(void)
{
  CursorControl cursorControl;
  SmartPointer<MDIWindow> mdiWindow;
	String strMessage;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
	CodeView &codeView=(CodeView&)*mdiWindow;
	if(codeView.isDirty()&&IDYES==::MessageBox(*this,(LPSTR)"Save Changes?",(LPSTR)"M68HC11",MB_YESNO))if(!handleFileSave())return;
	mStatusBar->setText("compiling...");
	cursorControl.waitCursor(TRUE);
	m68Assembler.assemble(codeView.getTitle());
	cursorControl.waitCursor(FALSE);
	strMessage=m68Assembler.strLastMessage()+String(", code size is ")+String().fromInt(m68Assembler.codeSize())+String(" byte(s).");
	mStatusBar->setText(strMessage);
}

void MainFrame::handleCodeCompileAndLoad(void)
{
  CursorControl cursorControl;
	BOOL assembleResult;
	String strPathBinary;
	String strMessage;

  SmartPointer<MDIWindow> mdiWindow;
	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
	CodeView &codeView=(CodeView&)*mdiWindow;
	if(codeView.isDirty()&&IDYES==::MessageBox(*this,(LPSTR)"Save Changes?",(LPSTR)"M68HC11",MB_YESNO))if(!handleFileSave())return;
	mStatusBar->setText("compiling...");
	cursorControl.waitCursor(TRUE);
	assembleResult=m68Assembler.assemble(codeView.getTitle());
	cursorControl.waitCursor(FALSE);
	strMessage=m68Assembler.strLastMessage()+String(", code size is ")+String().fromInt(m68Assembler.codeSize())+String(" byte(s).");
	mStatusBar->setText(strMessage);
	if(!assembleResult)return;
	strPathBinary=codeView.getTitle().betweenString(0,'.');
	strPathBinary+=".bin";
	codeLoad(strPathBinary);
}

void MainFrame::handleEditCut(void)
{
  SmartPointer<MDIWindow> mdiWindow;
	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
	((CodeView&)*mdiWindow).cut();
}

void MainFrame::handleEditCopy(void)
{
  SmartPointer<MDIWindow> mdiWindow;
	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
	((CodeView&)*mdiWindow).copy();
}

void MainFrame::handleEditPaste(void)
{
  SmartPointer<MDIWindow> mdiWindow;
	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
	((CodeView&)*mdiWindow).paste();
}

void MainFrame::handleEditFind(void)
{
  SmartPointer<MDIWindow> mdiWindow;
	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
	((CodeView&)*mdiWindow).find();
}

void MainFrame::handleFileNew(void)
{
//  CodeView *pCodeView;
//
//	pCodeView=::new CodeView;
//	pCodeView->setLineHandler(&mLineHandler);
//	pCodeView->createWindow(*this,STRING_CODEVIEWCLASSNAME,STRING_CODEVIEWCLASSNAME,"codeMenu","Doc");
//	insert(*pCodeView);
}

void MainFrame::handleFileOpen(CallbackData &someCallbackData)
{
/*	PureMenu fileMenu;
	String menuItemString;

	getFrameMenu().getSubMenu(0,fileMenu);
	menuItemString=fileMenu.menuItemString(someCallbackData.wParam(),PureMenu::ByCommand);
	if(menuItemString.isNull())return;
	menuItemString=menuItemString.betweenString(')',0);
	menuItemString.trimLeft();
	handleFileOpen(menuItemString);  */
}

void MainFrame::handleFileOpen(void)
{
/*  OpenDialog openDialog;
  String strPathFileName;

	if(!openDialog.getOpenFileName(*this,"*.asm","Open File","*.asm",strPathFileName))return;
	handleFileOpen(strPathFileName);  */
}

void MainFrame::handleFileOpen(const String &strPathFileName)
{
/*  CodeView *pCodeView;
	CursorControl cursorControl;

  if(bringDocumentToFront(strPathFileName))return;
  mStatusBar->setText("Loading...");
	cursorControl.waitCursor(TRUE);

  pCodeView=::new CodeView;
	insert(*pCodeView);        // insert the pointer before creating/activating the window
	pCodeView->createWindow(*this,STRING_CODEVIEWCLASSNAME,STRING_CODEVIEWCLASSNAME,"codeMenu","Doc");
	pCodeView->setLineHandler(&mLineHandler);
	pCodeView->open(strPathFileName);
  mStatusBar->setText("Ready");
	cursorControl.waitCursor(FALSE);
	updateHistory(strPathFileName);  */
}

void MainFrame::handleFileClose(void)
{
  SmartPointer<MDIWindow> mdiWindow;
	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
	mdiWindow->close();
}

void MainFrame::handleFilePrint(void)
{
/*  SmartPointer<MDIWindow> mdiWindow;
	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
	((CodeView&)*mdiWindow).print();  */
}

BOOL MainFrame::handleFileSave(void)
{
/*  SmartPointer<MDIWindow> mdiWindow;
	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return FALSE;
	CodeView &codeView=(CodeView&)*mdiWindow;
	if(codeView.getTitle()==String(STRING_UNTITLED))return handleFileSaveAs();
	if(!codeView.save())return mStatusBar->setText(codeView.getTitle()+String(" save failed.")),FALSE;
	return mStatusBar->setText(codeView.getTitle()+String(" saved.")),TRUE;  */
	return TRUE;
}

BOOL MainFrame::handleFileSaveAs(void)
{
/*  SmartPointer<MDIWindow> mdiWindow;
  OpenDialog openDialog;
	String strPathFileName;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return FALSE;
	if(!openDialog.getSaveFileName(*this,"Assembly Files","File Save","*.asm",strPathFileName))return FALSE;
	if(!strPathFileName.strstr(".asm"))strPathFileName+=".asm";
	if(!((CodeView&)*mdiWindow).save(strPathFileName))return mStatusBar->setText(strPathFileName+String(" save failed!.")),FALSE; 
  return mStatusBar->setText(strPathFileName+String(" saved.")),TRUE;  */

  return false;
}

void MainFrame::handleCommunications(void)
{
//  SerialDlg serDlg;
//	serDlg.perform(*this);
}

void MainFrame::handleHelp(void)
{
  String strPathHelpFileName;
  DiskInfo diskInfo;

	diskInfo.getCurrentDirectory(strPathHelpFileName);
	strPathHelpFileName+=String(STRING_HELPFILENAME);
	::WinHelp(*this,strPathHelpFileName,HELP_CONTENTS,0);
}

// support & testing 
BOOL MainFrame::codeLoad(const String &strPathBinary)
{
/*  MCUView *pMCUView;

	pMCUView=::new MCUView;
	pMCUView->createWindow(*this,STRING_MCUVIEWCLASSNAME,STRING_MCUVIEWCLASSNAME,"mcuMenu","Doc");
	insert(*pMCUView);
	pMCUView->setCode(strPathBinary);  */
  return TRUE;
}

void MainFrame::setParts(int numParts)
{
  GlobalData<int> statParts;
  if(1==numParts){statParts.size(1);*((int*)&statParts[0])=FirstPartWidth;}
	else {statParts.size(2);*((int*)&statParts[0])=FirstPartWidth;*((int*)&statParts[0]+1)=SecondPartWidth;}
	mStatusBar->setParts(statParts);
}

void MainFrame::updateHistory(const String &pathFileName)
{
/*  M68Reg m68Reg;
  SmartPointer<MDIWindow> mdiWindow;

	if(!m68Reg.insertHistory(pathFileName))return;
	removeHistory(getFrameMenu());
	applyHistory(getFrameMenu());
	if(getFirstDocument(mdiWindow))
	{
	  removeHistory(mdiWindow->getMenu());
		applyHistory(mdiWindow->getMenu());
	  while(getNextDocument(mdiWindow))
		{
	    removeHistory(mdiWindow->getMenu());
		  applyHistory(mdiWindow->getMenu());
		}
	}  */
}

void MainFrame::removeHistory(PureMenu &pureMenu)
{
/*	M68Reg m68Reg;
	UINT startID(StartDynamicID);
	Block<String> nameList;
	PureMenu fileMenu;

	m68Reg.getHistory(nameList);
	if(!nameList.size())return;
	pureMenu.getSubMenu(0,fileMenu);
	for(int itemIndex=0;itemIndex<nameList.size();itemIndex++)fileMenu.removeMenu(startID++,PureMenu::ByCommand);
  int entries(fileMenu.size());
	if((int)PureMenu::TypeSeparator&(int)fileMenu.getMenuItemType(entries-1,PureMenu::ByPosition))fileMenu.removeMenu(entries-1,PureMenu::ByPosition);  */
}

void MainFrame::applyHistory(PureMenu &pureMenu)
{
  M68Reg m68Reg;
	Block<String> nameList;
	PureMenu fileMenu;
  String strItem;

	m68Reg.getHistory(nameList);
	if(!nameList.size())return;
	pureMenu.getSubMenu(0,fileMenu);
	fileMenu.appendSeparator();
	for(int itemIndex=0;itemIndex<nameList.size();itemIndex++)
	{
	  ::sprintf(strItem,"%d) %s",itemIndex+1,(char*)nameList[itemIndex]);
		fileMenu.appendMenu(StartDynamicID+itemIndex,strItem);
	}
}

void MainFrame::createToolBar(void)
{
  Block<AddBitmap> addBitmaps;

  mToolBar.create(*this,ToolBarID);
	addBitmaps.insert(&AddBitmap(0,HINST_COMMCTRL));
	if(!mToolBar.addBitmaps(addBitmaps))return;
	mToolBar.addButton(ToolBarButton(STD_FILENEW,MenuFileNew,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_FILEOPEN,MenuFileOpen,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_FILESAVE,MenuFileSave,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_PRINT,MenuFilePrint,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_CUT,MenuEditCut,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_COPY,MenuEditCopy,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_PASTE,MenuEditPaste,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_FIND,MenuEditFind,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_PRINT,MenuFilePrint,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
}

BOOL MainFrame::bringDocumentToFront(const String &strTitle)
{
  SmartPointer<MDIWindow> mdiWindowPtr;

	if(getFirstDocument(mdiWindowPtr))
	{
	  if(((CodeView&)*mdiWindowPtr).getTitle()==strTitle){mdiWindowPtr->bringWindowToTop();return TRUE;}
	  while(getNextDocument(mdiWindowPtr))if(((CodeView&)*mdiWindowPtr).getTitle()==strTitle){mdiWindowPtr->bringWindowToTop();return TRUE;}
	}
	return FALSE;
}

void MainFrame::splash(void)
{
  SplashScreen splashScreen("SPLASH","M68HC11");
	splashScreen.perform();
}

// virtuals

void MainFrame::mdiDestroy(MDIWindow &mdiWindow)
{
  SmartPointer<MDIWindow> mdiWindowPtr;
  WORD winCount(0);

	if(getFirstDocument(mdiWindowPtr))
	{
	  if(mdiWindowPtr->className()==String(STRING_CODEVIEWCLASSNAME)&&((MDIWindow*)mdiWindowPtr!=&mdiWindow))winCount++;
	  while(getNextDocument(mdiWindowPtr))if(mdiWindowPtr->className()==String(STRING_CODEVIEWCLASSNAME)&&((MDIWindow*)mdiWindowPtr!=&mdiWindow))winCount++;
	}
	if(!winCount)setParts(SinglePart);
}

void MainFrame::mdiActivate(MDIWindow &mdiWindow)
{
  if(mdiWindow.className()==String(STRING_CODEVIEWCLASSNAME))setParts(DoublePart);
  removeHistory(mdiWindow.getMenu());
	applyHistory(mdiWindow.getMenu());
}

void MainFrame::mdiDeactivate(MDIWindow &/*mdiWindow*/)
{
}