//max 32 synced modifiers supported
enum eModifierSyncIDs 
{
	MODIFIER_SYNC_WOUND_INFECT_1 	= 0x00000001,
	MODIFIER_SYNC_WOUND_INFECT_2 	= 0x00000002,
	MODIFIER_SYNC_CONTAMINATION 	= 0x00000004,//stage1 
	MODIFIER_SYNC_CONTAMINATION2 	= 0x00000008,//stage2 and stage3 share the same sync id
	MODIFIER_SYNC_ZONE_EXPOSURE 	= 0x00000010,
	MODIFIER_SYNC_DROWNING 			= 0x00000020,
	MODIFIER_SYNC_FEVER				= 0x00000040,
	//0x00000080,
	//0x00000100,
	//0x00000200,
	//0x00000400,
	//0x00000800,
	//0x00001000,
	LAST_INDEX,
}

enum EActivationType
{
	TRIGGER_EVENT_OFF,
	TRIGGER_EVENT_ON_ACTIVATION,
	TRIGGER_EVENT_ON_CONNECT
}

const int DEFAULT_TICK_TIME_ACTIVE 			= 3;
const int DEFAULT_TICK_TIME_ACTIVE_SHORT 	= 1;
const int DEFAULT_TICK_TIME_INACTIVE 		= 3;
const int DEFAULT_TICK_TIME_INACTIVE_LONG 	= 10;

class ModifierDebugObj
{
	string 	m_Name;
	int 	m_ID;
	bool 	m_IsActive;
	bool	m_IsLocked;
	
	void ModifierDebugObj(int id, string name, bool active, bool locked)
	{
		m_Name = name;
		m_ID = id;
		m_IsActive = active;
		m_IsLocked = locked;
	}
	
	string GetName()
	{
		return m_Name;
	}
	
	int GetID()
	{
		return m_ID;
	}
	
	bool IsActive()
	{
		return m_IsActive;
	}
	
	bool IsLocked()
	{
		return m_IsLocked;
	}
}

class ModifiersManager
{
	const int STORAGE_VERSION = 121;

	bool m_AllowModifierTick;

	PlayerBase m_Player;

	ref map<int, ref ModifierBase> 	m_ModifierList;
	ref array< ref ModifierBase> 	m_ModifierListArray;
	ref array<ref Param> 			m_ParamList;

	void ModifiersManager(PlayerBase player)
	{
		m_ModifierList 		= new map<int, ref ModifierBase>();
		m_ModifierListArray = new array< ref ModifierBase>();
		m_ParamList 		= new array<ref Param>;
		m_Player 			= player;
		
		Init();
	}

	void Init()
	{
		#ifdef DEVELOPER
		AddModifier(new TestDiseaseMdfr);
		#endif
		AddModifier(new BloodRegenMdfr);
		AddModifier(new SalineMdfr);
		AddModifier(new HealthRegenMdfr);
		AddModifier(new HungerMdfr);
		AddModifier(new ImmuneSystemMdfr);
		AddModifier(new StomachMdfr);
		AddModifier(new HeatComfortMdfr);
		AddModifier(new ThirstMdfr);
		AddModifier(new BleedingCheckMdfr);
		AddModifier(new BrokenLegsMdfr);
		AddModifier(new VomitStuffedMdfr);
		AddModifier(new BurningMdfr);
		AddModifier(new FeverMdfr);
		AddModifier(new HeartAttackMdfr);
		AddModifier(new HemolyticReactionMdfr);
		AddModifier(new PoisoningMdfr);
		AddModifier(new StuffedStomachMdfr);
		AddModifier(new UnconsciousnessMdfr);
		AddModifier(new ShockDamageMdfr);
		AddModifier(new CommonColdMdfr);
		AddModifier(new CholeraMdfr);
		AddModifier(new InfluenzaMdfr);
		AddModifier(new SalmonellaMdfr);
		AddModifier(new BrainDiseaseMdfr);
		AddModifier(new WetMdfr);
		AddModifier(new ImmunityBoost);
		AddModifier(new AntibioticsMdfr);
		AddModifier(new ToxicityMdfr);
		AddModifier(new BreathVapourMdfr);
		AddModifier(new ShockMdfr);
		AddModifier(new WoundInfectStage1Mdfr);
		AddModifier(new WoundInfectStage2Mdfr);
		AddModifier(new CharcoalMdfr);
		AddModifier(new MorphineMdfr);
		AddModifier(new PainKillersMdfr);
		AddModifier(new EpinephrineMdfr);
		AddModifier(new HeatBufferMdfr);
		AddModifier(new DisinfectionMdfr);
		AddModifier(new FatigueMdfr);
		AddModifier(new ContaminationStage1Mdfr);
		AddModifier(new ContaminationStage2Mdfr);
		AddModifier(new ContaminationStage3Mdfr);
		AddModifier(new AreaExposureMdfr);
		AddModifier(new MaskMdfr);
		AddModifier(new FliesMdfr);
		AddModifier(new DrowningMdfr);
		AddModifier(new HeavyMetalPhase1Mdfr);
		AddModifier(new HeavyMetalPhase2Mdfr);
		AddModifier(new HeavyMetalPhase3Mdfr);
		AddModifier(new PneumoniaMdfr);
		AddModifier(new ChelationMdfr);
	}

	void SetModifiers(bool enable)
	{
		if (m_AllowModifierTick == enable)
			return;
		
		m_AllowModifierTick = enable;
		
		#ifdef DIAG_DEVELOPER
		#ifndef SERVER
		DiagMenu.SetValue(DiagMenuIDs.CHEATS_MODIFIERS, enable);
		#endif
		#endif
		
		if (!enable)
		{
			for (int i = 0; i < m_ModifierList.Count(); i++)
			{
				m_ModifierList.GetElement(i).ResetLastTickTime();
			}
		}
	}

	int GetStorageVersion()
	{
		return STORAGE_VERSION;
	}
	
	bool IsModifiersEnable()
	{
		return m_AllowModifierTick;
	}
	
	void AddModifier(ModifierBase modifier)
	{
		modifier.InitBase(m_Player, this);
		int id = modifier.GetModifierID();
		
		if (id < 1)
			ErrorEx("modifiers ID must be 1 or higher(for debugging reasons)", ErrorExSeverity.WARNING);
		
		if (m_ModifierListArray.Find(modifier) == -1)
		{
			m_ModifierList.Insert(id, modifier);
			m_ModifierListArray.Insert(modifier);
		}
		else
		{
			ErrorEx(string.Format("Modifier '%1' is already registered", modifier.GetName()), ErrorExSeverity.WARNING);
		}
	}
	
	bool IsModifierActive(eModifiers modifier_id)
	{
		return m_ModifierList.Get(modifier_id).IsActive();
	}

	void OnScheduledTick(float delta_time)
	{
		if (!m_AllowModifierTick)
			return;

		foreach (ModifierBase modifier : m_ModifierListArray)
			modifier.Tick(delta_time);
	}
	
	void DeactivateAllModifiers()
	{
		foreach (ModifierBase modifier : m_ModifierList)
			modifier.Deactivate();
	}
	
	void ActivateModifier(int modifier_id, bool triggerEvent = EActivationType.TRIGGER_EVENT_ON_ACTIVATION)
	{
		m_ModifierList.Get(modifier_id).ActivateRequest(triggerEvent);
	}

	void DeactivateModifier(int modifier_id, bool triggerEvent = true)
	{
		m_ModifierList.Get(modifier_id).Deactivate(triggerEvent);
	}
	
	void OnStoreSave( ParamsWriteContext ctx )
	{
		CachedObjectsArrays.ARRAY_INT.Clear();
		
		int modifierCount;
		foreach (ModifierBase modifier : m_ModifierList)
		{
			if (modifier.IsActive() && modifier.IsPersistent())
			{
				modifierCount++;
				//save the modifier id
				CachedObjectsArrays.ARRAY_INT.Insert(modifier.GetModifierID());
				if (modifier.IsTrackAttachedTime())
				{
					//save the overall attached time
					CachedObjectsArrays.ARRAY_INT.Insert(modifier.GetAttachedTime());
				}
			}
		}

		ctx.Write(modifierCount);

		//write the individual modifiers and respective attached times
		for (int i = 0; i < CachedObjectsArrays.ARRAY_INT.Count(); i++)
		{
			int item = CachedObjectsArrays.ARRAY_INT.Get(i);
			ctx.Write(item);
		}

		for (int z = 0; z < m_ParamList.Count(); z++)
		{
			m_ParamList.Get(z).Serialize(ctx);
		}

	}

	bool OnStoreLoad(ParamsReadContext ctx, int version)
	{
		int modifierCount;
		if (!ctx.Read(modifierCount))
			return false;

		for (int i = 0; i < modifierCount; i++)
		{
			int modifierId;
			if (!ctx.Read(modifierId))
				return false;

			ModifierBase modifier = GetModifier(modifierId);
			if (modifier)
			{
				if (modifier.IsTrackAttachedTime())
				{
					int time;
					if (!ctx.Read(time))//get the attached time
						return false;

					modifier.SetAttachedTime(time);
				}
				
				ActivateModifier(modifierId, EActivationType.TRIGGER_EVENT_ON_CONNECT);
			}
			else
			{
				Debug.LogError("DB loading: non-existent modifier with id:"+modifierId.ToString());
			}
		}
		
		for (int x = 0; x < m_ParamList.Count(); x++)
		{
			if (!m_ParamList.Get(x).Deserializer(ctx))
				return false;
		}

		return true;
	}

	ModifierBase GetModifier(int modifier_id)
	{
		return m_ModifierList.Get(modifier_id);
	}
		
	PlayerBase GetPlayer()
	{
		return m_Player;
	}

	void SetModifierLock(int modifier_id, bool state)
	{
		m_ModifierList.Get(modifier_id).SetLock(state);
	}

	bool GetModifierLock(int modifier_id)
	{
		return m_ModifierList.Get(modifier_id).IsLocked();
	}

	void DbgGetModifiers(array<ref ModifierDebugObj> modifiers)
	{
		modifiers.Clear();
		for (int i = 1;i < eModifiers.COUNT; i++)
		{
			if (m_ModifierList.Contains(i))
			{
				ModifierBase modifier = m_ModifierList.Get(i);

				int modifierId 	= modifier.GetModifierID();
				bool isLocked 	= modifier.IsLocked();
				bool active 	= modifier.IsActive();

				string modifierName = modifier.GetName();
				string debugText 	= modifier.GetDebugTextSimple();

				if (active && debugText != "")
					modifierName += " | " + debugText; 

				ModifierDebugObj obj = new ModifierDebugObj(modifierId, modifierName, active, isLocked);

				modifiers.Insert(obj);
			}
		}
	}
	
	void ResetAll()
	{
		bool hasAreaExposureModifier 	= IsModifierActive(eModifiers.MDF_AREAEXPOSURE);
		bool hasMaksModifier 			= IsModifierActive(eModifiers.MDF_MASK);

		DeactivateAllModifiers();
		
		if (hasAreaExposureModifier)
			ActivateModifier(eModifiers.MDF_AREAEXPOSURE);
		
		if (hasMaksModifier)
			ActivateModifier(eModifiers.MDF_MASK);
	}
}