//#define _USEDIRECTDRAW_
#include <ddraw/mainwnd.hpp>
#include <ddraw/draw.hpp>
#include <ddraw/sfccaps.hpp>
#include <ddraw/sfcdesc.hpp>
#include <ddraw/surface.hpp>
#include <ddraw/pixform.hpp>
#include <ddraw/texture.hpp>
#include <engine/device3d.hpp>
#include <engine/texture.hpp>
#include <common/keydata.hpp>
#include <stdio.h>

char MainWindow::szClassName[]="DDrawTest";
char MainWindow::szMenuName[]="";

MainWindow::MainWindow(void)
: mTextureBitmap("c:\\work\\scene\\media\\bmp\\FLAT221.bmp")
{
  mPaintHandler.setCallback(this,&MainWindow::paintHandler);
	mDestroyHandler.setCallback(this,&MainWindow::destroyHandler);
	mCommandHandler.setCallback(this,&MainWindow::commandHandler);
	mKeyDownHandler.setCallback(this,&MainWindow::keyDownHandler);
	mKeyUpHandler.setCallback(this,&MainWindow::keyUpHandler);
	mSizeHandler.setCallback(this,&MainWindow::sizeHandler);
	mCreateHandler.setCallback(this,&MainWindow::createHandler);
	mTimerHandler.setCallback(this,&MainWindow::timerHandler);
	mActivateAppHandler.setCallback(this,&MainWindow::activateAppHandler);
	mDisplayChangeHandler.setCallback(this,&MainWindow::displayChangeHandler);
	mDialogCodeHandler.setCallback(this,&MainWindow::dialogCodeHandler);
	insertHandlers();
	registerClass();
	::CreateWindow(szClassName,szClassName,
		WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_DLGFRAME|WS_CLIPCHILDREN|WS_SIZEBOX,
		CW_USEDEFAULT,CW_USEDEFAULT,
		CW_USEDEFAULT,CW_USEDEFAULT,
		NULL,NULL,processInstance(),(LPSTR)this);
	show(SW_SHOW);
	update();
}

MainWindow::~MainWindow()
{
	destroy();
}

void MainWindow::insertHandlers(void)
{
	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
	insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
	insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
	insertHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
	insertHandler(VectorHandler::KeyUpHandler,&mKeyUpHandler);
	insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
	insertHandler(VectorHandler::TimerHandler,&mTimerHandler);
	insertHandler(VectorHandler::ActivateAppHandler,&mActivateAppHandler);
	insertHandler(VectorHandler::DisplayChangeHandler,&mDisplayChangeHandler);
	insertHandler(VectorHandler::DialogCodeHandler,&mDialogCodeHandler);
}

void MainWindow::removeHandlers(void)
{
	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
	removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
	removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
	removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
	removeHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
	insertHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
	removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
	removeHandler(VectorHandler::TimerHandler,&mTimerHandler);
	removeHandler(VectorHandler::ActivateAppHandler,&mActivateAppHandler);
	removeHandler(VectorHandler::DisplayChangeHandler,&mDisplayChangeHandler);
	removeHandler(VectorHandler::DialogCodeHandler,&mDialogCodeHandler);
}
                                      
void MainWindow::registerClass(void)const
{
	WNDCLASS wndClass;

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

#if defined(_USEDIRECTDRAW_)
CallbackData::ReturnType MainWindow::createHandler(CallbackData &/*someCallbackData*/)
{
  SurfaceCapabilities surfaceCapabilities(SurfaceCapabilities::Capabilities(SurfaceCapabilities::PrimarySurface|SurfaceCapabilities::Device3D));
	SurfaceDescription surfaceDescription;

	mDevice3D=::new Device3D(*this);
  mDevice3D.disposition(PointerDisposition::Delete);
	mDevice3D->focusPoint(Point3D(0,0,-1));
  mDirectDraw=::new DirectDraw();
	mDirectDraw.disposition(PointerDisposition::Delete);
	mDirectDraw->setCooperativeLevel(*this,DirectDraw::CoopFlags(DirectDraw::Exclusive|DirectDraw::FullScreen));
	mDirectDraw->setDisplayMode(DisplayWidth,DisplayHeight,DisplayBPP);
  surfaceDescription.flags(SurfaceDescription::Capabilities);
  surfaceDescription.surfaceCapabilities(surfaceCapabilities);
	if(!mDirectDraw->createSurface(surfaceDescription,mPrimarySurface).okResult())return FALSE;
  mDirectPalette.readPalette("c:\\work\\scene\\media\\bmp\\redwall1.pal");
//  mDirectPalette.systemPalette();
  mDirectDraw->createPalette(mDirectPalette);
	mPrimarySurface.setPalette(mDirectPalette);
	mPrimarySurface.lock();
	mPrimarySurface.unlock();
//	mDirectDraw->createDirect3D(mPrimarySurface,mDirect3D,mDirectDevice3D);
	return FALSE;
}

CallbackData::ReturnType MainWindow::destroyHandler(CallbackData &/*someCallbackData*/)
{
  mDirectPalette.destroy();
  mDirectDevice3D.destroy();
  mDirect3D.destroy();
  mPrimarySurface.destroy();
	mDirectDraw.destroy();
	removeHandlers();
	::PostQuitMessage(0);
	return (CallbackData::ReturnType)FALSE;
}
#else
CallbackData::ReturnType MainWindow::createHandler(CallbackData &/*someCallbackData*/)
{
//  PurePalette purePalette("c:\\work\\scene\\media\\bmp\\redwall1.pal");
	mPalette="c:\\work\\scene\\media\\bmp\\redwall1.pal";
	mDevice3D=::new Device3D(*this);
  mDevice3D.disposition(PointerDisposition::Delete);
	mDevice3D->focusPoint(Point3D(0,0,-1));
	mDIBitmap=::new DIBitmap(*mDevice3D,width(),height(),mPalette);
	mDIBitmap.disposition(PointerDisposition::Delete);
	mPalette.usePalette(*mDevice3D,TRUE);
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainWindow::destroyHandler(CallbackData &/*someCallbackData*/)
{
	removeHandlers();
	::PostQuitMessage(0);
  return FALSE;
}
#endif

CallbackData::ReturnType MainWindow::activateAppHandler(CallbackData &someCallbackData)
{
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainWindow::displayChangeHandler(CallbackData &someCallbackData)
{
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainWindow::sizeHandler(CallbackData &/*someCallbackData*/)
{
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainWindow::commandHandler(CallbackData &someCallbackData)
{
	switch(someCallbackData.wmCommandID())
	{
	  default :
		  break;
	}
	return (CallbackData::ReturnType)FALSE;
}

#if defined(_USEDIRECTDRAW_)
CallbackData::ReturnType MainWindow::paintHandler(CallbackData &/*someCallbackData*/)
{
  Vector3D dstPoints;
	Triangle3D angle3D;
	Triangle angle;

//	mDirectDraw->setCooperativeLevel(*this,DirectDraw::CoopFlags(DirectDraw::Normal));
	mDirectDraw->setCooperativeLevel(*this,DirectDraw::CoopFlags(DirectDraw::Exclusive|DirectDraw::FullScreen));
	mDirectDraw->setDisplayMode(DisplayWidth,DisplayHeight,DisplayBPP);
	mDirectDraw->restoreAllSurfaces();

//	dstPoints[0]=Point3D(-20,20,10);
//	dstPoints[1]=Point3D(20,20,10);
//	dstPoints[2]=Point3D(20,-20,10);
//	dstPoints[3]=Point3D(-20,-20,10);
	angle3D[0]=Point3D(-20,0,0);
	angle3D[1]=Point3D(0,20,0);
	angle3D[2]=Point3D(20,0,0);

	mPrimarySurface.lock();
	mPrimarySurface.clear();
//	DirectTexture directTexture(dstPoints,mTextureBitmap,mPrimarySurface,*mDevice3D);
  DirectTexture directTexture(angle3D,mTextureBitmap,mPrimarySurface,*mDevice3D);
	directTexture.mapTexture();

	mDevice3D->mapCoordinates(angle3D,angle);
	mPrimarySurface.line(angle[0],angle[1],192);
	mPrimarySurface.line(angle[1],angle[2],192);
	mPrimarySurface.line(angle[2],angle[0],192);

	mPrimarySurface.unlock();
	return (CallbackData::ReturnType)FALSE;
}
#else
CallbackData::ReturnType MainWindow::paintHandler(CallbackData &/*someCallbackData*/)
{
	Triangle3D angle3D[3];
	Triangle angle;


//VERTEX(-4,16,-25);
//VERTEX(-24,16,-25);
//VERTEX(-9,-10,11);
//VERTEX(5,-19,0);
//VERTEX(-11,12,-36);
//VERTEX(-31,12,-36);
//VERTEX(-11,-19,2);
//VERTEX(3,-28,-8);
//VERTEX(-2,1,-28);
//VERTEX(-17,10,-17);
//VERTEX(-10,14,-5);
//VERTEX(4,5,-16);
//SURFACE(3,0,2);
//SURFACE(2,0,1);
//SURFACE(7,3,2);
//SURFACE(7,2,6);
//SURFACE(3,7,0);
//SURFACE(0,7,4);
//SURFACE(0,4,1);
//SURFACE(1,4,5);
//SURFACE(6,2,1);
//SURFACE(6,1,5);
//SURFACE(5,4,6);
//SURFACE(6,4,7);

	(angle3D[0])[0]=Point3D(5,-19,0);
	(angle3D[0])[1]=Point3D(-4,16,-25);
	(angle3D[0])[2]=Point3D(-9,-10,11);

	(angle3D[1])[0]=Point3D(-9,-10,11);
	(angle3D[1])[1]=Point3D(-4,16,-25);
	(angle3D[1])[2]=Point3D(-24,-16,-25);

	(angle3D[2])[0]=Point3D(3,-28,-8);
	(angle3D[2])[1]=Point3D(5,-19,0);
	(angle3D[2])[2]=Point3D(-9,-10,11);

//  Vector3D dstPoints;
//	dstPoints[0]=Point3D(-20,20,10);
//	dstPoints[1]=Point3D(20,20,10);
//	dstPoints[2]=Point3D(20,-20,10);
//	dstPoints[3]=Point3D(-20,-20,10);
//	Texture texture(dstPoints,mTextureBitmap,*mDIBitmap,*mDevice3D);


  mDIBitmap->clearBits();
	for(int index=0;index<sizeof(angle3D)/sizeof(Triangle3D);index++)
	{
    Texture texture(angle3D[index],mTextureBitmap,*mDIBitmap,*mDevice3D,Texture::MapLowerLeft);
	  texture.mapTexture();
	}
	for(index=0;index<sizeof(angle3D)/sizeof(Triangle3D);index++)
	{
	  mDevice3D->mapCoordinates(angle3D[index],angle);
	  mDIBitmap->line(angle[0],angle[1],192);
	  mDIBitmap->line(angle[1],angle[2],192);
	  mDIBitmap->line(angle[2],angle[0],192);
	}
	mDIBitmap->bitBlt(*mDevice3D);

#if 0
  Triangle3D angle3D;
	Triangle angle;

  mDIBitmap->clearBits();
	angle3D[0]=Point3D(0,0,0);
	angle3D[1]=Point3D(128,0,0);
	angle3D[2]=Point3D(0,128,0);
  {
    DirectTriTexture directTriTexture(angle3D,mTextureBitmap,*mDIBitmap,*mDevice3D);
	  directTriTexture.mapTexture();
	}
	mDevice3D->mapCoordinates(angle3D,angle);
	mDIBitmap->line(angle[0],angle[1],192);
	mDIBitmap->line(angle[1],angle[2],192);
	mDIBitmap->line(angle[2],angle[0],192);
	mDIBitmap->bitBlt(*mDevice3D);
#endif
	return (CallbackData::ReturnType)FALSE;
}
#endif

CallbackData::ReturnType MainWindow::timerHandler(CallbackData &/*someCallbackData*/)
{
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainWindow::dialogCodeHandler(CallbackData &/*someCallbackData*/)
{
  return (CallbackData::ReturnType)DLGC_WANTALLKEYS;
}

CallbackData::ReturnType MainWindow::keyUpHandler(CallbackData &/*someCallbackData*/)
{
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainWindow::keyDownHandler(CallbackData &someCallbackData)
{
	KeyData keyData(someCallbackData);
	int repeatIndex;

  switch(keyData.virtualKey())
	{
		case inKey :
			if(shiftKeyPressed())mDevice3D->cameraTwistDegrees(mDevice3D->cameraTwistDegrees()-ThetaDelta);
			mDevice3D->viewPlaneDistance(mDevice3D->viewPlaneDistance()+ViewDelta);
      invalidate(FALSE);
			break;
		case outKey :
			if(shiftKeyPressed())mDevice3D->cameraTwistDegrees(mDevice3D->cameraTwistDegrees()+ThetaDelta);
			mDevice3D->viewPlaneDistance(mDevice3D->viewPlaneDistance()-ViewDelta);
			invalidate(FALSE);
			break;
		case VK_UP :
		  for(repeatIndex=0;repeatIndex<keyData.repeatCount();repeatIndex++)if(!handleUpArrow())break;
			invalidate(FALSE);
			break;
		case VK_DOWN :
      for(repeatIndex=0;repeatIndex<keyData.repeatCount();repeatIndex++)if(!handleDownArrow())break;
			invalidate(FALSE);
			break;
		case VK_LEFT :
      for(repeatIndex=0;repeatIndex<keyData.repeatCount();repeatIndex++)if(!handleLeftArrow())break;
			invalidate(FALSE);
			break;
		case VK_RIGHT :
      for(repeatIndex=0;repeatIndex<keyData.repeatCount();repeatIndex++)if(!handleRightArrow())break;
			invalidate(FALSE);
			break;
	}
	return (CallbackData::ReturnType)FALSE;
}

WORD MainWindow::handleUpArrow(void)
{
	Point3D cameraPoint(mDevice3D->cameraPoint());
	cameraPoint.y(cameraPoint.y()+TurnDelta);
	mDevice3D->cameraPoint(cameraPoint);
	return TRUE;
}

WORD MainWindow::handleDownArrow(void)
{
	Point3D cameraPoint(mDevice3D->cameraPoint());
	cameraPoint.y(cameraPoint.y()-TurnDelta);
	mDevice3D->cameraPoint(cameraPoint);
	return TRUE;
}

WORD MainWindow::handleLeftArrow(void)
{
	Point3D cameraPoint(mDevice3D->cameraPoint());
	if(shiftKeyPressed())mDevice3D->cameraTwistDegrees(mDevice3D->cameraTwistDegrees()-ThetaDelta);
	else cameraPoint.x(cameraPoint.x()+TurnDelta);
	mDevice3D->cameraPoint(cameraPoint);
	return TRUE;
}

WORD MainWindow::handleRightArrow(void)
{
	Point3D cameraPoint(mDevice3D->cameraPoint());
	if(shiftKeyPressed())mDevice3D->cameraTwistDegrees(mDevice3D->cameraTwistDegrees()+ThetaDelta);
  else cameraPoint.x(cameraPoint.x()-TurnDelta);
  mDevice3D->cameraPoint(cameraPoint);
	return TRUE;
}

inline
WORD MainWindow::shiftKeyPressed(void)const
{
  return ::GetKeyState(VK_SHIFT)&0x8000;
}