/* 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 HPL1 Engine.
 */

#ifndef HPL_PHYSICS_JOINT_H
#define HPL_PHYSICS_JOINT_H

#include "hpl1/engine/math/MathTypes.h"
#include "hpl1/engine/system/SystemTypes.h"
#include "common/stablemap.h"

#include "hpl1/engine/game/SaveGame.h"

#include "hpl1/engine/physics/PhysicsController.h"

namespace hpl {

class iPhysicsBody;
class iPhysicsWorld;
class cSoundEntity;
class iPhysicsJoint;
class iPhysicsController;

typedef Common::StableMap<tString, iPhysicsController *> tPhysicsControllerMap;
typedef tPhysicsControllerMap::iterator tPhysicsControllerMapIt;

typedef cSTLMapIterator<iPhysicsController *, tPhysicsControllerMap, tPhysicsControllerMapIt> cPhysicsControllerIterator;

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

enum ePhysicsJointType {
	ePhysicsJointType_Ball,
	ePhysicsJointType_Hinge,
	ePhysicsJointType_Slider,
	ePhysicsJointType_Screw,
	ePhysicsJointType_LastEnum
};

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

enum ePhysicsJointSpeed {
	ePhysicsJointSpeed_Linear,
	ePhysicsJointSpeed_Angular,
	ePhysicsJointSpeed_LastEnum
};

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

class cJointLimitEffect : public iSerializable {
	kSerializableClassInit(cJointLimitEffect) public : tString msSound;
	float mfMinSpeed;
	float mfMaxSpeed;
};

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

class iPhysicsJointCallback {
public:
	virtual ~iPhysicsJointCallback() {}

	virtual void OnMinLimit(iPhysicsJoint *apJoint) = 0;
	virtual void OnMaxLimit(iPhysicsJoint *apJoint) = 0;

	// Ugly trick to support joint script callback.
	virtual bool IsScript() { return false; }
};

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

kSaveData_BaseClass(iPhysicsJoint) {
	kSaveData_ClassInit(iPhysicsJoint) public : tString msName;

	int mlParentBodyId;
	int mlChildBodyId;

	cMatrixf m_mtxParentBodySetup;
	cMatrixf m_mtxChildBodySetup;

	cVector3f mvPinDir;
	cVector3f mvStartPivotPoint;

	cContainerList<cSaveData_iPhysicsController> mlstControllers;

	cJointLimitEffect mMaxLimit;
	cJointLimitEffect mMinLimit;

	tString msMoveSound;

	float mfMinMoveSpeed;
	float mfMinMoveFreq;
	float mfMinMoveFreqSpeed;
	float mfMinMoveVolume;
	float mfMaxMoveFreq;
	float mfMaxMoveFreqSpeed;
	float mfMaxMoveVolume;
	float mfMiddleMoveSpeed;
	float mfMiddleMoveVolume;
	int mMoveSpeedType;

	bool mbBreakable;
	float mfBreakForce;
	tString msBreakSound;
	bool mbBroken;

	tString msCallbackMaxFunc;
	tString msCallbackMinFunc;
	bool mbAutoDeleteCallback;
};

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

class iPhysicsJoint : public iSaveObject {
	typedef iSaveObject super;

public:
	iPhysicsJoint(const tString &asName, iPhysicsBody *apParentBody, iPhysicsBody *apChildBody,
				  iPhysicsWorld *apWorld, const cVector3f &avPivotPoint);
	virtual ~iPhysicsJoint();

	const tString &GetName() { return msName; }

	iPhysicsBody *GetParentBody() { return mpParentBody; }
	iPhysicsBody *GetChildBody() { return mpChildBody; }

	void RemoveBody(iPhysicsBody *apBody);

	cVector3f GetPivotPoint() { return mvPivotPoint; }
	cVector3f GetPinDir() { return mvPinDir; }

	virtual ePhysicsJointType GetType() = 0;

	virtual void SetCollideBodies(bool abX) = 0;
	virtual bool GetCollideBodies() = 0;

	virtual void SetStiffness(float afX) = 0;
	virtual float GetStiffness() = 0;

	virtual cVector3f GetVelocity() = 0;
	virtual cVector3f GetAngularVelocity() = 0;
	virtual cVector3f GetForce() = 0;

	virtual float GetDistance() = 0;
	virtual float GetAngle() = 0;

	cJointLimitEffect *GetMaxLimit() { return &mMaxLimit; }
	cJointLimitEffect *GetMinLimit() { return &mMinLimit; }

	void SetMoveSound(tString &asName) { msMoveSound = asName; }

	void SetMoveSpeedType(ePhysicsJointSpeed aType) { mMoveSpeedType = aType; }
	void SetMinMoveSpeed(float afX) { mfMinMoveSpeed = afX; }
	void SetMinMoveFreq(float afX) { mfMinMoveFreq = afX; }
	void SetMinMoveFreqSpeed(float afX) { mfMinMoveFreqSpeed = afX; }
	void SetMinMoveVolume(float afX) { mfMinMoveVolume = afX; }
	void SetMaxMoveFreq(float afX) { mfMaxMoveFreq = afX; }
	void SetMaxMoveVolume(float afX) { mfMaxMoveVolume = afX; }
	void SetMaxMoveFreqSpeed(float afX) { mfMaxMoveFreqSpeed = afX; }
	void SetMiddleMoveSpeed(float afX) { mfMiddleMoveSpeed = afX; }
	void SetMiddleMoveVolume(float afX) { mfMiddleMoveVolume = afX; }

	void SetCallback(iPhysicsJointCallback *apCallback, bool abAutoDelete) {
		mpCallback = apCallback;
		mbAutoDeleteCallback = abAutoDelete;
	}

	iPhysicsJointCallback *GetCallback() { return mpCallback; }

	bool CheckBreakage();

	void SetBreakable(bool abX) { mbBreakable = abX; }
	bool IsBreakable() { return mbBreakable; }
	void SetBreakForce(float afForce) { mfBreakForce = afForce; }
	float GetBreakForce() { return mfBreakForce; }
	void SetBreakSound(const tString &asSound) { msBreakSound = asSound; }

	void SetLimitAutoSleep(bool abX) { mbLimitAutoSleep = abX; }
	void SetLimitAutoSleepDist(float afX) { mfLimitAutoSleepDist = afX; }
	void SetLimitAutoSleepNumSteps(int alX) { mlLimitAutoSleepNumSteps = alX; }

	bool GetLimitAutoSleep() { return mbLimitAutoSleep; }
	float GetLimitAutoSleepDist() { return mfLimitAutoSleepDist; }
	int GetLimitAutoSleepNumSteps() { return mlLimitAutoSleepNumSteps; }

	void SetStickyMinDistance(float afX) { mfStickyMinDistance = afX; }
	void SetStickyMaxDistance(float afX) { mfStickyMaxDistance = afX; }
	float GetStickyMinDistance() { return mfStickyMinDistance; }
	float GetStickyMaxDistance() { return mfStickyMaxDistance; }

	void Break();

	bool IsBroken() { return mbBroken; }

	void SetUserData(void *apUserData) { mpUserData = apUserData; }

	void AddController(iPhysicsController *apController);
	iPhysicsController *GetController(const tString &asName);
	bool ChangeController(const tString &asName);
	cPhysicsControllerIterator GetControllerIterator();

	void SetAllControllersPaused(bool abX);

	void OnPhysicsUpdate();

	void SetSound(cSoundEntity *apSound) { mpSound = apSound; }
	cSoundEntity *GetSound() { return mpSound; }

	// SaveObject implementation
	virtual iSaveData *CreateSaveData();
	virtual void SaveToSaveData(iSaveData *apSaveData);
	virtual void LoadFromSaveData(iSaveData *apSaveData);
	virtual void SaveDataSetup(cSaveObjectHandler *apSaveObjectHandler, cGame *apGame);

protected:
	tString msName;

	iPhysicsBody *mpParentBody;
	iPhysicsBody *mpChildBody;
	iPhysicsWorld *mpWorld;

	cMatrixf m_mtxParentBodySetup;
	cMatrixf m_mtxChildBodySetup;

	cVector3f mvPinDir;
	cVector3f mvPivotPoint;
	cVector3f mvStartPivotPoint;

	cVector3f mvLocalPivot;

	float mfStickyMinDistance;
	float mfStickyMaxDistance;

	tPhysicsControllerMap m_mapControllers;

	cJointLimitEffect mMaxLimit;
	cJointLimitEffect mMinLimit;

	int mlSpeedCount;

	cMatrixf m_mtxPrevChild;
	cMatrixf m_mtxPrevParent;

	tString msMoveSound;

	float mfMinMoveSpeed;
	float mfMinMoveFreq;
	float mfMinMoveFreqSpeed;
	float mfMinMoveVolume;
	float mfMaxMoveFreq;
	float mfMaxMoveFreqSpeed;
	float mfMaxMoveVolume;
	float mfMiddleMoveSpeed;
	float mfMiddleMoveVolume;
	ePhysicsJointSpeed mMoveSpeedType;

	bool mbBreakable;
	float mfBreakForce;
	tString msBreakSound;
	bool mbBroken;

	bool mbLimitAutoSleep;
	float mfLimitAutoSleepDist;
	int mlLimitAutoSleepNumSteps;

	cSoundEntity *mpSound;
	bool mbHasCollided;

	iPhysicsJointCallback *mpCallback;
	bool mbAutoDeleteCallback;

	int mlLimitStepCount;

	void *mpUserData;

	static void CheckLimitAutoSleep(iPhysicsJoint *apJoint, const float afMin, const float afMax,
									const float afDist);

	void OnMaxLimit();
	void OnMinLimit();
	void OnNoLimit();

	void CalcSoundFreq(float afSpeed, float *apFreq, float *apVol);

	void LimitEffect(cJointLimitEffect *pEffect);
};

} // namespace hpl

#endif // HPL_PHYSICS_JOINT_H