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

namespace TINK.Model.Services.CopriApi
{
	public class CopriProviderMonkeyStore : ICopriServer
	{
		/// <summary> Object which manages stored copri answers. </summary>
		private readonly CopriCallsMonkeyStore monkeyStore;

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

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

		/// <summary> Constructs object which Object which manages stored copri answers in a thread save way. </summary>
		/// <param name="merchantId">Id of the merchant TINK-App.</param>
		/// <param name="uiIsoLangugageName">Two letter ISO language name.</param>
		public CopriProviderMonkeyStore(
			string merchantId,
			string uiIsoLangugageName,
			string sessionCookie)
		{
			monkeyStore = new CopriCallsMonkeyStore(merchantId, uiIsoLangugageName, sessionCookie);
		}

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

		public Task<ReservationBookingResponse> DoReserveAsync(string bikeId, Uri operatorUri)
			=> throw new NotSupportedException($"{nameof(DoReserveAsync)} is not cachable.");

		public Task<ReservationCancelReturnResponse> DoCancelReservationAsync(string bikeId, Uri operatorUri)
			=> throw new NotSupportedException($"{nameof(DoCancelReservationAsync)} is not cachable.");

		public Task<ReservationBookingResponse> CalculateAuthKeysAsync(string bikeId, Uri operatorUri)
			=> throw new NotSupportedException($"{nameof(CalculateAuthKeysAsync)} is not cachable.");

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


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

		public async Task<ReservationBookingResponse> DoBookAsync(string bikeId, Guid guid, double batteryPercentage, Uri operatorUri)
		{
			return await monkeyStore.DoBookAsync(bikeId, guid, batteryPercentage, operatorUri);
		}

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

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

		public async Task<DoReturnResponse> DoReturn(
			string bikeId,
			LocationDto geolocation,
			ISmartDevice smartDevice,
			Uri operatorUri)
			=> await monkeyStore.DoReturn(bikeId, geolocation, smartDevice, operatorUri);

		public async Task<DoReturnResponse> ReturnAndStartClosingAsync(
			string bikeId,
			ISmartDevice smartDevice,
			Uri operatorUri)
			=> await monkeyStore.ReturnAndStartClosingAsync(bikeId, smartDevice, operatorUri);

		public Task<SubmitFeedbackResponse> DoSubmitFeedback(string bikeId, int? currentChargeBars, string messge, bool bIsBikeBroke, Uri operatorUri)
			=> throw new NotImplementedException();

		/// <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 NotSupportedException();


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

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

		public async Task<BikesAvailableResponse> GetBikesAvailableAsync()
		{
			return await monkeyStore.GetBikesAvailableAsync();
		}

		public async Task<BikesReservedOccupiedResponse> GetBikesOccupiedAsync()
		{
			return await monkeyStore.GetBikesOccupiedAsync();
		}

		public async Task<StationsAvailableResponse> GetStationsAsync()
		{
			return await monkeyStore.GetStationsAsync();
		}
	}
}