using MonkeyCache.FileStore;
using System;
using System.Threading.Tasks;
using TINK.Model.Connector;
using TINK.Model.Repository.Request;
using TINK.Model.Repository.Response;
using TINK.Model.Services.CopriApi;
using TINK.Repository.Response;

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

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

        public const string BIKESAVAILABLE = @"{
              ""copri_version"" : ""3.0.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"" : ""Konrad,TINK"",
              ""authcookie"" : """",
              ""response_state"" : ""OK"",
              ""bikes_occupied"" : {},
              ""copri_version"" : ""3.0.0.0"",
              ""apiserver"" : ""https://app.tink-konstanz.de""
        }";

        public const string STATIONS = @"{
              ""apiserver"" : ""https://app.tink-konstanz.de"",
              ""authcookie"" : """",
              ""response"" : ""stations_all"",
              ""copri_version"" : ""3.0.0.0"",
              ""stations"" : {},
              ""response_state"" : ""OK""
        }";

        /// <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> Initializes a instance of the copri monkey store object. </summary>
        /// <param name="p_strMerchantId">Id of the merchant.</param>
        /// <param name="sessionCookie">Session cookie if user is logged in, null otherwise.</param>
        public CopriCallsMonkeyStore(
            string merchantId,
            string sessionCookie = null,
            TimeSpan? expiresAfter = null)
        {
            ExpiresAfter = expiresAfter ?? TimeSpan.FromSeconds(1);

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

            // Ensure that store holds valid entries.
            if (!Barrel.Current.Exists(requestBuilder.GetBikesAvailable()))
            {
                AddToCache(JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE), new TimeSpan(0));
            }

            // Do not query bikes occupied if no user is logged in (leads to not implemented exception)
            if (!string.IsNullOrEmpty(sessionCookie) && !Barrel.Current.Exists(requestBuilder.GetBikesOccupied()))
            {
                AddToCache(JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED), new TimeSpan(0));
            }

            if (!Barrel.Current.Exists(requestBuilder.GetStations()))
            {
                AddToCache(JsonConvert.DeserializeObject<StationsAllResponse>(STATIONS), new TimeSpan(0));
            }
        }

        public Task<ReservationBookingResponse> DoReserveAsync(int bikeId, Uri operatorUri)
        {
            throw new System.Exception("Reservierung im Offlinemodus nicht möglich!");
        }

        public Task<ReservationCancelReturnResponse> DoCancelReservationAsync(int p_iBikeId, Uri operatorUri)
        {
            throw new System.Exception("Abbrechen einer Reservierung im Offlinemodus nicht möglich!");
        }

        public Task<ReservationBookingResponse> CalculateAuthKeysAsync(int bikeId, Uri operatorUri)
            => throw new System.Exception("Schlosssuche im Offlinemodus nicht möglich!");

        public Task<ReservationBookingResponse> UpdateLockingStateAsync(
            int bikeId, 
            LocationDto geolocation, 
            lock_state state,
            double batteryLevel,
            Uri operatorUri)
            => throw new System.Exception("Aktualisierung des Schlossstatuses im Offlinemodus nicht möglich!");

        public Task<ReservationBookingResponse> DoBookAsync(int bikeId, Guid guid, double batteryPercentage, Uri operatorUri)
        {
            throw new System.Exception("Buchung im Offlinemodus nicht möglich!");
        }

        public Task<ReservationCancelReturnResponse> DoReturn(int bikeId, LocationDto geolocation, Uri operatorUri)
        {
            throw new System.Exception("Rückgabe im Offlinemodus nicht möglich!");
        }

        public Task<SubmitFeedbackResponse> DoSubmitFeedback(string message, bool isBikeBroken, Uri operatorUri) =>
            throw new System.Exception("Übermittlung von Feedback im Offlinemodus nicht möglich!");

        public Task<AuthorizationResponse> DoAuthorizationAsync(string p_strMailAddress, string p_strPassword, string p_strDeviceId)
        {
            throw new System.Exception("Anmelden im Offlinemodus nicht möglich!");
        }

        public Task<AuthorizationoutResponse> DoAuthoutAsync()
        {
            throw new System.Exception("Abmelden im Offlinemodus nicht möglich!");
        }

        public async Task<BikesAvailableResponse> GetBikesAvailableAsync()
        {
            var l_oBikesAvailableTask = new TaskCompletionSource<BikesAvailableResponse>();
            lock (monkeyLock)
            {
                l_oBikesAvailableTask.SetResult(Barrel.Current.Get<BikesAvailableResponse>(requestBuilder.GetBikesAvailable()));
            }
            return await l_oBikesAvailableTask.Task;
        }

        public async Task<BikesReservedOccupiedResponse> GetBikesOccupiedAsync()
        {
            try
            {
                var l_oBikesOccupiedTask = new TaskCompletionSource<BikesReservedOccupiedResponse>();
                lock (monkeyLock)
                {
                    l_oBikesOccupiedTask.SetResult(Barrel.Current.Get<BikesReservedOccupiedResponse>(requestBuilder.GetBikesOccupied()));
                }

                return await l_oBikesOccupiedTask.Task;

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

        public async Task<StationsAllResponse> GetStationsAsync()
        {
            var l_oStationsAllTask = new TaskCompletionSource<StationsAllResponse>();
            lock (monkeyLock)
            {
                l_oStationsAllTask.SetResult(Barrel.Current.Get<StationsAllResponse>(requestBuilder.GetStations()));
            }
            return await l_oStationsAllTask.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(StationsAllResponse stations)
        {
            AddToCache(stations, ExpiresAfter);
        }

        /// <summary> Adds a stations all response to cache.</summary>
        /// <param name="stations">Stations to add.</param>
        /// <param name="expiresAfter">Time after which anser is considered to be expired.</param>
        private void AddToCache(StationsAllResponse stations, TimeSpan expiresAfter)
        {
            lock (monkeyLock)
            {
                Barrel.Current.Add(
                    requestBuilder.GetStations(),
                    JsonConvert.SerializeObject(stations), 
                    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>
        public void AddToCache(BikesAvailableResponse bikes)
        {
            AddToCache(bikes, ExpiresAfter);
        }

        /// <summary> Adds a bikes response to cache.</summary>
        /// <param name="bikes">Bikes to add.</param>
        /// <param name="expiresAfter">Time after which anser is considered to be expired.</param>
        private void AddToCache(BikesAvailableResponse bikes, TimeSpan expiresAfter)
        {
            lock (monkeyLock)
            {
                Barrel.Current.Add(
                    requestBuilder.GetBikesAvailable(), 
                    JsonConvert.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)
        {
            AddToCache(bikes, ExpiresAfter);

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