// This file(RequiresNUnitsForMUnitsRequirement.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2011 IBBoard
// 
// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or(at your option) any later version. Please see COPYING for more information and the full license.
using System;
using System.Collections.Generic;
using System.Text;
using IBBoard.WarFoundry.API.Objects.Requirement.Context;

namespace IBBoard.WarFoundry.API.Objects.Requirement
{
	public abstract class RequiresNUnitsForMObjectsRequirement<OBJECT_TYPE> : AbstractUnitRequirement<OBJECT_TYPE> where OBJECT_TYPE : IWarFoundryObject
	{
		public RequiresNUnitsForMObjectsRequirement(OBJECT_TYPE allowedObject, params UnitType[] requiredUnitTypes) : base(allowedObject, requiredUnitTypes)
		{
			//Do nothing
		}

		public override int GetHashCode()
		{
			int hash = 0;

			foreach (UnitCountRequirementData req in ConstraintTypes)
			{
				hash += req.UnitType.GetHashCode();
			}

			return hash;
		}

		protected override string GetFailedAddingRequirementsString(IWarFoundryObject toAdd, Army toArmy, AddingContext context)
		{
			return String.Join("; ", GetFailedAddingRequirements(toAdd, toArmy).ToArray());
		}

		private List<string> GetFailedAddingRequirements(IWarFoundryObject obj, Army toArmy)
		{
			List<string> failures = new List<string>();
			int allowedObjectCount = GetAllowedObjectCount(toArmy, AllowedObject, obj);

			foreach (UnitCountRequirementData limit in ConstraintTypes)
			{
				int limitedTypeCount = GetUnitTypesCount(toArmy, limit.UnitTypes, obj);

				if (!IsValidByRequirement(obj, toArmy, limit, allowedObjectCount))
				{
					string unitTypeList = GetUnitTypeList(limit);
					failures.Add(String.Format("{0} × {1} for every {2} × {3} (would have {4} for {5})", limit.Count, unitTypeList, limit.AllowsCount, AllowedObject.Name, limitedTypeCount, allowedObjectCount));
				}
			}

			return failures;
		}

		private bool IsValidByRequirement(IWarFoundryObject wfObject, Army toArmy, UnitCountRequirementData limit, int allowedTypeCount)
		{
			int limitedTypeCount = GetUnitTypesCount(toArmy, limit.UnitTypes, wfObject);
			return IsValidByRequirement(limit, allowedTypeCount, limitedTypeCount);
		}

		private bool IsValidByRequirement(UnitCountRequirementData limit, int allowedTypeCount, int limitedTypeCount)
		{
			//Round down limited units to get only whole amounts
			double normalisedLimited = Math.Floor(limitedTypeCount / (limit.Count * 1.0));
			double normalisedAllowed = allowedTypeCount / (limit.AllowsCount * 1.0);
			return normalisedLimited >= 1 && normalisedAllowed <= normalisedLimited;
		}

		protected override Validation CheckAllowsAdding(IWarFoundryObject wfObject, Army toArmy, AddingContext context)
		{
			Validation canAdd = Validation.NotApplicable;
			UnitType addedUnitType = (wfObject is Unit) ? ((Unit)wfObject).UnitType : wfObject as UnitType;
			bool typeFound = (wfObject == (IWarFoundryObject)AllowedObject || addedUnitType == (IWarFoundryObject)AllowedObject);
			int allowedTypeCount = GetAllowedObjectCount(toArmy, AllowedObject, wfObject);

			foreach (UnitCountRequirementData limit in ConstraintTypes)
			{
				typeFound |= (addedUnitType == limit.UnitType);

				if (!IsValidByRequirement(wfObject, toArmy, limit, allowedTypeCount))
				{
					canAdd = Validation.Failed;
					break;
				}
			}

			if (typeFound && canAdd == Validation.NotApplicable)
			{
				canAdd = Validation.Passed;
			}

			return canAdd;
		}

		private int GetAllowedObjectCount(Army toArmy, OBJECT_TYPE obj, IWarFoundryObject wfObject)
		{
			return GetObjectCountFromArmy(toArmy, obj) + GetCountFromObject(wfObject, obj);
		}

		private int GetCountFromObject(IWarFoundryObject wfObject, OBJECT_TYPE limitedType)
		{
			return (limitedType.Equals(wfObject) || (wfObject is Unit && ((Unit)wfObject).UnitType.Equals(limitedType))) ? 1 : 0;
		}

		public override Validation ValidatesArmy(Army army)
		{
			Validation canAdd;
			int allowedTypeCount = GetObjectCountFromArmy(army, AllowedObject);

			if (allowedTypeCount > 0)
			{
				canAdd = Validation.Passed;

				foreach (UnitCountRequirementData limit in ConstraintTypes)
				{
					int limitedTypeCount = GetUnitTypesCount(army, limit.UnitTypes);

					if (!IsValidByRequirement(limit, allowedTypeCount, limitedTypeCount))
					{
						canAdd = Validation.Failed;
						break;
					}
				}
			}
			else
			{
				canAdd = Validation.NotApplicable;
			}

			return canAdd;
		}

		protected override string GetFailedRequirementsString(Army army)
		{
			return String.Join("; ", GetFailedValidationRequirements(army).ToArray());
		}

		private List<string> GetFailedValidationRequirements(Army army)
		{
			List<string> failures = new List<string>();
			int allowedTypeCount = GetAllowedObjectCount(army);

			foreach (UnitCountRequirementData limit in ConstraintTypes)
			{
				int limitedTypeCount = GetUnitTypesCount(army, limit.UnitTypes);

				if (!IsValidByRequirement(limit, allowedTypeCount, limitedTypeCount))
				{
					string unitTypeList = GetUnitTypeList(limit);
					failures.Add(String.Format("{0} × {1} for every {2} × {3} (have {4} for {5})", limit.Count, unitTypeList, limit.AllowsCount, AllowedObject.Name, limitedTypeCount, allowedTypeCount));
				}
			}

			return failures;
		}

		protected abstract int GetAllowedObjectCount(Army army);

		/// <summary>
		/// Adds a requirement for there to be at least minCount of a given UnitType, allowing allowedCount of this UnitType
		/// </summary>
		/// <param name='unitType'>
		/// The unit type to require.
		/// </param>
		/// <param name='minCount'>
		/// The minimum number of that type that must exist.
		/// </param>
		/// <param name='allowedCount'>
		/// The number of units allowed for every minCount units of the supplied unit type.
		/// </param>
		public void AddUnitTypeRequirement(UnitType unitType, int minCount, int allowedCount)
		{
			ConstraintTypes.Add(new UnitCountRequirementData(unitType, minCount, allowedCount));
		}

		/// <summary>
		/// Adds a requirement for there to be at least one of a given UnitType, allowing allowedCount of this UnitType
		/// </summary>
		/// <param name='unitType'>
		/// The unit type to require.
		/// </param>
		/// <param name='allowedCount'>
		/// The number of units allowed for each unit of the supplied unit type.
		/// </param>
		public void AddUnitTypeRequirement(UnitType unitType, int allowedCount)
		{
			AddUnitTypeRequirement(allowedCount, unitType);
		}

		public override void AddUnitTypeRequirement(UnitType unitType)
		{
			AddUnitTypeRequirement(1, unitType);
		}

		/// <summary>
		/// Adds a requirement for there to be one or more of the given UnitTypes, allowing one of this UnitType. If multiple unit types
		/// are supplied here then the number is additive (so 1 x unitType1 and 1 x unitType2 allows two of this UnitType).
		/// </summary>
		/// <param name='unitType'>
		/// The unit type or types to require.
		/// </param>
		public void AddUnitTypeRequirement(params UnitType[] unitTypes)
		{
			AddUnitTypeRequirement(1, unitTypes);
		}

		/// <summary>
		/// Adds a requirement for there to be one or more of the given UnitTypes, allowing allowsAmount of this UnitType. If multiple unit types
		/// are supplied here then the number is additive (so 1 x unitType1 and 1 x unitType2 allows two of this UnitType).
		/// </summary>
		/// <param name="allowsAmount">
		/// The number of units to be allowed for each 1 of unitType
		/// </param>
		/// <param name='unitType'>
		/// The unit type or types to require.
		/// </param>
		public void AddUnitTypeRequirement(int allowsAmount, params UnitType[] unitTypes)
		{
			ConstraintTypes.Add(new UnitCountRequirementData(unitTypes, 1, allowsAmount));
		}

		/// <summary>
		/// Adds a requirement for there to be minCount or more of the given UnitTypes, allowing allowsAmount of this UnitType. If multiple unit types
		/// are supplied here then the number is additive (so 1 x unitType1 and 1 x unitType2 allows two of this UnitType).
		/// </summary>
		/// <param name='minCount'>
		/// The minimum number of that type that must exist.
		/// </param>
		/// <param name="allowsAmount">
		/// The number of units to be allowed for each 1 of unitType
		/// </param>
		/// <param name='unitType'>
		/// The unit type or types to require.
		/// </param>
		public void AddUnitTypeRequirement(int minCount, int allowsAmount, params UnitType[] unitTypes)
		{
			ConstraintTypes.Add(new UnitCountRequirementData(unitTypes, minCount, allowsAmount));
		}
	}
}