//-----------------------------------------------------------------------------
// Simple Engine implementation.
//-----------------------------------------------------------------------------

#include "NetWars.h" 

Engine *g_Engine = NULL;

//-----------------------------------------------------------------------------
// Simple Engine Constructor.
//-----------------------------------------------------------------------------
Engine::Engine( HINSTANCE instance )
{
	g_Engine = this;

	m_Window = new SimpleWindow( instance );

	m_UInput = new UserInput( m_Window->GetHandle() );	

	// Create the Direct3D interface.
	IDirect3D9 *d3d = Direct3DCreate9( D3D_SDK_VERSION );

	// Prepare the device presentation parameters.
	D3DPRESENT_PARAMETERS d3dpp;
	ZeroMemory( &d3dpp, sizeof( D3DPRESENT_PARAMETERS ) );
	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	d3dpp.hDeviceWindow = m_Window->GetHandle();
	d3dpp.Windowed = true;
	d3dpp.EnableAutoDepthStencil = false;
	//d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;


	// Create the Direct3D device with hardware vertex processing. 
	if( FAILED( d3d->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_Window->GetHandle(), D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &m_d3dDevice ) ) )
	{ 
		// Create the Direct3D device with mixed vertex processing. 
		if( FAILED( d3d->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_Window->GetHandle(), D3DCREATE_MIXED_VERTEXPROCESSING, &d3dpp, &m_d3dDevice ) ) ) 
		{ 
			// Create the Direct3D device with software vertex processing. 
			if( FAILED( d3d->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_Window->GetHandle(), D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &m_d3dDevice ) ) ) 
				MessageBox(m_Window->GetHandle(),L"Failed to create even the reference device!",L"InitializeDevice()",MB_OK);
				return;
			} 
	}


	// Release the Direct3D interface as it is no longer needed.
	SAFE_RELEASE( d3d );

	// Set the projection matrix.
	D3DXMATRIX projMatrix;
	D3DXMatrixPerspectiveFovLH( &projMatrix, D3DX_PI / 4, (float)d3dpp.BackBufferWidth / (float)d3dpp.BackBufferHeight, 0.1f, 1000.0f );
	m_d3dDevice->SetTransform( D3DTS_PROJECTION, &projMatrix );


	//-----------------------------------------------------------------------------
	// Setting up the Device Matricies
	//-----------------------------------------------------------------------------
	D3DXMATRIX matWorld;
	//D3DXMatrixIdentity( &matWorld );
	D3DXMatrixRotationY( &matWorld, timeGetTime()/150.0f );
	//d3dDevice->SetTransform( D3DTS_WORLD, &matWorld );

	D3DXVECTOR3 vEyePt   ( 0.0f, 0.0f, 150.0f );
	D3DXVECTOR3 vLookatPt( 0.0f, 0.0f, 0.0f );
	D3DXVECTOR3 vUpVec   ( 0.0f, 1.0f, 0.0f );
	D3DXMATRIXA16 matView;
	D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookatPt, &vUpVec );
	m_d3dDevice->SetTransform( D3DTS_VIEW, &matView );


	//m_d3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME );
	//m_d3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
	//m_d3dDevice->SetRenderState(D3DRS_LIGHTING,false);
	m_d3dDevice->SetRenderState(D3DRS_LIGHTING,true);
	m_d3dDevice->SetRenderState( D3DRS_AMBIENT, 0x00FFFFFF );


	D3DMATERIAL9 mtrl;
	ZeroMemory( &mtrl, sizeof(mtrl) );
	mtrl.Diffuse.r = mtrl.Ambient.r = 1.0f;
	mtrl.Diffuse.g = mtrl.Ambient.g = 0.0f;
	mtrl.Diffuse.b = mtrl.Ambient.b = 0.0f;
	mtrl.Diffuse.a = mtrl.Ambient.a = 1.0f;
	m_d3dDevice->SetMaterial( &mtrl );

	m_Window->Show();

	m_upVector    = b2Vec2( 0.0f, 1.0f );
	m_downVector  = b2Vec2( 0.0f, -1.0f );
	m_leftVector  = b2Vec2( 1.0f, 0.0f );
	m_rightVector = b2Vec2( -1.0f, 0.0f );



	// Make sure to initialize BEFORE any SceneObjects
	m_B2D = new B2DWrapper();

	m_GameBorder = new GameBorder( );

	m_sceneObjects = new LinkedList< SceneObject >;
	m_sceneObjects->Add( new SceneObject( 0.0f, 0.0f ) );
	m_sceneObjects->Add( new SceneObject(  30.0f,  30.0f ) );
	m_sceneObjects->Add( new SceneObject( -30.0f,  30.0f ) );
	m_sceneObjects->Add( new SceneObject(  30.0f, -30.0f ) );
	m_sceneObjects->Add( new SceneObject( -30.0f, -30.0f ) );
	m_PlayerShip = new SpaceShip( 20.0f, 20.0f );
	m_sceneObjects->Add( new SpaceShip( -60.0f, -50.0f ) );
	m_sceneObjects->Add( m_PlayerShip );


	
}

//-----------------------------------------------------------------------------
// Simple Engine Destructor.
//-----------------------------------------------------------------------------
Engine::~Engine(  )
{
	// Release the device.
	SAFE_RELEASE( m_d3dDevice );

	SAFE_DELETE( m_UInput );
	SAFE_DELETE( m_Window );
	SAFE_DELETE( m_sceneObjects );
	SAFE_DELETE( m_GameBorder );
	SAFE_DELETE( m_B2D );
}

void Engine::AddSceneObject( SceneObject * newSceneObject )
{
	m_sceneObjects->Add( newSceneObject );
}

//-----------------------------------------------------------------------------
// Getter for UserInput member
//-----------------------------------------------------------------------------
UserInput * Engine::GetUserInput(  )
{
	return m_UInput;
	
}

//-----------------------------------------------------------------------------
// Getter for UserInput member
//-----------------------------------------------------------------------------
SimpleWindow * Engine::GetWindow(  )
{
	return m_Window;	
}

//-----------------------------------------------------------------------------
// The Main Loop for the Engine
//-----------------------------------------------------------------------------
void Engine::Run(  )
{

	// Show the window.

	MSG msg;

	ZeroMemory( &msg, sizeof( MSG ) );

	float angle = 0.0f;
	float ship2x = 0.0f;
	float ship2y = 0.0f;

	m_lastTime = timeGetTime();

	while( msg.message != WM_QUIT )
	{
			if( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
			{
				TranslateMessage( &msg );
				DispatchMessage( &msg );
			} else {
				// Calculate the elapsed time.
				m_currentTime = timeGetTime();
				// Converts miliseconds to seconds
				m_elapsedTime = ( m_currentTime - m_lastTime ) / 1000.0f;
				m_lastTime = m_currentTime;

				m_d3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB( 200, 0, 0, 0), 1.0f, 0 );
				if( SUCCEEDED( m_d3dDevice->BeginScene() ) )
				{
					
					m_UInput->Update();

					m_B2D->Update( m_elapsedTime );

					// Updating all of the Scene Objects
					m_sceneObjects->Iterate( true );
					while( m_sceneObjects->Iterate() )
					{
						m_sceneObjects->GetCurrent()->Update();	
					}
					// Rendering all of the Scene Objects. 
					// I'm separating the Update and Render pass
					// So that any linked objects get a chance to be 
					// Updated by their kin.
					m_sceneObjects->Iterate( true );
					while( m_sceneObjects->Iterate() )
					{;	
						m_sceneObjects->GetCurrent()->Render();
					}

					m_GameBorder->Render();

					m_d3dDevice->EndScene();
					m_d3dDevice->Present( NULL, NULL, NULL, NULL );
				}
			}
	}


}

//-----------------------------------------------------------------------------
// Getter for PlayerShip member
//-----------------------------------------------------------------------------
SceneObject * Engine::GetPlayerShip()
{
	return m_PlayerShip;
}

//-----------------------------------------------------------------------------
// Getter for GameBorder member
//-----------------------------------------------------------------------------
GameBorder * Engine::GetGameBorder()
{
	return m_GameBorder;
}

//-----------------------------------------------------------------------------
// Getter for Box2D member
//-----------------------------------------------------------------------------
B2DWrapper * Engine::GetB2D()
{
	return m_B2D;
}

//-----------------------------------------------------------------------------
// Getter for the Direct3DDevice9 member 
//-----------------------------------------------------------------------------
IDirect3DDevice9 * Engine::GetD3DDevice()
{
	return m_d3dDevice;
}

//-----------------------------------------------------------------------------
// My First Stab at Collision Detection
//-----------------------------------------------------------------------------
void Engine::DetectCollisions(  )
{
	bool widthCollision = false;
	bool heightCollision = false;
	D3DXVECTOR3 forceDir;

	LinkedList::Element * sceneObjectElement = m_sceneObjects->GetCompleteElement( m_sceneObjects->GetFirst() );
	do {

		forceDir = sceneObjectElement->data->GetForceDir();

		if( (abs(sceneObjectElement->data->GetX())+11.0f) > m_GameBorder->GetWidth() )
		{
			widthCollision = true;

			if( (sceneObjectElement->data->GetX() > 0.0f) && (forceDir.x < 0.0f ) )
				forceDir.x = 0.0f;

			if( (sceneObjectElement->data->GetX() < 0.0f) && (forceDir.x > 0.0f ) )
				forceDir.x = 0.0f;
		}
			
		if( (abs(sceneObjectElement->data->GetY())+11.0f) > m_GameBorder->GetHeight() )
		{
			heightCollision = true;

			if( sceneObjectElement->data->GetY() > 0.0f && forceDir.y > 0.0f )
				forceDir.y = 0.0f;

			if( sceneObjectElement->data->GetY() < 0.0f && forceDir.y < 0.0f )
				forceDir.y = 0.0f;
		}

		if( widthCollision || heightCollision )
			sceneObjectElement->data->SetForceDir( forceDir );

	} while( sceneObjectElement = sceneObjectElement->next );
	

}