using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Threading.Tasks;
using TINK.Model;
using TINK.Model.Device;
using TINK.Repository;
using TINK.Repository.Request;
using TINK.Repository.Response;

namespace TestFramework.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"></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 ReadResource(string resourceName)
            {
                if (string.IsNullOrEmpty(resourceName))
                    return string.Empty;

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

            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) as IRequestBuilder
                : new RequestBuilderLoggedIn(MerchantId, 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">Mailaddress 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>
        /// <returns></returns>
        public async Task<BikesAvailableResponse> GetBikesAvailableAsync() 
            => await Task.Run(() => GetBikesAvailable(BikesAvailableResponse, null, SessionCookie));

        /// <summary>
        /// Gets a list of bikes reserved/ booked by acctive 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 behaviour 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="p_strCookie">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 canel booking request response.
        /// </summary>
        /// <param name="bikeId">Id of the bike to book.</param>
        /// <param name="p_strCookie">Cookie of the logged in user.</param>
        /// <returns>Response on cancel booking request.</returns>
        public async Task<ReservationCancelReturnResponse> DoCancelReservationAsync(string bikeId, Uri operatorUri)
            => await Task.Run(() => DoCancelReservation(CancelBookingRequestResponse, bikeId, SessionCookie));


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

        /// <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">Mailaddress 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="p_strMerchantId">Id of the merchant.</param>
        /// <param name="p_strSessionCookie">Auto cookie of user if user is logged in.</param>
        /// <param name="p_eSampleSet">Set of samples.</param>
        /// <param name="p_lStageIndex">Index of the stage.</param>
        /// <returns></returns>
        public static BikesAvailableResponse GetBikesAvailable(
            string BikesAvailableResponse,
            string p_strMerchantId,
            string p_strSessionCookie = null) => 
            CopriCallsStatic.DeserializeResponse<BikesAvailableResponse>(BikesAvailableResponse);

        /// <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 canel 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 ReservationCancelReturnResponse DoCancelReservation(
            string cancelBookingRequestResponse,
            string bikeId,
            string cookie)
            => JsonConvertRethrow.DeserializeObject<ResponseContainer<ReservationCancelReturnResponse>>(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)
            => null;

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

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

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

        public Task<SubmitFeedbackResponse> DoSubmitFeedback(string bikeId, 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 acctive 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""
           }
        }";
    }
}