/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/*
 * Copyright (C) 2006-2010 - Frictional Games
 *
 * This file is part of Penumbra Overture.
 */

#ifndef GAME_GAME_ENTITY_H
#define GAME_GAME_ENTITY_H

#include "hpl1/engine/engine.h"

using namespace hpl;

#include "hpl1/penumbra-overture/GameTypes.h"
#include "hpl1/penumbra-overture/SaveTypes.h"

class cInit;
class iGameEntity;
class cInventoryItem;

//-----------------------------------------

class cGameEntityScript : public iSerializable {
	kSerializableClassInit(cGameEntityScript) public : cGameEntityScript() : msScriptFunc("") {}

	int mlNum;
	tString msScriptFunc;
};

typedef Common::StableMap<tString, cGameEntityScript *> tGameEntityScriptMap;
typedef tGameEntityScriptMap::iterator tGameEntityScriptMapIt;

//-----------------------------------------

typedef Common::StableMap<tString, int> tGameEntityVarMap;
typedef tGameEntityVarMap::iterator tGameEntityVarMapIt;

//------------------------------------------

class iGameEntity;

//------------------------------------------

class cGameEntityAnimation_SaveData : public iSerializable {
	kSerializableClassInit(cGameEntityAnimation_SaveData) public : bool mbActive;
	bool mbLoop;

	float mfWeight;
	float mfFadeStep;
	float mfTimePos;
	float mfSpeed;
};
//------------------------------------------

class iGameEntity_SaveData : public iSerializable {
	kSerializableClassInit(iGameEntity_SaveData) public : bool mbActive;

	tString msFileName;

	tString msName;

	float mfHealth;

	float mfMaxExamineDist;
	float mfMaxInteractDist;

	bool mbHasBeenExamined;

	tWString msGameName;
	tWString msDescription;

	bool mbShowDescritionOnce;

	eGameEntityType mType;

	cMatrixf m_mtxTransform;

	// Engine types
	cContainerVec<cEngineBody_SaveData> mvBodies;
	cContainerVec<cEnginePS_SaveData> mvPS;
	cContainerVec<cEnginePS_SaveData> mvBeams;
	cContainerVec<cEngineLight_SaveData> mvLights;
	cContainerVec<cEngineSound_SaveData> mvSounds;

	cEnginePS_SaveData *GetParticleSystem(cParticleSystem3D *apPS);
	cEngineSound_SaveData *GetSoundEntity(cSoundEntity *apSound);

	// Animations
	cContainerVec<cGameEntityAnimation_SaveData> mvAnimations;

	// Callbacks
	cContainerList<cSaveGame_cGameCollideScript> mlstCollideCallbacks;

	cContainerList<cGameEntityScript> mlstCallbackScripts;

	// Script variables
	cContainerList<cScriptVar> mlstVars;

	// Creation
	virtual iGameEntity *CreateEntity() = 0;
};

//------------------------------------------

class iGameEntity {
	friend class cPlayer;

public:
	iGameEntity(cInit *apInit, const tString &asName);
	virtual ~iGameEntity();

	const tString &GetName() { return msName; }

	bool IsActive() { return mbActive; }
	void SetActive(bool abX);
	virtual void OnSetActive(bool abX) {}

	virtual bool IsSaved() { return mbIsSaved; }

	virtual void OnWorldLoad() {}
	virtual void OnPostLoadScripts() {}
	virtual void OnWorldExit() {}
	virtual void Update(float afTimeStep) {}
	virtual void OnDraw() {}
	virtual void OnPostSceneDraw() {}

	void OnUpdate(float afTimeStep);

	eGameEntityType GetType() { return mType; }

	const tString &GetSubType() { return msSubType; }

	void SetDescription(const tWString &asDesc) { msDescription = asDesc; }
	const tWString &GetDescription() { return msDescription; }

	void SetShowDescritionOnce(bool abX) { mbShowDescritionOnce = abX; }
	bool GetShowDescritionOnce() { return mbShowDescritionOnce; }

	bool GetHasBeenExamined() { return mbHasBeenExamined; }

	void SetGameName(const tWString &asName) { msGameName = asName; }
	const tWString &GetGameName() { return msGameName; }

	iPhysicsBody *GetBody(int alNum) { return mvBodies[alNum]; }
	int GetBodyNum() { return (int)mvBodies.size(); }
	void SetBodies(Common::Array<iPhysicsBody *> &avBodies) { mvBodies = avBodies; }

	iPhysicsJoint *GetJoint(int alNum) { return mvJoints[alNum]; }
	int GetJointNum() { return (int)mvJoints.size(); }
	void SetJoints(Common::Array<iPhysicsJoint *> &avJoints) { mvJoints = avJoints; }

	int GetLightNum() { return (int)mvLights.size(); }
	iLight3D *GetLight(int alX) { return mvLights[alX]; }
	void SetLights(Common::Array<iLight3D *> &avLights) { mvLights = avLights; }

	void SetParticleSystems(Common::Array<cParticleSystem3D *> &avParticleSystems) { mvParticleSystems = avParticleSystems; }
	void SetBillboards(Common::Array<cBillboard *> &avBillboards) { mvBillboards = avBillboards; }
	void SetBeams(Common::Array<cBeam *> &avBeams) { mvBeams = avBeams; }
	void SetSoundEntities(Common::Array<cSoundEntity *> &avSoundEntities) { mvSoundEntities = avSoundEntities; }

	void DestroyLight(iLight3D *apLight);
	void DestroyParticleSystem(cParticleSystem3D *apPS);
	void DestroyBillboard(cBillboard *apBillboard);
	void SetSoundEntity(cSoundEntity *apSound);

	cMeshEntity *GetMeshEntity() { return mpMeshEntity; }
	void SetMeshEntity(cMeshEntity *apEnity) { mpMeshEntity = apEnity; }

	void PlayerPick();
	void PlayerInteract();
	void PlayerExamine();

	virtual void OnPlayerPick() {}
	virtual void OnPlayerInteract() {}
	virtual void OnPlayerExamine();

	virtual bool OnUseItem(cInventoryItem *apItem) { return false; }

	virtual void BreakAction() {}

	virtual void OnDamage(float afDamage) {}
	virtual void OnDeath(float afDamage) {}

	virtual void OnPlayerGravityCollide(iCharacterBody *apCharBody, cCollideData *apCollideData) {}

	bool GetHasInteraction() { return mbHasInteraction; }

	float GetMaxExamineDist() { return mfMaxExamineDist; }
	void SetMaxExamineDist(float afX) { mfMaxExamineDist = afX; }
	float GetMaxInteractDist() { return mfMaxInteractDist; }
	void SetMaxInteractDist(float afX) { mfMaxInteractDist = afX; }

	virtual eCrossHairState GetPickCrossHairState(iPhysicsBody *apBody);
	virtual float GetPickedDistance();

	void AddCollideScript(eGameCollideScriptType aType, const tString &asFunc, const tString &asEntity);
	void RemoveCollideScript(eGameCollideScriptType aType, const tString &asFunc);
	void RemoveCollideScriptWithChildEntity(iGameEntity *apEntity);

	void AddScript(eGameEntityScriptType aType, const tString &asFunc);
	void RemoveScript(eGameEntityScriptType aType);

	void CreateVar(const tString &asName, int alVal);
	void SetVar(const tString &asName, int alVal);
	void AddVar(const tString &asName, int alVal);
	int GetVar(const tString &asName);

	void Damage(float afDamage, int alStrength);
	float GetHealth() { return mfHealth; }
	void SetHealth(float afHealth);

	void SetToughness(int alX) { mlToughness = alX; }
	int GetToughness() { return mlToughness; }

	bool GetDestroyMe() { return mbDestroyMe; }
	bool GetBreakMe() { return mbBreakMe; }

	void Break() { mbBreakMe = true; }

	void SetCharBody(iCharacterBody *apCharBody) { mpCharBody = apCharBody; }
	iCharacterBody *SetCharBody() { return mpCharBody; }

	void SetUpTransMaterials();
	void SetTransActive(bool abX);

	void SetPauseControllers(bool abX) { mbPauseControllers = abX; }
	bool GetPauseControllers() { return mbPauseControllers; }

	void SetPauseGravity(bool abX) { mbPauseGravity = abX; }
	bool GetPauseGravity() { return mbPauseGravity; }

	const cMatrixf &GetOnLoadTransform() { return m_mtxOnLoadTransform; }
	void SetOnLoadTransform(const cMatrixf &a_mtxPose) { m_mtxOnLoadTransform = a_mtxPose; }

	void SetLastImpulse(const cVector3f &avVec) { mvLastImpulse = avVec; }

	const tString &GetFileName() { return msFileName; }

	cGameEntityScript *GetCallbackScript(eGameEntityScriptType aType) { return mvCallbackScripts[aType]; }

	// Save data stuff
	void SetSaveData(iGameEntity_SaveData *apData) { mpSaveData = apData; }
	iGameEntity_SaveData *GetSaveData() { return mpSaveData; }

	virtual iGameEntity_SaveData *CreateSaveData() = 0;
	virtual void LoadFromSaveData(iGameEntity_SaveData *apSaveData);
	virtual void SaveToSaveData(iGameEntity_SaveData *apSaveData);
	virtual void SetupSaveData(iGameEntity_SaveData *apSaveData);

protected:
	tString GetScriptCommand(eGameEntityScriptType aType);

	void PreloadModel(const tString &asFile);

	cInit *mpInit;

	bool mbActive;

	tString msFileName;

	bool mbIsSaved;

	bool mbDestroyMe;
	bool mbBreakMe;

	bool mbHasInteraction;

	bool mbHasBeenExamined;

	tString msName;

	tString msSubType;

	float mfHealth;
	int mlToughness;

	tWString msGameName;
	tWString msDescription;

	bool mbShowDescritionOnce;

	float mfMaxExamineDist;
	float mfMaxInteractDist;

	eGameEntityType mType;

	bool mbPauseControllers;
	bool mbPauseGravity;

	cMatrixf m_mtxOnLoadTransform;

	iGameEntity_SaveData *mpSaveData;

	Common::Array<iPhysicsBody *> mvBodies;
	Common::Array<iPhysicsJoint *> mvJoints;

	Common::Array<iLight3D *> mvLights;
	Common::Array<cParticleSystem3D *> mvParticleSystems;
	Common::Array<cBillboard *> mvBillboards;
	Common::Array<cBeam *> mvBeams;
	Common::Array<cSoundEntity *> mvSoundEntities;

	bool mbSaveLights;

	cMeshEntity *mpMeshEntity;

	Common::Array<iMaterial *> mvNormalMaterials;
	Common::Array<iMaterial *> mvTransMaterials;
	bool mbTransActive;
	bool mbTransShadow;

	cVector3f mvLastImpulse;

	Common::Array<cMesh *> mvPreloadedBreakMeshes;

	iCharacterBody *mpCharBody;

	cGameEntityScript *mvCallbackScripts[eGameEntityScriptType_LastEnum];
	tGameCollideScriptMap m_mapCollideCallbacks;

	tGameEntityVarMap m_mapVars;

	bool mbUpdatingCollisionCallbacks;
};

#endif // GAME_GAME_ENTITY_H