#include <common/purehdc.hpp>
#include <midiapp/musdlg.hpp>
#include <midiapp/mididef.hpp>
#include <midiapp/instrmnt.hpp>

char MUSDlg::szClassName[]={"MUSConverter"};
char MUSDlg::szMenuName[]={""};

MUSDlg::MUSDlg(Window &parentWindow,String midiPathFileName,String musPathFileName)
: MUSConverter(midiPathFileName,musPathFileName),
	mCommandHandler(this,&MUSDlg::commandHandler),
  mCreateHandler(this,&MUSDlg::createHandler),
	mDrawItemHandler(this,&MUSDlg::drawItemHandler),
	mPaintHandler(this,&MUSDlg::paintHandler),
	mDestroyHandler(this,&MUSDlg::destroyHandler),
	mCloseHandler(this,&MUSDlg::closeHandler),
  mControlColorHandler(this,&MUSDlg::controlColorHandler),
	mParentWindow(parentWindow), mlpLedTrackDisplay(0), mlpLedTempoDisplay(0),
	mOwnerDraw(OwnerDraw::UseInstance), mhButtonCvtWnd(0), mhButtonUpWnd(0),
	mhGrayBrush(::CreateSolidBrush(RGB(btnRed,btnGreen,btnBlue))),
	mhButtonDnWnd(0), mhListBoxWnd(0), mhStaticWnd(0),
	mLinkedBitmap(0,String("WND"),parentWindow.processInstance()),
	mOutputPathFileName(midiPathFileName)
{
	registerClass();
	insertHandlers();
}

MUSDlg::~MUSDlg()
{
	if(mlpLedTrackDisplay){delete mlpLedTrackDisplay;mlpLedTrackDisplay=0;}
	if(mlpLedTempoDisplay){delete mlpLedTempoDisplay;mlpLedTempoDisplay=0;}
	if(::IsWindow(mhButtonUpWnd))::DestroyWindow(mhButtonUpWnd);
	if(::IsWindow(mhButtonDnWnd))::DestroyWindow(mhButtonDnWnd);
  if(::IsWindow(mhButtonCvtWnd))::DestroyWindow(mhButtonCvtWnd);
	if(::IsWindow(mhListBoxWnd))::DestroyWindow(mhListBoxWnd);
  if(::IsWindow(mhStaticWnd))::DestroyWindow(mhStaticWnd);
  if(mhGrayBrush)::DeleteObject(mhGrayBrush);
	if((HWND)*this)destroy();
	removeHandlers();
}

void MUSDlg::registerClass(void)const
{
	WNDCLASS wndClass;

	if(::GetClassInfo(mParentWindow.processInstance(),szClassName,(WNDCLASS FAR*)&wndClass))return;
	wndClass.style         =CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS;
	wndClass.lpfnWndProc   =(WNDPROC)Window::WindowWndProc;
	wndClass.cbClsExtra    =0;
	wndClass.cbWndExtra    =sizeof(MUSDlg*);
	wndClass.hInstance     =mParentWindow.processInstance();
	wndClass.hIcon         =::LoadIcon(NULL,IDI_APPLICATION);
	wndClass.hCursor       =::LoadCursor(NULL,IDC_ARROW);
	wndClass.hbrBackground =(HBRUSH)::GetStockObject(LTGRAY_BRUSH);
	wndClass.lpszMenuName  =szMenuName;
	wndClass.lpszClassName =szClassName;
	::RegisterClass(&wndClass);
	assert(0!=::GetClassInfo(mParentWindow.processInstance(),szClassName,(WNDCLASS FAR*)&wndClass));
}

WORD MUSDlg::performDialog(void)
{
	createDialogControls();
  loadInstruments();
	while(::IsWindow((HWND)*this))yieldTask();
  return FALSE;
}

void MUSDlg::loadInstruments(void)
{
  Instruments midiInstruments(StartOrdinal,EndOrdinal);
	PureVector<PureInstrument> vectoredInstruments;
  String itemString;

	midiInstruments.getInstruments(vectoredInstruments);
  ::SendMessage(mhListBoxWnd,WM_SETREDRAW,FALSE,0L);
	for(int index=0;index<vectoredInstruments.size();index++)
	{
		itemString=vectoredInstruments[index].category();
		itemString+="-";
    itemString+=vectoredInstruments[index].name();
		::SendMessage(::GetDlgItem(*this,MUS_LISTBOX),LB_ADDSTRING,-1,(LPARAM)(LPSTR)itemString);
	}
	::SendMessage(mhListBoxWnd,WM_SETREDRAW,TRUE,0L);
}

void MUSDlg::insertHandlers(void)
{
	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
	insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
	insertHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler);
	insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
	insertHandler(VectorHandler::CloseHandler,&mCloseHandler);
  insertHandler(VectorHandler::ControlColorHandler,&mControlColorHandler);
}

void MUSDlg::removeHandlers(void)
{
	removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
	removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
	removeHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler);
	removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
  removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
	removeHandler(VectorHandler::CloseHandler,&mCloseHandler);
  removeHandler(VectorHandler::ControlColorHandler,&mControlColorHandler);
}

void MUSDlg::createDialogControls(void)
{
	String buttonString(STRING_BUTTONSTRING);
	String listboxString(STRING_LISTBOXSTRING);
  String staticString(STRING_STATICSTRING);

	PureDevice pureDevice;
	::CreateWindow(szClassName,szClassName,
		WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_CLIPCHILDREN,
		CW_USEDEFAULT,CW_USEDEFAULT,
		mLinkedBitmap.width(),mLinkedBitmap.height()+CaptionHeight,
		NULL,NULL,mParentWindow.processInstance(),(LPSTR)((MUSDlg*)this));
	mhButtonUpWnd=::CreateWindow(buttonString,"",BS_OWNERDRAW|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS,152,45,10,8,*this,(HMENU)MUS_TEMPOBUTTONUP,mParentWindow.processInstance(),0);
	mhButtonDnWnd=::CreateWindow(buttonString,"",BS_OWNERDRAW|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS,152,54,10,8,*this,(HMENU)MUS_TEMPOBUTTONDN,mParentWindow.processInstance(),0);
	mhButtonCvtWnd=::CreateWindow(buttonString,"",BS_OWNERDRAW|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS,167,17,15,15,*this,(HMENU)MUS_CVTBUTTON,mParentWindow.processInstance(),0);
	mhListBoxWnd=::CreateWindow(listboxString,"",LBS_NOTIFY|WS_VSCROLL|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS,19,130,280,62,*this,(HMENU)MUS_LISTBOX,mParentWindow.processInstance(),0);
	mhStaticWnd=::CreateWindow(staticString,"",WS_CHILD|WS_CLIPSIBLINGS,21,210,275,18,*this,(HMENU)MUS_STATIC,mParentWindow.processInstance(),0);
	show(SW_SHOW);update();
  ::ShowWindow(mhStaticWnd,SW_SHOW);
}

CallbackData::ReturnType MUSDlg::commandHandler(CallbackData &someCallbackData)
{
	switch(someCallbackData.wmCommandID())
	{
		case MUS_TEMPOBUTTONUP :
			handleTempoUpEvent();
			break;
		case MUS_TEMPOBUTTONDN :
      handleTempoDnEvent();
			break;
		case MUS_CVTBUTTON :
			::PostMessage(*this,WM_COMMAND,MUS_CONVERTFILE,0L);
			return FALSE;
		case MUS_CONVERTFILE :
      handleConvertFileEvent();
			break;
		case IDCANCEL :
      destroy();
			break;
  }
  return (CallbackData::ReturnType)FALSE;
}

void MUSDlg::handleTempoUpEvent(void)
{
	setTempo(getTempo()+1);
  mlpLedTempoDisplay->setNumber(getTempo());
}

void MUSDlg::handleTempoDnEvent(void)
{
	setTempo(getTempo()-1);
  mlpLedTempoDisplay->setNumber(getTempo());
}

void MUSDlg::handleConvertFileEvent(void)
{
	String convertMessageString("writing ");

  convertMessageString+=mOutputPathFileName;
	setMessage(convertMessageString);
	if(!convertFile())setMessage("Error converting file...");
  else setMessage("Complete...");
}

CallbackData::ReturnType MUSDlg::createHandler(CallbackData &/*someCallbackData*/)
{
	mOwnerDraw.associate(MUS_TEMPOBUTTONUP,String(STRING_BITMAPUPARUP),String(STRING_BITMAPUPARUP),String(STRING_BITMAPUPARDN),OwnerDraw::NOFOCUS);
	mOwnerDraw.associate(MUS_TEMPOBUTTONDN,String(STRING_BITMAPDNARUP),String(STRING_BITMAPDNARUP),String(STRING_BITMAPDNARDN),OwnerDraw::NOFOCUS);
	mOwnerDraw.associate(MUS_CVTBUTTON,String(STRING_BITMAPCNVTUP),String(STRING_BITMAPCNVTUP),String(STRING_BITMAPCNVTDN),OwnerDraw::NOFOCUS);
	mlpLedTrackDisplay=new LedDisplay(*this,Point(xTrack,yTrack));
	mlpLedTempoDisplay=new LedDisplay(*this,Point(xTempo,yTempo));
  mlpLedTempoDisplay->setNumber(getTempo());
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MUSDlg::destroyHandler(CallbackData &/*someCallbackData*/)
{
	mOwnerDraw.freeBitmap(MUS_TEMPOBUTTONUP);
	mOwnerDraw.freeBitmap(MUS_TEMPOBUTTONDN);
	mOwnerDraw.freeBitmap(MUS_CVTBUTTON);
	return (CallbackData::ReturnType)FALSE;  
}

CallbackData::ReturnType MUSDlg::closeHandler(CallbackData &/*someCallbackData*/)
{
  destroy();
	return (CallbackData::ReturnType)FALSE;  
}

CallbackData::ReturnType MUSDlg::controlColorHandler(CallbackData &someCallbackData)
{
	::SetBkColor((HDC)someCallbackData.wParam(),RGB(btnRed,btnGreen,btnBlue));
	return (CallbackData::ReturnType)mhGrayBrush;
}

CallbackData::ReturnType MUSDlg::drawItemHandler(CallbackData &someCallbackData)
{
	if(MUS_TEMPOBUTTONUP==((LPDRAWITEMSTRUCT)someCallbackData.lParam())->CtlID)
		mOwnerDraw.handleOwnerButton(MUS_TEMPOBUTTONUP,someCallbackData.lParam());
	else if(MUS_TEMPOBUTTONDN==((LPDRAWITEMSTRUCT)someCallbackData.lParam())->CtlID)
		mOwnerDraw.handleOwnerButton(MUS_TEMPOBUTTONDN,someCallbackData.lParam());
	else if(MUS_CVTBUTTON==((LPDRAWITEMSTRUCT)someCallbackData.lParam())->CtlID)
		mOwnerDraw.handleOwnerButton(MUS_CVTBUTTON,someCallbackData.lParam());
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MUSDlg::paintHandler(CallbackData &someCallbackData)
{
	RECT windowRect;

	PaintInformation *lpPaintInformation((PaintInformation*)someCallbackData.lParam());
	::SetRect(&windowRect,0,0,mLinkedBitmap.width(),mLinkedBitmap.height()+CaptionHeight);
	mLinkedBitmap.drawBitmap((PureDevice)(*lpPaintInformation),windowRect);
	if(mlpLedTrackDisplay)mlpLedTrackDisplay->paint();
  if(mlpLedTempoDisplay)mlpLedTempoDisplay->paint();
	return (CallbackData::ReturnType)0;
}

void MUSDlg::yieldTask(void)const
{
	MSG msg;

	while(::IsWindow((HWND)*this)&&::PeekMessage(&msg,0,0,0,PM_REMOVE))
	{::TranslateMessage(&msg);::DispatchMessage(&msg);}
}

WORD MUSDlg::handleScoreStart(void)
{
  return MUSConverter::handleScoreStart();
}

WORD MUSDlg::handleReleaseNote(PureEvent &pureEvent,PureDelay &pureDelay,PureNote &releaseNote,BYTE trackNumber)
{
	if(trackNumber!=mlpLedTrackDisplay->getNumber())
		mlpLedTrackDisplay->setNumber(trackNumber);
	return MUSConverter::handleReleaseNote(pureEvent,pureDelay,releaseNote,trackNumber);
}

WORD MUSDlg::handlePlayNote(PureEvent &pureEvent,PureDelay &pureDelay,PureNote &playNote,BYTE trackNumber)
{
	if(trackNumber!=mlpLedTrackDisplay->getNumber())
		mlpLedTrackDisplay->setNumber(trackNumber);
	return MUSConverter::handlePlayNote(pureEvent,pureDelay,playNote,trackNumber);
}

WORD MUSDlg::handlePitchBend(PureEvent &pureEvent,PureDelay &pureDelay,BYTE pitchBenderValue,BYTE trackNumber)
{
	if(trackNumber!=mlpLedTrackDisplay->getNumber())
		mlpLedTrackDisplay->setNumber(trackNumber);
	return MUSConverter::handlePitchBend(pureEvent,pureDelay,pitchBenderValue,trackNumber);
}

WORD MUSDlg::handleReset(PureEvent &pureEvent,PureDelay &pureDelay,BYTE tempoValue,BYTE trackNumber)
{
	if(trackNumber!=mlpLedTrackDisplay->getNumber())
		mlpLedTrackDisplay->setNumber(trackNumber);
	return MUSConverter::handleReset(pureEvent,pureDelay,tempoValue,trackNumber);
}

WORD MUSDlg::handleController(PureEvent &pureEvent,PureDelay &pureDelay,PureController &pureController,BYTE trackNumber)
{
	if(trackNumber!=mlpLedTrackDisplay->getNumber())
		mlpLedTrackDisplay->setNumber(trackNumber);
	return MUSConverter::handleController(pureEvent,pureDelay,pureController,trackNumber);
}

WORD MUSDlg::handleScoreEnd(PureDelay &pureDelay)
{
	return MUSConverter::handleScoreEnd(pureDelay);
}