#include <drums/viewwnd.hpp>
#include <drums/drums.hpp>
#include <drums/DrumControl.hpp>

//#include <guitar/guitar.hpp>
//#include <guitar/GlobalDefs.hpp>
//#include <guitar/MessageBox.hpp>
#include <statbar/statbarx.hpp>
#include <common/profile.hpp>
#include <common/puremenu.hpp>
#include <common/opendlg.hpp>
#include <common/mdifrm.hpp>

ViewWindow::ViewWindow(void)
//: mIsInRepeatPlay(false)
{
  mCreateHandler.setCallback(this,&ViewWindow::createHandler);
  mSizeHandler.setCallback(this,&ViewWindow::sizeHandler);
	mPaintHandler.setCallback(this,&ViewWindow::paintHandler);
	mLeftButtonDoubleHandler.setCallback(this,&ViewWindow::leftButtonDoubleHandler);
	mThreadHandler.setCallback(this,&ViewWindow::threadHandler);
	mCloseHandler.setCallback(this,&ViewWindow::closeHandler);
	mRightButtonDownHandler.setCallback(this,&ViewWindow::rightButtonDownHandler);
	MDIWindow::insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
	MDIWindow::insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
	MDIWindow::insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
	MDIWindow::insertHandler(VectorHandler::LeftButtonDoubleHandler,&mLeftButtonDoubleHandler);
	MDIWindow::insertHandler(VectorHandler::CloseHandler,&mCloseHandler);
	MDIWindow::insertHandler(VectorHandler::RightButtonDownHandler,&mRightButtonDownHandler);
	MessageThread::insertHandler(&mThreadHandler);
	start();
}

ViewWindow::~ViewWindow()
{
	MDIWindow::removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
	MDIWindow::removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
	MDIWindow::removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
	MDIWindow::removeHandler(VectorHandler::LeftButtonDoubleHandler,&mLeftButtonDoubleHandler);
	MDIWindow::removeHandler(VectorHandler::CloseHandler,&mCloseHandler);
	MDIWindow::removeHandler(VectorHandler::RightButtonDownHandler,&mRightButtonDownHandler);
	stop();
}

CallbackData::ReturnType ViewWindow::createHandler(CallbackData &someCallbackData)
{
/*  mTabPage=::new TabPage(*this);
	mTabPage.disposition(PointerDisposition::Delete);
	setTitle(STRING_NOTITLE);*/
	mDrumControl=new DrumControl(*this);
	mDrumControl.disposition(PointerDisposition::Delete);
	setTitle("{None}");
	return false;
}

CallbackData::ReturnType ViewWindow::closeHandler(CallbackData &someCallbackData)
{
/*  mTabPage->setCancelled(true);
	if(mTabPage->isDirty())
	{
		LRESULT result=MessageBox::messageBox(*this,"Project has changed.","Save changes?",MB_YESNOCANCEL);
		if(IDCANCEL==result)return true;
		else if(IDNO==result)
		{
		  mTabPage->isDirty(false);
		  return false;
		}
		else 
		{
		  saveProject();
		  mTabPage->isDirty(false);
			return false;
		}
	}
*/
  return false;
}

CallbackData::ReturnType ViewWindow::rightButtonDownHandler(CallbackData &someCallbackData)
{
/*  GlobalDefs::outDebug("ViewWindow::rightButtonDownHandler");

  PureMenu popupMenu(PureMenu::PopupMenu);
  GDIPoint trackPoint;
	trackPoint.x(someCallbackData.loWord());
	trackPoint.y(someCallbackData.hiWord());
	clientToScreen(trackPoint);
	if(mTabPage->isInPlay())
	{
    popupMenu.appendMenu(MENU_TABLATURE_STOP,"&Stop");
	}
	else
	{
	  popupMenu.appendMenu(MENU_TABLATURE_PLAY,"&Play");
		popupMenu.appendMenu(MENU_TABLATURE_PLAYREPEATED,"Play (&Repeated)");
		if(mTabPage->hasRange())
		{
	    popupMenu.appendMenu(MENU_TABLATURE_PLAYRANGE,"Play R&ange...");
		  popupMenu.appendMenu(MENU_TABLATURE_PLAYRANGE_REPEATED,"Play Rang&e (Repeated)...");
		}
    if(mTabPage->isInOutline())
		{
      popupMenu.appendMenu(MENU_TABLATURE_PLAYTOEND,"P&lay From Here");
			if(!mTabPage->isInSetRange())
			{
			  popupMenu.appendSeparator();
			  popupMenu.appendMenu(MENU_TABLATURE_SETSTARTRANGE,"S&tart Range");
			}
			else 
			{
 			  popupMenu.appendSeparator();
			  popupMenu.appendMenu(MENU_TABLATURE_SETENDRANGE,"&End Range");
			}
		  popupMenu.appendSeparator();
		  popupMenu.appendMenu(MENU_TABLATURE_ENTRYPROPS,"&Properties...");
		}
	}
	popupMenu.trackPopupMenu(*(getFrame()),trackPoint);
	::SetCursorPos(trackPoint.x(),trackPoint.y());			
*/
  return false;
}

CallbackData::ReturnType ViewWindow::sizeHandler(CallbackData &someCallbackData)
{
  return false;
}

CallbackData::ReturnType ViewWindow::paintHandler(CallbackData &someCallbackData)
{
  return false;
}

CallbackData::ReturnType ViewWindow::leftButtonDoubleHandler(CallbackData &someCallbackData)
{
  return false;
}

// ************************************************************************************************

/*
bool ViewWindow::insert(const TabEntry &entry)
{
//  return mTabPage->insert(entry);
  return false;
}
*/

/*
bool ViewWindow::insert(const TabEntries &entries)
{
  if(!mTabPage->insert(entries))return false;
	invalidate();
	mTabPage->isDirty(true);

	return true;
}
*/

void ViewWindow::setTitle(const String &strTitle)
{
  String strCaption;
  String strString;

	windowText(strCaption);
	strString=strCaption;
	strCaption=strCaption.betweenString(0,' ');
	if(strCaption.isNull())strCaption=strString;
	strCaption+=String(" - [")+strTitle+String("]");
	setCaption(strCaption);
}

String ViewWindow::getTitle(void)const
{
  String strCaption;

	windowText(strCaption);
	return strCaption.betweenString('[',']');
}

/*
void ViewWindow::play(void)
{
  ThreadMessage thMessage(ThreadMessage::TM_USER,THPlay);
	enablePlaySelect(false);
	MessageThread::postMessage(thMessage);
	return;
}

void ViewWindow::playFromCurrent(void)
{
  ThreadMessage thMessage(ThreadMessage::TM_USER,THPlayFromCurrent);
	enablePlaySelect(false);
	MessageThread::postMessage(thMessage);
	return;
}

void ViewWindow::playRepeated(void)
{
  ThreadMessage thMessage(ThreadMessage::TM_USER,THPlay);
	enablePlaySelect(false);
	isInRepeatPlay(true);
	MessageThread::postMessage(thMessage);
	return;
}

void ViewWindow::playRange(int rangeIndex)
{
  ThreadMessage thMessage(ThreadMessage::TM_USER,THPlayRange,rangeIndex);
	enablePlaySelect(false);
	MessageThread::postMessage(thMessage);
}

void ViewWindow::playRangeRepeated(int rangeIndex)
{
  ThreadMessage thMessage(ThreadMessage::TM_USER,THPlayRange,rangeIndex);
	enablePlaySelect(false);
	isInRepeatPlay(true);
	MessageThread::postMessage(thMessage);
}

void ViewWindow::stopPlay(void)
{
  isInRepeatPlay(false);
  mTabPage->setCancelled(true);
}

void ViewWindow::modifyProperties(void)
{
  mTabPage->modifyProperties();
}

void ViewWindow::increaseTempo(void)
{
  mTabPage->increaseTempo();
}

void ViewWindow::decreaseTempo(void)
{
  mTabPage->decreaseTempo();
}

void ViewWindow::enablePlaySelect(bool enable)
{
  PureMenu &pureMenu=getMenu();
	if(enable)
	{
	  pureMenu.enableMenuItem(MENU_TABLATURE_PLAY,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
	  pureMenu.enableMenuItem(MENU_TABLATURE_PLAYREPEATED,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
	  pureMenu.enableMenuItem(MENU_TABLATURE_PLAYRANGE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
	  pureMenu.enableMenuItem(MENU_TABLATURE_STOP,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
  }
	else
	{
	  pureMenu.enableMenuItem(MENU_TABLATURE_PLAY,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
	  pureMenu.enableMenuItem(MENU_TABLATURE_PLAYREPEATED,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
	  pureMenu.enableMenuItem(MENU_TABLATURE_PLAYRANGE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
	  pureMenu.enableMenuItem(MENU_TABLATURE_STOP,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
	}
}

void ViewWindow::enableCut(bool enable)
{
  PureMenu &pureMenu=getMenu();
  pureMenu.enableMenuItem(MENU_EDIT_CUT,PureMenu::ByCommand,enable?PureMenu::InsertFlags(PureMenu::ItemEnabled):PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
}

void ViewWindow::enableCopy(bool enable)
{
  PureMenu &pureMenu=getMenu();
  pureMenu.enableMenuItem(MENU_EDIT_COPY,PureMenu::ByCommand,enable?PureMenu::InsertFlags(PureMenu::ItemEnabled):PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
}

void ViewWindow::enablePaste(bool enable)
{
  PureMenu &pureMenu=getMenu();
  pureMenu.enableMenuItem(MENU_EDIT_PASTE,PureMenu::ByCommand,enable?PureMenu::InsertFlags(PureMenu::ItemEnabled):PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
}

bool ViewWindow::getEnableCut(void)
{
  UINT state;
  PureMenu &pureMenu=getMenu();
  state=pureMenu.getMenuState(MENU_EDIT_CUT,PureMenu::ByCommand);
	return !((state&MF_GRAYED)||(state&MF_DISABLED));
}

bool ViewWindow::getEnableCopy(void)
{
  UINT state;
  PureMenu &pureMenu=getMenu();
  state=pureMenu.getMenuState(MENU_EDIT_COPY,PureMenu::ByCommand);
	return !((state&MF_GRAYED)||(state&MF_DISABLED));
}

bool ViewWindow::getEnablePaste(void)
{
  UINT state;
  PureMenu &pureMenu=getMenu();
  state=pureMenu.getMenuState(MENU_EDIT_PASTE,PureMenu::ByCommand);
	return !((state&MF_GRAYED)||(state&MF_DISABLED));
}

void ViewWindow::enableStopSelect(bool enable)
{
  PureMenu &pureMenu=getMenu();

	if(enable)pureMenu.enableMenuItem(MENU_TABLATURE_STOP,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
	else pureMenu.enableMenuItem(MENU_TABLATURE_STOP,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
}

bool ViewWindow::createProject(const String &strPathTabFile)
{
	if(Profile::verifyPathFileName(Tablature::getPathFileProject(strPathTabFile)))
	{
	  String strMessage=String("Project '")+Tablature::getPathFileProject(strPathTabFile)+String("' already exists, overwrite?");
	  if(IDCANCEL==MessageBox::messageBox(*this,"Warning",strMessage,MB_OKCANCEL))return false;
	}
  if(!mTablature.import(strPathTabFile))
	{
	  switch(mTablature.getLastError())
		{
		  case Tablature::FileOpenError :
	      MessageBox::messageBox(*this,"Load Tablature","Referenced tablature could not be opened.");
				return false;
			case Tablature::NoTabsParsedError :
				MessageBox::messageBox(*this,"Load Tablature","File contained no valid tablatures.",MB_OK);
				return false;
			case Tablature::NoFrettedNotesError :
	      MessageBox::messageBox(*this,"Load Tablature","File contained tablatures, but none of them were parsed.");
				return false;
			default :
        MessageBox::messageBox(*this,"Load Tablature","Error creating project.");
				return false;
		}
	}
	setTitle(mTablature.getPathFileProject());
	saveProject();
	show(SW_SHOW);
	top();
	mTabPage->insert(mTablature.getTabEntries(),false);
  PureMenu &pureMenu=getMenu();
	pureMenu.enableMenuItem(MENU_TABLATURE_STOP,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
	invalidate();
	return true;
}

bool ViewWindow::createProject(void)
{
	show(SW_SHOW);
	top();
	setTitle(STRING_NOTITLE);
  PureMenu &pureMenu=getMenu();
	pureMenu.enableMenuItem(MENU_TABLATURE_STOP,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
	invalidate();
	mTabPage->isDirty(true);
	return true;
}

bool ViewWindow::openProject(const String &pathFileName)
{
  if(!mTablature.openProject(pathFileName))
	{
	  switch(mTablature.getLastError())
		{
		  case Tablature::FileOpenError :
	      MessageBox::messageBox(*this,pathFileName,"Referenced tablature could not be opened.");
				return false;
			case Tablature::NoTabsParsedError :
	      MessageBox::messageBox(*this,pathFileName,"File contained no valid tablatures.");
				return false;
			case Tablature::NoFrettedNotesError :
	      MessageBox::messageBox(*this,pathFileName,"Warning, No tablatures were found in the file.\nYou can insert tablature by using the Insert key.");
		}
	}
  PureMenu &pureMenu=getMenu();
	show(SW_SHOW);
	top();
  mTabPage->insert(mTablature.getTabEntries(),false);   // don't set the dirty flag when loading
	if(mTabPage->insert(mTablature.getTabRanges(),false)) // don't set the dirty flag when loading
	{
	  pureMenu.enableMenuItem(MENU_TABLATURE_PLAYRANGE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
	  pureMenu.enableMenuItem(MENU_TABLATURE_PLAYRANGE_REPEATED,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
	}
	setTitle(mTablature.getPathFileProject());
	pureMenu.enableMenuItem(MENU_TABLATURE_STOP,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
	return true;
}

bool ViewWindow::getProjectName(String &strPathFileProject)
{
  OpenDialog openDialog;

	if(!openDialog.getSaveFileName(*this,"Project Files","Project Save",String(STRING_PRJALLEXTENSION),strPathFileProject))return false;
	if(!strPathFileProject.strstr(String(STRING_PRJEXTENSION)))strPathFileProject+=String(STRING_PRJEXTENSION);
	return true;
}

bool ViewWindow::saveProject(const String &pathFileName)
{
  bool returnCode=false;
  if(mTabPage->isDirty())
	{
    mTablature.setTabEntries(mTabPage->getEntries());
		mTablature.setTabRanges(mTabPage->getRanges());
		mTabPage->isDirty(false);
	}
  returnCode=mTablature.saveProject(pathFileName);
	if(returnCode&&String(STRING_NOTITLE)==getTitle())setTitle(mTablature.getPathFileProject());
	return returnCode;
}

bool ViewWindow::saveProject(void)
{
  bool returnCode=false;

  if(getTitle()==String(STRING_NOTITLE))
	{
		Registry registry;
	  String strPathFileProject;
		if(!getProjectName(strPathFileProject))return false;
		if(!saveProject(strPathFileProject))return false;
		registry.insertHistory(strPathFileProject);
		setTitle(mTablature.getPathFileProject());
		return true;
	}
  if(mTabPage->isDirty())
	{
    mTablature.setTabEntries(mTabPage->getEntries());
		mTablature.setTabRanges(mTabPage->getRanges());
		mTabPage->isDirty(false);
	}
  returnCode=mTablature.saveProject();
	if(returnCode&&String(STRING_NOTITLE)==getTitle())setTitle(mTablature.getPathFileProject());
	return returnCode;
}

void ViewWindow::cut(void)
{
  mTabPage->cut();
}

void ViewWindow::copy(void)
{
  mTabPage->copy();
}

void ViewWindow::paste(void)
{
  mTabPage->paste();
}

void ViewWindow::setStartRange(void)
{  
  mTabPage->setStartRange();
}

void ViewWindow::setEndRange(void)
{
  PureMenu &pureMenu=getMenu();
  mTabPage->setEndRange();
  pureMenu.enableMenuItem(MENU_TABLATURE_PLAYRANGE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
  pureMenu.enableMenuItem(MENU_TABLATURE_PLAYRANGE_REPEATED,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
}

bool ViewWindow::getTabRanges(TabRanges &ranges)
{
  ranges.remove();
	ranges=mTabPage->getRanges();
	return ranges.size()?true:false;
}

void ViewWindow::setTabRanges(const TabRanges &ranges)
{
  PureMenu &pureMenu=getMenu();
  mTabPage->setRanges(ranges);
	if(ranges.size())
	{
	  pureMenu.enableMenuItem(MENU_TABLATURE_PLAYRANGE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
	  pureMenu.enableMenuItem(MENU_TABLATURE_PLAYRANGE_REPEATED,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
	}
	else
	{
	  pureMenu.enableMenuItem(MENU_TABLATURE_PLAYRANGE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
	  pureMenu.enableMenuItem(MENU_TABLATURE_PLAYRANGE_REPEATED,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
	}
}

*/
// thread handler

DWORD ViewWindow::threadHandler(ThreadMessage &threadMessage)
{
  switch(threadMessage.message())
	{
	  case ThreadMessage::TM_USER :
		  break;
//		  if(THPlay==threadMessage.userDataOne())thPlay();
//			else if(THPlayFromCurrent==threadMessage.userDataOne())thPlayFromCurrent();
//			else if(THPlayRange==threadMessage.userDataOne())thPlayRange(threadMessage.userDataTwo());
	}
  return 0;
}

/*
void ViewWindow::thPlayRange(int rangeIndex)
{
  ::OutputDebugString("[ViewWindow::thPlayRange] ENTER\n");
	ThreadPriority prevPriority=setThreadPriority(PureThread::ThreadPriorityHighest);
  mTabPage->playRange(rangeIndex);
	setThreadPriority(prevPriority);
  if(mTabPage->getCancelled())isInRepeatPlay(false);
  if(isInRepeatPlay())
	{
	  ::Sleep(RestBeforeRepeat);
    ThreadMessage thMessage(ThreadMessage::TM_USER,THPlayRange,rangeIndex);
	  MessageThread::postMessage(thMessage);
	}
	else 
	{
	  enablePlaySelect(true);
	}
  ::OutputDebugString("[ViewWindow::thPlayRange] LEAVE\n");
}

void ViewWindow::thPlay()
{
  ::OutputDebugString("[ViewWindow::thPlay] ENTER\n");
	ThreadPriority prevPriority=setThreadPriority(PureThread::ThreadPriorityHighest);
  mTabPage->play();
	setThreadPriority(prevPriority);
  if(mTabPage->getCancelled())isInRepeatPlay(false);
  if(isInRepeatPlay())
	{
	  ::Sleep(RestBeforeRepeat);
    ThreadMessage thMessage(ThreadMessage::TM_USER,THPlay);
	  MessageThread::postMessage(thMessage);
	}
	else 
	{
	  enablePlaySelect(true);
	}
  ::OutputDebugString("[ViewWindow::thPlay] LEAVE\n");
}

void ViewWindow::thPlayFromCurrent()
{
  ::OutputDebugString("[ViewWindow::thPlayFromCurrent] ENTER\n");
	ThreadPriority prevPriority=setThreadPriority(PureThread::ThreadPriorityHighest);
  mTabPage->playFromCurrent();
	setThreadPriority(prevPriority);
  enablePlaySelect(true);
  ::OutputDebugString("[ViewWindow::thPlayFromCurrent] LEAVE\n");
}
*/

// *** virtuals

void ViewWindow::preRegister(WNDCLASS &wndClass)
{
  wndClass.style|=CS_SAVEBITS|CS_OWNDC;
  wndClass.hbrBackground=(HBRUSH)::GetStockObject(WHITE_BRUSH);
	wndClass.hCursor=::LoadCursor(processInstance(),MAKEINTRESOURCE(HARROW));
}

void ViewWindow::preCreate(MDICREATESTRUCT &createStruct)
{
  createStruct.style=WS_SYSMENU|WS_CAPTION|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_CLIPCHILDREN|WS_CLIPSIBLINGS;
}