/JTacticalSim.Service/UnitService.cs

using System;
using System.Configuration;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;
using System.Transactions;
using System.ServiceModel;
using JTacticalSim.API;
using JTacticalSim.API.Component;
using JTacticalSim.API.Data;
using JTacticalSim.API.InfoObjects;
using JTacticalSim.API.Service;
using JTacticalSim.Component.Battle;
using JTacticalSim.Service;
using JTacticalSim.Utility;
using JTacticalSim.DataContext;
using JTacticalSim.DataContext.Repository;
using ctxUtil = JTacticalSim.DataContext.Utility;
using JTacticalSim.Component.GameBoard;
using JTacticalSim.World;

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

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

				return _instance;
			}
		}

		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

		private UnitService()
		{}


#region Service Methods

		[OperationBehavior]
		public IServiceResult<IUnit> CreateUnit(string name,
												ICoordinate coordinate,
												ICountry country,
												UnitInfo unitInfo,
												ISubNodeLocation subNodeLocation)
		{
			var result = new ServiceResult<IUnit>();

			result.Status = ResultStatus.SUCCESS;

			try
			{
				var unit = new Unit(name, coordinate, unitInfo) { Country = country, SubNodeLocation = subNodeLocation };
				result.SuccessfulObjects.Add(unit);
				result.Result = unit;
				result.Messages.Add("Unit Created");
			}
			catch (Exception ex)
			{
				result.ex = ex;
				result.Status = ResultStatus.EXCEPTION;
				result.Messages.Add("Unit not created");
			}


			return result;
		}

		[OperationBehavior]
		public IServiceResult<IUnit> SaveUnits(List<IUnit> units)
		{
			return ComponentRepository.SaveUnits(units);
		}

		[OperationBehavior]
		public IServiceResult<IUnit> RemoveUnits(List<IUnit> units)
		{
			return ComponentRepository.RemoveUnits(units);
		}

		[OperationBehavior]
		public IServiceResult<IUnit> UpdateUnits(List<IUnit> units)
		{
			return ComponentRepository.UpdateUnits(units);
		}

		[OperationBehavior]
		public void UpdateUnitLocation(IUnit unit, INode node, INode lastNode)
		{
			if (!unit.ExistsInContext()) return;

			// Set node coordinate location
			unit.Location = node.Location;

			// Set SubNodeLocation
			// TODO: we might need to force a setting based on hybrid demographics and multiple stacks. Not sure yet.
			var direction = (lastNode != null)
							? (Direction)JTSServices.NodeService.GetNodeDirectionFromNeighborSourceNode(lastNode, node)
							: Direction.NONE;

			unit.SubNodeLocation = (direction == Direction.NONE)
									? new SubNodeLocation(5)
									: new SubNodeLocation(Orienting.ConvertDirectionToSubNodeLocation(direction));

			UpdateUnits(new List<IUnit> { unit });
		}

		[OperationBehavior]
		public IEnumerable<IUnit> GetAllUnits(IEnumerable<IFaction> factions)
		{
			var q = ComponentRepository.GetUnits();
			var comps = q.Select(u => u.ToComponent());
			return comps
				.Where(u => factions.Contains(u.Country.Faction))
				.Select(u => u);
		}

		[OperationBehavior]
		public IEnumerable<IUnit> GetAllUnits(ICountry country)
		{
			var q = ComponentRepository.GetUnits();
			var comps = q.Select(u => u.ToComponent());
			return comps
				.Where(u => u.Country.Equals(country));
		}

		[OperationBehavior]
		public List<IUnit> GetUnitsAt(ICoordinate coordinate, IEnumerable<IFaction> factions)
		{
			var comps = ComponentRepository.GetUnits().Where(u => u.Location != null).Select(u => u.ToComponent());
			return comps
					.Where(u => u.LocationEquals(coordinate))
					.Where(u => factions.Any(f => f.Equals(u.Faction)))
					.Select(u => u).ToList();
		}

		[OperationBehavior]
		public List<IUnit> GetUnitsAt(ICoordinate coordinate, IEnumerable<ICountry> countries)
		{
			var comps = ComponentRepository.GetUnits().Where(u => u.Location != null).Select(u => u.ToComponent());
			return comps
					.Where(u => u.Location.Equals(coordinate))
					.Where(u => countries.Any(c => c.Equals(u.Country)))
					.Select(u => u).ToList();
		}

		[OperationBehavior]
		public List<IUnit> GetAllUnitsAt(ICoordinate coordinate)
		{
			var factions = JTSServices.GameService.GetAllFactions();
			return GetUnitsAt(coordinate, factions);
		}

		[OperationBehavior]
		public List<IUnit> GetUnitsByUnitAssignment(int unitID)
		{
			var ids = DataRepository.GetUnitAssignments().Where(ua => ua.AssignedToUnit == unitID).Select(ua => ua.Unit);
			var retVal = ComponentRepository.GetUnits().Where(u => ids.Contains(u.ID)).Select(u => u.ToComponent());
			return retVal.ToList();
		}

		[OperationBehavior]
		public List<IUnit> GetUnitsByUnitAssignmentRecursive(int unitID)
		{
			var retVal = new List<IUnit>();
			var nextLevel = GetUnitsByUnitAssignment(unitID);
			retVal.AddRange(nextLevel);

			while (nextLevel.Any())
			{
				var thisLevel = new List<IUnit>();
				// Get all units by assignment for current level
				nextLevel.ForEach(u => thisLevel.AddRange(GetUnitsByUnitAssignment(u.ID)));

				// Add this level to the total assigned units
				retVal.AddRange(thisLevel);

				nextLevel = thisLevel;
			}

			return retVal;
		}

		[OperationBehavior]
		public List<IUnit> GetUnitsByTransport(int transportID)
		{
			var ids = DataRepository.GetUnitTransports().Where(ut => ut.TransportUnit == transportID).Select(ua => ua.Unit);
			var retVal = ComponentRepository.GetUnits().Where(u => ids.Contains(u.ID)).Select(u => u.ToComponent());
			return retVal.ToList();
		}

		[OperationBehavior]
		public IUnit GetUnitAssignedToUnit(int unitID)
		{
			var id = DataRepository.GetUnitAssignments()
				.Where(ua => ua.Unit == unitID)
				.Select(ua => ua.AssignedToUnit)
				.SingleOrDefault();

			var unit = ComponentRepository.GetUnits().SingleOrDefault(u => u.ID == id);

			return unit.ToComponent();
		}

		[OperationBehavior]
		public IUnit GetUnitByID(int id)
		{
			var dto = ComponentRepository.GetUnits().SingleOrDefault(u => u.ID == id);

			if (dto == null)
				throw new ComponentNotFoundException("No unit found with id {0}".F(id));

			return dto.ToComponent();
		}

		[OperationBehavior]
		public IServiceResult<IEnumerable<IUnitClass>> GetAllowableUnitClassesForUnit(IUnit unit)
		{
			var r = new ServiceResult<IEnumerable<IUnitClass>>();

			var ids = JTSServices.DataService.LookupAllowableUnitClassesByUnitBaseType(unit.UnitInfo.UnitType.BaseType.ID);
			r.Result = JTSServices.UnitService.GetUnitClassesByIDs(ids).Result;

			return r;
		}


		[OperationBehavior]
		public IUnitClass GetUnitClassByID(int id)
		{
			var dto = ComponentRepository.GetUnitClasses().SingleOrDefault(uc => uc.ID == id);

			if (dto == null)
				throw new ComponentNotFoundException("No unit class found with id {0}".F(id));

			return dto.ToComponent();
		}

		[OperationBehavior]
		public IUnitClass GetUnitClassByName(string name)
		{
			var dto = ComponentRepository.GetUnitClasses().SingleOrDefault(uc => uc.Name.ToLowerInvariant() == name.ToLowerInvariant());

			if (dto == null)
				throw new ComponentNotFoundException("No unit class found with name {0}".F(name));

			return dto.ToComponent();
		}

		[OperationBehavior]
		public IServiceResult<IEnumerable<IUnitClass>> GetUnitClassesByIDs(IEnumerable<int> ids)
		{
			var r = new ServiceResult<IEnumerable<IUnitClass>>();
			r.Result = ComponentRepository.GetUnitClasses().Where(uc => ids.Contains(uc.ID)).Select(uc => uc.ToComponent());
			return r;
		}

		[OperationBehavior]
		public IEnumerable<IUnitClass> GetUnitClasses()
		{
			return ComponentRepository.GetUnitClasses().Select(uc => uc.ToComponent());
		}

		[OperationBehavior]
		public IServiceResult<IUnitClass> SaveUnitClasses(List<IUnitClass> unitClasses)
		{
			return ComponentRepository.SaveUnitClasses(unitClasses);
		}

		[OperationBehavior]
		public IServiceResult<IUnitClass> RemoveUnitClasses(List<IUnitClass> unitClasses)
		{
			return ComponentRepository.RemoveUnitClasses(unitClasses);
		}

		[OperationBehavior]
		public IServiceResult<IUnitClass> UpdateUnitClasses(List<IUnitClass> unitClasses)
		{
			return ComponentRepository.UpdateUnitClasses(unitClasses);
		}


		[OperationBehavior]
		public IEnumerable<IUnitBaseType> GetUnitBaseTypes()
		{
			return ComponentRepository.GetUnitBaseTypes().Select(ubt => ubt.ToComponent());
		}

		[OperationBehavior]
		public IServiceResult<IUnitBaseType> SaveUnitBaseTypes(List<IUnitBaseType> unitBaseTypes)
		{
			return ComponentRepository.SaveUnitBaseTypes(unitBaseTypes);
		}

		[OperationBehavior]
		public IServiceResult<IUnitBaseType> RemoveUnitBaseTypes(List<IUnitBaseType> unitBaseTypes)
		{
			return ComponentRepository.RemoveUnitBaseTypes(unitBaseTypes);
		}

		[OperationBehavior]
		public IServiceResult<IUnitBaseType> UpdateUnitBaseTypes(List<IUnitBaseType> unitBaseTypes)
		{
			return ComponentRepository.UpdateUnitBaseTypes(unitBaseTypes);
		}



		[OperationBehavior]
		public IUnitGroupType GetUnitGroupTypeByID(int id)
		{
			var dto = ComponentRepository.GetUnitGroupTypes().SingleOrDefault(ugt => ugt.ID == id);
			if (dto == null)
				throw new ComponentNotFoundException("No unit group type found with id {0}".F(id));

			return dto.ToComponent();
		}

		[OperationBehavior]
		public IUnitGroupType GetUnitGroupTypeByName(string name)
		{
			var dto = ComponentRepository.GetUnitGroupTypes().SingleOrDefault(o => o.Name.ToLowerInvariant() == name.ToLowerInvariant());

			if (dto == null)
				throw new ComponentNotFoundException("No unit group type found with name {0}".F(name));

			return dto.ToComponent();
		}

		[OperationBehavior]
		public IServiceResult<IEnumerable<IUnitGroupType>> GetUnitGroupTypesByIDs(IEnumerable<int> ids)
		{
			var r = new ServiceResult<IEnumerable<IUnitGroupType>>();
			r.Result = ComponentRepository.GetUnitGroupTypes().Where(ugt => ids.Contains(ugt.ID)).Select(ugt => ugt.ToComponent());
			return r;
		}

		[OperationBehavior]
		public IEnumerable<IUnitGroupType> GetUnitGroupTypes()
		{
			return ComponentRepository.GetUnitGroupTypes().Select(ugt => ugt.ToComponent());
		}

		[OperationBehavior]
		public IServiceResult<IUnitGroupType> SaveUnitGroupTypes(List<IUnitGroupType> unitGroupTypes)
		{
			return ComponentRepository.SaveUnitGroupTypes(unitGroupTypes);
		}

		[OperationBehavior]
		public IServiceResult<IUnitGroupType> RemoveUnitGroupTypes(List<IUnitGroupType> unitGroupTypes)
		{
			return ComponentRepository.RemoveUnitGroupTypes(unitGroupTypes);
		}

		[OperationBehavior]
		public IServiceResult<IUnitGroupType> UpdateUnitGroupTypes(List<IUnitGroupType> unitGroupTypes)
		{
			return ComponentRepository.UpdateUnitGroupTypes(unitGroupTypes);
		}

		[OperationBehavior]
		public IUnitGroupType GetNextHighestUnitGroupType(IUnitGroupType ugt)
		{
			var allUnitLevels = ComponentRepository.GetUnitGroupTypes().Select(gt => gt.ToComponent()).ToList();
			allUnitLevels.Sort();
			return allUnitLevels.FirstOrDefault(ul => ul.Level > ugt.Level);
		}


		[OperationBehavior]
		public IEnumerable<IUnitGeogType> GetUnitGeogTypes()
		{
			return ComponentRepository.GetUnitGeogTypes().Select(ugt => ugt.ToComponent());
		}

		[OperationBehavior]
		public IServiceResult<IUnitGeogType> SaveUnitGeogTypes(List<IUnitGeogType> unitGeogTypes)
		{
			return ComponentRepository.SaveUnitGeogTypes(unitGeogTypes);
		}

		[OperationBehavior]
		public IServiceResult<IUnitGeogType> RemoveUnitGeogTypes(List<IUnitGeogType> unitGeogTypes)
		{
			return ComponentRepository.RemoveUnitGeogTypes(unitGeogTypes);
		}

		[OperationBehavior]
		public IServiceResult<IUnitGeogType> UpdateUnitGeogTypes(List<IUnitGeogType> unitGeogTypes)
		{
			return ComponentRepository.UpdateUnitGeogTypes(unitGeogTypes);
		}


		[OperationBehavior]
		public IEnumerable<IUnitTask> GetUnitTasks()
		{
			return ComponentRepository.GetUnitTasks().Select(ut => ut.ToComponent());
		}

		[OperationBehavior]
		public IServiceResult<IUnitTask> SaveUnitTasks(List<IUnitTask> unitTasks)
		{
			return ComponentRepository.SaveUnitTasks(unitTasks);
		}

		[OperationBehavior]
		public IServiceResult<IUnitTask> RemoveUnitTasks(List<IUnitTask> unitTasks)
		{
			return ComponentRepository.RemoveUnitTasks(unitTasks);
		}

		[OperationBehavior]
		public IServiceResult<IUnitTask> UpdateUnitTasks(List<IUnitTask> unitTasks)
		{
			return ComponentRepository.UpdateUnitTasks(unitTasks);
		}

		[OperationBehavior]
		public IServiceResult<List<IUnitTask>> GetUnitTasksForMissionObjective(IMissionObjective objective)
		{
			var r = new ServiceResult<List<IUnitTask>> { Status = ResultStatus.SUCCESS };

			try
			{
				var unitTaskIDs = DataRepository.GetMissionObjectiveUnitTasks()
										.Where(mout => mout.MissionObjective == objective.ID).ToList()
										.Select(mout => Convert.ToInt32(mout.UnitTask));

				r.Result = ComponentRepository.GetUnitTasks().Where(ut => unitTaskIDs.Contains(ut.ID)).Select(ut => ut.ToComponent()).ToList();

				return r;

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


		[OperationBehavior]
		public IUnitType GetUnitTypeByID(int id)
		{
			var dto = ComponentRepository.GetUnitTypes().SingleOrDefault(ut => ut.ID == id);

			if (dto == null)
				throw new ComponentNotFoundException("No unit type found with id {0}".F(id));

			return dto.ToComponent();
		}

		[OperationBehavior]
		public IUnitType GetUnitTypeByName(string name)
		{
			var dto = ComponentRepository.GetUnitTypes().SingleOrDefault(o => o.Name.ToLowerInvariant() == name.ToLowerInvariant());

			if (dto == null)
				throw new ComponentNotFoundException("No unit type found with name {0}".F(name));

			return dto.ToComponent();
		}

		[OperationBehavior]
		public IServiceResult<IEnumerable<IUnitType>> GetUnitTypesByIDs(IEnumerable<int> ids)
		{
			var r = new ServiceResult<IEnumerable<IUnitType>>();
			r.Result = ComponentRepository.GetUnitTypes().Where(ut => ids.Contains(ut.ID)).Select(ut => ut.ToComponent());
			return r;
		}

		[OperationBehavior]
		public IServiceResult<IUnitType> SaveUnitTypes(List<IUnitType> unitTypes)
		{
			return ComponentRepository.SaveUnitTypes(unitTypes);
		}

		[OperationBehavior]
		public IServiceResult<IUnitType> RemoveUnitTypes(List<IUnitType> unitTypes)
		{
			return ComponentRepository.RemoveUnitTypes(unitTypes);
		}

		[OperationBehavior]
		public IServiceResult<IUnitType> UpdateUnitTypes(List<IUnitType> unitTypes)
		{
			return ComponentRepository.UpdateUnitTypes(unitTypes.ToList());
		}

		[OperationBehavior]
		public IEnumerable<IUnitType> GetUnitTypesAllowableForTile(ITile tile)
		{
			var retVal = new List<IUnitType>();

			var unitTypes = ComponentRepository.GetUnitTypes().Select(ut => ut.ToComponent());

			Action<IUnitType> componentAction = ut =>
			{
				if (JTSServices.RulesService.TileIsAllowableForUnitType(ut, tile).Result) retVal.Add(ut);
			};

			if (Convert.ToBoolean(ConfigurationManager.AppSettings["run_multithreaded"]))
			{
				Parallel.ForEach(unitTypes, componentAction);
			}
			else
			{
				foreach (var ut in unitTypes)
				{
					componentAction(ut);
				};
			}

			return retVal;
		}

#endregion

	}
}