/JTacticalSim.Service/RulesService.cs

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Reflection;
using System.ServiceModel;
using LinqKit;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using JTacticalSim.API;
using JTacticalSim.API.InfoObjects;
using JTacticalSim.API.Component;
using JTacticalSim.API.Game;
using JTacticalSim.API.Service;
using JTacticalSim.Service;
using JTacticalSim.DataContext;
using JTacticalSim.Utility;

namespace JTacticalSim.Service
{
	[ServiceBehavior]
	public class RulesService : BaseGameService, IRulesService
	{
		static readonly object padlock = new object();

		private static volatile IRulesService _instance;
		public static IRulesService Instance
		{
			get
			{
				if (_instance == null)
				{
					lock (padlock)
						if (_instance == null) _instance = new RulesService();
				}

				return _instance;
			}
		}

		private RulesService()
		{}

#region Service Methods


	// Node/Tile

		[OperationBehavior]
		public IServiceResult<bool> NodeIsFactionNode(ICoordinate location, IFaction faction)
		{
			var r = new ServiceResult<bool>();

			var existingNode =  JTSServices.NodeService.GetNodeAt(location);

			if (existingNode.Faction.Equals(faction))
				r.Result = true;

			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> NodeIsValidForMove(IUnit unit, INode targetNode)
		{
			var r = new ServiceResult<bool>{Status = ResultStatus.SUCCESS, Result = true};
			
			try
			{
				var sourceNode = unit.GetNode();
				var allPossibleNodes = JTSServices.NodeService.GetAllNodesWithinDistance(sourceNode, unit.CurrentMoveStats.MovementPoints, true, false).ToList();

				if (!allPossibleNodes.Any(n => n.Equals(targetNode)))
				{
					r.Status = ResultStatus.OTHER;
					r.Messages.Add("Node is not in movement range for {0}".F(unit.Name));
					r.Result = false;
					return r;
				}

				// Remove any nodes with default tiles that prohibit movement for this unit based on geography
				allPossibleNodes.RemoveAll(n => !JTSServices.RulesService.TileIsAllowableForUnit(unit, n.DefaultTile()).Result);

				var path = JTSServices.AIService.FindPath(sourceNode, targetNode, allPossibleNodes, unit);

				if (path.Result == null)
				{
					r.Messages.Add("Node is not a valid move for {0}".F(unit.Name));
					r.Result = false;
					return r;
				}
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.Result = false;
				r.ex = ex;
				return r;
			}

			r.Messages.Add("Node is a valid move for {0}".F(unit.Name));
			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> NodeIsChokepoint(INode node)
		{
			var r = new ServiceResult<bool> { Status = ResultStatus.SUCCESS, Result = false};

			List<Tuple<ITile, ITile>> neighborPairs;

			// Bridge
			var isBridge = node.DefaultTile().Infrastructure.Any(d => d.IsDemographicClass("bridge"));

			if (isBridge)
			{
				r.Result = true;
				r.Messages.Add("Node has a bridge.");
				return r;
			}
			
			// Get all the surrounding node tiles in opposite pairs.
			// We determine if this is a chokepoint by ascertaining whether there is ANY opposite pair
			// That would force units to use this node in a path
			try
			{
				neighborPairs = JTSServices.NodeService.GetNeighborNodesOppositeTilePairs(node);
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
				return r;
			}

			try
			{
				var pathThroughRestrictedMovementResult = TileIsPassThroughRestrictedMovement(node.DefaultTile(), neighborPairs);
				if (pathThroughRestrictedMovementResult.Status == ResultStatus.EXCEPTION) throw pathThroughRestrictedMovementResult.ex;
				if (pathThroughRestrictedMovementResult.Result) return pathThroughRestrictedMovementResult;

				var narrowGeogResult = TileIsNarrowGeography(node.DefaultTile(), neighborPairs);
				if (narrowGeogResult.Status == ResultStatus.EXCEPTION) throw narrowGeogResult.ex;
				if (narrowGeogResult.Result) return narrowGeogResult;
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
				return r;
			}
			
			// Is not a chokepoint
			r.Messages.Add("Node is not a chokepoint.");
			return r;
		}


		[OperationBehavior]
		public IServiceResult<bool> TileIsPassThroughRestrictedMovement(ITile tile, List<Tuple<ITile, ITile>> neighborPairs)
		{
			var r = new ServiceResult<bool> { Status = ResultStatus.SUCCESS, Result = false };

			// Mountain Pass/ or pass through any other restricted movement areas
			try
			{
				var isPathThroughRestrictedMovement = neighborPairs.Any(p => (tile.GetNetMovementAdjustment() >= 0) // If the source is restricted, then there is no path
																				&& // One is null. The other has movement restrictions
																				((p.Item1 == null && p.Item2 != null) && (p.Item2.GetNetMovementAdjustment() < 0)
																				||
																				(p.Item2 == null && p.Item1 != null) && (p.Item1.GetNetMovementAdjustment() < 0))
																				|| // Neither are null and both have restricted movement
																				(p.Item1 != null && p.Item2 != null) && (p.Item1.GetNetMovementAdjustment() < 0 && p.Item2.GetNetMovementAdjustment() < 0));

				if (isPathThroughRestrictedMovement)
				{
					r.Result = true;
					r.Messages.Add("Tile allows for movement through otherwise movement restricted area.");
					return r;
				}

				return r;
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
				return r;
			}
		}

		[OperationBehavior]
		public IServiceResult<bool> TileIsNarrowGeography(ITile tile, List<Tuple<ITile, ITile>> neighborPairs)
		{
			var r = new ServiceResult<bool> { Status = ResultStatus.SUCCESS, Result = false};

			// Narrow Land/Waterway (base geog)
			// Either of the pair tiles' base geography can not match the source node
			// The pair tiles MUST match each other. One can be a hybrid.
			try
			{
				var isNarrowGeog = neighborPairs.Any(p => (p.Item1 == null && p.Item2 == null)		// both are null - corner node
				                                            ||	// One is null and the other is either a hybrid or does not match the source
				                                            (p.Item1 == null && p.Item2 != null) &&
				                                            (p.Item2.BaseGeography.Any(g => g.IsHybrid()) || !p.Item2.BaseGeography.Any(g => tile.BaseGeography.Contains(g)))
				                                            ||
				                                            (p.Item2 == null && p.Item1 != null) &&
				                                            (p.Item1.BaseGeography.Any(g => g.IsHybrid()) || !p.Item1.BaseGeography.Any(g => tile.BaseGeography.Contains(g)))
				                                            ||	// Neither are null and both opposites are hybrids
				                                            (p.Item1 != null && p.Item2 != null) &&
				                                            p.Item2.BaseGeography.Any(g => g.IsHybrid()) && p.Item1.BaseGeography.Any(g => g.IsHybrid())
				                                            ||	// Neither are null and neither match the source
				                                            (p.Item1 != null && p.Item2 != null) &&
				                                            (p.Item1.BaseGeography.Any(g => g.IsHybrid()) || !p.Item1.BaseGeography.Any(g => tile.BaseGeography.Contains(g))) &&
				                                            (p.Item2.BaseGeography.Any(g => g.IsHybrid()) || !p.Item2.BaseGeography.Any(g => tile.BaseGeography.Contains(g))));

				if (isNarrowGeog)
				{
					r.Result = true;
					r.Messages.Add("Tile geography is narrow.");
					return r;
				}

				return r;
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
				return r;
			}
		}

		[OperationBehavior]
		public IServiceResult<bool> TileIsAllowableForUnit(IUnit unit, ITile tile)
		{
			var r = new ServiceResult<bool>{Status = ResultStatus.SUCCESS, Result = true};

			var rGeog = TileIsAllowableForUnitType(unit.UnitInfo.UnitType, tile);
			var rOverride = TileHasMovementOverrideForUnitType(unit.UnitInfo.UnitType, tile);

			r.Result = rGeog.Result || rOverride.Result;

			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> TileIsAllowableForUnitType(IUnitType unitType, ITile tile)
		{
			var r = new ServiceResult<bool>{Status = ResultStatus.SUCCESS, Result = true};

			try
			{
				var tileGeogTypeIDs = tile.AllGeography.Select(g => g.DemographicClass.ID);
				var unitGeogTypeIDs = JTSServices.DataService.LookupUnitGeogTypesByBaseTypes(new[] {unitType.BaseType.ID});
				var demoClassIDs = JTSServices.DataService.LookupDemographicClassesByUnitGeogTypes(unitGeogTypeIDs);

				// Tile has at least one geographic demographic compatible with this unit, a movement override or no geographic demos
				r.Result =	demoClassIDs.Any(dID => tileGeogTypeIDs.Contains(dID)) ||
							demoClassIDs.Any(dID => dID == 9999) || // Applies to all records in a table
							tileGeogTypeIDs.Count() == 0;

				return r;
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
				r.Result = false;
				return r;
			}
		}

		[OperationBehavior]
		public IServiceResult<bool> TileHasMovementOverrideForUnit(IUnit unit, ITile tile)
		{
			var r = TileHasMovementOverrideForUnitType(unit.UnitInfo.UnitType, tile);
			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> TileHasMovementOverrideForUnitType(IUnitType unitType, ITile tile)
		{
			var r = new ServiceResult<bool>{Status = ResultStatus.SUCCESS, Result = true};
			
			try
			{
				var unitGeogTypeIDs = JTSServices.DataService.LookupUnitGeogTypesByBaseTypes(new [] {unitType.BaseType.ID});
				var tileGeogTypeIDs = tile.AllGeography.Select(g => g.DemographicClass.ID);
				var tileInfraTypeIDs = tile.Infrastructure.Select(i => i.DemographicClass.ID);

				var overrides = DataRepository.GetUnitGeogTypeMovementOverrides();

				// Global override
				if (overrides.Any(ov => Enumerable.Contains(unitGeogTypeIDs, ov.UnitGeogType) &&
								(ov.Geography == 9999 & ov.Infrastructure == 9999)))
				{
					r.Result = true;
					return r;
				}

				var q = from ov in overrides
						join ugt in unitGeogTypeIDs on ov.UnitGeogType equals ugt
						join tgt in tileGeogTypeIDs on ov.Geography equals tgt
						join tit in tileInfraTypeIDs on ov.Infrastructure equals tit
						select new {ov.UnitGeogType, ov.Geography, ov.Infrastructure};


				r.Result = q.Any();
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
				r.Result = false;
				return r;
			}

			return r;
		}
		

	// Unit

		[OperationBehavior]
		public IServiceResult<int> GetAllowableDeployDistanceForTransport(IUnit transport)
		{
			var r = new ServiceResult<int> {Status = ResultStatus.SUCCESS};

			try
			{
				r.Result = (transport.IsUnitBaseType("Watercraft") || transport.IsUnitBaseType("Watercraft-sub")) ? 1 : 0;
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
			}

			return r;
		}

		[OperationBehavior]
		public IServiceResult<int> GetAllowableLoadDistanceForTransport(IUnit transport)
		{
			var r = new ServiceResult<int> {Status = ResultStatus.SUCCESS};

			try
			{
				r.Result = (transport.IsUnitBaseType("Watercraft") || transport.IsUnitBaseType("Watercraft-sub")) ? 1 : 0;
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
			}

			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitNameIsUnique(string name)
		{
			var r = new ServiceResult<bool>();
			r.Result = ComponentRepository.GetUnits().All(m => m.Name.ToLowerInvariant() != name.ToLowerInvariant());
			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitsCanDoBattleWithUnits(List<IUnit> units, List<IUnit> opponents, BattleType battleType)
		{

			var r = new ServiceResult<bool> { Status = ResultStatus.SUCCESS };
			r.Result = false;

			units.ForEach(u => opponents.ForEach(o =>
				{
					if (UnitCanDoBattleWithUnit(u, o, battleType).Result)
					{
						r.Result = true;
						return;
					}
				}));

			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitCanDoBattleWithUnit(IUnit unit, IUnit opponent, BattleType battleType)
		{
			var r = new ServiceResult<bool>();

			// This isn't actually necessary as local battles will always have a distance of 0
			// I'm leaving this in here to
			//		a) as a gate to save some processing time
			//		b) assist in testing where the sim may be assembling units at different locations to simulate a local battle
			if (battleType == BattleType.BARRAGE)
			{
				// Check distance first. Local battles should all pass with distance of 0
				// else, opponent (target) needs to be within the range of the remaining remote fire points for the attacker (source)
				var distanceResult = JTSServices.AIService.CalculateNodeCountToUnit(unit, opponent, unit.CurrentMoveStats.RemoteFirePoints);
				if (distanceResult.Status == ResultStatus.FAILURE)
				{
					r.Result = false;
					r.Messages.Add(distanceResult.Message);
					return r;
				}
			}			

			// Within range, check other rules

			IEnumerable<int> battleAllowedGeogTypeIDs = DataRepository.GetUnitBattleEffectiveLookup()
																.Where(ube => ube.UnitType == unit.UnitInfo.UnitType.ID)
																.Select(ube => Convert.ToInt32(ube.UnitGeogType as int?));

			var defenderGeogTypes = JTSServices.DataService.LookupUnitGeogTypesByBaseTypes(new[] {opponent.UnitInfo.UnitType.BaseType.ID});
				
			r.Result =	battleAllowedGeogTypeIDs.Any(id => defenderGeogTypes.Contains(id)) ||
						battleAllowedGeogTypeIDs.Any(id => defenderGeogTypes.Contains(9999)) ||
						battleAllowedGeogTypeIDs.Any(id => id == 9999);


			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitCanDoBattle(IUnit unit)
		{
			var r = new ServiceResult<bool>();

			r.Result =	((unit.CurrentMoveStats.RemoteFirePoints > 0) || 
						!unit.CurrentMoveStats.HasPerformedAction);

			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitCanClaimNodeForFaction(IUnit unit)
		{
			//For now, unit must only not be an air unit
			var r = new ServiceResult<bool>();
			r.Result = (!unit.IsUnitBaseType("Plane") && !unit.IsUnitBaseType("Helicopter"));
			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitCanAttachToUnit(IUnit unit, IUnit attachToUnit)
		{
			var r = new ServiceResult<bool>();
			r.Status = ResultStatus.SUCCESS;

			// First rule : only attach to units at the next highest group type level
			r.Result = attachToUnit.UnitInfo.UnitGroupType.Equals(unit.UnitInfo.UnitGroupType.NextHighestGroupType);

			if (!r.Result)
			{
				r.Status = ResultStatus.FAILURE;
				r.Messages.Add("{0} can not be attached to {1} due to it's organization level.".F(unit.Name, attachToUnit.Name));
				return r;
			}

			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitIsSupplied(IUnit unit)
		{
			var r = new ServiceResult<bool> {Result = false, Status = ResultStatus.SUCCESS};

			try
			{
				r.Result = (JTSServices.AIService.FindSupplyPath(unit.GetNode(), unit.Faction, BaseGamePointValues.MaxSupplyDistance) != null);
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
			}

			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitHasMedicalSupport(IUnit unit)
		{
			// Should only be determined based on medical unit AT current node including current unit
			// Aircraft that can not land should not get medical bonus unless it is medical unit class
			var r = new ServiceResult<bool> {Result = true, Status = ResultStatus.SUCCESS};

			// Check the current unit first to save some processing
			if (unit.IsUnitClass("medical"))
			{
				r.Messages.Add("{0} is a medical unit.".F(unit.Name));
				return r;
			}

			if (!unit.UnitInfo.UnitType.BaseType.CanReceiveMedicalSupport)
			{
				r.Result = false;
				r.Messages.Add("{0} has a base type that can not receive medical suppport.".F(unit.Name));
				return r;
			}

			var units = JTSServices.UnitService.GetAllUnits(new[] {unit.Faction})
			                   .Where(u => u.Location != null &&
			                               u.LocationEquals(unit.Location));

			r.Result = units.Any(u => u.IsUnitClass("medical"));

			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitIsUnitClass(IUnit unit, string className)
		{
			var r = new ServiceResult<bool> {Result = false, Status = ResultStatus.SUCCESS};

			try
			{
				var uc = JTSServices.UnitService.GetUnitClassByName(className);
				r.Result = (unit.UnitInfo.UnitClass.Equals(uc));
			}
			catch (ComponentNotFoundException ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
				return r;
			}

			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitIsUnitBaseType(IUnit unit, string baseTypeName)
		{
			var r = new ServiceResult<bool> {Result = false, Status = ResultStatus.SUCCESS};

			try
			{

					var baseType = ComponentRepository.GetUnitBaseTypes()
										.Single(ubt => ubt.Name.ToLowerInvariant() == baseTypeName.ToLowerInvariant())
										.ToComponent();					
					
					if (baseTypeName == null)
						throw new ComponentNotFoundException("UnitBaseType '{0}' not found.");

					r.Result = (unit.UnitInfo.UnitType.BaseType.Equals(baseType));

				
			}
			catch (ComponentNotFoundException ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
			}

			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitIsDeployableToNode(IUnit unit, INode node)
		{
			// Node must be compatible with the unit
			// Unit must have the 1 remaining movement point to move
			return JTSServices.RulesService.NodeIsValidForMove(unit, node);
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitCanReinforceAtLocation(IUnit unit, INode node)
		{
			// Node must be compatible with the unit
			// Node must be a friendly
			// There must be an HQ for the player at the location
			var r = new ServiceResult<bool>
				{
					Result = true, 
					Status = ResultStatus.SUCCESS
				};

			var playerUnits = node.GetAllUnits().Where(u => u.Country.Equals(unit.Country));

			var tileValidResult = JTSServices.RulesService.TileIsAllowableForUnit(unit, node.DefaultTile());

			if (!tileValidResult.Result)
			{
				return tileValidResult;
			}

			if (!node.IsFriendly())
			{
				r.Result = false;
				r.Status = ResultStatus.FAILURE;
				r.Messages.Add("Node is not friendly.");
				return r;
			}

			//if (!playerUnits.Any())
			//{
			//    r.Status = ResultStatus.FAILURE;
			//    r.Message = "Location {0} has no units for {1}.".F(node.Location.ToStringForName(), unit.Country.Name);
			//    r.Result = false;
			//    return r;
			//}

			// HQs can be placed on any friendly space with units existing - FYI
			if (!playerUnits.Any(u => JTSServices.RulesService.UnitIsUnitClass(u, "HQ").Result) &&
				!JTSServices.RulesService.UnitIsUnitClass(unit, "HQ").Result)
			{
				r.Status = ResultStatus.FAILURE;
				r.Messages.Add("Location {0} has no HQ for {1}.".F(node.Location.ToStringForName(), unit.Country.Name));
				r.Result = false;
				return r;
			}

			r.Messages.Add("{0} is deployable to {1}".F(unit.Name, node.Location.ToStringForName()));
			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitCanTransportUnitTypeAndClass(IUnit transport, IUnit unit)
		{
			var r = new ServiceResult<bool> {Result = false, Status = ResultStatus.SUCCESS};

			r.Result = DataRepository.GetUnitTransportUnitTypeUnitClasses().Any(te => (te.TransportUnitType == transport.UnitInfo.UnitType.ID &&
																				(te.CarriedUnitType == unit.UnitInfo.UnitType.ID || te.CarriedUnitType == 9999) &&
																				(te.CarriedUnitClass == unit.UnitInfo.UnitClass.ID || te.CarriedUnitClass == 9999)));

			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitCanMoveInDirection(IUnit unit, Direction direction)
		{
			var r = new ServiceResult<bool> { Status = ResultStatus.SUCCESS, Result = false };
			var unitGeog = JTSServices.DataService.LookupUnitGeogTypesByBaseTypes(new [] {unit.UnitInfo.UnitType.BaseType.ID});
			var node = unit.GetNode();

			INode targetNode = null;

			try
			{
				targetNode = node.GetNodeInDirection(direction, 1);
			}
			catch (ComponentNotFoundException)
			{}

	
			var canExitCurrentNode = true;
			var canEnterTargetNode = true;

			// We only want to be checking this for hybrid demographics
			// Do check on demographics first
			var currentHybridDemographicTypes = node.DefaultTile().GetAllHybridDemographics().Select(d => d.DemographicClass.ID);
			canExitCurrentNode = !DataRepository.GetMovementHinderanceInDirection()
															.Any(h => (	(Enumerable.Contains(currentHybridDemographicTypes, h.DemographicClass)) &&
																		(Enumerable.Contains(unitGeog, h.UnitGeogType) || h.UnitGeogType == 9999) &&
																		(h.Direction == direction)));

			// Then Check for overrides
			if (!canExitCurrentNode)
				canExitCurrentNode = JTSServices.RulesService.TileHasMovementOverrideForUnit(unit, node.DefaultTile()).Result;


				
			if (targetNode != null) //We're assumed to have reached the board edge... no target node
			{
				    
				var targetHybridDemographics = targetNode.DefaultTile().GetAllHybridDemographics().Select(d => d.DemographicClass.ID);
				canEnterTargetNode = !DataRepository.GetMovementHinderanceInDirection()
																.Any(h => ( (Enumerable.Contains(targetHybridDemographics, h.DemographicClass)) &&
																			(Enumerable.Contains(unitGeog, h.UnitGeogType) || h.UnitGeogType == 9999) &&
																			(h.Direction == Orienting.GetOppositeDirection(direction))));

				// Then Check for overrides
				if (!canEnterTargetNode)
					canEnterTargetNode = JTSServices.RulesService.TileHasMovementOverrideForUnit(unit, targetNode.DefaultTile()).Result;
			}
			else
			{
				canEnterTargetNode = false;
			}
			
			r.Result = (canExitCurrentNode && canEnterTargetNode);
			//retVal.Result = canExitCurrentNode;

			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> UnitCanPerformTask(IUnit unit, IUnitTask task)
		{
			// Based on allowable task assignments for a UnitClass and UnitGroupType

			var r = new ServiceResult<bool>() { Status = ResultStatus.SUCCESS, Result = false};
			bool unitClassCanPerformTask = false;
			bool unitGroupTypeCanPerformTask = false;

			try
			{
				unitClassCanPerformTask = DataRepository.GetUnitTaskUnitClassesLookup()
																.Any(utuc => utuc.UnitTask == task.ID && 
																	(utuc.UnitClass == unit.UnitInfo.UnitClass.ID || utuc.UnitClass == 9999));
				unitGroupTypeCanPerformTask = DataRepository.GetUnitGroupTypeUnitTaskLookup()
																.Any(ugtut => ugtut.UnitTask == task.ID && 
																	(ugtut.UnitGroupType == unit.UnitInfo.UnitGroupType.ID || ugtut.UnitGroupType == 9999));

				if (!unitClassCanPerformTask)
				{
					r.Messages.Add("{0} can not perform task {1} due to its unit class.".F(unit.Name, task.Name));
					return r;
				}

				if (!unitGroupTypeCanPerformTask)
				{
					r.Messages.Add("{0} can not perform task {1} due to its unit group type.".F(unit.Name, task.Name));
					return r;
				}

				r.Result = true;
				r.Messages.Add("{0} is allowable for {1}.".F(task.Name, unit.Name));
				return r;

			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
				return r;
			}	
		}

		[OperationBehavior]
		public IServiceResult<bool> ComponentIsVisible(IMoveableComponent component)
		{
			var r = new ServiceResult<bool> {Result = false, Status = ResultStatus.SUCCESS};
			r.Result = (!component.IsBeingTransported());
			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> ComponentIsBeingTransported(IMoveableComponent component)
		{
			var r = new ServiceResult<bool> {Result = false, Status = ResultStatus.SUCCESS};
			r.Result = DataRepository.GetUnitTransports().Any(ut => ut.Unit == component.ID);
			return r;
		}


	// Game

		[OperationBehavior]
		public IServiceResult<bool> GameVictoryAchieved(IFaction faction)
		{
			var conditions = faction.VictoryConditions();
			var r = new ServiceResult<bool>{Status = ResultStatus.SUCCESS, Result = false};

			if (conditions == null || conditions.Count == 0)
				throw new Exception("{0} has no victory condition and can not win the game.".F(faction.Name));

			// Check each condition based on its own set of rules
			
			foreach(var vc in conditions)
			{
				switch (vc.ConditionType)
				{
					case GameVictoryCondition.ENEMY_UNITS_REMAINING :
						{
							var enemyFactions = ComponentRepository.GetFactions()
														.Where(f => !f.ToComponent().Equals(faction))
														.Select(f => f.ToComponent());

							var enemyUnits = JTSServices.UnitService.GetAllUnits(enemyFactions);
								
								
							r.Result = enemyUnits.Count() <= vc.Value;

							// Condition met... we're good
							if (r.Result) return r;

							break;
						}
					case GameVictoryCondition.VICTORY_POINTS_HELD :
						{
							r.Result = faction.GetCurrentVictoryPoints() >= vc.Value;

							// Condition met... we're good
							if (r.Result) return r;

							break;
						}
					case GameVictoryCondition.FLAG_CAPTURED :
						{
							var enemyFactions = ComponentRepository.GetFactions()
														.Where(f => !f.ToComponent().Equals(faction))
														.Select(f => f.ToComponent());

								
							// Get all the remaining flag-holders for all factions
							var enemyUnits = JTSServices.UnitService.GetAllUnits(enemyFactions)
														.Where(u => u.ID == vc.Value);	


							// if there are none, all flags are captured
							r.Result = !enemyUnits.Any();
								
							// Condition met
							if (r.Result) return r;

							break;
						}
				}

			}
			
			// No victory conditions met
			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> GameTitleIsValid(string title)
		{

			var r = new ServiceResult<bool>
				{
					Status = ResultStatus.SUCCESS, 
					Result = true
				};

			var reg = new Regex("^[-_0-9a-zA-Z]*$");
			var nameInUse = false;
			
			if (title.IndexOfAny(new[] {' '}) > 0)
			{
				r.Status = ResultStatus.FAILURE;
				r.Messages.Add("Title contains spaces.");
				r.Result = false;
				return r;
			}
			
			if (!reg.IsMatch(title))
			{
				r.Status = ResultStatus.FAILURE;
				r.Messages.Add("Title contains special characters.");
				r.Result = false;
				return r;
			}

			nameInUse = (ComponentRepository.GetSavedGames().Any(f => f.Name.ToLowerInvariant().Equals(title.ToLowerInvariant())));

			if (nameInUse)
			{
				r.Status = ResultStatus.FAILURE;
				r.Messages.Add("Title currently in use.");
				r.Result = false;
				return r;
			}

			r.Messages.Add("Game title is valid");
			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> ScenarioTitleIsValid(string title)
		{

			var r = new ServiceResult<bool>
				{
					Status = ResultStatus.SUCCESS, 
					Result = true
				};

			var validScenario = false;

			validScenario = (ComponentRepository.GetScenarios().Any(f => f.Name.ToLowerInvariant().Equals(title.ToLowerInvariant())));

			if (!validScenario)
			{
				r.Status = ResultStatus.FAILURE;
				r.Messages.Add("{0} is not a currently available scenario.".F(title));
				r.Result = false;
				return r;
			}
			
			r.Messages.Add("Scenario title is valid");
			return r;
		}


	// Battle

		[OperationBehavior]
		public IServiceResult<ISkirmish> CheckSkirmishVictoryCondition(ISkirmish skirmish)
		{
			var r = new ServiceResult<ISkirmish> {Status = ResultStatus.SUCCESS, Result = skirmish};

			var attackerDestroyed = (skirmish.Destroyed.Any() && skirmish.Destroyed.Contains(skirmish.Attacker));
			var defenderDestroyed = (skirmish.Destroyed.Any() && skirmish.Destroyed.Contains(skirmish.Defender));

			if (attackerDestroyed && defenderDestroyed)
			{
				skirmish.VictoryCondition = BattleVictoryCondition.ALL_DESTROYED;
				r.Messages.Add("Both units were destroyed.");
				return r;
			}

			if (attackerDestroyed && !defenderDestroyed)
			{
				skirmish.VictoryCondition = BattleVictoryCondition.DEFENDERS_VICTORIOUS;
				r.Messages.Add("{0} was destroyed.".F(skirmish.Destroyed.Single().Name));
				return r;
			}

			if (!attackerDestroyed && defenderDestroyed)
			{
				skirmish.VictoryCondition = BattleVictoryCondition.ATTACKERS_VICTORIOUS;
				r.Messages.Add("{0} was destroyed.".F(skirmish.Destroyed.Single().Name));
				return r;
			}


			if (skirmish.DefenderEvaded)
			{
				skirmish.VictoryCondition = BattleVictoryCondition.EVADED;
				r.Messages.Add("{0} evaded attack.".F(skirmish.Defender.Name));
				return r;
			}

			return r;
		}

		[OperationBehavior]
		public IServiceResult<IBattle> CheckBattleVictoryCondition(IBattle battle)
		{
			// - One or both of the battle factions have no remaining units
			// - No suitable defenders left for attackers 
			//		Local - surrender and retreat
			//		Remote - stalemate
			// - no victor yet

			var r = new ServiceResult<IBattle> {Status = ResultStatus.SUCCESS, Result = battle};
			
			try
			{
				if (battle.Attackers.Any() && battle.Defenders.Any())
				{
					if (!JTSServices.RulesService.UnitsCanDoBattleWithUnits(battle.Attackers, battle.Defenders, battle.BattleType).Result)
					{
						if (battle.BattleType == BattleType.LOCAL)
						{
							// No suitable defenders to attack in a local battle.
							// This emulates that the roles would be reversed and the attackers may have no
							// Defence against the remaining defenders. Attackers will be forced to surrender
							// and retreat.
							battle.VictoryCondition = BattleVictoryCondition.SURRENDER;
							battle.VictorFaction = battle.DefenderFaction;
							return r;
						}

						if (battle.BattleType == BattleType.BARRAGE)
						{
							// In remote battle where the barrage is limited to number of available attack points
							// if attackers and defenders deplete these points and remain standing,
							// the battle is a stalemate. Victory will still be to the defender as they have held off
							// the barrage
							battle.VictoryCondition = BattleVictoryCondition.STALEMATE;
							battle.VictorFaction = battle.DefenderFaction;
							return r;
						}
						
					}

					// Battle is not over.....
					battle.VictoryCondition = BattleVictoryCondition.NO_VICTOR;
					return r;
				}

				if (!battle.Attackers.Any() && !battle.Defenders.Any())
				{
					// All units destroyed
					battle.VictorFaction = battle.DefenderFaction;
					battle.VictoryCondition = BattleVictoryCondition.ALL_DESTROYED;
					return r;
				}

				// Attackers win
				if (battle.Attackers.Any())
				{
					battle.VictoryCondition = BattleVictoryCondition.ATTACKERS_VICTORIOUS;
					battle.VictorFaction = battle.AttackerFaction;
					return r;
				}

				// Defenders win
				if (battle.Defenders.Any())
				{
					battle.VictoryCondition = BattleVictoryCondition.DEFENDERS_VICTORIOUS;
					battle.VictorFaction = battle.DefenderFaction;
					return r;
				}
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
				return r;
			}

			r.Status = ResultStatus.FAILURE;
			r.Messages.Add("No victory condition could be met.");
			return r;
		}

		[OperationBehavior]
		public IServiceResult<bool> BattleCanContinue(IBattle battle)
		{
			// 1. Can any attacking units fire at defending units?
			// 2. ???

			var r = new ServiceResult<bool> {Status = ResultStatus.SUCCESS, Result = true};

			if (!battle.Attackers.Any() || !battle.Defenders.Any())
			{
				r.Status = ResultStatus.FAILURE;
				r.Result = false;
				r.Messages.Add("No Defenders or Attackers left in battle.");
				return r;
			}

			if (!UnitsCanDoBattleWithUnits(battle.Attackers, battle.Defenders, battle.BattleType).Result)
			{
				r.Status = ResultStatus.FAILURE;
				r.Result = false;
				r.Messages.Add("There are no attackers able to do battle with the current defenders.");
				return r;
			}

			r.Messages.Add("Battle can continue.");
			return r;
		}

	// AI

		[OperationBehavior]
		public IServiceResult<StrategicAssessmentRating> GetOverallRatingForStrategicAssessment(StrategicAssessmentInfo assessment)
		{
			var r = new ServiceResult<StrategicAssessmentRating> {Status = ResultStatus.SUCCESS};
			double total = 0;

			try
			{
				PropertyInfo[] props = typeof(StrategicAssessmentInfo).GetProperties()
									.Where(p => p.PropertyType == typeof(StrategicAssessmentRating)).ToArray();

				// We didn't pick up any of the assessment properties for some reason
				if (!props.Any())
				{
					r.Status = ResultStatus.FAILURE;
					r.Messages.Add("No property values could be ascertained for the assessment object.");
					return r;
				}

				Action<PropertyInfo> infoAction = p =>
				{
					lock (props)
					{
						total += Convert.ToInt32(p.GetValue(assessment, null));
					}
				};

				if (Convert.ToBoolean(ConfigurationManager.AppSettings["run_multithreaded"]))
				{
					Parallel.ForEach(props, infoAction);
				}
				else
				{
					props.ForEach(p => infoAction(p));
				}

				total = (total/props.Count());
				r.Result = (StrategicAssessmentRating) Math.Round(total);
				return r;
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
				return r;
			}
		}


	#region Rules Calculations

		[OperationBehavior]
		public IServiceResult<double> CalculateTotalUnitWeight(IUnit unit)
		{
			var r = new ServiceResult<double> {Status = ResultStatus.SUCCESS};
			List<IUnit> allUnits;

			try
			{
				allUnits = unit.GetAllAttachedUnits().ToList();
				allUnits.Add(unit);
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
				r.Messages.Add("Could not get attached units for {0}".F(unit.Name));
				return r;
			}

			try
			{
				r.Result = allUnits.Sum(s => CalculateUnitWeight(s).Result);
				return r;
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
				return r;
			}
		}

		[OperationBehavior]
		public IServiceResult<double> CalculateUnitWeight(IUnit unit)
		{
			var r = new ServiceResult<double> {Status = ResultStatus.SUCCESS};

			var weightBase = JTSServices.DataService.GetBasePointValues().WeightBase;
			r.Result = (unit.UnitInfo.UnitType.UnitWeightModifier * weightBase);

			return r;
		}

		[OperationBehavior]
		public IServiceResult<double> CalculateAllowableTransportWeight(IUnit unit)
		{
			var r = new ServiceResult<double>();

			var weightBase = JTSServices.DataService.GetBasePointValues().WeightBase;
			r.Result = (unit.UnitInfo.UnitType.AllowableWeightModifier * weightBase);

			return r;
		}

		[OperationBehavior]
		public double? CalculateMovementHeuristic(IPathableObject component)
		{
			double? retVal = 0;

			//retVal = 10*
			//         (Math.Abs(component.Location.X - component.Target.Location.X) +
			//          Math.Abs(component.Location.Y - component.Target.Location.Y));

			retVal =	Math.Max(Math.Abs(component.Location.X - component.Target.Location.X), 
			            Math.Abs(component.Location.Y - component.Target.Location.Y));
			
			// Use cross-product to favor direct paths
			var dx1 = component.Location.X - component.Target.Location.X;
			var dy1 = component.Location.Y - component.Target.Location.Y;
			var dx2 = component.Source.Location.X - component.Target.Location.X;
			var dy2 = component.Source.Location.Y - component.Target.Location.Y;

			var cross = Math.Abs((dx1 * dy2) - (dx2 * dy1));

			retVal += (cross * Math.Sqrt(2));


			return retVal;

		}

		[OperationBehavior]
		public IServiceResult<int> CalculateTotalVictoryPoints(IFaction faction)
		{
			var r = new ServiceResult<int>();

			// Start off with total of faction-held nodes/tiles
			var nodes = JTSServices.NodeService.GetAllNodes();
			var fromNodes = nodes.Where(n => n.Faction.Equals(faction))
									.Sum(n => n.DefaultTile().VictoryPoints);

			// One point per squad. Maybe make this dynamic? Increase with experience or some such
			var fromSquads = JTSServices.UnitService.GetAllUnits(new[] { faction }).Count();

			r.Result = (fromNodes + fromSquads);

			return r;			
		}

		[OperationBehavior]
		public IServiceResult<int> CalculateReinforcementPointsForTurn(IPlayer player)
		{
			// Percentage of total board held by country
			// Percentage of total board held by other faction countries
			// Percentage of victory points held by country

			var r = new ServiceResult<int>();
			var allNodes = JTSServices.NodeService.GetAllNodes();

			var totalNodeCount = allNodes.Count();
			var playerNodeCount = allNodes.Count(n => n.Country.Equals(player.Country));
			var otherFactionNodeCount = allNodes.Count(n => n.Country.Faction.Equals(player.Country.Faction) && 
															!n.Country.Equals(player.Country));
			var playerVictoryPoints = allNodes
										.Where(n => n.Country.Equals(player.Country))
										.Sum(n => n.DefaultTile().VictoryPoints);

			var pctOfTotalNodes_Country = (Convert.ToDouble(playerNodeCount) / Convert.ToDouble(totalNodeCount));
			var pctOfTotalNodes_Faction = (Convert.ToDouble(otherFactionNodeCount) / Convert.ToDouble(totalNodeCount));

			// Calculate points based on Base Game Point Value modifiers

			var totalPoints =	(pctOfTotalNodes_Country * BaseGamePointValues.ReinforcementCalcBaseCountry) +
								(pctOfTotalNodes_Faction * BaseGamePointValues.ReinforcementCalcBaseFaction) +
								(playerVictoryPoints * BaseGamePointValues.ReinforcementCalcBaseVP);

			r.Result = Convert.ToInt32(Math.Floor(totalPoints));
			return r;			
		}

		[OperationBehavior]
		public double CalculateUnitAttackValueForCurrentGeog(IUnit unit)
		{
			// Combat base value
			// Unit Net Attack adjustment
			// Occupied tile attack adjustment
			// HQ'd bonus
			// Supplied bonus

				var retVal =	unit.GetNetAttackAdjustment() +
								unit.GetNode().DefaultTile().GetNetAttackAdjustment() +
								((unit.AttachedToUnit != null) ? BaseGamePointValues.HQBonus : 0) +
								((UnitIsSupplied(unit).Result) ? BaseGamePointValues.SuppliedBonus : 0) +
								BaseGamePointValues.CombatBase;

				if (retVal > BaseGamePointValues.CombatRoll) retVal = BaseGamePointValues.CombatRoll;
				if (retVal < 0) retVal = 0;

				return retVal;		
		}

		[OperationBehavior]
		public double CalculateUnitDefenceValueForCurrentGeog(IUnit unit)
		{
			// Combat base value
			// Unit Net Defence adjustment
			// Occupied tile defence adjustment
			// HQ'd bonus
			// Supplied bonus

			var retVal =	unit.GetNetDefenceAdjustment() +
							unit.GetNode().DefaultTile().GetNetDefenceAdjustment() +
							((unit.AttachedToUnit != null) ? BaseGamePointValues.HQBonus : 0) +
							((UnitIsSupplied(unit).Result) ? BaseGamePointValues.SuppliedBonus : 0) +
							BaseGamePointValues.CombatBase;

			if (retVal > BaseGamePointValues.CombatRoll) retVal = BaseGamePointValues.CombatRoll;
			if (retVal < 0) retVal = 0;

			return retVal;		
		}

		[OperationBehavior]
		public double CalculateUnitStealthValueForCurrentGeog(IUnit unit)
		{
			// Combat base value
			// Unit Net Defence adjustment
			// Occupied tile defence adjustment
			var retVal =	unit.GetNetStealthAdjustment() +
							unit.GetNode().DefaultTile().GetNetStealthAdjustment() +
							BaseGamePointValues.StealthBase;

			if (retVal > BaseGamePointValues.StealthRoll) retVal = BaseGamePointValues.StealthRoll;
			if (retVal < 0) retVal = 0;

			return retVal;
		}

		[OperationBehavior]
		public double CalculateUnitStrength(IUnit unit)
		{
			// Based on:
			// unit cost factor
			// unit movement
			// total unit attack and defend (after adjustments)
			// unit attack distance
			// 1/2 unit stealth

			var strength = 0.0;

			strength += unit.GetNetCostMultiplier();
			strength += unit.GetNetAttackAdjustment() + unit.GetNetDefenceAdjustment();
			strength += unit.MovementPoints;
			strength += unit.GetNetAttackDistanceAdjustment();
			strength += (unit.GetFullNetStealthValue() / 2);

			return strength;
		}

		[OperationBehavior]
		public double CalculateTargetDesirabilityForUnit(IUnit unit)
		{
			// bonus if unit has attached units (depletes HQ bonus for attached units)
			// bonus for medical or supply (depletes medical bonus roll and supply bonuses for other units)

			// Concept is that since Medical and supply give combat bonuses to other units, they have a priority
			// HQ units (units with units attached) give combat bonuses to others, they have a priority
			//		but based on the number of units affected
			// The rest are based on a relative 'strength' metric
			var attachedUnits = unit.GetAllAttachedUnits();
			
			// Baseline
			var factor = unit.GetNetStrengthFactor();

			// Bonuses
			factor += (attachedUnits.Any() ? (attachedUnits.Count() * BaseGamePointValues.TargetAttachedUnitBonus) : 0);
			factor += (unit.IsUnitClass("medical")) ? BaseGamePointValues.TargetMedicalUnitBonus : 0;
			factor += (unit.IsUnitClass("supply")) ? BaseGamePointValues.TargetSupplyUnitBonus : 0;

			return factor;
		}

		[OperationBehavior]
		public IServiceResult<double> CalculateTotalRPCostForUnit(IUnit unit)
		{
			var r = new ServiceResult<double> { Status = ResultStatus.SUCCESS };

			try
			{
				r.Result = CalculateTotalRPByUnitTypeUnitClass(unit.UnitInfo.UnitType, unit.UnitInfo.UnitClass);
			}
			catch (Exception ex)
			{
				r.Status = ResultStatus.EXCEPTION;
				r.ex = ex;
			}

			return r;
		}

		[OperationBehavior]
		public double CalculateTotalRPByUnitTypeUnitClass(IUnitType ut, IUnitClass uc)
		{
			return Math.Ceiling(((ut.UnitCostModifier + uc.UnitCostModifier) * BaseGamePointValues.CostBase));			
		}

		[OperationBehavior]
		public int CalculateThreatDistance(int factorValue, int baseValue)
		{
			return Convert.ToInt32(Math.Round((Convert.ToDouble(factorValue) - 1) * 10 / baseValue));		
		}

		[OperationBehavior]
		public IServiceResult<double> CalculateOffensiveStrategicImportance(INode node)
		{
			var r = CalculateGeneralStrategicImportance(node);
			if (r.Status != ResultStatus.SUCCESS) { return r; }

			r.Result += node.DefaultTile().GetNetAttackAdjustment();

			return r;
		}

		[OperationBehavior]
		public IServiceResult<double> CalculateDefensiveStrategicImportance(INode node)
		{
			var r = CalculateGeneralStrategicImportance(node);
			if (r.Status != ResultStatus.SUCCESS) { return r; }

			r.Result += node.DefaultTile().GetNetDefenceAdjustment();

			return r;
		}

		[OperationBehavior]
		private IServiceResult<double> CalculateGeneralStrategicImportance(INode node)
		{
			var r = new ServiceResult<double> { Status = ResultStatus.SUCCESS };

			var demographicModifier = node.DefaultTile().GetNetStealthAdjustment();

			return r;
		}

	#endregion

#endregion

	// Utility

		[OperationBehavior]
		public bool DemographicIsHybrid(IDemographic demographic)
		{
			return DataRepository.GetHybridDemographicsClasses().Contains(demographic.DemographicClass.ID);
		}

	}
}