using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Threading.Tasks;
using ShareeBike.Model;
using ShareeBike.Model.Bikes.BikeInfoNS.BluetoothLock;
using ShareeBike.Model.Connector;
using ShareeBike.Repository;
using ShareeBike.Repository.Request;
using ShareeBike.Repository.Response;
using ShareeBike.Repository.Response.Stations;

namespace SharedBusinessLogic.Tests.Framework.Repository
{
	/// <summary> Provides functionality for keeping a set of COPRI responses. </summary>
	public abstract class CopriCallMemoryBase
	{
		private string BikesAvailableResponse { get; }

		private string BikesOccupiedResponse { get; }

		private string AuthResponse { get; }

		private string AuthOutResponse { get; }

		private string Stations { get; }

		private string BookingRequestResponse { get; }

		private string CancelBookingRequestResponse { get; }

		private IRequestBuilder requestBuilder;

		/// <summary>
		/// Constructs copri server mock from build in resources.
		/// </summary>
		/// <param name="bikesAvailableResponseResource"></param>
		/// <param name="bikesOccupiedResponseResoure"></param>
		/// <param name="authResponseResource"></param>
		/// <param name="authOutResponseResource"></param>
		/// <param name="stationsResponseResource"></param>
		/// <param name="bookingRequestResponseResource"></param>
		/// <param name="cancelBookingRequestResponseResource"></param>
		/// <param name="sessionCookie">Session cookie.</param>
		/// <param name="merchantId">Merchant identifier.</param>
		public CopriCallMemoryBase(
			string bikesAvailableResponseResource = null,
			string bikesOccupiedResponseResoure = null,
			string authResponseResource = null,
			string authOutResponseResource = null,
			string stationsResponseResource = null,
			string bookingRequestResponseResource = null,
			string cancelBookingRequestResponseResource = null,
			string sessionCookie = null,
			string merchantId = null)
		{
			string ReadResource(string resourceName)
			{
				if (string.IsNullOrEmpty(resourceName))
					return string.Empty;

				using (var streamReader = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName)))
				{
					return streamReader.ReadToEnd();
				}
			}

			MerchantId = merchantId ?? ShareeBikeApp.MerchantId;

			SessionCookie = sessionCookie;

			BikesAvailableResponse = ReadResource(bikesAvailableResponseResource);
			BikesOccupiedResponse = ReadResource(bikesOccupiedResponseResoure);
			AuthResponse = ReadResource(authResponseResource);
			AuthOutResponse = ReadResource(authOutResponseResource);
			Stations = ReadResource(stationsResponseResource);
			BookingRequestResponse = ReadResource(bookingRequestResponseResource);
			CancelBookingRequestResponse = ReadResource(cancelBookingRequestResponseResource);

			requestBuilder = string.IsNullOrEmpty(sessionCookie)
				? new RequestBuilder(merchantId ?? MerchantId, null /*UI language */) as IRequestBuilder
				: new RequestBuilderLoggedIn(merchantId ?? MerchantId, null /*UI language */, sessionCookie);
		}

		/// <summary> Holds the session id of the logged in user, null otherwise. </summary>
		public string SessionCookie { get; private set; }

		/// <summary> Logs user in. </summary>
		/// <param name="p_oUser">User to log in.</param>
		/// <param name="deviceId">Id specifying user and hardware.</param>
		/// <param name="mailAddress">Mail address of user to log in.</param>
		/// <param name="password">Password to log in.</param>
		/// <remarks>Response which holds auth cookie <see cref="ResponseBase.authcookie"/></remarks>
		public async Task<AuthorizationResponse> DoAuthorizationAsync(
			string mailAddress,
			string password,
			string deviceId)
			=> await Task.Run(() => DoAuthorize(AuthResponse, mailAddress, password, deviceId));

		/// <summary> Logs user out. </summary>
		/// <param name="sessionCookie">User to log in.</param>
		/// <remarks>Response which holds auth cookie <see cref="ResponseBase.authcookie"/></remarks>
		public async Task<AuthorizationoutResponse> DoAuthoutAsync()
			=> await Task.Run(() => DoAuthout(AuthOutResponse, SessionCookie));

		/// <summary>
		/// Gets list of bikes from memory.
		/// </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></returns>
		public async Task<BikesAvailableResponse> GetBikesAvailableAsync(Uri operatorUri = null, string stationId = null, string bikeId = null)
			=> await Task.Run(() => GetBikesAvailable(
				BikesAvailableResponse,
				null /* merchant id*/,
				SessionCookie,
				operatorUri,
				stationId,
				bikeId));

		/// <summary>
		/// Gets a list of bikes reserved/ booked by active user from Copri.
		/// </summary>
		/// <param name="p_strSessionCookie">Cookie to authenticate user.</param>
		/// <returns>Response holding list of bikes.</returns>
		public async Task<BikesReservedOccupiedResponse> GetBikesOccupiedAsync()
		{
			try
			{
				requestBuilder.GetBikesOccupied(); // Non mock implementation if ICopriServer call this member as well. To ensure comparable behavior this member is called here as well.
			}
			catch (NotSupportedException)
			{
				// No user logged in.
				await Task.CompletedTask;
				return ResponseHelper.GetBikesOccupiedNone();
			}
			return await Task.Run(() => GetBikesOccupied(BikesOccupiedResponse, SessionCookie));
		}

		/// <summary>
		/// Get list of stations from file.
		/// </summary>
		/// <param name="cookie">Auto cookie of user if user is logged in.</param>
		/// <returns>List of files.</returns>
		public async Task<StationsAvailableResponse> GetStationsAsync()
			=> await Task.Run(() => GetStationsAll(Stations, null, SessionCookie));

		/// <summary>
		/// Gets booking request response.
		/// </summary>
		/// <param name="bikeId">Id of the bike to book.</param>
		/// <returns>Booking response.</returns>
		public async Task<ReservationBookingResponse> DoReserveAsync(string bikeId, Uri operatorUri)
			=> await Task.Run(() => DoReserve(BookingRequestResponse, bikeId, SessionCookie));

		/// <summary>
		/// Gets cancel booking request response.
		/// </summary>
		/// <param name="bikeId">Id of the bike to book.</param>
		/// <param name="cookie">Cookie of the logged in user.</param>
		/// <returns>Response on cancel booking request.</returns>
		public async Task<BookingActionResponse> DoCancelReservationAsync(string bikeId, Uri operatorUri)
			=> await Task.Run(() => DoCancelReservation(CancelBookingRequestResponse, bikeId, SessionCookie));


		/// <summary> Gets the merchant id.</summary>
		public string MerchantId { get; }

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

		/// <summary> Logs user in. </summary>
		/// <param name="deviceId">Id specifying user and hardware.</param>
		/// <param name="mailAddress">Mail address of user to log in.</param>
		/// <param name="password">Password to log in.</param>
		/// <remarks>Response which holds auth cookie <see cref="ResponseBase.authcookie"/></remarks>
		public static AuthorizationResponse DoAuthorize(
			string doAuthResponse,
			string mailAddress,
			string password,
			string deviceId)
		{
			return mailAddress == "javaminister@gmail.com"
				&& password == "*********" &&
				deviceId == "HwId1000000000000"
				? JsonConvertRethrow.DeserializeObject<ResponseContainer<AuthorizationResponse>>(doAuthResponse).shareejson
				: JsonConvertRethrow.DeserializeObject<ResponseContainer<AuthorizationResponse>>(DO_AUTH_Unknown_User_FILE).shareejson;

		}

		/// <summary> Logs user in. </summary>
		/// <remarks>Response which holds auth cookie <see cref="ResponseBase.authcookie"/></remarks>
		public static AuthorizationoutResponse DoAuthout(
			string authOutResponse,
			string sessionCookie)
		{
			// Response contains auth cookie of user "JavaministerHardwareNr1"
			// For this reason do not return answer if mail and pwd do not match.

			return !string.IsNullOrEmpty(sessionCookie)
				? JsonConvertRethrow.DeserializeObject<ResponseContainer<AuthorizationoutResponse>>(authOutResponse).shareejson
				: throw new NotSupportedException();

		}

		/// <summary>
		/// Gets list of bikes from memory.
		/// </summary>
		/// <param name="merchantId">Id of the merchant.</param>
		/// <param name="sessionCookie">Auto cookie of user if user is logged in.</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 static BikesAvailableResponse GetBikesAvailable(
			string BikesAvailableResponse,
			string merchantId,
			string sessionCookie = null,
			Uri operatorUri = null,
			string stationId = null,
			string bikeid = null)
		{
			return CopriCallsStatic.DeserializeResponse<BikesAvailableResponse>(BikesAvailableResponse)
				.FilterByStation(stationId)
				.FilterByBike(bikeid);
		}

		/// <summary>
		/// Gets stations response.
		/// </summary>
		/// <param name="merchantId">Id of the merchant.</param>
		/// <param name="cookie">Auto cookie of user if user is logged in.</param>
		/// <param name="p_eSampleSet"></param>
		/// <param name="p_lStageIndex"></param>
		/// <returns></returns>
		public static StationsAvailableResponse GetStationsAll(
			string stations,
			string merchantId,
			string cookie = null)
			=> JsonConvertRethrow.DeserializeObject<ResponseContainer<StationsAvailableResponse>>(stations).shareejson;

		/// <summary>
		/// Gets booking request response.
		/// </summary>
		/// <param name="bikeId">Id of the bike.</param>
		/// <param name="sessionCookie">Identifies the logged in user.</param>
		/// <param name="sampleSet">Sample set to use.</param>
		/// <param name="stageIndex">Index of the stage.</param>
		/// <returns></returns>
		public static ReservationBookingResponse DoReserve(
			string bookingRequestResponse,
			string bikeId,
			string sessionCookie)
			=> JsonConvertRethrow.DeserializeObject<ResponseContainer<ReservationBookingResponse>>(bookingRequestResponse).shareejson;

		/// <summary>
		/// Gets cancel booking request response.
		/// </summary>
		/// <param name="bikeId">Id of the bike to book.</param>
		/// <param name="cookie">Cookie of the logged in user.</param>
		/// <returns>Response on cancel booking request.</returns>
		public static BookingActionResponse DoCancelReservation(
			string cancelBookingRequestResponse,
			string bikeId,
			string cookie)
			=> JsonConvertRethrow.DeserializeObject<ResponseContainer<BookingActionResponse>>(cancelBookingRequestResponse).shareejson;

		public Task<ReservationBookingResponse> CalculateAuthKeysAsync(string bikeId, Uri operatorUri)
			=> null;

		public Task<ResponseBase> StartReturningBike(
			string bikeId,
			Uri operatorUri)
			=> null;

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

		public Task<ReservationBookingResponse> DoBookAsync(Uri operatorUri, string bikeId, Guid guid, double batteryPercentage, LockingAction? nextAction = null)
			=> null;
		public Task<ReservationBookingResponse> BookAvailableAndStartOpeningAsync(string bikeId, Uri operatorUri)
			=> null;

		public Task<ReservationBookingResponse> BookReservedAndStartOpeningAsync(string bikeId, Uri operatorUri)
			=> null;

		public Task<DoReturnResponse> DoReturn(
			string bikeId,
			LocationDto geolocation,
			Uri operatorUri)
			=> null;

		public Task<DoReturnResponse> ReturnAndStartClosingAsync(
			string bikeId,
			Uri operatorUri)
			=> null;

		public Task<SubmitFeedbackResponse> DoSubmitFeedback(string bikeId, int? currentChargeBars, string message, bool isBikeBroken, Uri operatorUri)
			=> null;

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

		/// <summary>
		/// Gets a list of bikes reserved/ booked by active user from Copri.
		/// </summary>
		/// <param name="sessionCookie">Cookie to authenticate user.</param>
		/// <param name="SampleSet">Sample set to use.</param>
		/// <param name="p_lStageIndex">Index of the stage.</param>
		/// <returns>Response holding list of bikes.</returns>
		public static BikesReservedOccupiedResponse GetBikesOccupied(
			string bikesOccupied,
			string sessionCookie = null)
		{
			var response = CopriCallsStatic.DeserializeResponse<BikesReservedOccupiedResponse>(bikesOccupied);
			return sessionCookie != null && (response?.authcookie?.Contains(sessionCookie) ?? false)
				? response
				: ResponseHelper.GetBikesOccupiedNone(sessionCookie);

		}

		public const string DO_AUTH_Unknown_User_FILE = @"
        {
           ""shareejson"" : {
              ""response"" : ""authorization"",
              ""authcookie"" : 0,
              ""response_state"" : ""Failure: cannot generate authcookie"",
              ""apiserver"" : ""https://tinkwwp.copri-bike.de""
           }
        }";
	}
}