#include <ddraw/draw.hpp>
#include <ddraw/surface.hpp>
#include <ddraw/dspenum.hpp>
#include <ddraw/sfcdesc.hpp>
#include <ddraw/direct3d.hpp>
#include <ddraw/device3d.hpp>
#include <ddraw/devenum.hpp>
#include <ddraw/palette.hpp>
#include <common/guiwnd.hpp>

DirectDraw::DirectDraw(void)
{
  createDirectDraw();
}

DirectDraw::DirectDraw(const DirectDraw &directDraw)
{ // private implementation
  *this=directDraw;
}

DirectDraw &DirectDraw::operator=(const DirectDraw &/*directDraw*/)
{
  return *this;
}

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

DirectDrawError DirectDraw::setCooperativeLevel(GUIWindow &parentWindow,CoopFlags coopFlags)
{
  if(!isOkay())return DirectDrawError::GenericFailure;
	return DirectDrawError::DirectDrawResult(mDirectDraw4->SetCooperativeLevel(parentWindow,coopFlags));
}

DirectDrawError DirectDraw::testCooperativeLevel(void)
{
  if(!isOkay())return DirectDrawError::GenericFailure;
  return DirectDrawError::DirectDrawResult(mDirectDraw4->TestCooperativeLevel());
}

DirectDrawError DirectDraw::setCooperativeLevel(CoopFlags coopFlags)
{
  if(!isOkay())return DirectDrawError::GenericFailure;
	return DirectDrawError::DirectDrawResult(mDirectDraw4->SetCooperativeLevel((HWND)0,coopFlags));
}

BOOL DirectDraw::enumerateModes(DisplayEnumerator &displayEnumerator)
{
  if(!isOkay())return FALSE;
	displayEnumerator.enumeratedModes().remove();
	mDirectDraw4->EnumDisplayModes(DDEDM_REFRESHRATES,0,&displayEnumerator,DisplayEnumerator::enumModesCallback);
	return TRUE;
}

BOOL DirectDraw::setDisplayMode(int width,int height,int bpp,int refreshRate)
{
  if(!isOkay())return FALSE;
	return (DD_OK==mDirectDraw4->SetDisplayMode(width,height,bpp,refreshRate,0));
}

BOOL DirectDraw::getDisplayMode(SurfaceDescription &surfaceDescription)
{
	if(!isOkay())return FALSE;
	return (DD_OK==mDirectDraw4->GetDisplayMode(&surfaceDescription.getDDSURFACEDESC2()));
}

BOOL DirectDraw::restoreDisplayMode(void)
{
  if(!isOkay())return FALSE;
	return (DD_OK==mDirectDraw4->RestoreDisplayMode());
}

BOOL DirectDraw::restoreAllSurfaces(void)
{
  if(!isOkay())return FALSE;
	return DD_OK==mDirectDraw4->RestoreAllSurfaces();
}

DirectDrawError DirectDraw::createSurface(const SurfaceDescription &surfaceDescription,Surface &surface)
{
  LPDIRECTDRAWSURFACE4 lpDDSurface4;
	DirectDrawError errorResult(DirectDrawError::GenericFailure);

  surface.destroy();
  if(!isOkay())return DirectDrawError::GenericFailure;
	errorResult=DirectDrawError::DirectDrawResult(mDirectDraw4->CreateSurface(&((SurfaceDescription&)surfaceDescription).getDDSURFACEDESC2(),&lpDDSurface4,0));
	if(!(DirectDrawError::Ok==errorResult.result()))return errorResult;
	(SmartPointer<IDirectDrawSurface4>&)surface=lpDDSurface4;
	return errorResult;
}

BOOL DirectDraw::createDirectDraw(void)
{
  HRESULT hResult;
  LPDIRECTDRAW lpDirectDraw;
	LPDIRECTDRAW4 lpDirectDraw4;

	hResult=::DirectDrawCreate(NULL,&lpDirectDraw,NULL);
	if(hResult<0)return FALSE;
	mDirectDraw=lpDirectDraw;
	hResult=mDirectDraw->QueryInterface(IID_IDirectDraw4,(void**)&lpDirectDraw4);
	if(hResult<0){mDirectDraw->Release();mDirectDraw.destroy();return FALSE;}
  mDirectDraw4=lpDirectDraw4;
	return isOkay();
}

DirectDrawError DirectDraw::createDirect3D(Surface &renderSurface,Direct3D &direct3D,DirectDevice3D &device3D)
{
	DirectDrawError status(DirectDrawError::GenericFailure);
  LPDIRECT3D3 lpDirect3D3;
	LPDIRECT3DDEVICE3 lpDirect3DDevice3;
	DeviceEnumerator enumDevice;

  if(!isOkay())return status;
	direct3D.destroy();
	status=DirectDrawError::DirectDrawResult(mDirectDraw->QueryInterface(IID_IDirect3D3,(void**)&lpDirect3D3));
	if(!status.okResult())return status;
	(SmartPointer<IDirect3D3>&)direct3D=lpDirect3D3;
	direct3D.enumerateDevice(enumDevice);
	if(!enumDevice.enumeratedDevices().size()){direct3D.destroy();status.result(DirectDrawError::GenericFailure);return status;}
	status=direct3D.createDevice(enumDevice.enumeratedDevices()[0],renderSurface,device3D);
	if(!status.okResult())return status;
	return status;
}

DirectDrawError DirectDraw::createPalette(DirectPalette &directPalette)
{
  DirectDrawError status(DirectDrawError::GenericFailure);
  LPDIRECTDRAWPALETTE lpDDPalette;

  if(!isOkay())return status;
	directPalette.destroy();
	status=DirectDrawError::DirectDrawResult(mDirectDraw4->CreatePalette(directPalette.flags(),&((PALETTEENTRY&)directPalette[0]),&lpDDPalette,0));
	if(!status.okResult())return status;
	(SmartPointer<IDirectDrawPalette>&)directPalette=lpDDPalette;
	return status;
}

DirectDrawError DirectDraw::flipToGDISurface(void)
{
  if(!isOkay())return DirectDrawError::GenericFailure;
	return DirectDrawError::DirectDrawResult(mDirectDraw4->FlipToGDISurface());
}

void DirectDraw::destroy(void)
{
  if(!isOkay())return;
	if(mDirectDraw4.isOkay()){mDirectDraw4->Release();mDirectDraw4.destroy();}
	if(mDirectDraw.isOkay()){mDirectDraw->Release();mDirectDraw.destroy();}
}

BOOL DirectDraw::isOkay(void)const
{
  return mDirectDraw.isOkay()&&mDirectDraw4.isOkay();
}