// This file (UnitEquipmentItem.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 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 IBBoard.Lang;

namespace IBBoard.WarFoundry.API.Objects
{
	/// <summary>
	/// Summary description for UnitEquipmentItem.
	/// </summary>
	public class UnitEquipmentItem : WarFoundryObject
	{
		private EquipmentItem item;
		private bool required;
		private bool roundUp;
		private int minNum;
		private int maxNum;
		private double minPercentage;
		private double maxPercentage;
		private double costMultiplier;
		private RoundType roundType;
		private string[] mutexGroups;
		private UnitType unitType;

		public UnitEquipmentItem(EquipmentItem equipmentItem, UnitType equipmentFor) : this(equipmentItem, equipmentFor, new string[0])
		{
			//Do nothing extra
		}
		
		public UnitEquipmentItem(EquipmentItem equipmentItem, UnitType equipmentFor, params string[] mutexGroups)
		{
			item = equipmentItem;
			unitType = equipmentFor;
			this.mutexGroups = mutexGroups;
			unitType.AddEquipmentItem(this);
		}
		
		public override string Name
		{
			get 
			{
				return item.Name;
			}
			set
			{
				base.Name = value;
			}
		}

		public override string ID {
			get
			{
				return (EquipmentForUnit == null ? base.ID : EquipmentForUnit.ID) + EquipmentItemID;
			}
			set
			{
				base.ID = value;
			}
		}

		
		public string EquipmentItemID
		{
			get { return item.ID; }
		}

        public double Cost
        {
            get
			{
				return IBBMath.Round(EquipmentItem.Cost * CostMultiplier, CostRoundType);
			}
        }

		public double CostMultiplier
		{
			get { return costMultiplier; }
			set
			{
				costMultiplier = value;
			}
		}

		public RoundType CostRoundType
		{
			get { return roundType; }
			set
			{
				roundType = value;
			}	
		}

		public bool IsRequired
		{
			get { return required; }
			set { required = value; }
		}

		public bool RoundNumberUp
		{
			get { return roundUp; }
			set { roundUp = value; }
		}

		[Obsolete("Use MutexGroups instead for greater flexibility")]
		public string MutexGroup
		{
			get { return (mutexGroups.Length == 0 ? "" : mutexGroups[0]); }
		}

		public String[] MutexGroups
		{
			get { return (string[]) mutexGroups.Clone(); }
		}

		public UnitType EquipmentForUnit
		{
			get { return unitType; }
		}
		
		public bool IsRatioLimit
		{
			get { return minPercentage!=100 || maxPercentage!=100; }
		}
		
		public int MinNumber
		{
			get { return minNum; }
			set
			{
				if (value >=0 || value == WarFoundryCore.INFINITY)
				{
					minNum = value;
				}
				//TODO: Check Min<Max
			}
		}
		
		public int MaxNumber
		{
			get { return maxNum; }
			set
			{
				if (value >=0 || value == WarFoundryCore.INFINITY)
				{
					maxNum = value;
				}
				//TODO: Check Min<Max
			}
		}
		
		public double MinPercentage
		{
			get { return minPercentage; }
			set
			{
				if (value >=0 && value <= 100)
				{
					minPercentage = value;
				}
				//TODO: Check Min<Max
			}
		}
		
		public double MaxPercentage
		{
			get { return maxPercentage; }
			set
			{
				if (value >=0 && value <= 100)
				{
					maxPercentage = value;
				}
				//TODO: Check Min<Max
			}
		}

		public EquipmentItem EquipmentItem
		{
			get { return item; }
		}

		public override string ToString()
		{
			return EquipmentItem.Name+ " ("+EquipmentItem.Cost+"pts each)";
		}

		public bool HasAlternatives()
		{
			if (MutexGroups.Length == 0)
			{
				return false;
			}
			else if (EquipmentForUnit == null)
			{
				return false;
			}
			else
			{
				//If the number of items in the MutEx group is greater than one then it must be this item plus another
				return EquipmentForUnit.GetEquipmentItemsByExclusionGroups(MutexGroups).Length > 1;
			}
		}

		public ArmourType ItemArmourType
		{
			get { return EquipmentItem.ItemArmourType; }
		}
		
		public string Description
		{
			get { return EquipmentItem.Description; }
		}
		
		public Race EquipmentForRace
		{
			get { return EquipmentItem.EquipmentForRace; }
		}

		public bool CanBeUsedWithItem(EquipmentItem item)
		{
			return EquipmentItem.CanBeUsedWithItem(item);
		}

		public bool CanBeUsedWithArmourType(ArmourType otherItemType)
		{
			return EquipmentItem.CanBeUsedWithArmourType(otherItemType);
		}

		/// <summary>
		/// Checks the "mutex" (mutual exclusion) groups of the other item against its own and determines whether the two items are mutually exclusive (share at least one mutex group)
		/// </summary>
		/// <param name="item">the item to check against</param>
		/// <returns><code>true</code> if the two items share at least one mutex group, else <code>false</code></returns>
		public bool IsMutuallyExclusive(UnitEquipmentItem item)
		{
			bool areMutex = false;

			foreach (string mutex in MutexGroups)
			{
				foreach (string otherMutex in item.MutexGroups)
				{
					if (mutex.Equals(otherMutex))
					{
						areMutex = true;
						goto postLoop;
					}
				}
			}
			postLoop:

			return areMutex;
		}
	}
}