using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Serilog;
using TINK.Model.Bikes.BikeInfoNS.BluetoothLock;
using TINK.Model.Connector;
using TINK.Model.Connector.Updater;
using TINK.Model.Device;
using TINK.Repository;
using TINK.Repository.Request;
using TINK.Repository.Response;
using TINK.Repository.Response.Stations;

namespace TINK.Model.Services.CopriApi
{
	/// <summary> Object which manages calls to copri in a thread safe way including cache functionality. </summary>
	public class CopriProviderHttps : ICachedCopriServer
	{
		/// <summary> Object which manages stored copri answers. </summary>
		private ICopriCache CacheServer { get; }

		/// <summary> Communicates with copri server. </summary>
		private ICopriServer HttpsServer { get; }

		/// <summary> True if connector has access to copri server, false if cached values are used. </summary>
		public bool IsConnected => HttpsServer.IsConnected;

		/// <summary> Gets the session cookie if user is logged in, an empty string otherwise. </summary>
		public string SessionCookie => HttpsServer.SessionCookie;

		/// <summary> Gets the merchant id.</summary>
		public string MerchantId => HttpsServer.MerchantId;

		/// <summary> Constructs copri provider object to connect to https using a cache object. </summary>
		/// <param name="copriHost"></param>
		/// <param name="appContextInfo">Provides app related info (app name and version, merchant id) to pass to COPRI.</param>
		/// <param name="uiIsoLangugageName">Two letter ISO language name.</param>
		/// <param name="smartDevice">Holds info about smart device.</param>
		/// <param name="sessionCookie">Cookie of user if a user is logged in, false otherwise.</param>
		/// <param name="expiresAfter">Timespan which holds value after which cache expires.</param>
		public CopriProviderHttps(
			Uri copriHost,
			string merchantId,
			AppContextInfo appContextInfo,
			string uiIsoLangugageName,
			ISmartDevice smartDevice = null,
			string sessionCookie = null,
			TimeSpan? expiresAfter = null,
			ICopriCache cacheServer = null,
			ICopriServer httpsServer = null)
		{
			CacheServer = cacheServer ?? new CopriCallsMonkeyStore(merchantId, uiIsoLangugageName, sessionCookie, smartDevice, expiresAfter);
			HttpsServer = httpsServer ?? new CopriCallsHttps(copriHost, appContextInfo, uiIsoLangugageName, sessionCookie, smartDevice);
		}

		/// <summary>Gets bikes available.</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>
		/// <returns>Response holding list of bikes.</returns>
		public async Task<Result<BikesAvailableResponse>> GetBikesAvailable(
			bool fromCache = false,
			Uri operatorUri = null)
		{
			Log.ForContext<CopriProviderHttps>().Debug($"Request to get bikes available{(fromCache ? " from cache" : "")}...");
			if (!CacheServer.IsBikesAvailableExpired
				|| fromCache)
			{
				// No need to query because previous answer is not yet outdated.
				Log.ForContext<CopriProviderHttps>().Debug($"Returning bikes available from cache.");
				var bikesAvailableResponse = await CacheServer.GetBikesAvailableAsync(operatorUri);
				return new Result<BikesAvailableResponse>(typeof(CopriCallsMonkeyStore), bikesAvailableResponse, bikesAvailableResponse.GetGeneralData());
			}

			try
			{
				Log.ForContext<CopriProviderHttps>().Debug($"Querying bikes available from copri.");
				var bikesAvailableResponse = await HttpsServer.GetBikesAvailableAsync(operatorUri);
				return new Result<BikesAvailableResponse>(
					typeof(CopriCallsHttps),
					bikesAvailableResponse.GetIsResponseOk(MultilingualResources.AppResources.ErrorBikesAvailableResponseNotOk),
					bikesAvailableResponse.GetGeneralData());
			}
			catch (Exception exception)
			{
				// Return response from cache.
				Log.ForContext<CopriProviderHttps>().Debug("An error occurred querying bikes available. {Exception}.", exception);
				var bikesAvailableResponse = await CacheServer.GetBikesAvailableAsync(operatorUri);
				return new Result<BikesAvailableResponse>(typeof(CopriCallsMonkeyStore), bikesAvailableResponse, bikesAvailableResponse.GetGeneralData(), exception);
			}
		}

		/// <summary> Gets a list of bikes reserved/ booked by active user. </summary>
		/// <param name="sessionCookie">Cookie to authenticate user.</param>
		/// <returns>Response holding list of bikes.</returns>
		public async Task<Result<BikesReservedOccupiedResponse>> GetBikesOccupied(bool fromCache = false)
		{
			Log.ForContext<CopriProviderHttps>().Debug($"Request to get bikes occupied{(fromCache ? " from cache" : "")}...");
			if (!CacheServer.IsBikesOccupiedExpired
			|| fromCache)
			{
				// No need to query because previous answer is not yet outdated.
				var bikesOccupiedResponse = await CacheServer.GetBikesOccupiedAsync();
				Log.ForContext<CopriProviderHttps>().Debug($"Returning bikes occupied from cache.");
				return new Result<BikesReservedOccupiedResponse>(typeof(CopriCallsMonkeyStore), bikesOccupiedResponse, bikesOccupiedResponse.GetGeneralData());
			}

			try
			{
				Log.ForContext<CopriProviderHttps>().Debug($"Querying bikes occupied from copri.");
				var bikesOccupiedResponse = await HttpsServer.GetBikesOccupiedAsync();
				return new Result<BikesReservedOccupiedResponse>(
					typeof(CopriCallsHttps),
					bikesOccupiedResponse.GetIsResponseOk("Abfrage der reservierten/ gebuchten Räder fehlgeschlagen."),
					bikesOccupiedResponse.GetGeneralData());

			}
			catch (Exception exception)
			{
				// Return response from cache.
				Log.ForContext<CopriProviderHttps>().Debug("An error occurred querying bikes occupied. {Exception}.", exception);
				var bikesOccupiedResponse = await CacheServer.GetBikesOccupiedAsync();
				return new Result<BikesReservedOccupiedResponse>(typeof(CopriCallsMonkeyStore), bikesOccupiedResponse, bikesOccupiedResponse.GetGeneralData(), exception);
			}
		}

		/// <summary> Get list of stations. </summary>
		/// <returns>List of files.</returns>
		public async Task<Result<StationsAvailableResponse>> GetStations(bool fromCache = false)
		{
			Log.ForContext<CopriProviderHttps>().Debug($"Request to get stations{(fromCache ? " from cache" : "")}...");
			if (!CacheServer.IsStationsExpired
				|| fromCache)
			{
				// No need to query because previous answer is not yet outdated.
				Log.ForContext<CopriProviderHttps>().Debug($"Returning stations from cache.");
				var stationsResponse = await CacheServer.GetStationsAsync();
				return new Result<StationsAvailableResponse>(typeof(CopriCallsMonkeyStore), stationsResponse, stationsResponse.GetGeneralData());
			}

			try
			{
				Log.ForContext<CopriProviderHttps>().Debug($"Querying stations from copri.");

				var stations = await HttpsServer.GetStationsAsync();

				return new Result<StationsAvailableResponse>(
					typeof(CopriCallsHttps),
					stations.GetIsResponseOk("Abfrage der Stationen fehlsgeschlagen."),
					stations.GetGeneralData());
			}
			catch (Exception exception)
			{
				// Return response from cache.
				Log.ForContext<CopriProviderHttps>().Debug("An error occurred querying stations. {Exception}.", exception);
				var stationsResponse = await CacheServer.GetStationsAsync();
				return new Result<StationsAvailableResponse>(typeof(CopriCallsMonkeyStore), stationsResponse, stationsResponse.GetGeneralData(), exception);
			}
		}

		/// <summary>Adds https--response to cache if response is ok. </summary>
		/// <param name="response">Response to add to cache.</param>
		/// <returns></returns>
		public void AddToCache(Result<StationsAvailableResponse> result)
		{
			Log.ForContext<CopriProviderHttps>().Debug($"Request to add stations all response to cache...");
			if (result.Source == typeof(CopriCallsMonkeyStore)
				|| result.Exception != null)
			{
				// Do not add responses form cache or invalid responses to cache.
				return;
			}

			Log.ForContext<CopriProviderHttps>().Debug($"Add bikes available response to cache.");
			CacheServer.AddToCache(result.Response);
		}

		/// <summary>Adds https--response to cache if response is ok. </summary>
		/// <param name="result">Response to add to cache.</param>
		/// <param name="operatorUri">Uri of the operator host to get bikes from or null if bikes have to be gotten form primary host.</param>
		/// <returns></returns>
		public void AddToCache(Result<BikesAvailableResponse> result, Uri operatorUri = null)
		{
			Log.ForContext<CopriProviderHttps>().Debug($"Request to add bikes available response to cache...");
			if (result.Source == typeof(CopriCallsMonkeyStore)
				|| result.Exception != null)
			{
				// Do not add responses form cache or invalid responses to cache.
				return;
			}

			Log.ForContext<CopriProviderHttps>().Debug($"Add bikes available response to cache.");
			CacheServer.AddToCache(result.Response, operatorUri);

		}

		/// <summary>Adds https--response to cache if response is ok. </summary>
		/// <param name="response">Response to add to cache.</param>
		/// <returns></returns>
		public void AddToCache(Result<BikesReservedOccupiedResponse> result)
		{
			Log.ForContext<CopriProviderHttps>().Debug($"Request to add bikes occupied response to cache...");
			if (result.Source == typeof(CopriCallsMonkeyStore)
				|| result.Exception != null)
			{
				// Do not add responses form cache or invalid responses to cache.
				return;
			}

			Log.ForContext<CopriProviderHttps>().Debug($"Add bikes occupied response to cache.");
			CacheServer.AddToCache(result.Response);
		}

		public async Task<AuthorizationResponse> DoAuthorizationAsync(string p_strMailAddress, string p_strPassword, string p_strDeviceId)
		{
			return await HttpsServer.DoAuthorizationAsync(p_strMailAddress, p_strPassword, p_strDeviceId);
		}

		public async Task<AuthorizationoutResponse> DoAuthoutAsync()
		{
			return await HttpsServer.DoAuthoutAsync();
		}

		public async Task<ReservationBookingResponse> DoReserveAsync(string bikeId, Uri operatorUri)
			=> await HttpsServer.DoReserveAsync(bikeId, operatorUri);

		public async Task<ReservationCancelReturnResponse> DoCancelReservationAsync(string bikeId, Uri operatorUri)
			=> await HttpsServer.DoCancelReservationAsync(bikeId, operatorUri);

		public async Task<ReservationBookingResponse> CalculateAuthKeysAsync(string bikeId, Uri operatorUri)
		{
			return await HttpsServer.CalculateAuthKeysAsync(bikeId, operatorUri);
		}

		public async Task<ResponseBase> StartReturningBike(
			string bikeId,
			Uri operatorUri)
				=> await HttpsServer.StartReturningBike(bikeId, operatorUri);

		public async Task<ReservationBookingResponse> UpdateLockingStateAsync(
			string bikeId,
			lock_state state,
			Uri operatorUri,
			LocationDto location,
			double batteryLevel,
			IVersionInfo versionInfo)
				=> await HttpsServer.UpdateLockingStateAsync(
					bikeId,
					state,
					operatorUri,
					location,
					batteryLevel,
					versionInfo);

		/// <summary> Books a bike. </summary>
		/// <param name="operatorUri">Holds the uri of the operator or null, in case of single operator setup.</param>
		/// <param name="bikeId">Id of the bike to book.</param>
		/// <param name="guid">Used to publish GUID from app to copri. Used for initial setup of bike in copri.</param>
		/// <param name="batteryPercentage">Holds the filling level percentage of the battery.</param>
		/// <param name="nextAction">If not null next locking action which is performed after booking.</param>
		/// <returns>Response on booking request.</returns>
		public async Task<ReservationBookingResponse> DoBookAsync(Uri operatorUri, string bikeId, Guid guid, double batteryPercentage, LockingAction? nextAction = null)
			=> await HttpsServer.DoBookAsync(operatorUri, bikeId, guid, batteryPercentage, nextAction);

		/// <summary> Books a bike and starts opening bike. </summary>
		/// <param name="bikeId">Id of the bike to book.</param>
		/// <param name="operatorUri">Holds the uri of the operator or null, in case of single operator setup.</param>
		/// <returns>Response on booking request.</returns>
		public async Task<ReservationBookingResponse> BookAvailableAndStartOpeningAsync(
			string bikeId,
			Uri operatorUri)
			=> await HttpsServer.BookAvailableAndStartOpeningAsync(bikeId, operatorUri);

		/// <summary> Books a bike and starts opening bike. </summary>
		/// <param name="bikeId">Id of the bike to book.</param>
		/// <param name="operatorUri">Holds the uri of the operator or null, in case of single operator setup.</param>
		/// <returns>Response on booking request.</returns>
		public async Task<ReservationBookingResponse> BookReservedAndStartOpeningAsync(
			string bikeId,
			Uri operatorUri)
			=> await HttpsServer.BookReservedAndStartOpeningAsync(bikeId, operatorUri);


		public async Task<DoReturnResponse> DoReturn(
			string bikeId,
			LocationDto location,
			Uri operatorUri)
			=> await HttpsServer.DoReturn(bikeId, location, operatorUri);

		/// <summary> Returns a bike and starts closing. </summary>
		/// <param name="bikeId">Id of the bike to return.</param>
		/// <param name="operatorUri">Holds the uri of the operator or null, in case of single operator setup.</param>
		/// <returns>Response on returning request.</returns>
		public async Task<DoReturnResponse> ReturnAndStartClosingAsync(
			string bikeId,
			Uri operatorUri)
			=> await HttpsServer.ReturnAndStartClosingAsync(bikeId, operatorUri);

		/// <summary>
		/// Submits feedback to copri server.
		/// </summary>
		/// <param name="bikeId">Id of the bike to submit feedback for.</param>
		/// <param name="message">General purpose message or error description.</param>
		/// <param name="isBikeBroken">True if bike is broken.</param>
		public async Task<SubmitFeedbackResponse> DoSubmitFeedback(string bikeId, int? currentChargeBars, string message, bool isBikeBroken, Uri opertorUri) =>
			 await HttpsServer.DoSubmitFeedback(bikeId, currentChargeBars, message, isBikeBroken, opertorUri);

		/// <summary> Submits mini survey to copri server. </summary>
		/// <param name="answers">Collection of answers.</param>
		public async Task<ResponseBase> DoSubmitMiniSurvey(IDictionary<string, string> answers)
			=> await HttpsServer.DoSubmitMiniSurvey(answers);

	}
}