#include <guitar/SettingsDlg.hpp>
#include <guitar/registry.hpp>
#include <guitar/GlobalDefs.hpp>
#include <guitar/Timing.hpp>
#include <guitar/guitar.hpp>
#include <midiseq/midiout.hpp>

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

SettingsDialog::SettingsDialog(const SettingsDialog &someSettingsDialog)
{ // private implementation
  *this=someSettingsDialog;
}

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

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

bool SettingsDialog::perform(GUIWindow &parentWindow)
{
	Rect clientRect;
  parentWindow.clientRect(clientRect);
	mDisplayPoint.x((clientRect.right()-clientRect.left())/2);
	mDisplayPoint.y((clientRect.bottom()-clientRect.top())/2);
	return ::DialogBoxParam(processInstance(),(LPSTR)"SETTINGSDIALOG",(HWND)parentWindow,DWindow::DlgProc,(LPARAM)(DWindow*)this);
}

CallbackData::ReturnType SettingsDialog::initHandler(CallbackData &someCallbackData)
{
  mDisplayPoint.x(mDisplayPoint.x()-(width()/2));
  mDisplayPoint.y(mDisplayPoint.y()-(height()/2));
  move(mDisplayPoint);
	initialize();
  return (CallbackData::ReturnType)false;
}

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

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

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

CallbackData::ReturnType SettingsDialog::commandHandler(CallbackData &someCallbackData)
{
  switch(someCallbackData.wmCommandID())
	{
    case IDCANCEL :
			endDialog(false);
      break;
		case IDOK :
		  apply();
			break;
		case SETTINGS_DEFAULTS :
		  selectDefaults();
	}
	if(someCallbackData.wmCommandCommand()==BN_CLICKED)
	{
	  handleInstrumentSelect(someCallbackData);
	}
  return (CallbackData::ReturnType)FALSE;
}

void SettingsDialog::initialize(void)
{
  Registry registry;

  selectTiming(registry.getMicrosecondsPerQuarterNote());
	selectInstrument(registry.getInstrument());
	selectAction(registry.getShowAction());
	selectShowNotes(registry.getShowNotes());
	selectMIDIOutputDevice(registry.getMIDIOutputDevice());
}

void SettingsDialog::handleInstrumentSelect(CallbackData &someCallbackData)
{
  switch(someCallbackData.wmCommandID())
	{
	  case SETTINGS_ACOUSTICGRANDPIANO :
		  selectInstrument(AcousticGrandPiano);
			break;
		case SETTINGS_BRIGHTACOUSTICPIANO :
		  selectInstrument(BrightAcousticPiano);
			break;
		case SETTINGS_ELECTRICGRANDPIANO :
		  selectInstrument(ElectricGrandPiano);
			break;
	  case SETTINGS_ACOUSTICNYLON :
		  selectInstrument(AcousticGuitarNylon);
			break;
		case SETTINGS_ACOUSTICSTEEL :
		  selectInstrument(AcousticGuitarSteel);
			break;
		case SETTINGS_JAZZELECTRIC :
		  selectInstrument(JazzGuitarElectric);
			break;
		case SETTINGS_CLEANELECTRIC :
		  selectInstrument(CleanGuitarElectric);
			break;
		case SETTINGS_MUTEDELECTRIC :
		  selectInstrument(MutedGuitarElectric);
		  break;
		default :
		  break;
	}
}

void SettingsDialog::selectInstrument(Instrument instrument)
{
  if(AcousticGrandPiano==instrument)sendMessage(SETTINGS_ACOUSTICGRANDPIANO,BM_SETCHECK,1,0);
	else sendMessage(SETTINGS_ACOUSTICGRANDPIANO,BM_SETCHECK,0,0);
	if(BrightAcousticPiano==instrument)sendMessage(SETTINGS_BRIGHTACOUSTICPIANO,BM_SETCHECK,1,0);
	else sendMessage(SETTINGS_BRIGHTACOUSTICPIANO,BM_SETCHECK,0,0);
	if(ElectricGrandPiano==instrument)sendMessage(SETTINGS_ELECTRICGRANDPIANO,BM_SETCHECK,1,0);
	else sendMessage(SETTINGS_ELECTRICGRANDPIANO,BM_SETCHECK,0,0);
	if(AcousticGuitarNylon==instrument)sendMessage(SETTINGS_ACOUSTICNYLON,BM_SETCHECK,1,0);
	else sendMessage(SETTINGS_ACOUSTICNYLON,BM_SETCHECK,0,0);
	if(AcousticGuitarSteel==instrument)sendMessage(SETTINGS_ACOUSTICSTEEL,BM_SETCHECK,1,0);
	else sendMessage(SETTINGS_ACOUSTICSTEEL,BM_SETCHECK,0,0);
	if(JazzGuitarElectric==instrument)sendMessage(SETTINGS_JAZZELECTRIC,BM_SETCHECK,1,0);
	else sendMessage(SETTINGS_JAZZELECTRIC,BM_SETCHECK,0,0);
	if(CleanGuitarElectric==instrument)sendMessage(SETTINGS_CLEANELECTRIC,BM_SETCHECK,1,0);
	else sendMessage(SETTINGS_CLEANELECTRIC,BM_SETCHECK,0,0);
	if(MutedGuitarElectric==instrument)sendMessage(SETTINGS_MUTEDELECTRIC,BM_SETCHECK,1,0);
	else sendMessage(SETTINGS_MUTEDELECTRIC,BM_SETCHECK,0,0);
}

Instrument SettingsDialog::getInstrument(void)
{
  if(sendMessage(SETTINGS_ACOUSTICGRANDPIANO,BM_GETCHECK,0,0))return AcousticGrandPiano; 
  if(sendMessage(SETTINGS_BRIGHTACOUSTICPIANO,BM_GETCHECK,0,0))return BrightAcousticPiano;
  if(sendMessage(SETTINGS_ELECTRICGRANDPIANO,BM_GETCHECK,0,0))return ElectricGrandPiano; 
  if(sendMessage(SETTINGS_ACOUSTICNYLON,BM_GETCHECK,0,0))return AcousticGuitarNylon;
  if(sendMessage(SETTINGS_ACOUSTICSTEEL,BM_GETCHECK,0,0))return AcousticGuitarSteel;
  if(sendMessage(SETTINGS_JAZZELECTRIC,BM_GETCHECK,0,0))return JazzGuitarElectric;
  if(sendMessage(SETTINGS_CLEANELECTRIC,BM_GETCHECK,0,0))return CleanGuitarElectric;
  if(sendMessage(SETTINGS_MUTEDELECTRIC,BM_GETCHECK,0,0))return MutedGuitarElectric;
	return Instrument(GlobalDefs::Program);
}

bool SettingsDialog::getAction(void)
{
  return sendMessage(SETTINGS_SHOWACTION,BM_GETCHECK,0,0);
}

bool SettingsDialog::getShowNotes(void)
{
  return sendMessage(SETTINGS_SHOWNOTES,BM_GETCHECK,0,0);
}

int SettingsDialog::getTiming(void)
{
  String strText;

	getText(SETTINGS_MICROSECSPERQTRNOTE,strText);
	return strText.toInt();
}

String SettingsDialog::getMIDIOutputDevice(void)
{
  int currentSelection;
	String midiOutputDevice;

	currentSelection=sendMessage(SETTINGS_MIDIOUT,CB_GETCURSEL,0,0L);
	sendMessage(SETTINGS_MIDIOUT,CB_GETLBTEXT,currentSelection,(LPARAM)midiOutputDevice.str());
	return midiOutputDevice;
}

void SettingsDialog::selectDefaults()
{
  selectInstrument(Instrument(GlobalDefs::Program));
	selectTiming(GlobalDefs::MicrosecondsPerQuarterNote);
	selectAction(GlobalDefs::ShowAction);
	selectShowNotes(GlobalDefs::ShowNotes);
}

void SettingsDialog::selectTiming(int timing)
{
	setText(SETTINGS_MICROSECSPERQTRNOTE,String().fromInt(timing));
}

void SettingsDialog::selectAction(bool action)
{
	sendMessage(SETTINGS_SHOWACTION,BM_SETCHECK,action,0);
}

void SettingsDialog::selectShowNotes(bool showNotes)
{
  sendMessage(SETTINGS_SHOWNOTES,BM_SETCHECK,showNotes,0);
}

void SettingsDialog::selectMIDIOutputDevice(const String &midiOutputDeviceName)
{
  Block<String> deviceNames;
	int currentSelection=-1;

	MIDIOutputDevice::getDeviceNames(deviceNames);
	sendMessage(SETTINGS_MIDIOUT,CB_RESETCONTENT,0,0L);
	deviceNames.insert(&String("MIDIMAPPER"));
	for(int index=0;index<deviceNames.size();index++)
	{
	  sendMessage(SETTINGS_MIDIOUT,CB_ADDSTRING,0,(LPARAM)deviceNames[index].str());
		if(midiOutputDeviceName==deviceNames[index])currentSelection=index;
	}
	if(-1==currentSelection)currentSelection=0;
	sendMessage(SETTINGS_MIDIOUT,CB_SETCURSEL,currentSelection,0L);
}

void SettingsDialog::apply()
{
  Registry registry;
	int microsecondsPerQuarterNote;

	microsecondsPerQuarterNote=getTiming();
	registry.setShowAction(getAction());
	registry.setMicrosecondsPerQuarterNote(microsecondsPerQuarterNote);
	registry.setInstrument(getInstrument());
	Timing::microsecondsPerQuarterNote(microsecondsPerQuarterNote);
	registry.setShowNotes(getShowNotes());
	registry.setMIDIOutputDevice(getMIDIOutputDevice());
}