using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Serilog;
using TINK.Model.Bikes;
using TINK.Model.Connector.Updater;
using TINK.Model.Services.CopriApi;
using TINK.Repository;
using TINK.Repository.Response;

namespace TINK.Model.Connector
{
	/// <summary> Provides query functionality for a logged in user. </summary>
	public class CachedQueryLoggedIn : BaseLoggedIn, IQuery
	{
		/// <summary> Cached copri server (connection to copri backed up by cache). </summary>
		private ICachedCopriServer Server { get; }

		/// <summary>Constructs a copri query object.</summary>
		/// <param name="copriServer">Server which implements communication.</param>
		public CachedQueryLoggedIn(ICopriServerBase copriServer,
			string sessionCookie,
			string mail,
			Func<DateTime> dateTimeProvider) : base(copriServer, sessionCookie, mail, dateTimeProvider)
		{
			Server = copriServer as ICachedCopriServer;
			if (Server == null)
			{
				throw new ArgumentException($"Copri server is not of expected type. Type detected is {copriServer.GetType()}.");
			}
		}

		/// <summary> Gets all stations including positions.</summary>
		public async Task<Result<StationsAndBikesContainer>> GetBikesAndStationsAsync()
		{
			BikeCollection GetBikeCollection(IEnumerable<BikeInfoReservedOrBooked> bikeInfoEnumerable, Bikes.BikeInfoNS.BC.DataSource dataSource) =>
				BikeCollectionFactory.GetBikesAll(
											null, // Bikes available are no more of interest because count of available bikes at each given station is was added to station object. 
											bikeInfoEnumerable ?? new Dictionary<string, BikeInfoReservedOrBooked>().Values,
											Mail,
											DateTimeProvider,
											dataSource);

			var stationsResponse = await Server.GetStations();

			if (stationsResponse.Source == typeof(CopriCallsMonkeyStore)
				|| stationsResponse.Exception != null)
			{
				// Stations were read from cache ==> get bikes available and occupied from cache as well to avoid inconsistencies
				return new Result<StationsAndBikesContainer>(
					stationsResponse.Source,
					new StationsAndBikesContainer(
						stationsResponse.Response.GetStationsAllMutable(),
						GetBikeCollection(stationsResponse.Response.bikes_occupied?.Values, Bikes.BikeInfoNS.BC.DataSource.Cache)),
					stationsResponse.GeneralData,
					stationsResponse.Exception);
			}


			// Both types bikes could read from copri =>  update cache
			Server.AddToCache(stationsResponse);

			return new Result<StationsAndBikesContainer>(
				stationsResponse.Source,
				new StationsAndBikesContainer(
					stationsResponse.Response.GetStationsAllMutable(),
					GetBikeCollection(stationsResponse.Response.bikes_occupied?.Values, Bikes.BikeInfoNS.BC.DataSource.Copri)),
				stationsResponse.GeneralData,
				stationsResponse?.Exception);
		}

		/// <summary> Gets bikes occupied. </summary>
		/// <returns>Collection of bikes.</returns>
		public async Task<Result<BikeCollection>> GetBikesOccupiedAsync()
		{
			var bikesAvailableResponse = await Server.GetBikesAvailable(false);
			if (bikesAvailableResponse.Source == typeof(CopriCallsMonkeyStore)
				|| bikesAvailableResponse.Exception != null)
			{
				// Bikes available were read from cache ==> get bikes occupied from cache as well to avoid inconsistencies.
				Log.ForContext<CachedQueryLoggedIn>().Debug("Bikes available read from cache. Reading bikes occupied from cache as well.");
				return new Result<BikeCollection>(
					bikesAvailableResponse.Source,
					BikeCollectionFactory.GetBikesAll(
						bikesAvailableResponse.Response?.bikes?.Values?.Where(bike => bike.GetState() == State.InUseStateEnum.FeedbackPending),
						(await Server.GetBikesOccupied(true))?.Response?.bikes_occupied?.Values,
						Mail,
						DateTimeProvider,
						Bikes.BikeInfoNS.BC.DataSource.Cache),
					bikesAvailableResponse.GeneralData,
					bikesAvailableResponse.Exception);
			}

			var bikesOccupiedResponse = await Server.GetBikesOccupied(false);
			if (bikesOccupiedResponse.Source == typeof(CopriCallsMonkeyStore)
				|| bikesOccupiedResponse.Exception != null)
			{
				// Bikes occupied were read from cache ==> get bikes available from cache as well to avoid inconsistencies
				Log.ForContext<CachedQueryLoggedIn>().Debug("Bikes occupied read from cache. Reread bikes available from cache as well.");
				return new Result<BikeCollection>(
					bikesOccupiedResponse.Source,
					BikeCollectionFactory.GetBikesAll(
						(await Server.GetBikesAvailable(true)).Response?.bikes?.Values?.Where(bike => bike.GetState() == State.InUseStateEnum.FeedbackPending),
						bikesOccupiedResponse.Response?.bikes_occupied?.Values,
						Mail,
						DateTimeProvider,
					Bikes.BikeInfoNS.BC.DataSource.Cache),
					bikesOccupiedResponse.GeneralData,
					bikesOccupiedResponse.Exception);
			}

			// Both types bikes could read from copri =>  update bikes occupied cache.
			// // Do not add bikes available to cache because this might lead to conflicts calls GetBikesAsync() and bikes with FeedbackPending state are of no use offline. 
			Server.AddToCache(bikesOccupiedResponse);

			return new Result<BikeCollection>(
				bikesOccupiedResponse.Source,
			   BikeCollectionFactory.GetBikesAll(
					bikesAvailableResponse?.Response.bikes?.Values?.Select(bike => bike)?.Where(bike => bike.GetState() == State.InUseStateEnum.FeedbackPending),
					bikesOccupiedResponse?.Response?.bikes_occupied?.Values,
					Mail,
					DateTimeProvider,
					Bikes.BikeInfoNS.BC.DataSource.Copri),
				bikesOccupiedResponse.GeneralData,
				bikesOccupiedResponse.Exception);
		}

		/// <summary> Gets bikes available and bikes occupied. </summary>
		/// <param name="operatorUri">Uri of the operator host to get bikes from or null if bikes have to be gotten form primary host.</param>
		/// <param name="stationId"> Id of station which is used for filtering bikes. Null if no filtering should be applied.</param>
		/// <param name="bikeId"> Id of bike which is used for filtering bikes. Null if no filtering should be applied.</param>
		/// <returns>Collection of bikes.</returns>
		public async Task<Result<BikeCollection>> GetBikesAsync(Uri operatorUri = null, string stationId = null, string bikeId = null)
		{
			var bikesAvailableResponse = await Server.GetBikesAvailable(operatorUri: operatorUri, stationId: stationId, bikeId: bikeId);

			if (bikesAvailableResponse.Source == typeof(CopriCallsMonkeyStore)
				|| bikesAvailableResponse.Exception != null)
			{
				// Bikes were read from cache.
				Log.ForContext<CachedQueryLoggedIn>().Debug("Bikes available and bikes occupied from cache invoking one single call.");
				return new Result<BikeCollection>(
					bikesAvailableResponse.Source,
					BikeCollectionFactory.GetBikesAll(
						bikesAvailableResponse.Response?.bikes?.Values,
						operatorUri?.AbsoluteUri == null ?
							(await Server.GetBikesOccupied(true)).Response?.bikes_occupied?.Values // Get bikes occupied from cache as well to avoid inconsistencies.
							: bikesAvailableResponse.Response?.bikes_occupied?.Values,
						Mail,
						DateTimeProvider,
						Bikes.BikeInfoNS.BC.DataSource.Cache),
					bikesAvailableResponse.GeneralData,
					bikesAvailableResponse.Exception);
			}

			if (operatorUri?.AbsoluteUri != null)
			{
				// Both types bikes could read from copri successfully =>  update cache
				Server.AddToCache(bikesAvailableResponse, operatorUri, stationId, bikeId);

				Log.ForContext<CachedQueryLoggedIn>().Debug("Bikes available and occupied read successfully from server invoking one single request.");
				return new Result<BikeCollection>(
					bikesAvailableResponse.Source,
					BikeCollectionFactory.GetBikesAll(
						bikesAvailableResponse.Response?.bikes?.Values,
						bikesAvailableResponse.Response?.bikes_occupied?.Values,
						Mail,
						DateTimeProvider,
						Bikes.BikeInfoNS.BC.DataSource.Copri),
					bikesAvailableResponse.GeneralData,
					bikesAvailableResponse.Exception != null ? new AggregateException(new[] { bikesAvailableResponse.Exception }) : null);
			}

			/// Legacy implementation: GetBikesOccupied are not returned in <see cref="ICachedCopriServer.GetBikesAvailable"/> call.
			/// A separate call <see cref="ICachedCopriServer.GetBikesOccupied"/> is required to retrieve all bikes.
			var bikesOccupiedResponse = await Server.GetBikesOccupied(); /* Only query bikes occupied if operator uri is unknown. */
			if (bikesOccupiedResponse.Source == typeof(CopriCallsMonkeyStore)
				|| bikesOccupiedResponse.Exception != null)
			{
				// Bikes occupied were read from cache ==> get bikes available from cache as well to avoid inconsistencies
				Log.ForContext<CachedQueryLoggedIn>().Debug("Bikes occupied read from cache. Reread bikes available from cache as well.");
				return new Result<BikeCollection>(
					bikesOccupiedResponse.Source,
					BikeCollectionFactory.GetBikesAll(
						(await Server.GetBikesAvailable(true, operatorUri, stationId, bikeId)).Response?.bikes?.Values,
						bikesOccupiedResponse.Response?.bikes_occupied?.Values,
						Mail,
						DateTimeProvider,
						Bikes.BikeInfoNS.BC.DataSource.Cache),
					bikesOccupiedResponse.GeneralData,
					bikesOccupiedResponse.Exception);
			}

			// Both types bikes could read from copri =>  update cache
			Server.AddToCache(bikesAvailableResponse, operatorUri, stationId, bikeId);
			Server.AddToCache(bikesOccupiedResponse);

			Log.ForContext<CachedQueryLoggedIn>().Debug("Bikes available and occupied read successfully from server.");
			return new Result<BikeCollection>(
				bikesAvailableResponse.Source,
				BikeCollectionFactory.GetBikesAll(
					bikesAvailableResponse.Response?.bikes?.Values,
					bikesOccupiedResponse.Response?.bikes_occupied?.Values,
					Mail,
					DateTimeProvider,
					Bikes.BikeInfoNS.BC.DataSource.Copri),
				bikesAvailableResponse.GeneralData,
				bikesAvailableResponse.Exception != null || bikesOccupiedResponse.Exception != null ? new AggregateException(new[] { bikesAvailableResponse.Exception, bikesOccupiedResponse.Exception }) : null);
		}
	}
}