#include <proto/display.hpp>
#include <common/guiwnd.hpp>
#include <common/keydata.hpp>
#include <engine/asmutil.hpp>
#include <engine/dib3d.hpp>
#include <engine/vector3d.hpp>
#include <proto/pureobj.hpp>

DisplayManager::DisplayManager(GUIWindow &displayWindow,const PurePalette &systemPalette)
: mDisplayWindow(displayWindow), mSystemPalette(systemPalette), mIsCancelled(FALSE),
  mBitmapBkGnd("stars1.bmp")
{
  mSizeHandler.setCallback(this,&DisplayManager::sizeHandler);
	mKeyDownHandler.setCallback(this,&DisplayManager::keyDownHandler);
	mDialogCodeHandler.setCallback(this,&DisplayManager::dialogCodeHandler);
	mDisplayWindow.insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
	mDisplayWindow.insertHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
	mDisplayWindow.insertHandler(VectorHandler::DialogCodeHandler,&mDialogCodeHandler);
	mDIB3D=::new DIB3D(mDisplayWindow,mSystemPalette);
	mDIB3D.disposition(PointerDisposition::Delete);
}

DisplayManager::~DisplayManager()
{
  shutdown();
}

CallbackData::ReturnType DisplayManager::sizeHandler(CallbackData &someCallbackData)
{
  mMutex.requestMutex();
  mDIB3D.destroy();
	mDIB3D=::new DIB3D(mDisplayWindow,mSystemPalette);
	mDIB3D.disposition(PointerDisposition::Delete);
	mMutex.releaseMutex();
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType DisplayManager::dialogCodeHandler(CallbackData &someCallbackData)
{
  return (CallbackData::ReturnType)DLGC_WANTALLKEYS;
}

CallbackData::ReturnType DisplayManager::keyDownHandler(CallbackData &someCallbackData)
{
  KeyData keyData(someCallbackData);

  keyDownHandler(keyData);
  return (CallbackData::ReturnType)FALSE;
}

void DisplayManager::shutdown(void)
{
  ::OutputDebugString("cancelling...\n");
  cancel();
  ::OutputDebugString("waiting for message to complete.\n");
	waitForProcess();
  ::OutputDebugString("waiting for thread shutdown.\n");
	wait();
	mDisplayWindow.removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
}

bool DisplayManager::isCancelled(void)const
{
  return mIsCancelled;
}

void DisplayManager::cancel(void)
{
  mIsCancelled=true;
}

// virtuals

void DisplayManager::processHandler(void)
{
  PureDevice pureDevice(mDisplayWindow);

  if(!mDIB3D.isOkay())return;
	if(0==initializeHandler(mPureObjects))return;
	mDIB3D->usePalette(true);
  while(!isCancelled())
	{
	  mMutex.requestMutex();
		setBackground();
//		ASMRoutines::clearBitmap((DWORD)mDIBitmap->ptrData(),mDIBitmap->imageExtent());
	  for(int index=0;index<mPureObjects.size();index++)
		{
		  PointerPureObject &pureObject=mPureObjects[index];
		  if(!preprocessHandler(pureObject))continue;
      if(!pureObject->isInView(mDIB3D))
			{
			  if(scopeHandler(pureObject))pureObject->setState(PureObject::Delete);
			}
      else pureObject->map(mDIB3D);
		}
		mDIB3D->bitBlt(pureDevice);
		mMutex.releaseMutex();
	  for(index=0;index<mPureObjects.size();index++)
		{
		  PointerPureObject &pureObject=mPureObjects[index];
			if(PureObject::Delete==pureObject->getState())
			{
			  mPureObjects.remove(index);
				index=-1;
			}
		}
	}
}

void DisplayManager::setBackground(void)
{
  char *ptrSrcData;
	char *ptrDstData;
	int rows(mDIB3D->height()>mBitmapBkGnd.height()?mBitmapBkGnd.height():mDIB3D->height());
	int cols((*mDIB3D).width()>mBitmapBkGnd.width()?mBitmapBkGnd.width():(*mDIB3D).width());

	ptrDstData=(char*)mDIB3D->ptrData();
	ptrSrcData=(char*)mBitmapBkGnd.ptrData();
	for(int row=0;row<rows;row++)
	{
	  ::memcpy(ptrDstData,ptrSrcData,cols);
		ptrDstData+=mDIB3D->width();
		ptrSrcData+=mBitmapBkGnd.width();
	}
}


// virtuals

bool DisplayManager::initializeHandler(PointerPureObjectBlock &pureObjects)
{
  return false;
}

bool DisplayManager::preprocessHandler(PointerPureObject &pureObject)
{
  return true;
}

bool DisplayManager::scopeHandler(PointerPureObject &pureObject)
{
  return true;
}

void DisplayManager::keyDownHandler(const KeyData &keyData)
{
  return;
}