#include "dxstdafx.h"
#include ".\HUDRenderer.h"
#include "GameManager.h"
#include "UserPlayer.h"
#include "HUD.h"

extern bool GLOBAL_display_help_screenQ;


HUDRenderer::HUDRenderer(void) : Renderer()
{
	this->setRenderPriority(300);
	this->rendererType |= Renderer::RENDERER_HUD;
	this->sprite = NULL;
}

HUDRenderer::~HUDRenderer(void)
{
	SAFE_RELEASE(this->myFont);
	SAFE_RELEASE(sprite);
	this->myFont = NULL;
	this->sprite = NULL;
}

void HUDRenderer::init() {
	// Create a D3DX font object
	this->setRenderPriority(60);
	D3DXCreateSprite(DXUTGetD3DDevice(),&sprite);
	D3DXCreateFont( this->device, 26, 0, FW_BOLD, 0, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, TEXT("Arial"), &myFont );
	fontColor = D3DCOLOR_ARGB(255,255,255,255);
	SetRect(&textRectangle, 0, this->myScene->manager->screenHeight-200, this->myScene->manager->screenWidth, this->myScene->manager->screenHeight);
	SetRect(&timeRectangle, 0, this->myScene->manager->screenHeight-100, this->myScene->manager->screenWidth - 20, this->myScene->manager->screenHeight);
	SetRect(&ammoRectangle, 0, this->myScene->manager->screenHeight-60, this->myScene->manager->screenWidth - 20, this->myScene->manager->screenHeight);
	SetRect(&helpRectangle, 10, this->myScene->manager->screenHeight-500, this->myScene->manager->screenWidth - 20, this->myScene->manager->screenHeight);

	
}

void HUDRenderer::render() 
{
	if(this->myScene->getActivePassId()==Scene::PASS_NORMAL) {
		this->device->BeginScene();
		SPTR<Node> node = this->myNode.lock();
		HUD *hud = (HUD *) (node.get());
		if(hud!=NULL) {
			//disable z buffer:
			this->device->SetRenderState(D3DRS_ZENABLE, FALSE);

			// get the scene in order to receive players
			GameScene* gs = (GameScene*)(this->myScene);
			//get the sprite:
			//LPD3DXSPRITE sprite = *hud->getSprite();
			//create scale/rotate matrices
			D3DXMATRIX mat;
			D3DXMATRIX mat2;
			//create surface descriptor
			D3DSURFACE_DESC desc;
			D3DSURFACE_DESC desc2;
			
			//draw crosshair:
			hud->Textures[0]->GetLevelDesc(0, &desc);	//get texture size		
			//calculate transfomation:
			D3DXVECTOR3 center((FLOAT)desc.Width/2, (FLOAT)desc.Height/2, 0);
			D3DXVECTOR2 trans((float)(this->myScene->getMousePos()[0]),(float)(this->myScene->getMousePos()[1]));
			D3DXVECTOR2 scaling(hud->getScaleCrosshairX(),hud->getScaleCrosshairY());
			//set matrix:
			D3DXMatrixTransformation2D(&mat,NULL,0.0,&scaling,NULL,0,&trans);
			sprite->SetTransform(&mat);
			//draw crosshair:
			sprite->Begin(D3DXSPRITE_ALPHABLEND);
			sprite->Draw(hud->Textures[0], NULL, &center, NULL, 0xFFFFFFFF);

			//draw radar:
			hud->Textures[1]->GetLevelDesc(0, &desc);	//get texture size		
			//calculate transfomation:
			D3DXVECTOR2 rotPoint((FLOAT)desc.Width/2*hud->getScaleRadarX() + hud->getRadarOffsetX(), (FLOAT) this->myScene->manager->screenHeight - (desc.Height/2*hud->getScaleRadarY() + hud->getRadarOffsetY()));
			trans = D3DXVECTOR2(rotPoint.x - (FLOAT)(gs->player->getPosition().x/this->myScene->getWidth()*desc.Width*hud->getScaleRadarX()),rotPoint.y - (FLOAT)(desc.Height*hud->getScaleRadarY() - (gs->player->getPosition().z/this->myScene->getDepth()*desc.Height*hud->getScaleRadarY())));
			D3DXVECTOR2 trans2(trans.x, trans.y);
			scaling = D3DXVECTOR2(hud->getScaleRadarX(),hud->getScaleRadarY());
			float rotation = -(gs->player->myRotation.y);
			//reset matrix:
			D3DXMatrixIdentity(&mat);
			D3DXMatrixIdentity(&mat2);
			D3DXMATRIX res;
			D3DXMatrixTransformation2D(&mat,0,0.0,&scaling,0,0.0f,&trans);
			D3DXMatrixTransformation2D(&mat2,0,0.0,0,&rotPoint,rotation,0);
			D3DXMatrixMultiply(&res, &mat, &mat2);
			sprite->SetTransform(&res);
			//draw radar:
			sprite->Draw(hud->Textures[1], NULL, 0, 0, 0xFFFFFFFF);
			
			//draw ai players (enemies)
			hud->Textures[2]->GetLevelDesc(0, &desc2);	//get texture size
			//calculate location:
			center = D3DXVECTOR3((FLOAT)desc2.Width/2, (FLOAT)desc2.Height/2, 0);
			//get list:
			std::list<SPTR<Node> > *playerList = ((GameScene *)this->myScene)->getPlayerList();
			std::list<SPTR<Node> >::iterator it;
			Player *activeOpponent = NULL;
			for(it=playerList->begin();it!=playerList->end();it++) {
				activeOpponent = ((Player *) (*it).get());
				if(activeOpponent != (Player *)gs->player) {
					trans = D3DXVECTOR2(trans2.x + activeOpponent->getPosition().x/this->myScene->getWidth()*desc.Width*hud->getScaleRadarX(), trans2.y + (desc.Height*hud->getScaleRadarY() - (activeOpponent->getPosition().z/this->myScene->getDepth()*desc.Height*hud->getScaleRadarY())));
					//reset matrix:
					D3DXMatrixIdentity(&mat);
					D3DXMatrixIdentity(&mat2);
					D3DXMATRIX res;
					D3DXMatrixTransformation2D(&mat,0,0.0,0,0,0.0f,&trans);
					D3DXMatrixTransformation2D(&mat2,0,0.0,0,&rotPoint,rotation,0);
					D3DXMatrixMultiply(&res, &mat, &mat2);
					sprite->SetTransform(&res);
					//draw player:
					sprite->Draw(hud->Textures[2], NULL, &center, NULL, 0xFF0000FF);
				}
			}

			//draw player:
			trans = D3DXVECTOR2((FLOAT)(desc.Width/2*hud->getScaleRadarX() + hud->getRadarOffsetX()),(FLOAT) this->myScene->manager->screenHeight - (desc.Height/2*hud->getScaleRadarY() + hud->getRadarOffsetY()));
			//reset matrix:
			D3DXMatrixIdentity(&mat);
			D3DXMatrixTransformation2D(&mat,0,0.0,0,0,0,&trans);
			sprite->SetTransform(&mat);
			//draw player:
			sprite->Draw(hud->Textures[2], NULL, &center, NULL, 0xFFFF0000);
			
			//draw human player health logo & health bar:
			hud->Textures[3]->GetLevelDesc(0, &desc);	//get texture size
			hud->Textures[4]->GetLevelDesc(0, &desc2);
			float offset = 20;
			RECT rectangle;
			float health = gs->player->getHealth();
			if(health>100.0f) {
				this->myScene->manager->printToConsole("Health over 100 percent!!!!");
				health = 100.0f;
			}
			if (health<0.0f) {
				this->myScene->manager->printToConsole("Health under 0 percent!!!!");
				health = 0.0f;
			}
			SetRect(&rectangle, 0, 0, (int)(desc2.Width*health/100), (int)(desc2.Height)); 
			scaling = D3DXVECTOR2(hud->getScaleUserPlayer(),hud->getScaleUserPlayer());
			//reset matrix:
			D3DXMatrixIdentity(&mat);
			D3DXMatrixTransformation2D(&mat,0,0.0,&scaling,0,0.0f,0);
			sprite->SetTransform(&mat);
			//set logo position:
			D3DXVECTOR3 pos (offset,offset,0.0f);
			//draw health logo:
			sprite->Draw(hud->Textures[3], NULL, NULL, &pos, 0xFFFFFFFF);
			//set bar position:
			pos = D3DXVECTOR3(offset + desc.Width + offset, offset, 0);
			sprite->Draw(hud->Textures[4], &rectangle, NULL, &pos, 0xFFFFFFFF);

			//draw ai players health logos & health bars:
			hud->Textures[5]->GetLevelDesc(0, &desc);	//get texture size
			hud->Textures[6]->GetLevelDesc(0, &desc2);	//get texture size
			//scale according to xml settings
			scaling = D3DXVECTOR2(hud->getScaleAIPlayer(),hud->getScaleAIPlayer());
			D3DXVECTOR2 scalepos((float)this->myScene->manager->screenWidth, 0);
			D3DXMatrixIdentity(&mat);
			D3DXMatrixTransformation2D(&mat,&scalepos,0.0,&scaling,0,0.0f,0);
			sprite->SetTransform(&mat);
			//draw info for alle opponents:
			float sum = offset;
			for(it=playerList->begin();it!=playerList->end();it++) {
				activeOpponent = ((Player *) (*it).get());
				if(activeOpponent != (Player *)gs->player) {
					//set logo position:
					pos = D3DXVECTOR3((float)this->myScene->manager->screenWidth - desc.Width - offset,sum,0);
					//draw logo:
					sprite->Draw(hud->Textures[5], NULL, NULL, &pos, 0xFFFFFFFF);
					//set health bar position:
					health = activeOpponent->getHealth();
					if(health>100.0f) {
						this->myScene->manager->printToConsole("Health over 100 percent!!!!");
						health = 100.0f;
					}
					if (health<0.0f) {
						this->myScene->manager->printToConsole("Health under 0 percent!!!!");
						health = 0.0f;
					}
					SetRect(&rectangle, (int)(desc2.Width - desc2.Width*health/100), 0, (int)desc2.Width, (int)(desc2.Height));
					pos = D3DXVECTOR3((float)this->myScene->manager->screenWidth - desc.Width - 2*offset - desc2.Width + (int)(desc2.Width - desc2.Width*health/100),sum, 0);
					//draw health bar:
					sprite->Draw(hud->Textures[6], &rectangle, NULL, &pos, 0xFFFFFFFF);
					//next player position:
					sum += desc.Width + offset;
				}
			}

			//reset matrix:
			D3DXMatrixIdentity(&mat);
			sprite->SetTransform(&mat);
			
			//time output:
			std::ostringstream ostr;
			ostr.str("");
			ostr << "Time left: ";
			ostr << hud->minutes;
			ostr << " min ";
			ostr << hud->seconds;
			ostr << " sec";
			std::string temp = ostr.str();
			std::wstring time(temp.begin(), temp.end());
			myFont->DrawText(sprite, time.c_str(), -1, &timeRectangle, DT_RIGHT, fontColor);
			
			//ammunition output:
			ostr.str("");
			ostr << "Ammo: ";
			ostr << hud->ammoAmount;
			temp = ostr.str();
			std::wstring ammo(temp.begin(), temp.end());
			myFont->DrawText(sprite, ammo.c_str(), -1, &ammoRectangle, DT_RIGHT, fontColor);

			//message output:
			#if(0)
				// display message for messagethreshold period of time
				if (hud->messagetimer < hud->messagethreshold) {
					hud->messagetimer += hud->messagedt;
					if(!hud->bHelp) {
											myFont->DrawText(sprite, hud->messagestring.c_str(), -1, &textRectangle, DT_CENTER | DT_WORDBREAK, fontColor);
					} 
					else {
						myFont->DrawText(sprite, hud->messagestring.c_str(), -1, &helpRectangle, DT_LEFT | DT_WORDBREAK, fontColor);
					}
				}
			#elif(1) // MG
				// F1 toggles help screen display
				if (hud->messagetimer < hud->messagethreshold) {
					hud->messagetimer += hud->messagedt;
				}

				if(GLOBAL_display_help_screenQ) {
						myFont->DrawText(sprite, this->myScene->manager->HelpScreenString_Get().c_str(), -1, &helpRectangle, DT_LEFT | DT_WORDBREAK, fontColor);
				}
				else {
					// No help screen active => display message (if active)
					if (hud->messagetimer < hud->messagethreshold) {
						myFont->DrawText(sprite, hud->messagestring.c_str(), -1, &textRectangle, DT_CENTER | DT_WORDBREAK, fontColor);
					}
				}
			#endif

			//you win output:
			if (hud->youwintimer < hud->youwinthreshold) {
				hud->youwintimer += hud->youwindt;
				//now draw the you win stuff:
				std::list<HUD::Letter>::iterator iter;
				for(UINT i = 0; i < hud->YouWin.size(); i++) {
					HUD::Letter *tempLetter = &hud->YouWin.at(i);
					scaling = D3DXVECTOR2(tempLetter->scale,tempLetter->scale);
					scalepos = D3DXVECTOR2(tempLetter->x - tempLetter->centerX,tempLetter->y - tempLetter->centerY);
					rotPoint = D3DXVECTOR2(tempLetter->x,tempLetter->y);
					rotation = hud->youwintimer * tempLetter->rotation;
					D3DXMatrixIdentity(&mat);
					D3DXMatrixTransformation2D(&mat,&scalepos,0.0,&scaling,&rotPoint,rotation,0);
					sprite->SetTransform(&mat);
					pos = D3DXVECTOR3(tempLetter->x, tempLetter->y, 0);
					center = D3DXVECTOR3((FLOAT)tempLetter->centerX, (FLOAT)tempLetter->centerY, 0);
					sprite->Draw(tempLetter->texture, NULL, &center, &pos, 0xFFFFFFFF);
				}
			}
			//you lose output:
			if (hud->youlosetimer < hud->youlosethreshold) {
				hud->youlosetimer += hud->youlosedt;
				//now draw the you lose stuff:
				std::list<HUD::Letter>::iterator iter;
				for(UINT i = 0; i < hud->YouLose.size(); i++) {
					HUD::Letter *tempLetter = &hud->YouLose.at(i);
					scaling = D3DXVECTOR2(tempLetter->scale,tempLetter->scale);
					scalepos = D3DXVECTOR2(tempLetter->x - tempLetter->centerX,tempLetter->y - tempLetter->centerY);
					rotPoint = D3DXVECTOR2(tempLetter->x,tempLetter->y);
					rotation = hud->youlosetimer * tempLetter->rotation;
					D3DXMatrixIdentity(&mat);
					D3DXMatrixTransformation2D(&mat,&scalepos,0.0,&scaling,&rotPoint,rotation,0);
					sprite->SetTransform(&mat);
					pos = D3DXVECTOR3(tempLetter->x, tempLetter->y, 0);
					center = D3DXVECTOR3((FLOAT)tempLetter->centerX, (FLOAT)tempLetter->centerY, 0);
					sprite->Draw(tempLetter->texture, NULL, &center, &pos, 0xFFFFFFFF);
				}
			}

			//toasted output:
			if (hud->toastedtimer < hud->toastedthreshold) {
				hud->toastedtimer += hud->toasteddt;
				//now draw the you lose stuff:
				std::list<HUD::Letter>::iterator iter;
				for(UINT i = 0; i < hud->Toasted.size(); i++) {
					HUD::Letter *tempLetter = &hud->Toasted.at(i);
					scaling = D3DXVECTOR2(tempLetter->scale,tempLetter->scale);
					scalepos = D3DXVECTOR2(tempLetter->x - tempLetter->centerX,tempLetter->y - tempLetter->centerY);
					rotPoint = D3DXVECTOR2(tempLetter->x,tempLetter->y);
					rotation = hud->toastedtimer * tempLetter->rotation;
					D3DXMatrixIdentity(&mat);
					D3DXMatrixTransformation2D(&mat,&scalepos,0.0,&scaling,&rotPoint,rotation,0);
					sprite->SetTransform(&mat);
					pos = D3DXVECTOR3(tempLetter->x, tempLetter->y, 0);
					center = D3DXVECTOR3((FLOAT)tempLetter->centerX, (FLOAT)tempLetter->centerY, 0);
					sprite->Draw(tempLetter->texture, NULL, &center, &pos, 0xFFFFFFFF);
				}
			}

			sprite->End();

			//deactivate textures
			this->device->SetTexture(0, 0);

			//enable z buffer:
			this->device->SetRenderState(D3DRS_ZENABLE, TRUE);
		}
		this->device->EndScene();
	}
}

void HUDRenderer::OnLostDevice( void* pUserContext )
{
	this->myFont->OnLostDevice();
	this->sprite->OnLostDevice();
}

void HUDRenderer::OnDestroyDevice( void* pUserContext )
{
	SAFE_RELEASE(this->myFont);
	SAFE_RELEASE(sprite);
	this->myFont = NULL;
	this->sprite = NULL;
}

HRESULT HUDRenderer::OnResetDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext )
{
	this->device = pd3dDevice;
	D3DXCreateSprite(this->device,&sprite);
	D3DXCreateFont( this->device, 26, 0, FW_BOLD, 0, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, TEXT("Arial"), &myFont );
	fontColor = D3DCOLOR_ARGB(255,255,255,255);
	return S_OK;
}

bool HUDRenderer::isLowerThan(Renderer* renderer)
{
	//Unter der Annahme, dass es kein zweites HUD gibt!
	return this->getRenderPriority() < renderer->getRenderPriority();
}