// Copyright (C) 2007 Id Software, Inc.
//

#ifndef __GAME_WEAPON_H__
#define __GAME_WEAPON_H__

#include "interfaces/NetworkInterface.h"
#include "client/ClientEntity.h"

/*
===============================================================================

	Player Weapon
	
===============================================================================
*/

#include "AnimatedEntity.h"

typedef enum {
	WP_READY,
	WP_RELOAD,
	WP_HOLSTERED,
	WP_RISING,
	WP_LOWERING
} weaponStatus_t;

class idWeapon;

class sdWeaponNetworkInterface : public sdNetworkInterface {
public:
										sdWeaponNetworkInterface( void ) { owner = NULL; }

	void								Init( idWeapon* _owner ) { owner = _owner; }

	virtual void						HandleNetworkMessage( idPlayer* player, const char* message );
	virtual void						HandleNetworkEvent( const char* message );

protected:
	idWeapon*							owner;
};

class sdWeaponLockInfo {
public:
							sdWeaponLockInfo( void ) { lockingSound = NULL; lockedSound = NULL; lockDistance = 0.f; supported = false; lockFriendly = false; sticky = false; }

	void					Load( const idDict& dict );

	void					SetSupported( bool value ) { supported = value; }

	bool					IsSupported( void ) const { return supported; }
	bool					IsSticky( void ) const { return sticky; }
	float					GetLockDistance( void ) const { return lockDistance; }
	const idSoundShader*	GetLockingSound( void ) const { return lockingSound; }
	const idSoundShader*	GetLockedSound( void ) const { return lockedSound; }
	int						GetLockDuration( void ) const { return lockDuration; }
	bool					LockFriendly( void ) const { return lockFriendly; }

	const sdDeclTargetInfo*	GetLockFilter( void ) const { return lockFilter; }

private:
	const idSoundShader*	lockingSound;
	const idSoundShader*	lockedSound;
	float					lockDistance;
	int						lockDuration;
	bool					supported;
	bool					lockFriendly;
	bool					sticky;
	const sdDeclTargetInfo*	lockFilter;
};

class idPlayer;
class idProjectile;
class idMoveableItem;
class sdPlayerStatEntry;

extern const idEventDef EV_Weapon_LaunchProjectiles;

typedef struct modInfo_s {
	const idDeclEntityDef*	projectileDef;
	const char*				clientProjectileScript;
	ammoType_t				ammoType;
	int						ammoRequired;		// amount of ammo to use each shot.  0 means weapon doesn't need ammo.
	int						clipSize;			// 0 means no reload
	int						lowAmmo;			// if ammo in clip hits this threshold, snd_
} modInfo_t;

struct weaponSpreadValues_t {
	float					min;
	float					max;
	float					inc;
	int						numIgnoreRounds;	// e.g., the assualt rifle's burst fire should all have the same cone
	int						maxSettleTime;

	// movement dependant
	float					viewRateMin;
	float					viewRateMax;
	float					viewRateInc;
};

struct weaponAimValues_t {
	float					bobscaleyaw;
	float					bobscalepitch;
	float					lagscaleyaw;
	float					lagscalepitch;
	float					speedlr;
};

struct weaponFeedback_t {
	int						recoilTime;
	idAngles				recoilAngles;
	float					kickback;
	float					kickbackProne;
};

enum weaponSpreadValueIndex_t {
	WSV_STANDING,
	WSV_CROUCHING,
	WSV_PRONE,
	WSV_JUMPING,
	WSV_NUM,
};

enum weaponAimValueIndex_t {
	WAV_NORMAL,
	WAV_IRONSIGHTS,
	WAV_NUM,
};

class idWeapon : public idAnimatedEntity {
public:
	CLASS_PROTOTYPE( idWeapon );

							idWeapon();
	virtual					~idWeapon();

	// Init
	void					Spawn( void );
	void					SetOwner( idPlayer* _owner );
	idPlayer*				GetOwner( void ) { return owner; }
	virtual bool			ShouldConstructScriptObjectAtSpawn( void ) const;

	virtual bool			StartSynced( void ) const { return true; }

	void					UpdateVisibility( void );

	virtual bool			NoThink( void ) const { return true; }

	bool					OnActivate( idPlayer* player, float distance );
	bool					OnActivateHeld( idPlayer* player, float distance );
	bool					OnUsed( idPlayer* player, float distance );
	bool					OnWeapNext();
	bool					OnWeapPrev();

	virtual sdTeamInfo*		GetGameTeam( void ) const;

	// Weapon definition management
	void					Clear( void );
	void					LinkScriptVariables( void );
	void					GetWeaponDef( const sdDeclInvItem* item );
	bool					IsLinked( void );

	void					MakeReady( void ) { Event_WeaponReady(); }
	void					OnProxyEnter( void );
	void					OnProxyExit( void );

	void					LogTimeUsed( void );

	virtual void			SetModel( const char *modelname );
	bool					GetGlobalJointTransform( bool viewModel, const jointHandle_t jointHandle, idVec3 &offset, idMat3 &axis );

	void					UpdateShadows( void );

	// State control/player interface
	void					Think( void );
	void					Raise( void );
	void					PutAway( void );
	void					Reload( void );
	void					LowerWeapon( void );
	void					RaiseWeapon( void );
	void					HideWorldModel( void );
	void					ShowWorldModel( void );
	void					OwnerDied( void );
	void					BeginAttack( void );
	void					EndAttack( void );
	
	void					UpdateSpreadValue( void );
	void					UpdateSpreadValue( const idVec3& velocity, const idAngles& angles, const idAngles& oldAngles );

	virtual bool			ClientReceiveEvent( int event, int time, const idBitMsg &msg );
	virtual	bool			ClientReceiveUnreliableEvent( int event, int time, const idBitMsg &msg );

	void					DoStanceTransition( weaponSpreadValueIndex_t oldStanceState );

	void					BeginModeSwitch( void );
	void					EndModeSwitch( void );

	void					BeginAltFire( void );
	void					EndAltFire( void );

	bool					IsReady( void ) const;
	bool					IsReloading( void ) const;
	bool					IsHolstered( void ) const;
	void					InstantSwitch( void );
	bool					CanAttack( void );

	bool					IsAttacking( void ) const;

	const idVec3&			GetViewOffset( void ) const { return viewOffset; }

	float					GetLargeFOVScale( void ) const { return largeFOVScale; }

	float					GetSpreadValue() const;
	float					GetSpreadValueNormalized( bool useGlobalMax = true ) const;
	float					GetCrosshairSpreadMin() const { return crosshairSpreadMin; }
	float					GetCrosshairSpreadMax() const { return crosshairSpreadMax; }
	float					GetCrosshairSpreadScale() const { return crosshairSpreadScale; }

	int						GetGrenadeFuseTime( void );

	void					SetOwnerStanceState( weaponSpreadValueIndex_t state );

	// Script state management
	virtual sdProgramThread* ConstructScriptObject( void );
	virtual void			DeconstructScriptObject( void );
	void					SetState( const char *statename, int blendFrames );
	void					UpdateScript( void );

	// Visual presentation
	virtual void			Present( void );
	virtual void			FreeModelDef( void );
	void					PresentWeapon( void );
	void					SwayAngles( idAngles& angles ) const;

	// Ammo
	static ammoType_t		GetAmmoType( const char *ammoname );
	ammoType_t				GetAmmoType( int modIndex ) const;
	int						ShotsAvailable( int modIndex ) const;
	int						GetClipSize( int modIndex ) const;
	int						LowAmmo( int modIndex ) const;
	int						AmmoRequired( int modIndex ) const;
	bool					IsClipBased() const;
	bool					UsesStroyent() const;

	void							UpdatePlayerWeaponInfo(); //mal: update what this player's current weapon is for the bots.
	const playerWeaponTypes_t&		GetPlayerWeaponNum( void ) const { return playerWeaponNum; }
	bool							IsIronSightsEnabled( void );

	const weaponAimValues_t&		GetAimValues( weaponAimValueIndex_t index ) { return aimValues[ index ]; }

	virtual sdNetworkInterface*			GetNetworkInterface( void ) { return &networkInterface; }

	const sdWeaponLockInfo*	GetLockInfo( void ) const { return &lockInfo; }

	void					ClampAngles( idAngles& angles, const idAngles& oldAngles ) const;

	float					GetDriftScale( void ) const { return driftScale; }

	bool					GetFov( float& fov ) const;

	static void				RegisterCVarCallback( void );
	static void				UnRegisterCVarCallback( void );
	static void				UpdateWeaponVisibility( void );

	const sdDeclInvItem*	GetInvItemDecl( void ) const { return weaponItem; }

	void					SetNumWorldModels( int count );

	// allow scripts to cleanup their state before we do something like lower from code (e.g. allow the script to exit iron-sights)
	void					ScriptCleanup( void );

	bool					ActivateAttack( void ) const { return activateAttack; }

private:
	void					SetupAnimClass( const char* prefix );

	// script control
	idScriptBool			WEAPON_ATTACK;
	idScriptBool			WEAPON_ALTFIRE;
	idScriptBool			WEAPON_MODESWITCH;
	idScriptBool			WEAPON_RELOAD;
	idScriptBool			WEAPON_RAISEWEAPON;
	idScriptBool			WEAPON_LOWERWEAPON;
	idScriptBool			WEAPON_HIDE;

	weaponStatus_t			status;

	sdProgramThread*		thread;

	idStr					state;
	idStr					idealState;

	int						animBlendFrames;
	int						animDoneTime;
	bool					isLinked;
	bool					modelDisabled;
	bool					worldModelDisabled;
	bool					activateAttack;

	sdWeaponLockInfo		lockInfo;

	struct stats_t {
		sdPlayerStatEntry*	shotsFired;
		sdPlayerStatEntry*	timeUsed;
	};
	stats_t					stats;

	const sdProgram::sdFunction*		onActivateFunc;
	const sdProgram::sdFunction*		onActivateFuncHeld;
	const sdProgram::sdFunction*		onUsedFunc;
	const sdProgram::sdFunction*		onWeapNextFunc;
	const sdProgram::sdFunction*		onWeapPrevFunc;
	const sdProgram::sdFunction*		cleanupFunc;
	const sdProgram::sdFunction*		getGrenadeFuseStartFunc;
	const sdProgram::sdFunction*		ironSightsEnabledFunc;

	playerWeaponTypes_t					playerWeaponNum;

	// precreated projectile
	idEntity				*projectileEnt;

	idPlayer*										owner;

	idList< rvClientEntityPtr< sdClientAnimated > >	worldModels;
	idList< jointHandle_t >							barrelJointsWorld;

	// hiding (for GUIs and NPCs)
	int						hideTime;
	float					hideDistance;
	int						hideStartTime;
	float					hideStart;
	float					hideEnd;
	float					hideOffset;
	bool					hide;
	bool					disabled;

	float					largeFOVScale;

	// some weapons aren't clip-based (e.g. grenades) and this affects the GUI
	bool					clipBased;

	// some strogg weapons' ammo is not based on stroyent
	bool					usesStroyent;

	// these are the player render view parms, which include bobbing
	idVec3					playerViewOrigin;
	idMat3					playerViewAxis;

	// the view weapon render entity parms
	idVec3					viewWeaponOrigin;
	idMat3					viewWeaponAxis;

	idVec3					viewOffset;

	float					viewForeShorten;
	idMat3					viewForeShortenAxis;

	idInterpolate< float >	zoomFov;
	
	weaponSpreadValueIndex_t	ownerStanceState;

	weaponSpreadValues_t	spreadValues[ WSV_NUM ];
	weaponAimValues_t		aimValues[ WAV_NUM ];
	float					spreadValueMax;				// used to normalize against
	bool					spreadEvalVelocity;
	bool					spreadEvalView;

	float					spreadCurrentValue;
	float					spreadModifier;

	float					crosshairSpreadMin;
	float					crosshairSpreadMax;
	float					crosshairSpreadScale;

	float					driftScale;

	float					zoomPitchAmplitude;
	float					zoomPitchFrequency;
	float					zoomPitchMinAmplitude;
	float					zoomYawAmplitude;
	float					zoomYawFrequency;
	float					zoomYawMinAmplitude;
	bool					swayEnabled;

	// weapon definition
	const sdDeclInvItem*	weaponItem;
	
	const sdDeclDamage*		meleeDamage;
	const sdDeclDamage*		meleeSpecialDamage;

	// weapon kick
	int						kick_endtime;
	int						muzzle_kick_time;
	int						muzzle_kick_maxtime;
	idAngles				muzzle_kick_angles;
	idVec3					muzzle_kick_offset;

	// zoom

	// joints from models
	jointHandle_t			barrelJointView;

	trace_t					meleeTrace;			// FIXME: static?

	sdWeaponNetworkInterface	networkInterface;

	angleClamp_t			clampPitch;
	angleClamp_t			clampYaw;
	bool					clampEnabled;
	idAngles				clampBaseAngles;

	int						tracerCounter;

	int						timeStartedUsing;

	rvClientEntityPtr< rvClientEffect > lastTracer;

	renderEntity_t			dofRenderEntity;
	int						dofModelDefHandle;
	const idDeclSkin*		dofSkin;

	const idDeclSkin*		climateSkin;

	weaponFeedback_t		feedback;

	// Visual presentation
	void					InitWorldModel( int index );
	void					MuzzleRise( idVec3 &origin, idMat3 &axis );

	void					SetupStats( const char* statName );

	virtual void			SetSkin( const idDeclSkin* skin );

	// script events
	void					Event_Clear( void );
	void					Event_GetOwner( void );
	void					Event_GetWeaponState( void );
	void					Event_WeaponState( const char *statename, int blendFrames );
	void					Event_SetWeaponStatus( float newStatus );
	void					Event_WeaponReady( void );
	void					Event_WeaponReloading( void );
	void					Event_WeaponHolstered( void );
	void					Event_WeaponRising( void );
	void					Event_WeaponLowering( void );
	void					Event_AddToClip( int modIndex, int amount );
	void					Event_AmmoInClip( int modIndex );
	void					Event_NeedsAmmo( int modIndex );
	void					Event_AmmoAvailable( int modIndex );
	void					Event_AmmoRequired( int modIndex );
	void					Event_AmmoType( int modIndex );
	void					Event_UseAmmo( ammoType_t type, int amount );
	void					Event_ClipSize( int modIndex );
	void					Event_PlayAnim( animChannel_t channel, const char *animname );
	void					Event_PlayCycle( animChannel_t channel, const char *animname );
	void					Event_AnimDone( animChannel_t channel, int blendFrames );
	void					Event_SetBlendFrames( animChannel_t channel, int blendFrames );
	void					Event_GetBlendFrames( animChannel_t channel );
	void					Event_Next( void );
	void					Event_LaunchProjectiles( int numProjectiles, int projectileIndex, float spread, float fuseOffset, float launchPower, float dmgPower );
	void					Event_DoProjectileTracer( int projectileIndex, const idVec3& start, const idVec3& end );
	void					Event_CreateProjectile( int projectileIndex );
	void					Event_Melee( int contentMask, float distance, bool ignoreOwner, bool useAntiLag );
	void					Event_MeleeAttack( float damageScale );
	void					Event_SaveMeleeTrace( void );
	void					Event_GetMeleeFraction( void );
	void					Event_GetMeleeEndPos( void );
	void					Event_GetMeleePoint( void );
	void					Event_GetMeleeNormal( void );
	void					Event_GetMeleeEntity( void );
	void					Event_GetMeleeSurfaceFlags( void );
	void					Event_GetMeleeSurfaceType( void );
	void					Event_GetMeleeSurfaceColor( void );
	void					Event_GetMeleeJoint( void );
	void					Event_GetMeleeBody( void );

	void					Event_AutoReload( void );
	void					Event_NetReload( void );
	void					Event_NetEndReload( void );
	void					Event_EnableTargetLock( bool enable );
	void					Event_SetFov( float startFov, float endFov, float duration );
	void					Event_SetFovStart( float startFov, float endFov, float startTime, float duration );
	void					Event_ClearFov( void );
	void					Event_GetFov( void );
	void					Event_EnableClamp( const idAngles& baseAngles );
	void					Event_DisableClamp( void );
	void					Event_GetSpreadValue( void );
	void					Event_IncreaseSpreadValue( void );
	void					Event_SetSpreadModifier( float modifier );
	void					Event_Hide( void );
	void					Event_Show( void );
							// weapons that don't do melee or projectile attacks still need to indicate they've been fired to their owner
	void					Event_Fired( void );
	void					Event_GetWorldModel( int index );
	void					Event_EnableSway( bool enable );
	void					Event_SetDriftScale( float scale );
	void					Event_ResetTracerCounter( void );
	void					Event_GetLastTracer( void );
	void					Event_SetupAnimClass( const char* prefix );
	void					Event_HasWeaponAnim( const char* anim );
	void					Event_SetStatName( const char* statName );

	void					Event_SendTracerMessage( const idVec3& start, const idVec3& end, float strength );

	enum {
		EVENT_RELOAD = idEntity::EVENT_MAXEVENTS,
		EVENT_TRACER,		// unreliable event
		EVENT_MAXEVENTS
	};
};

ID_INLINE bool idWeapon::IsLinked( void ) {
	return isLinked;
}

#endif /* !__GAME_WEAPON_H__ */