sharee.bike-App/SharedBusinessLogic/Repository/CopriCallsMonkeyStore.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using MonkeyCache.FileStore;
using SharedBusinessLogic.Tests.Framework.Repository;
using ShareeBike.Model.Bikes.BikeInfoNS.BluetoothLock;
using ShareeBike.Model.Connector;
using ShareeBike.Model.Device;
using ShareeBike.Model.Services.CopriApi;
using ShareeBike.MultilingualResources;
using ShareeBike.Repository.Request;
using ShareeBike.Repository.Response;
using ShareeBike.Repository.Response.Stations;

namespace ShareeBike.Repository
{
	public class CopriCallsMonkeyStore : ICopriCache
	{
		/// <summary> Prevents concurrent communication. </summary>
		private object monkeyLock = new object();

		/// <summary> Builds requests.</summary>
		private IRequestBuilder requestBuilder;

		public const string BIKESAVAILABLE = @"{
				""copri_version"" : ""4.1.0.0"",
				""bikes"" : {},
				""response_state"" : ""OK"",
				""apiserver"" : ""https://app.tink-konstanz.de"",
				""authcookie"" : """",
				""response"" : ""bikes_available""
		}";

		public const string BIKESOCCUPIED = @"{
				""debuglevel"" : ""1"",
				""user_id"" : """",
				""response"" : ""user_bikes_occupied"",
				""user_group"" : [ ""Citybike"", ""ShareeBike"" ],
				""authcookie"" : """",
				""response_state"" : ""OK"",
				""bikes_occupied"" : {},
				""copri_version"" : ""4.1.0.0"",
				""apiserver"" : ""https://app.tink-konstanz.de""
		}";

		/// <summary> Version COPRI 4.0. or earlier</summary>
		public const string STATIONSALL = @"{
				""apiserver"" : """",
				""authcookie"" : """",
				""response"" : ""stations_all"",
				""copri_version"" : ""4.1.0.0"",
				""stations"" : {},
				""response_state"" : ""OK"",
				""bikes_occupied"" : {}
		}";

		/// <summary>
		/// Holds the seconds after which station and bikes info is considered to be invalid.
		/// Default value 1s.
		/// </summary>
		private TimeSpan ExpiresAfter { get; }

		/// <summary> Returns false because cached values are returned. </summary>
		public bool IsConnected => false;

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

		/// <summary> Gets the merchant id.</summary>
		public string SessionCookie => requestBuilder.SessionCookie;

		/// <summary>
		/// Holds a cache of copri, i.e. stations and bikes.
		/// </summary>
		private readonly CopriResponseModel copriModel;

		/// <summary> Initializes a instance of the copri monkey store object. </summary>
		/// <param name="merchantId">Id of the merchant. Used to access </param>
		/// <param name="uiIsoLangugageName">Two letter ISO language name.</param>
		/// <param name="sessionCookie">Session cookie if user is logged in, null otherwise.</param>
		/// <param name="smartDevice">Holds info about smart device.</param>
		public CopriCallsMonkeyStore(
			string merchantId,
			string uiIsoLangugageName,
			string sessionCookie = null,
			ISmartDevice smartDevice = null,
			TimeSpan? expiresAfter = null)
		{
			ExpiresAfter = expiresAfter ?? TimeSpan.FromSeconds(1);

			requestBuilder = string.IsNullOrEmpty(sessionCookie)
				? new RequestBuilder(merchantId, uiIsoLangugageName, smartDevice) as IRequestBuilder
				: new RequestBuilderLoggedIn(merchantId, uiIsoLangugageName, sessionCookie, smartDevice);

			var bikesAvailableEntryExists = Barrel.Current.Exists(requestBuilder.GetBikesAvailable());
			var bikesAvailable = bikesAvailableEntryExists
				? Barrel.Current.Get<BikesAvailableResponse>(requestBuilder.GetBikesAvailable())
				: JsonConvertRethrow.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE);
			// Ensure that store holds valid entries.
			if (!bikesAvailableEntryExists)
			{
				AddToCache(bikesAvailable, new TimeSpan(0));
			}

			// Do not query bikes occupied if no user is logged in (leads to not implemented exception)
			var isLoggedIn = !string.IsNullOrEmpty(sessionCookie);
			var readBikesOccupiedFromCache = isLoggedIn && Barrel.Current.Exists(requestBuilder.GetBikesOccupied());
			var bikesOccupied = readBikesOccupiedFromCache
				? Barrel.Current.Get<BikesReservedOccupiedResponse>(requestBuilder.GetBikesOccupied())
				: JsonConvertRethrow.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED);

			if (isLoggedIn && !readBikesOccupiedFromCache)
			{
				AddToCache(bikesOccupied, new TimeSpan(0));
			}

			var stationsEntryExists = Barrel.Current.Exists(requestBuilder.GetStations());
			var stations = stationsEntryExists
				? Barrel.Current.Get<StationsAvailableResponse>(requestBuilder.GetStations())
				: JsonConvertRethrow.DeserializeObject<StationsAvailableResponse>(STATIONSALL);

			if (!stationsEntryExists)
			{
				AddToCache(stations, new TimeSpan(0));
			}

			copriModel = new CopriResponseModel(bikesAvailable, bikesOccupied, stations);
		}

		public Task<ReservationBookingResponse> DoReserveAsync(string bikeId, Uri operatorUri)
		{
			throw new System.Exception(AppResources.ErrorNoWeb);
		}

		public Task<BookingActionResponse> DoCancelReservationAsync(string bikeId, Uri operatorUri)
		{
			throw new System.Exception(AppResources.ErrorNoWeb);
		}

		public Task<ReservationBookingResponse> CalculateAuthKeysAsync(string bikeId, Uri operatorUri)
			=> throw new System.Exception(AppResources.ErrorNoWeb);

		public Task<ResponseBase> StartReturningBike(
			string bikeId,
			Uri operatorUri)
			=> throw new System.Exception(AppResources.ErrorNoWeb);

		public Task<ReservationBookingResponse> UpdateLockingStateAsync(
			string bikeId,
			lock_state state,
			Uri operatorUri,
			LocationDto geolocation,
			double batteryLevel,
			IVersionInfo versionInfo)
			=> throw new System.Exception(AppResources.ErrorNoWeb);

		public Task<ReservationBookingResponse> DoBookAsync(Uri operatorUri, string bikeId, Guid guid, double batteryPercentage, LockingAction? nextAction = null)
			=> throw new System.Exception(AppResources.ErrorNoWeb);

		/// <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 Task<ReservationBookingResponse> BookAvailableAndStartOpeningAsync(
			string bikeId,
			Uri operatorUri)
			=> throw new System.Exception(AppResources.ErrorNoWeb);

		/// <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 Task<ReservationBookingResponse> BookReservedAndStartOpeningAsync(
			string bikeId,
			Uri operatorUri)
			=> throw new System.Exception(AppResources.ErrorNoWeb);

		public Task<DoReturnResponse> DoReturn(
			string bikeId,
			LocationDto geolocation,
			Uri operatorUri)
			=> throw new System.Exception(AppResources.ErrorNoWeb);

		/// <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 Task<DoReturnResponse> ReturnAndStartClosingAsync(
			string bikeId,
			Uri operatorUri)
			=> throw new System.Exception(AppResources.ErrorNoWeb);

		public Task<SubmitFeedbackResponse> DoSubmitFeedback(string bikeId, int? currentChargeBars, string message, bool isBikeBroken, Uri operatorUri)
			=> throw new System.Exception(AppResources.ErrorNoWeb);

		/// <summary> Submits mini survey to copri server. </summary>
		/// <param name="answers">Collection of answers.</param>
		public Task<ResponseBase> DoSubmitMiniSurvey(IDictionary<string, string> answers)
			=> throw new System.Exception(AppResources.ErrorNoWeb);

		public Task<AuthorizationResponse> DoAuthorizationAsync(string p_strMailAddress, string p_strPassword, string p_strDeviceId)
		{
			throw new System.Exception(AppResources.ErrorNoWeb);
		}

		public Task<AuthorizationoutResponse> DoAuthoutAsync()
		{
			throw new System.Exception(AppResources.ErrorNoWeb);
		}

		/// <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>
		/// <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>
		public async Task<BikesAvailableResponse> GetBikesAvailableAsync(
			Uri operatorUri = null,
			string stationId = null,
			string bikeId = null)
		{
			var bikesAvailableTask = new TaskCompletionSource<BikesAvailableResponse>();
			bikesAvailableTask.SetResult(copriModel.BikesAll
				.FilterByStation(stationId)
				.FilterByBike(bikeId));

			return await bikesAvailableTask.Task;
		}

		public async Task<BikesReservedOccupiedResponse> GetBikesOccupiedAsync()
		{
			try
			{
				var bikesOccupiedTask = new TaskCompletionSource<BikesReservedOccupiedResponse>();
				bikesOccupiedTask.SetResult(copriModel.BikesReservedOccupied);
				return await bikesOccupiedTask.Task;

			}
			catch (NotSupportedException)
			{
				// No user logged in.
				await Task.CompletedTask;
				return ResponseHelper.GetBikesOccupiedNone();
			}
		}

		public async Task<StationsAvailableResponse> GetStationsAsync()
		{
			var stationsAllTask = new TaskCompletionSource<StationsAvailableResponse>();
			stationsAllTask.SetResult(copriModel.Stations);
			return await stationsAllTask.Task;
		}

		/// <summary> Gets a value indicating whether stations are expired or not.</summary>
		public bool IsStationsExpired
		{
			get
			{
				lock (monkeyLock)
				{
					return Barrel.Current.IsExpired(requestBuilder.GetStations());
				}
			}
		}

		/// <summary> Adds a stations all response to cache.</summary>
		/// <param name="stations">Stations to add.</param>
		public void AddToCache(StationsAvailableResponse stations)
		{
			var updateTarget = copriModel.Update(stations);

			AddToCache(copriModel.Stations, ExpiresAfter);

			if (updateTarget.HasFlag(UpdateTarget.BikesAvailableResponse))
			{
				AddToCache(copriModel.BikesAll, ExpiresAfter);
			}

			if (updateTarget.HasFlag(UpdateTarget.BikesReservedOccupiedResponse))
			{
				AddToCache(copriModel.BikesReservedOccupied, ExpiresAfter);
			}
		}

		/// <summary> Adds a stations all response to cache.</summary>
		/// <param name="stations">Stations to add.</param>
		/// <param name="expiresAfter">Time after which answer is considered to be expired.</param>
		private void AddToCache(StationsAvailableResponse stations, TimeSpan expiresAfter)
		{
			lock (monkeyLock)
			{
				Barrel.Current.Add(
					requestBuilder.GetStations(),
					JsonConvertRethrow.SerializeObject(stations),
					expiresAfter);
			}
		}

		/// <summary>
		/// Updates cache from bike which changed rental state.
		/// </summary>
		/// <param name="response">Response to update from.</param>
		public void Update(BikeInfoReservedOrBooked response)
		{
			var updateTarget = copriModel.Update(response);

			if (updateTarget.HasFlag(UpdateTarget.StationsAvailableResponse))
			{
				AddToCache(copriModel.Stations, ExpiresAfter);
			}

			if (updateTarget.HasFlag(UpdateTarget.BikesAvailableResponse))
			{
				AddToCache(copriModel.BikesAll, ExpiresAfter);
			}

			if (updateTarget.HasFlag(UpdateTarget.BikesReservedOccupiedResponse))
			{
				AddToCache(copriModel.BikesReservedOccupied, ExpiresAfter);
			}
		}

		/// <summary> Updates cache from bike which changed rental state (reservation/ booking canceled). </summary>
		public void Update(BookingActionResponse response)
		{
			var updateTarget = copriModel.Update(response);

			if (updateTarget.HasFlag(UpdateTarget.StationsAvailableResponse))
			{
				AddToCache(copriModel.Stations, ExpiresAfter);
			}

			if (updateTarget.HasFlag(UpdateTarget.BikesAvailableResponse))
			{
				AddToCache(copriModel.BikesAll, ExpiresAfter);
			}

			if (updateTarget.HasFlag(UpdateTarget.BikesReservedOccupiedResponse))
			{
				AddToCache(copriModel.BikesReservedOccupied, ExpiresAfter);
			}
		}

		/// <summary> Gets a value indicating whether stations are expired or not.</summary>
		public bool IsBikesAvailableExpired
		{
			get
			{
				lock (monkeyLock)
				{
					return Barrel.Current.IsExpired(requestBuilder.GetBikesAvailable());
				}
			}
		}

		/// <summary> Adds a bikes response to cache.</summary>
		/// <param name="bikes">Bikes to add.</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>
		/// <param name="stationId"> Id of station which was used for filtering bikes. Null if no filtering was applied.</param>
		/// <param name="bikeId"> Id of bike which was used for filtering bikes. Null if no filtering was applied.</param>
		public void AddToCache(
			BikesAvailableResponse bikes,
			Uri operatorUri = null,
			string stationId = null,
			string bikeId = null)
		{
			var updateTarget = copriModel.Update(bikes, stationId, bikeId);

			AddToCache(copriModel.BikesAll, ExpiresAfter);

			if (updateTarget.HasFlag(UpdateTarget.BikesReservedOccupiedResponse))
			{
				AddToCache(copriModel.BikesReservedOccupied, ExpiresAfter);
			}

			if (updateTarget.HasFlag(UpdateTarget.StationsAvailableResponse))
			{
				AddToCache(copriModel.Stations, ExpiresAfter);
			}
		}

		/// <summary> Adds a bikes response to cache.</summary>
		/// <param name="bikes">Bikes to add.</param>
		/// <param name="expiresAfter">Time after which answer is considered to be expired.</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>
		/// <param name="stationId"> Id of station which is used for filtering bikes. Null if no filtering should be applied.</param>
		private void AddToCache(
			BikesAvailableResponse bikes,
			TimeSpan expiresAfter)
		{
			lock (monkeyLock)
			{
				Barrel.Current.Add(
					$"{requestBuilder.GetBikesAvailable()}",
					JsonConvertRethrow.SerializeObject(bikes),
					expiresAfter);
			}
		}

		/// <summary> Gets a value indicating whether stations are expired or not.</summary>
		public bool IsBikesOccupiedExpired
		{
			get
			{
				lock (monkeyLock)
				{
					return Barrel.Current.IsExpired(requestBuilder.GetBikesOccupied());
				}
			}
		}

		/// <summary> Adds a bikes response to cache.</summary>
		/// <param name="bikes">Bikes to add.</param>
		public void AddToCache(BikesReservedOccupiedResponse bikes)
		{
			// Update model in order to ensure a consistent state.
			var updateTarget = copriModel.Update(bikes);

			// Update cache.
			AddToCache(copriModel.BikesReservedOccupied, ExpiresAfter);
			if (updateTarget.HasFlag(UpdateTarget.BikesAvailableResponse))
			{
				AddToCache(copriModel.BikesAll, ExpiresAfter);
			}
			if (updateTarget.HasFlag(UpdateTarget.StationsAvailableResponse))
			{
				AddToCache(copriModel.Stations, ExpiresAfter);
			}
		}

		/// <summary> Adds a bikes response to cache.</summary>
		/// <param name="bikes">Bikes to add.</param>
		/// <param name="expiresAfter">Time after which answer is considered to be expired.</param>
		private void AddToCache(BikesReservedOccupiedResponse bikes, TimeSpan expiresAfter)
		{
			lock (monkeyLock)
			{
				Barrel.Current.Add(
					requestBuilder.GetBikesOccupied(),
					JsonConvertRethrow.SerializeObject(bikes),
					expiresAfter);
			}
		}
	}
}