// AntennaRange © 2014 toadicus
//
// AntennaRange provides incentive and requirements for the use of the various antenna parts.
// Nominally, the breakdown is as follows:
//
//     Communotron 16 - Suitable up to Kerbalsynchronous Orbit
//     Comms DTS-M1 - Suitable throughout the Kerbin subsystem
//     Communotron 88-88 - Suitable throughout the Kerbol system.
//
// This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. To view a
// copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/
//
// This software uses the ModuleManager library © 2013 ialdabaoth, used under a Creative Commons Attribution-ShareAlike
// 3.0 Uported License.
//
// This software uses code from the MuMechLib library, © 2013 r4m0n, used under the GNU GPL version 3.

using System;
using System.Collections.Generic;
using System.Linq;

namespace AntennaRange
{
	public class AntennaRelay : IAntennaRelay
	{
		// We don't have a Bard, so we'll hide Kerbin here.
		protected CelestialBody Kerbin;

		protected System.Diagnostics.Stopwatch searchTimer;
		protected long millisecondsBetweenSearches;

		/// <summary>
		/// Gets the parent Vessel.
		/// </summary>
		/// <value>The parent Vessel.</value>
		public Vessel vessel
		{
			get;
			protected set;
		}

		/// <summary>
		/// Gets or sets the nearest relay.
		/// </summary>
		/// <value>The nearest relay</value>
		public IAntennaRelay nearestRelay
		{
			get;
			protected set;
		}

		/// <summary>
		/// Gets the transmit distance.
		/// </summary>
		/// <value>The transmit distance.</value>
		public double transmitDistance
		{
			get
			{
				this.nearestRelay = this.FindNearestRelay();

				// If there is no available relay nearby...
				if (nearestRelay == null)
				{
					// .. return the distance to Kerbin
					return this.DistanceTo(this.Kerbin);
				}
				else
				{
					/// ...otherwise, return the distance to the nearest available relay.
					return this.DistanceTo(nearestRelay);
				}
			}
		}

		/// <summary>
		/// The maximum distance at which this relay can operate.
		/// </summary>
		/// <value>The max transmit distance.</value>
		public virtual float maxTransmitDistance
		{
			get;
			set;
		}

		/// <summary>
		/// Gets a value indicating whether this <see cref="AntennaRange.ProtoDataTransmitter"/> has been checked during
		/// the current relay attempt.
		/// </summary>
		/// <value><c>true</c> if relay checked; otherwise, <c>false</c>.</value>
		public virtual bool relayChecked
		{
			get;
			protected set;
		}

		/// <summary>
		/// Determines whether this instance can transmit.
		/// </summary>
		/// <returns><c>true</c> if this instance can transmit; otherwise, <c>false</c>.</returns>
		public bool CanTransmit()
		{
			if (this.transmitDistance > this.maxTransmitDistance)
			{
				return false;
			}
			else
			{
				return true;
			}
		}

		/// <summary>
		/// Finds the nearest relay.
		/// </summary>
		/// <returns>The nearest relay or null, if no relays in range.</returns>
		public IAntennaRelay FindNearestRelay()
		{
			if (this.searchTimer.IsRunning && this.searchTimer.ElapsedMilliseconds < this.millisecondsBetweenSearches)
			{
				return this.nearestRelay;
			}

			if (this.searchTimer.IsRunning)
			{
				this.searchTimer.Stop();
				this.searchTimer.Reset();
			}

			this.searchTimer.Start();

			// Set this relay as checked, so that we don't check it again.
			this.relayChecked = true;

			// Get a list of vessels within transmission range.
			List<Vessel> nearbyVessels = FlightGlobals.Vessels
				.Where(v => (v.GetWorldPos3D() - vessel.GetWorldPos3D()).magnitude < this.maxTransmitDistance)
					.ToList();

			nearbyVessels.RemoveAll(v => v.vesselType == VesselType.Debris);

			Tools.PostDebugMessage(string.Format(
				"{0}: Non-debris vessels in range: {1}",
				this.GetType().Name,
				nearbyVessels.Count
				));

			// Remove this vessel.
			nearbyVessels.RemoveAll(v => v.id == vessel.id);

			Tools.PostDebugMessage(string.Format(
				"{0}: Vessels in range excluding self: {1}",
				this.GetType().Name,
				nearbyVessels.Count
				));

			// Get a flattened list of all IAntennaRelay modules and protomodules in transmission range.
			List<IAntennaRelay> nearbyRelays = nearbyVessels.SelectMany(v => v.GetAntennaRelays()).ToList();

			Tools.PostDebugMessage(string.Format(
				"{0}: Found {1} nearby relays.",
				this.GetType().Name,
				nearbyRelays.Count
				));

			// Remove all relays already checked this time.
			nearbyRelays.RemoveAll(r => r.relayChecked);

			Tools.PostDebugMessage(string.Format(
				"{0}: Found {1} nearby relays not already checked.",
				this.GetType().Name,
				nearbyRelays.Count
				));

			// Remove all relays that cannot transmit.
			// This call to r.CanTransmit() starts a depth-first recursive search for relays with a path back to Kerbin.
			nearbyRelays.RemoveAll(r => !r.CanTransmit());

			Tools.PostDebugMessage(string.Format(
				"{0}: Found {1} nearby relays not already checked that can transmit.",
				this.GetType().Name,
				nearbyRelays.Count
				));

			// Sort the available relays by distance.
			nearbyRelays.Sort(new RelayComparer(this.vessel));

			// Get the nearest available relay, or null if there are no available relays nearby.
			IAntennaRelay _nearestRelay = nearbyRelays.FirstOrDefault();

			// If we have a nearby relay...
			if (_nearestRelay != null)
			{
				// ...but that relay is farther than Kerbin...
				if (this.DistanceTo(_nearestRelay) > this.DistanceTo(Kerbin))
				{
					// ...just use Kerbin.
					_nearestRelay = null;
				}
			}

			// Now that we're done with our recursive CanTransmit checks, flag this relay as not checked so it can be
			// used next time.
			this.relayChecked = false;

			// Return the nearest available relay, or null if there are no available relays nearby.
			return _nearestRelay;
		}

		public override string ToString()
		{
			return string.Format(
				"Antenna relay on vessel {0}.",
				vessel
			);
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="AntennaRange.ProtoDataTransmitter"/> class.
		/// </summary>
		/// <param name="ms"><see cref="ProtoPartModuleSnapshot"/></param>
		public AntennaRelay(Vessel v)
		{
			this.vessel = v;

			this.searchTimer = new System.Diagnostics.Stopwatch();
			this.millisecondsBetweenSearches = 5000;

			// HACK: This might not be safe in all circumstances, but since AntennaRelays are not built until Start,
			// we hope it is safe enough.
			this.Kerbin = FlightGlobals.Bodies.FirstOrDefault(b => b.name == "Kerbin");
		}

		/*
		 * Class implementing IComparer<IAntennaRelay> for use in sorting relays by distance.
		 * */
		internal class RelayComparer : IComparer<IAntennaRelay>
		{
			/// <summary>
			/// The reference Vessel (usually the active vessel).
			/// </summary>
			protected Vessel referenceVessel;

			// We don't want no stinking public parameterless constructors.
			private RelayComparer() {}

			/// <summary>
			/// Initializes a new instance of the <see cref="AntennaRange.AntennaRelay+RelayComparer"/> class for use
			/// in sorting relays by distance.
			/// </summary>
			/// <param name="reference">The reference Vessel</param>
			public RelayComparer(Vessel reference)
			{
				this.referenceVessel = reference;
			}

			/// <summary>
			/// Compare the <see cref="IAntennaRelay"/>s "one" and "two".
			/// </summary>
			/// <param name="one">The first IAntennaRelay in the comparison</param>
			/// <param name="two">The second IAntennaRelay in the comparison</param>
			public int Compare(IAntennaRelay one, IAntennaRelay two)
			{
				double distanceOne;
				double distanceTwo;

				distanceOne = one.vessel.DistanceTo(referenceVessel);
				distanceTwo = two.vessel.DistanceTo(referenceVessel);

				return distanceOne.CompareTo(distanceTwo);
			}
		}
	}
}