#include <guitar/scaledlg.hpp>
#include <guitar/guitar.hpp>
#include <guitar/GlobalDefs.hpp>
#include <guitar/Fingering.hpp>
#include <music/scales.hpp>
#include <common/puredwrd.hpp>
#include <common/commctrl.hpp>
#include <common/richedit.hpp>

ScaleDialog::ScaleDialog(void)
: mInEdit(false)
{
  mInitHandler.setCallback(this,&ScaleDialog::initHandler);
	mCreateHandler.setCallback(this,&ScaleDialog::createHandler);
	mCloseHandler.setCallback(this,&ScaleDialog::closeHandler);
	mDestroyHandler.setCallback(this,&ScaleDialog::destroyHandler);
	mCommandHandler.setCallback(this,&ScaleDialog::commandHandler);
	insertHandler(VectorHandler::InitDialogHandler,&mInitHandler);
	insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
	insertHandler(VectorHandler::CloseHandler,&mCloseHandler);
	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
}

ScaleDialog::ScaleDialog(const ScaleDialog &someScaleDialog)
{ // private implementation
  *this=someScaleDialog;
}

ScaleDialog::~ScaleDialog()
{
	removeHandler(VectorHandler::InitDialogHandler,&mInitHandler);
	removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
	removeHandler(VectorHandler::CloseHandler,&mCloseHandler);
	removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
}

ScaleDialog &ScaleDialog::operator=(const ScaleDialog &someScaleDialog)
{ // private implementation
  return *this;
}

bool ScaleDialog::perform(GUIWindow &parentWindow,CallbackPointer &callbackPointer)
{
  mPlayNoteHandler=callbackPointer;
	return ::DialogBoxParam(processInstance(),(LPSTR)"ScaleDialog",(HWND)parentWindow,DWindow::DlgProc,(LPARAM)(DWindow*)this);
}

CallbackData::ReturnType ScaleDialog::initHandler(CallbackData &someCallbackData)
{
  GDIPoint cursorPoint;

	mMIDIDevice=::new Sequencer();
	mMIDIDevice.disposition(PointerDisposition::Delete);
	::GetCursorPos(&cursorPoint.getPOINT());
	move(cursorPoint);
  mScaleList=::new OwnerDrawListAltColor(*this,getItem(SCALEDLG_LIST),SCALEDLG_LIST);
	mScaleList.disposition(PointerDisposition::Delete);
  mScaleList->addString("Ionian");
  mScaleList->addString("Dorian");
  mScaleList->addString("Phrygian");
  mScaleList->addString("Lydian");
  mScaleList->addString("Mixolydian");
  mScaleList->addString("Aeolian");
  mScaleList->addString("Locrian");
  mScaleList->addString("Pentatonic Minor");
  mScaleList->addString("Harmonic Minor");
  mScaleList->addString("Melodic Minor");
  mScaleList->addString("Dorian-II");
  mScaleList->addString("Lydian Augmented");
  mScaleList->addString("Lydian Dominant");
  mScaleList->addString("Half Diminished");
  mScaleList->addString("Diminished Whole Tone");
	sendMessage(SCALEDLG_SPIN,UDM_SETRANGE,0,(LPARAM)MAKELONG(11,0));
	sendMessage(SCALEDLG_SPIN,UDM_SETBUDDY,(WPARAM)getItem(SCALEDLG_ROOT),0L);
	sendMessage(SCALEDLG_SPIN,UDM_SETPOS,0,0L);
  setText(SCALEDLG_ROOT,"A");
  mScaleList->setCurrent(0);
	showScale();
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType ScaleDialog::createHandler(CallbackData &someCallbackData)
{
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType ScaleDialog::closeHandler(CallbackData &someCallbackData)
{
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType ScaleDialog::destroyHandler(CallbackData &someCallbackData)
{
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType ScaleDialog::commandHandler(CallbackData &someCallbackData)
{
  switch(someCallbackData.wmCommandID())
	{
    case IDCANCEL :
			endDialog(false);
      break;
		case IDOK :
		  handleOk();
			endDialog(true);
			break;
		case SCALEDLG_SPIN :
		  break;
		case SCALEDLG_ROOT :
      handleRoot();
			break;
		case SCALEDLG_LIST :
		  handleList();
		  break;
	}
  return (CallbackData::ReturnType)FALSE;
}

void ScaleDialog::handleOk(void)
{
}

void ScaleDialog::handleRoot(void)
{
	String strRoot;

  if(mInEdit)return;
	mInEdit=true;
	getText(SCALEDLG_ROOT,strRoot);
	strRoot.upper();
	if(strRoot=="0")setText(SCALEDLG_ROOT,"A");
	else if(strRoot=="1")setText(SCALEDLG_ROOT,"A#");
	else if(strRoot=="2")setText(SCALEDLG_ROOT,"B");
	else if(strRoot=="3")setText(SCALEDLG_ROOT,"C");
	else if(strRoot=="4")setText(SCALEDLG_ROOT,"C#");
	else if(strRoot=="5")setText(SCALEDLG_ROOT,"D");
	else if(strRoot=="6")setText(SCALEDLG_ROOT,"D#");
	else if(strRoot=="7")setText(SCALEDLG_ROOT,"E");
	else if(strRoot=="8")setText(SCALEDLG_ROOT,"F");
	else if(strRoot=="9")setText(SCALEDLG_ROOT,"F#");
	else if(strRoot=="10")setText(SCALEDLG_ROOT,"G");
	else if(strRoot=="11")setText(SCALEDLG_ROOT,"G#");
  if(!showScale())setText(SCALEDLG_ROOT,"A");
	mInEdit=false;
}

void ScaleDialog::handleList(void)
{
  showScale();
}

bool ScaleDialog::showScale(void)
{
  String strScale;
	String strRoot;
  DWORD current;

	current=mScaleList->getCurrent();
	getText(SCALEDLG_ROOT,strRoot);
	if(Note::None==Note::getNoteType(strRoot))return false;
	mScaleList->getText(strScale,current);
	showScale(strRoot,strScale);
	return true;
}

void ScaleDialog::showScale(const String &root,const String &scale)
{
	if(scale=="Ionian")
	{
	  IonianScale ionianScale(Note::getNoteType(root));
		showScale(ionianScale);
	}
	else if(scale=="Dorian")
	{
	  DorianScale dorianScale(Note::getNoteType(root));
		showScale(dorianScale);
	}
	else if(scale=="Phrygian")
	{
	  PhrygianScale phrygianScale(Note::getNoteType(root));
		showScale(phrygianScale);
	}
	else if(scale=="Lydian")
	{
	  LydianScale lydianScale(Note::getNoteType(root));
		showScale(lydianScale);
	}
	else if(scale=="Mixolydian")
	{
	  MixolydianScale mixolydianScale(Note::getNoteType(root));
		showScale(mixolydianScale);
	}
	else if(scale=="Aeolian")
	{
	  AeolianScale aeolianScale(Note::getNoteType(root));
		showScale(aeolianScale);
	}
	else if(scale=="Locrian")
	{
	  LocrianScale locrianScale(Note::getNoteType(root));
		showScale(locrianScale);
	}
	else if(scale=="Pentatonic Minor")
	{
	  PentatonicMinorScale pentatonicMinorScale(Note::getNoteType(root));
		showScale(pentatonicMinorScale);
	}
	else if(scale=="Harmonic Minor")
	{
	  HarmonicMinorScale harmonicMinorScale(Note::getNoteType(root));
		showScale(harmonicMinorScale);
	}
	else if(scale=="Melodic Minor")
	{
	  MelodicMinorScale melodicMinorScale(Note::getNoteType(root));
		showScale(melodicMinorScale);
	}
	else if(scale=="Dorian-II")
	{
	  DorianIIScale dorianIIScale(Note::getNoteType(root));
		showScale(dorianIIScale);
	}
	else if(scale=="Lydian Augmented")
	{
	  LydianAugmentedScale lydianAugmentedScale(Note::getNoteType(root));
		showScale(lydianAugmentedScale);
	}
	else if(scale=="Lydian Dominant")
	{
	  LydianDominantScale lydianDominantScale(Note::getNoteType(root));
		showScale(lydianDominantScale);
	}
	else if(scale=="Half Diminished")
	{
	  HalfDiminishedScale halfDiminishedScale(Note::getNoteType(root));
		showScale(halfDiminishedScale);
	}
	else if(scale=="Diminished Whole Tone")
	{
	  DiminishedWholeToneScale diminishedWholeToneScale(Note::getNoteType(root));
		showScale(diminishedWholeToneScale);
	}
}

void ScaleDialog::showScale(const Scale &scale)
{
  CallbackData cbData(2,(LPARAM)&scale);
  mPlayNoteHandler.callback(cbData);
//  if(!mMIDIDevice->getDevice().hasDevice())mMIDIDevice->getDevice().openDevice(); 
//	scale.play(mMIDIDevice->getDevice());
}