#pragma once

#include "RwHelper.h"

#include "AnimManager.h"
#include "Crime.h"
#include "EventList.h"
#include "PedIK.h"

#include "PedType.h"

#include "Physical.h"

#include "Weapon.h"

#include "WeaponInfo.h"

#include "Collision.h"

#define FEET_OFFSET	1.04f
#define CHECK_NEARBY_THINGS_MAX_DIST	15.0f

#define ENTER_CAR_MAX_DIST	30.0f

#define CAN_SEE_ENTITY_ANGLE_THRESHOLD	DEGTORAD(60.0f)

struct CPathNode;

class CAccident;

class CObject;

class CFire;
struct AnimBlendFrameData;
class CAnimBlendAssociation;

struct PedAudioData

{
	int m_nFixedDelayTime;
	int m_nOverrideFixedDelayTime;
	int m_nOverrideMaxRandomDelayTime;
	int m_nMaxRandomDelayTime;
};

enum eFormation
{

	FORMATION_UNDEFINED,

	FORMATION_REAR,
	FORMATION_REAR_LEFT,
	FORMATION_REAR_RIGHT,
	FORMATION_FRONT_LEFT,
	FORMATION_FRONT_RIGHT,
	FORMATION_LEFT,
	FORMATION_RIGHT,
	FORMATION_FRONT
};

enum FightState {

	FIGHTSTATE_MOVE_FINISHED = -2,
	FIGHTSTATE_JUST_ATTACKED,
	FIGHTSTATE_NO_MOVE,
	FIGHTSTATE_1
};

enum
{
	ENDFIGHT_NORMAL,
	ENDFIGHT_WITH_A_STEP,
	ENDFIGHT_FAST
};

enum PedRouteType
{
	PEDROUTE_STOP_WHEN_DONE = 1,
	PEDROUTE_GO_BACKWARD_WHEN_DONE,
	PEDROUTE_GO_TO_START_WHEN_DONE
};

enum FightMoveHitLevel
{
	HITLEVEL_NULL,
	HITLEVEL_GROUND,
	HITLEVEL_LOW,
	HITLEVEL_MEDIUM,
	HITLEVEL_HIGH
};

struct FightMove
{
	AnimationId animId;
	float startFireTime;
	float endFireTime;
	float comboFollowOnTime;
	float strikeRadius;

	uint8 hitLevel; // FightMoveHitLevel

	uint8 damage;
	uint8 flags;
};

VALIDATE_SIZE(FightMove, 0x18);

// TODO: This is eFightState on mobile.

enum PedFightMoves
{
	FIGHTMOVE_NULL,

	// Attacker

	FIGHTMOVE_STDPUNCH,
	FIGHTMOVE_IDLE,
	FIGHTMOVE_SHUFFLE_F,
	FIGHTMOVE_KNEE,
	FIGHTMOVE_HEADBUTT,
	FIGHTMOVE_PUNCHJAB,
	FIGHTMOVE_PUNCHHOOK,
	FIGHTMOVE_KICK,
	FIGHTMOVE_LONGKICK,
	FIGHTMOVE_ROUNDHOUSE,
	FIGHTMOVE_BODYBLOW,
	FIGHTMOVE_GROUNDKICK,

	// Opponent

	FIGHTMOVE_HITFRONT,
	FIGHTMOVE_HITBACK,
	FIGHTMOVE_HITRIGHT,
	FIGHTMOVE_HITLEFT,
	FIGHTMOVE_HITBODY,
	FIGHTMOVE_HITCHEST,
	FIGHTMOVE_HITHEAD,
	FIGHTMOVE_HITBIGSTEP,
	FIGHTMOVE_HITONFLOOR,
	FIGHTMOVE_HITBEHIND,

	FIGHTMOVE_IDLE2NORM,
	NUM_FIGHTMOVES

};

enum ePedPieceTypes
{

	PEDPIECE_TORSO,
	PEDPIECE_MID,

	PEDPIECE_LEFTARM,
	PEDPIECE_RIGHTARM,
	PEDPIECE_LEFTLEG,
	PEDPIECE_RIGHTLEG,
	PEDPIECE_HEAD,
};

enum eWaitState {

	WAITSTATE_FALSE,
	WAITSTATE_TRAFFIC_LIGHTS,
	WAITSTATE_CROSS_ROAD,
	WAITSTATE_CROSS_ROAD_LOOK,
	WAITSTATE_LOOK_PED,
	WAITSTATE_LOOK_SHOP,
	WAITSTATE_LOOK_ACCIDENT,
	WAITSTATE_FACEOFF_GANG,
	WAITSTATE_DOUBLEBACK,
	WAITSTATE_HITWALL,
	WAITSTATE_TURN180,
	WAITSTATE_SURPRISE,
	WAITSTATE_STUCK,
	WAITSTATE_LOOK_ABOUT,
	WAITSTATE_PLAYANIM_DUCK,
	WAITSTATE_PLAYANIM_COWER,
	WAITSTATE_PLAYANIM_TAXI,
	WAITSTATE_PLAYANIM_HANDSUP,
	WAITSTATE_PLAYANIM_HANDSCOWER,
	WAITSTATE_PLAYANIM_CHAT,
	WAITSTATE_FINISH_FLEE
};

enum eObjective {

	OBJECTIVE_NONE,

	OBJECTIVE_WAIT_ON_FOOT,
	OBJECTIVE_FLEE_ON_FOOT_TILL_SAFE,

	OBJECTIVE_GUARD_SPOT,

	OBJECTIVE_GUARD_AREA,	// not implemented

	OBJECTIVE_WAIT_IN_CAR,

	OBJECTIVE_WAIT_IN_CAR_THEN_GET_OUT,

	OBJECTIVE_KILL_CHAR_ON_FOOT,
	OBJECTIVE_KILL_CHAR_ANY_MEANS,
	OBJECTIVE_FLEE_CHAR_ON_FOOT_TILL_SAFE,
	OBJECTIVE_FLEE_CHAR_ON_FOOT_ALWAYS,
	OBJECTIVE_GOTO_CHAR_ON_FOOT,

	OBJECTIVE_FOLLOW_CHAR_IN_FORMATION,
	OBJECTIVE_LEAVE_CAR,

	OBJECTIVE_ENTER_CAR_AS_PASSENGER,
	OBJECTIVE_ENTER_CAR_AS_DRIVER,

	OBJECTIVE_FOLLOW_CAR_IN_CAR, // not implemented
	OBJECTIVE_FIRE_AT_OBJECT_FROM_VEHICLE,	// not implemented
	OBJECTIVE_DESTROY_OBJECT,	// not implemented

	OBJECTIVE_DESTROY_CAR,
	OBJECTIVE_GOTO_AREA_ANY_MEANS,
	OBJECTIVE_GOTO_AREA_ON_FOOT,
	OBJECTIVE_RUN_TO_AREA,

	OBJECTIVE_GOTO_AREA_IN_CAR,	// not implemented
	OBJECTIVE_FOLLOW_CAR_ON_FOOT_WITH_OFFSET,	// not implemented
	OBJECTIVE_GUARD_ATTACK,

	OBJECTIVE_SET_LEADER,
	OBJECTIVE_FOLLOW_ROUTE,

	OBJECTIVE_SOLICIT_VEHICLE,

	OBJECTIVE_HAIL_TAXI,
	OBJECTIVE_CATCH_TRAIN,
	OBJECTIVE_BUY_ICE_CREAM,
	OBJECTIVE_STEAL_ANY_CAR,
	OBJECTIVE_MUG_CHAR,
	OBJECTIVE_FLEE_CAR,

#ifdef VC_PED_PORTS
	OBJECTIVE_LEAVE_CAR_AND_DIE
#endif

};

enum {

	RANDOM_CHAR = 1,
	MISSION_CHAR,

};

enum PedLineUpPhase {
	LINE_UP_TO_CAR_START,
	LINE_UP_TO_CAR_END,

	LINE_UP_TO_CAR_2 // Buggy. Used for cops arresting you from passenger door

};

enum PedOnGroundState {
	NO_PED,

	PED_IN_FRONT_OF_ATTACKER,

	PED_ON_THE_FLOOR,
	PED_DEAD_ON_THE_FLOOR
};

enum PointBlankNecessity {

	NO_POINT_BLANK_PED,
	POINT_BLANK_FOR_WANTED_PED,
	POINT_BLANK_FOR_SOMEONE_ELSE
};

enum PedState

{

	PED_NONE,

	PED_IDLE,
	PED_LOOK_ENTITY,
	PED_LOOK_HEADING,
	PED_WANDER_RANGE,
	PED_WANDER_PATH,
	PED_SEEK_POS,
	PED_SEEK_ENTITY,
	PED_FLEE_POS,
	PED_FLEE_ENTITY,
	PED_PURSUE,
	PED_FOLLOW_PATH,
	PED_SNIPER_MODE,

	PED_ROCKET_MODE,

	PED_DUMMY,
	PED_PAUSE,
	PED_ATTACK,
	PED_FIGHT,
	PED_FACE_PHONE,
	PED_MAKE_CALL,
	PED_CHAT,
	PED_MUG,
	PED_AIM_GUN,
	PED_AI_CONTROL,
	PED_SEEK_CAR,
	PED_SEEK_IN_BOAT,
	PED_FOLLOW_ROUTE,
	PED_CPR,
	PED_SOLICIT,
	PED_BUY_ICECREAM,
	PED_INVESTIGATE,
	PED_STEP_AWAY,
	PED_ON_FIRE,

	PED_UNKNOWN,	// Same with IDLE, but also infects up to 5 peds with same pedType and WANDER_PATH, so they become stone too. HANG_OUT in Fire_Head's idb

	PED_STATES_NO_AI,

	// One of these states isn't on PS2 - start

	PED_JUMP,
	PED_FALL,
	PED_GETUP,
	PED_STAGGER,
	PED_DIVE_AWAY,

	PED_STATES_NO_ST,
	PED_ENTER_TRAIN,
	PED_EXIT_TRAIN,
	PED_ARREST_PLAYER,

	// One of these states isn't on PS2 - end

	PED_DRIVING,
	PED_PASSENGER,
	PED_TAXI_PASSENGER,
	PED_OPEN_DOOR,

	PED_DIE,
	PED_DEAD,

	PED_CARJACK,
	PED_DRAG_FROM_CAR,
	PED_ENTER_CAR,
	PED_STEAL_CAR,
	PED_EXIT_CAR,
	PED_HANDS_UP,

	PED_ARRESTED,

};

enum eMoveState {

	PEDMOVE_NONE,
	PEDMOVE_STILL,
	PEDMOVE_WALK,
	PEDMOVE_RUN,
	PEDMOVE_SPRINT,
};

class CVehicle;

class CPed : public CPhysical
{
public:
	// 0x128

	CStoredCollPoly m_collPoly;
	float m_fCollisionSpeed;

	// cf. https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_sa/game_sa/CPed.h from R*

	uint32 bIsStanding : 1;

	uint32 bWasStanding : 1;

	uint32 bIsAttacking : 1;		// doesn't reset after fist fight
	uint32 bIsPointingGunAt : 1;
	uint32 bIsLooking : 1;
	uint32 bKeepTryingToLook : 1; // if we can't look somewhere due to unreachable angles
	uint32 bIsRestoringLook : 1;
	uint32 bIsAimingGun : 1;

	uint32 bIsRestoringGun : 1;
	uint32 bCanPointGunAtTarget : 1;
	uint32 bIsTalking : 1;
	uint32 bIsInTheAir : 1;
	uint32 bIsLanding : 1;
	uint32 bIsRunning : 1; // on some conditions
	uint32 bHitSomethingLastFrame : 1;
	uint32 bVehEnterDoorIsBlocked : 1; // because someone else enters/exits from there

	uint32 bCanPedEnterSeekedCar : 1;
	uint32 bRespondsToThreats : 1;
	uint32 bRenderPedInCar : 1;
	uint32 bChangedSeat : 1;
	uint32 bUpdateAnimHeading : 1;
	uint32 bBodyPartJustCameOff : 1;
	uint32 bIsShooting : 1;
	uint32 bFindNewNodeAfterStateRestore : 1;

	uint32 bHasACamera : 1; // does ped possess a camera to document accidents involves fire/explosion
	uint32 bGonnaInvestigateEvent : 1;
	uint32 bPedIsBleeding : 1;
	uint32 bStopAndShoot : 1; // Ped cannot reach target to attack with fist, need to use gun
	uint32 bIsPedDieAnimPlaying : 1;
	uint32 bUsePedNodeSeek : 1;
	uint32 bObjectiveCompleted : 1;
	uint32 bScriptObjectiveCompleted : 1;

	uint32 bKindaStayInSamePlace : 1;
	uint32 bBeingChasedByPolice : 1; // Unused VC leftover. Should've been set for criminal/gang members
	uint32 bNotAllowedToDuck : 1;
	uint32 bCrouchWhenShooting : 1;
	uint32 bIsDucking : 1;
	uint32 bGetUpAnimStarted : 1;
	uint32 bDoBloodyFootprints : 1;
	uint32 bFleeAfterExitingCar : 1;

	uint32 bWanderPathAfterExitingCar : 1;
	uint32 bIsLeader : 1;
	uint32 bDontDragMeOutCar : 1; // unfinished feature
	uint32 m_ped_flagF8 : 1;
	uint32 bWillBeQuickJacked : 1;
	uint32 bCancelEnteringCar : 1; // after door is opened or couldn't be opened due to it's locked
	uint32 bObstacleShowedUpDuringKillObjective : 1;
	uint32 bDuckAndCover : 1;

	uint32 bStillOnValidPoly : 1; // set if the polygon the ped is on is still valid for collision
	uint32 bAllowMedicsToReviveMe : 1;
	uint32 bResetWalkAnims : 1;
	uint32 bStartWanderPathOnFoot : 1; // exits the car if he's in it, reset after path found
	uint32 bOnBoat : 1; // not just driver, may be just standing
	uint32 bBusJacked : 1;
	uint32 bGonnaKillTheCarJacker : 1; // only set when car is jacked from right door and when arrested by police
	uint32 bFadeOut : 1;

	uint32 bKnockedUpIntoAir : 1; // has ped been knocked up into the air by a car collision
	uint32 bHitSteepSlope : 1; // has ped collided/is standing on a steep slope (surface type)
	uint32 bCullExtraFarAway : 1; // special ped only gets culled if it's extra far away (for roadblocks)
	uint32 bClearObjective : 1;
	uint32 bTryingToReachDryLand : 1; // has ped just exited boat and trying to get to dry land
	uint32 bCollidedWithMyVehicle : 1;
	uint32 bRichFromMugging : 1; // ped has lots of cash cause they've been mugging people
	uint32 bChrisCriminal : 1; // Is a criminal as killed during Chris' police mission (should be counted as such)

	uint32 bShakeFist : 1;  // test shake hand at look entity
	uint32 bNoCriticalHits : 1; // if set, limbs won't came off
	uint32 bVehExitWillBeInstant : 1;
	uint32 bHasAlreadyBeenRecorded : 1;
	uint32 bFallenDown : 1;

#ifdef VC_PED_PORTS

	uint32 bSomeVCflag1 : 1;

#endif

#ifdef PED_SKIN
	uint32 bDontAcceptIKLookAts : 1;	// TODO: find uses of this
#endif

	uint32 m_ped_flagI40 : 1;
	uint32 m_ped_flagI80 : 1; // originally unused, KANGAROO_CHEAT define makes use of this as cheat toggle 

	uint8 CharCreatedBy;

	eObjective m_objective;
	eObjective m_prevObjective;
	CPed *m_pedInObjective;
	CVehicle *m_carInObjective;

	CVector m_nextRoutePointPos;

	CPed *m_leader;

	eFormation m_pedFormation;

	uint32 m_fearFlags;
	CEntity *m_threatEntity;

	CVector2D m_eventOrThreat;

	uint32 m_eventType;
	CEntity* m_pEventEntity;

	float m_fAngleToEvent;

	AnimBlendFrameData *m_pFrames[PED_NODE_MAX];

#ifdef PED_SKIN
	// stored inside the clump with non-skin ped
	RpAtomic *m_pWeaponModel;
#endif

	AssocGroupId m_animGroup;
	CAnimBlendAssociation *m_pVehicleAnim;

	CVector2D m_vecAnimMoveDelta;
	CVector m_vecOffsetSeek;
	CPedIK m_pedIK; 

	float m_actionX;
	float m_actionY;

	uint32 m_nPedStateTimer;

	PedState m_nPedState;

	PedState m_nLastPedState;

	eMoveState m_nMoveState;

	int32 m_nStoredMoveState;
	int32 m_nPrevMoveState;

	eWaitState m_nWaitState;

	uint32 m_nWaitTimer;

	void *m_pPathNodesStates[8]; // unused, probably leftover from VC

	CVector2D m_stPathNodeStates[10];

	uint16 m_nPathNodes;

	int16 m_nCurPathNode;

	int8 m_nPathDir;

public:
	CPathNode *m_pLastPathNode;

	CPathNode *m_pNextPathNode;

	float m_fHealth;
	float m_fArmour;

	int16 m_routeLastPoint;

	uint16 m_routeStartPoint;
	int16 m_routePointsPassed;

	int16 m_routeType;	// See PedRouteType

	int16 m_routePointsBeingPassed;

	CVector2D m_moved;

	float m_fRotationCur;
	float m_fRotationDest;

	float m_headingRate;

	uint16 m_vehDoor;

	int16 m_walkAroundType;

	CPhysical *m_pCurrentPhysSurface;

	CVector m_vecOffsetFromPhysSurface;
	CEntity *m_pCurSurface;

	CVector m_vecSeekPos;

	CEntity *m_pSeekTarget;

	CVehicle *m_pMyVehicle;

	bool bInVehicle;

	float m_distanceToCountSeekDone;

	bool bRunningToPhone;

	int16 m_phoneId;

#ifdef PEDS_REPORT_CRIMES_ON_PHONE
	bool m_facePhoneStart;
	CEntity *m_victimOfPlayerCrime;
#endif

	eCrimeType m_crimeToReportOnPhone;

	uint32 m_phoneTalkTimer;

	CAccident *m_lastAccident;

	uint32 m_nPedType;

	CPedStats *m_pedStats;

	float m_fleeFromPosX;
	float m_fleeFromPosY;
	CEntity *m_fleeFrom;
	uint32 m_fleeTimer;

	CEntity* m_collidingEntityWhileFleeing;
	uint32 m_collidingThingTimer;

	CEntity *m_pCollidingEntity;

	uint8 m_stateUnused;
	uint32 m_timerUnused;

	class CRange2D *m_wanderRangeBounds;

	CWeapon m_weapons[WEAPONTYPE_TOTAL_INVENTORY_WEAPONS];

	eWeaponType m_storedWeapon;

	uint8 m_currentWeapon;			// eWeaponType
	uint8 m_maxWeaponTypeAllowed;	// eWeaponType

	uint8 m_wepSkills;
	uint8 m_wepAccuracy;
	CEntity *m_pPointGunAt;

	CVector m_vecHitLastPos;

	uint32 m_curFightMove;

	uint8 m_fightButtonPressure;

	int8 m_fightState;

	bool m_takeAStepAfterAttack;

	CFire *m_pFire;

	CEntity *m_pLookTarget;

	float m_fLookDirection;
	int32 m_wepModelID;

	uint32 m_leaveCarTimer;
	uint32 m_getUpTimer;
	uint32 m_lookTimer;

	uint32 m_chatTimer;

	uint32 m_attackTimer;

	uint32 m_shootTimer; // shooting is a part of attack

	uint32 m_carJackTimer;

	uint32 m_objectiveTimer;

	uint32 m_duckTimer;

	uint32 m_duckAndCoverTimer;

	uint32 m_bloodyFootprintCountOrDeathTime;	// Death time when bDoBloodyFootprints is false. Weird decision

	uint8 m_panicCounter;

	bool m_deadBleeding;

	int8 m_bodyPartBleeding;		// PedNode, but -1 if there isn't

	CPed *m_nearPeds[10];

	uint16 m_numNearPeds;

	int8 m_lastWepDam;

	uint32 m_lastSoundStart;
	uint32 m_soundStart;

	uint16 m_lastQueuedSound;
	uint16 m_queuedSound;

	CVector m_vecSeekPosEx; // used for OBJECTIVE_GUARD_SPOT
	float m_distanceToCountSeekDoneEx; // used for OBJECTIVE_GUARD_SPOT

	static void *operator new(size_t) throw();
	static void *operator new(size_t, int) throw();
	static void operator delete(void*, size_t) throw();
	static void operator delete(void*, int) throw();

	CPed(uint32 pedType);

	~CPed(void);

	void SetModelIndex(uint32 mi);
	void ProcessControl(void);
	void Teleport(CVector);
	void PreRender(void);
	void Render(void);
	bool SetupLighting(void);
	void RemoveLighting(bool);
	void FlagToDestroyWhenNextProcessed(void);
	int32 ProcessEntityCollision(CEntity*, CColPoint*);

	virtual void SetMoveAnim(void);

	void AddWeaponModel(int id);

	void AimGun(void);

	void KillPedWithCar(CVehicle *veh, float impulse);

	void Say(uint16 audio);

	void SetLookFlag(CEntity *target, bool keepTryingToLook);
	void SetLookFlag(float direction, bool keepTryingToLook);

	void SetLookTimer(int time);

	void SetDie(AnimationId anim, float arg1, float arg2);

	void SetDead(void);

	void ApplyHeadShot(eWeaponType weaponType, CVector pos, bool evenOnPlayer);

	void RemoveBodyPart(PedNode nodeId, int8 direction);

	bool OurPedCanSeeThisOne(CEntity *target);

	void Avoid(void);

	void Attack(void);
	void ClearAimFlag(void);
	void ClearLookFlag(void);
	void RestorePreviousState(void);
	void ClearAttack(void);
	bool IsPedHeadAbovePos(float zOffset);

	void RemoveWeaponModel(int modelId);

	void SetCurrentWeapon(uint32 weaponType);

	void Duck(void);
	void ClearDuck(void);
	void ClearPointGunAt(void);

	void BeingDraggedFromCar(void);
	void RestartNonPartialAnims(void);
	void LineUpPedWithCar(PedLineUpPhase phase);
	void SetPedPositionInCar(void);

	void PlayFootSteps(void);

	void QuitEnteringCar(void);

	void BuildPedLists(void);

	uint32 GiveWeapon(eWeaponType weaponType, uint32 ammo);

	void CalculateNewOrientation(void);
	float WorkOutHeadingForMovingFirstPerson(float);
	void CalculateNewVelocity(void);

	bool CanSeeEntity(CEntity*, float threshold = CAN_SEE_ENTITY_ANGLE_THRESHOLD);

	void RestorePreviousObjective(void);

	void SetIdle(void);

#ifdef _MSC_VER

#if _MSC_VER >= 1920 && _MSC_VER < 1929

	__declspec(noinline) // workaround for a compiler bug, hooray MS :P

#endif

#endif

	void SetObjective(eObjective, void*);

	void SetObjective(eObjective);
	void SetObjective(eObjective, int16, int16);

	void SetObjective(eObjective, CVector);
	void SetObjective(eObjective, CVector, float);

	void ClearChat(void);
	void InformMyGangOfAttack(CEntity*);
	void ReactToAttack(CEntity*);
	void SetDuck(uint32);
	void RegisterThreatWithGangPeds(CEntity*);
	bool TurnBody(void);
	void Chat(void);

	void CheckAroundForPossibleCollisions(void);

	void SetSeek(CVector, float);

	void SetSeek(CEntity*, float);

	bool MakePhonecall(void);
	bool FacePhone(void);
	CPed *CheckForDeadPeds(void);

#ifdef PEDS_REPORT_CRIMES_ON_PHONE
	int32 CheckForPlayerCrimes(CPed *victim = nil);
#endif

	bool CheckForExplosions(CVector2D &area);
	CPed *CheckForGunShots(void);

	uint8 CheckForPointBlankPeds(CPed*);

	bool CheckIfInTheAir(void);
	void ClearAll(void);
	void SetPointGunAt(CEntity*);

	bool Seek(void);

	bool SetWanderPath(int8);

	bool SetFollowPath(CVector);