#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mdiwin/windowsx.hpp>
#include <mdiwin/string.hpp>
#include <mdiwin/process.hpp>
#include <mdiwin/main.hpp>
#include <mdiwin/average.hpp>
#include <mdiwin/mdiwin.h>

Process *Process::smCurrInstance=0;

Process::Process(HPALETTE hPalette,UHUGE *hpImage,WORD width,WORD height)
: mIsConstructed(FALSE), mhPalette(hPalette), mhpImage(hpImage), mWidth(width),
	mHeight(height), mCurrentSelection(FALSE), mIsInThread(TRUE)
{
	if(smCurrInstance)return;
	smCurrInstance=this;
	mIsConstructed=TRUE;
}

Process::~Process()
{
}

WORD Process::showProcess(HWND hParent,char *imageName)
{
  WORD retCode;
	DLGPROC lpfnDlgProc;
	HINSTANCE hInstance;

	if(!mIsConstructed)return FALSE;
	::strcpy(mImageName,imageName);
	buildMatrices();
#if defined(__FLAT__)
	hInstance=(HINSTANCE)::GetWindowLong(hParent,GWL_HINSTANCE);
#else
	hInstance=(HINSTANCE)::GetWindowWord(hParent,GWW_HINSTANCE);
#endif
	lpfnDlgProc=(DLGPROC)MakeProcInstance((FARPROC)ProcessDlgProc,hInstance);
	retCode=DialogBox(hInstance,"Processing",hParent,lpfnDlgProc);
	FreeProcInstance((FARPROC)lpfnDlgProc);
	smCurrInstance=0;
	if(!retCode)return FALSE;
	switch(mCurrentSelection)
	{
		case IP_HIGHPASS :
    {
			Average averageImage(mImageName,mhPalette,mhpImage,mWidth,mHeight,&mIsInThread);
			averageImage.processImage(mAveragingMatrixUse,Average::RangeClipping);
    }
			return TRUE;
		case IP_LOWPASS :
		case IP_AVERAGING :
    {
			Average averageImage(mImageName,mhPalette,mhpImage,mWidth,mHeight,&mIsInThread);
			averageImage.processImage(mAveragingMatrixUse,Average::Normalization);
		}
			return TRUE;
		case IP_SOBEL :
      break;
		case IP_SMOOTHED :
      break;
		case IP_LAPLACE :
      break;
		case IP_ISOTROPIC :
      break;
		case IP_STOCHASTIC :
      break;
	}
	return FALSE;
}

int FAR PASCAL Process::ProcessDlgProc(HWND hWnd,WORD message,WPARAM wParam,LPARAM lParam)
{
	if(WM_INITDIALOG==message)smCurrInstance->SetHandle(hWnd);
	return smCurrInstance->ProcessProc(message,wParam,lParam);
}

void Process::buildMatrices(void)
{
	mAveragingMatrixOne.insert(&Integer(1));
	mAveragingMatrixOne.insert(&Integer(1));
	mAveragingMatrixOne.insert(&Integer(1));
	mAveragingMatrixOne.insert(&Integer(1));
	mAveragingMatrixOne.insert(&Integer(0));
	mAveragingMatrixOne.insert(&Integer(1));
	mAveragingMatrixOne.insert(&Integer(1));
	mAveragingMatrixOne.insert(&Integer(1));
	mAveragingMatrixOne.insert(&Integer(1));

	mAveragingMatrixTwo.insert(&Integer(1));
	mAveragingMatrixTwo.insert(&Integer(1));
	mAveragingMatrixTwo.insert(&Integer(1));
	mAveragingMatrixTwo.insert(&Integer(1));
	mAveragingMatrixTwo.insert(&Integer(1));
	mAveragingMatrixTwo.insert(&Integer(1));
	mAveragingMatrixTwo.insert(&Integer(1));
	mAveragingMatrixTwo.insert(&Integer(1));
	mAveragingMatrixTwo.insert(&Integer(1));

	mAveragingMatrixThree.insert(&Integer(1));
	mAveragingMatrixThree.insert(&Integer(1));
	mAveragingMatrixThree.insert(&Integer(1));
	mAveragingMatrixThree.insert(&Integer(1));
	mAveragingMatrixThree.insert(&Integer(4));
	mAveragingMatrixThree.insert(&Integer(1));
	mAveragingMatrixThree.insert(&Integer(1));
	mAveragingMatrixThree.insert(&Integer(1));
	mAveragingMatrixThree.insert(&Integer(1));

	mAveragingMatrixFour.insert(&Integer(1));
	mAveragingMatrixFour.insert(&Integer(1));
	mAveragingMatrixFour.insert(&Integer(1));
	mAveragingMatrixFour.insert(&Integer(1));
	mAveragingMatrixFour.insert(&Integer(8));
	mAveragingMatrixFour.insert(&Integer(1));
	mAveragingMatrixFour.insert(&Integer(1));
	mAveragingMatrixFour.insert(&Integer(1));
	mAveragingMatrixFour.insert(&Integer(1));

	mLowPassMatrix.insert(&Integer(1));
	mLowPassMatrix.insert(&Integer(2));
	mLowPassMatrix.insert(&Integer(1));
	mLowPassMatrix.insert(&Integer(2));
	mLowPassMatrix.insert(&Integer(4));
	mLowPassMatrix.insert(&Integer(2));
	mLowPassMatrix.insert(&Integer(1));
	mLowPassMatrix.insert(&Integer(2));
	mLowPassMatrix.insert(&Integer(1));

	mHighPassMatrixOne.insert(&Integer(-1));
	mHighPassMatrixOne.insert(&Integer(-2));
	mHighPassMatrixOne.insert(&Integer(-1));
	mHighPassMatrixOne.insert(&Integer(-2));
	mHighPassMatrixOne.insert(&Integer(12));
	mHighPassMatrixOne.insert(&Integer(-2));
	mHighPassMatrixOne.insert(&Integer(-1));
	mHighPassMatrixOne.insert(&Integer(-2));
	mHighPassMatrixOne.insert(&Integer(-1));

	mHighPassMatrixTwo.insert(&Integer(-1));
	mHighPassMatrixTwo.insert(&Integer(-2));
	mHighPassMatrixTwo.insert(&Integer(-1));
	mHighPassMatrixTwo.insert(&Integer(-2));
	mHighPassMatrixTwo.insert(&Integer(16));
	mHighPassMatrixTwo.insert(&Integer(-2));
	mHighPassMatrixTwo.insert(&Integer(-1));
	mHighPassMatrixTwo.insert(&Integer(-2));
	mHighPassMatrixTwo.insert(&Integer(-1));

	mHighPassMatrixThree.insert(&Integer(-1));
	mHighPassMatrixThree.insert(&Integer(-3));
	mHighPassMatrixThree.insert(&Integer(-1));
	mHighPassMatrixThree.insert(&Integer(-3));
	mHighPassMatrixThree.insert(&Integer(16));
	mHighPassMatrixThree.insert(&Integer(-3));
	mHighPassMatrixThree.insert(&Integer(-1));
	mHighPassMatrixThree.insert(&Integer(-3));
	mHighPassMatrixThree.insert(&Integer(-1));

	mHighPassMatrixFour.insert(&Integer(-2));
	mHighPassMatrixFour.insert(&Integer(-3));
	mHighPassMatrixFour.insert(&Integer(-2));
	mHighPassMatrixFour.insert(&Integer(-3));
	mHighPassMatrixFour.insert(&Integer(20));
	mHighPassMatrixFour.insert(&Integer(-3));
	mHighPassMatrixFour.insert(&Integer(-2));
	mHighPassMatrixFour.insert(&Integer(-3));
	mHighPassMatrixFour.insert(&Integer(-2));
}

int Process::ProcessProc(WORD message,WPARAM wParam,LPARAM lParam)
{
	switch(message)
	{
		case WM_INITDIALOG :
			Main::smhBitmap.associate(IDOK,
			  String(STRING_BITMAPOKFOCUSUP,Main::processInstance()),
			  String(STRING_BITMAPOKNOFUP,Main::processInstance()),
			  String(STRING_BITMAPOKFOCUSDN,Main::processInstance()),
			  OwnerDraw::NOFOCUS);
			Main::smhBitmap.associate(IDCANCEL,
			  String(STRING_BITMAPCAFOCUSUP,Main::processInstance()),
			  String(STRING_BITMAPCANOFUP,Main::processInstance()),
			  String(STRING_BITMAPCAFOCUSDN,Main::processInstance()),
			  OwnerDraw::NOFOCUS);
			::SendDlgItemMessage(GetHandle(),IP_AVERAGING,BM_SETCHECK,TRUE,0L);
			setMatrix(mAveragingMatrixOne);
			mCurrentAveragingMatrix=0;
			return TRUE;
	  case WM_DRAWITEM :
      switch(((LPDRAWITEMSTRUCT)lParam)->CtlID)
	    {
	case IDOK :
		Main::smhBitmap.handleOwnerButton(IDOK,lParam);
		return TRUE;
	case IDCANCEL :
		Main::smhBitmap.handleOwnerButton(IDCANCEL,lParam);
	  return TRUE;
      }
			return TRUE;
		case WM_COMMAND :
			switch(GET_WM_COMMAND_ID(wParam,lParam))
			{
				case IP_AVERAGING :
	  {
					  LRESULT checkState;

						checkState=::SendDlgItemMessage(GetHandle(),IP_AVERAGING,BM_GETCHECK,0,0L);
						if(!checkState)
	    {
							uncheckControls();
							mCurrentAveragingMatrix=0;
							setMatrix(mAveragingMatrixOne);
						  ::SendDlgItemMessage(GetHandle(),IP_AVERAGING,BM_SETCHECK,TRUE,0L);
						}
						else
						{
							if(++mCurrentAveragingMatrix>GreatestAveragingMatrixIndex)
								mCurrentAveragingMatrix=0;
							switch(mCurrentAveragingMatrix)
							{
								case 0 :
									setMatrix(mAveragingMatrixOne);
									break;
								case 1 :
									setMatrix(mAveragingMatrixTwo);
									break;
								case 2 :
									setMatrix(mAveragingMatrixThree);
									break;
								case 3 :
									setMatrix(mAveragingMatrixFour);
									break;
							}
						}
					}
					return TRUE;
				case IP_LOWPASS :
					{
					  LRESULT checkState;

						checkState=::SendDlgItemMessage(GetHandle(),IP_LOWPASS,BM_GETCHECK,0,0L);
						if(!checkState)
		 {
							uncheckControls();
							setMatrix(mLowPassMatrix);
						  ::SendDlgItemMessage(GetHandle(),IP_LOWPASS,BM_SETCHECK,TRUE,0L);
						}
					}
					return TRUE;
				case IP_HIGHPASS :
	  {
					  LRESULT checkState;

						checkState=::SendDlgItemMessage(GetHandle(),IP_HIGHPASS,BM_GETCHECK,0,0L);
						if(!checkState)
		 {
							uncheckControls();
							mCurrentHighPassMatrix=0;
							setMatrix(mHighPassMatrixOne);
							::SendDlgItemMessage(GetHandle(),IP_HIGHPASS,BM_SETCHECK,TRUE,0L);
						}
						else
						{
							if(++mCurrentHighPassMatrix>GreatestHighPassMatrixIndex)
								mCurrentHighPassMatrix=0;
							switch(mCurrentHighPassMatrix)
							{
								case 0 :
									setMatrix(mHighPassMatrixOne);
									break;
								case 1 :
									setMatrix(mHighPassMatrixTwo);
									break;
								case 2 :
									setMatrix(mHighPassMatrixThree);
									break;
								case 3 :
									setMatrix(mHighPassMatrixFour);
									break;
							}
						}
					}
					return TRUE;
				case IP_SOBEL :
					{
					  LRESULT checkState;

						checkState=::SendDlgItemMessage(GetHandle(),IP_SOBEL,BM_GETCHECK,0,0L);
						if(!checkState)uncheckControls();
						::SendDlgItemMessage(GetHandle(),IP_SOBEL,BM_SETCHECK,!checkState,0L);
	  }
					return TRUE;
				case IP_SMOOTHED :
					{
					  LRESULT checkState;

						checkState=::SendDlgItemMessage(GetHandle(),IP_SMOOTHED,BM_GETCHECK,0,0L);
						if(!checkState)uncheckControls();
						::SendDlgItemMessage(GetHandle(),IP_SMOOTHED,BM_SETCHECK,!checkState,0L);
	  }
					return TRUE;
				case IP_LAPLACE :
					{
					  LRESULT checkState;

						checkState=::SendDlgItemMessage(GetHandle(),IP_LAPLACE,BM_GETCHECK,0,0L);
						if(!checkState)uncheckControls();
						::SendDlgItemMessage(GetHandle(),IP_LAPLACE,BM_SETCHECK,!checkState,0L);
	  }
					return TRUE;
				case IP_ISOTROPIC :
					{
					  LRESULT checkState;

						checkState=::SendDlgItemMessage(GetHandle(),IP_ISOTROPIC,BM_GETCHECK,0,0L);
						if(!checkState)uncheckControls();
						::SendDlgItemMessage(GetHandle(),IP_ISOTROPIC,BM_SETCHECK,!checkState,0L);
	  }
					return TRUE;
				case IP_STOCHASTIC :
					{
					  LRESULT checkState;

						checkState=::SendDlgItemMessage(GetHandle(),IP_STOCHASTIC,BM_GETCHECK,0,0L);
						if(!checkState)uncheckControls();
						::SendDlgItemMessage(GetHandle(),IP_STOCHASTIC,BM_SETCHECK,!checkState,0L);
	  }
					return TRUE;
				case IDOK :
					mCurrentSelection=IP_AVERAGING;
					if(0==(mCurrentSelection=activeControl()))return FALSE;
					processUserSelection();
				  Main::smhBitmap.freeButton(IDOK);
					Main::smhBitmap.freeButton(IDCANCEL);
					::EndDialog(mhWnd,TRUE);
					smCurrInstance=0;
					return TRUE;
				case IDCANCEL :
					Main::smhBitmap.freeButton(IDOK);
					Main::smhBitmap.freeButton(IDCANCEL);
					::EndDialog(mhWnd,FALSE);
					smCurrInstance=0;
					return TRUE;
		}
	}
  return FALSE;
}

void Process::uncheckControls(void)const
{
	LRESULT checkState;

	checkState=::SendDlgItemMessage(GetHandle(),IP_AVERAGING,BM_GETCHECK,FALSE,0L);
	if(checkState)
  {
		::SendDlgItemMessage(GetHandle(),IP_AVERAGING,BM_SETCHECK,FALSE,0L);
		return;
  }
	checkState=::SendDlgItemMessage(GetHandle(),IP_LOWPASS,BM_GETCHECK,FALSE,0L);
	if(checkState)
  {
		::SendDlgItemMessage(GetHandle(),IP_LOWPASS,BM_SETCHECK,FALSE,0L);
		return;
  }
	checkState=::SendDlgItemMessage(GetHandle(),IP_HIGHPASS,BM_GETCHECK,FALSE,0L);
	if(checkState)
  {
		::SendDlgItemMessage(GetHandle(),IP_HIGHPASS,BM_SETCHECK,FALSE,0L);
		return;
  }
	checkState=::SendDlgItemMessage(GetHandle(),IP_SOBEL,BM_GETCHECK,FALSE,0L);
	if(checkState)
  {
		::SendDlgItemMessage(GetHandle(),IP_SOBEL,BM_SETCHECK,FALSE,0L);
		return;
	}
	checkState=::SendDlgItemMessage(GetHandle(),IP_SMOOTHED,BM_GETCHECK,FALSE,0L);
	if(checkState)
  {
		::SendDlgItemMessage(GetHandle(),IP_SMOOTHED,BM_SETCHECK,FALSE,0L);
		return;
	}
	checkState=::SendDlgItemMessage(GetHandle(),IP_LAPLACE,BM_GETCHECK,FALSE,0L);
	if(checkState)
  {
		::SendDlgItemMessage(GetHandle(),IP_LAPLACE,BM_SETCHECK,FALSE,0L);
		return;
	}
	checkState=::SendDlgItemMessage(GetHandle(),IP_ISOTROPIC,BM_GETCHECK,FALSE,0L);
	if(checkState)
  {
		::SendDlgItemMessage(GetHandle(),IP_ISOTROPIC,BM_SETCHECK,FALSE,0L);
		return;
	}
	checkState=::SendDlgItemMessage(GetHandle(),IP_STOCHASTIC,BM_GETCHECK,FALSE,0L);
	if(checkState)
  {
		::SendDlgItemMessage(GetHandle(),IP_STOCHASTIC,BM_SETCHECK,FALSE,0L);
		return;
  }
}

void Process::setMatrix(Block<Integer> &matrix)
{
	char Buffer[10];

	::sprintf(Buffer,"%d",(int)matrix[0]);
	::SetDlgItemText(GetHandle(),IP_33R1C1,(LPSTR)Buffer);
	::sprintf(Buffer,"%d",(int)matrix[1]);
	::SetDlgItemText(GetHandle(),IP_33R1C2,(LPSTR)Buffer);
	::sprintf(Buffer,"%d",(int)matrix[2]);
	::SetDlgItemText(GetHandle(),IP_33R1C3,(LPSTR)Buffer);
	::sprintf(Buffer,"%d",(int)matrix[3]);
	::SetDlgItemText(GetHandle(),IP_33R2C1,(LPSTR)Buffer);
	::sprintf(Buffer,"%d",(int)matrix[4]);
	::SetDlgItemText(GetHandle(),IP_33R2C2,(LPSTR)Buffer);
	::sprintf(Buffer,"%d",(int)matrix[5]);
	::SetDlgItemText(GetHandle(),IP_33R2C3,(LPSTR)Buffer);
	::sprintf(Buffer,"%d",(int)matrix[6]);
	::SetDlgItemText(GetHandle(),IP_33R3C1,(LPSTR)Buffer);
	::sprintf(Buffer,"%d",(int)matrix[7]);
	::SetDlgItemText(GetHandle(),IP_33R3C2,(LPSTR)Buffer);
	::sprintf(Buffer,"%d",(int)matrix[8]);
	::SetDlgItemText(GetHandle(),IP_33R3C3,(LPSTR)Buffer);
}

WORD Process::activeControl(void)const
{
	LRESULT activeControl;

	activeControl=::SendDlgItemMessage(GetHandle(),IP_AVERAGING,BM_GETCHECK,FALSE,0L);
	if(activeControl)return IP_AVERAGING;
	activeControl=::SendDlgItemMessage(GetHandle(),IP_LOWPASS,BM_GETCHECK,FALSE,0L);
	if(activeControl)return IP_LOWPASS;
	activeControl=::SendDlgItemMessage(GetHandle(),IP_HIGHPASS,BM_GETCHECK,FALSE,0L);
	if(activeControl)return IP_HIGHPASS;
	activeControl=::SendDlgItemMessage(GetHandle(),IP_SOBEL,BM_GETCHECK,FALSE,0L);
	if(activeControl)return IP_SOBEL;
	activeControl=::SendDlgItemMessage(GetHandle(),IP_SMOOTHED,BM_GETCHECK,FALSE,0L);
	if(activeControl)return IP_SMOOTHED;
	activeControl=::SendDlgItemMessage(GetHandle(),IP_LAPLACE,BM_GETCHECK,FALSE,0L);
	if(activeControl)return IP_LAPLACE;
	activeControl=::SendDlgItemMessage(GetHandle(),IP_ISOTROPIC,BM_GETCHECK,FALSE,0L);
	if(activeControl)return IP_ISOTROPIC;
	activeControl=::SendDlgItemMessage(GetHandle(),IP_STOCHASTIC,BM_GETCHECK,FALSE,0L);
	if(activeControl)return IP_STOCHASTIC;
	return 0L;
}


void Process::processUserSelection(void)
{
	char buffer[10];

	switch(mCurrentSelection)
	{
		case IP_AVERAGING :
		case IP_LOWPASS :
		case IP_HIGHPASS :
			::GetDlgItemText(GetHandle(),IP_33R1C1,(LPSTR)buffer,sizeof(buffer)-1);
			mAveragingMatrixUse.insert(&Integer(::atoi(buffer)));
			::GetDlgItemText(GetHandle(),IP_33R1C2,(LPSTR)buffer,sizeof(buffer)-1);
			mAveragingMatrixUse.insert(&Integer(::atoi(buffer)));
			::GetDlgItemText(GetHandle(),IP_33R1C3,(LPSTR)buffer,sizeof(buffer)-1);
			mAveragingMatrixUse.insert(&Integer(::atoi(buffer)));
			::GetDlgItemText(GetHandle(),IP_33R2C1,(LPSTR)buffer,sizeof(buffer)-1);
			mAveragingMatrixUse.insert(&Integer(::atoi(buffer)));
			::GetDlgItemText(GetHandle(),IP_33R2C2,(LPSTR)buffer,sizeof(buffer)-1);
			mAveragingMatrixUse.insert(&Integer(::atoi(buffer)));
			::GetDlgItemText(GetHandle(),IP_33R2C3,(LPSTR)buffer,sizeof(buffer)-1);
			mAveragingMatrixUse.insert(&Integer(::atoi(buffer)));
			::GetDlgItemText(GetHandle(),IP_33R3C1,(LPSTR)buffer,sizeof(buffer)-1);
			mAveragingMatrixUse.insert(&Integer(::atoi(buffer)));
			::GetDlgItemText(GetHandle(),IP_33R3C2,(LPSTR)buffer,sizeof(buffer)-1);
			mAveragingMatrixUse.insert(&Integer(::atoi(buffer)));
			::GetDlgItemText(GetHandle(),IP_33R3C3,(LPSTR)buffer,sizeof(buffer)-1);
			mAveragingMatrixUse.insert(&Integer(::atoi(buffer)));
			break;
		case IP_SOBEL :
      break;
		case IP_SMOOTHED :
      break;
		case IP_LAPLACE :
      break;
		case IP_ISOTROPIC :
      break;
		case IP_STOCHASTIC :
			break;
	}
}