using Microsoft.AspNetCore.SignalR.Client;
using Microsoft.Extensions.Configuration;
using Polly;
using Refit;
using Sledgemapper.Shared.Entities;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;

namespace Sledgemapper
{
    public class CommunicationManager
    {
        public IMapApi Api { get; private set; }
        public HubConnection Connection { get; private set; }
        public readonly Session SessionData;
        private readonly ChannelsQueue Queue = new();
        private AuthenticateResponse _authenticateResponse;

        public CommunicationManager(Session sessionData)
        {

#if DEBUG
            var baseAddress = "http://localhost:5000";
#else
            var baseAddress = "http://hub.michelescandura.com:5000";
#endif

            SessionData = sessionData;
            Connection = new HubConnectionBuilder()
                                       .WithAutomaticReconnect()

                                       .WithUrl($"{baseAddress}/SledgemapperHub", options =>
                                        {
                                            options.AccessTokenProvider = () => Task.FromResult(_authenticateResponse.Token);
                                        })
                                        .Build();

            Api = RestService.For<IMapApi>(
              new HttpClient(new AuthenticatedHttpClientHandler(GetToken))
              {
                  BaseAddress = new Uri(baseAddress)
              }
          );

            Connection.On<Session>("UpdateMap", (map) =>
            {
                SessionData.Map = map.Map;
                SessionData.Walls = map.Walls;
                SessionData.Overlays = map.Overlays;
            });

            Connection.On<Player>("PlayerUpdate", (player) =>
            {
                var p = SessionData.Players.FirstOrDefault(m => m.UserId == player.UserId);
                if (p != null)
                {
                    p.Position = player.Position;
                }
                else
                {
                    SessionData.Players.Add(player);
                }
            });

            Connection.On<Tile>("DeleteTile", (tile) =>
            {
                SessionData.Map.Remove(tile.ToString(), out var _);
            });

            Connection.On<Wall>("DeleteWall", (tile) =>
           {
               SessionData.Walls.Remove(tile.ToString(), out var _);
           });

            Connection.On<Note>("DeleteNote", (tile) =>
          {
              SessionData.Notes.Remove(tile.ToString(), out var _);
          });

            Connection.On<Overlay>("DeleteOverlay", (tile) =>
           {
               SessionData.Overlays.Remove(tile.ToString(), out var _);
           });

            Connection.On<Tile>("NewTile", (tile) =>
          {
              SessionData.Map.Remove(tile.ToString(), out var _);
              SessionData.Map.TryAdd(tile.ToString(), tile);
          });

               Connection.On<Room>("NewRoom", (room) =>
          {
              SessionData.Rooms.Remove(room.ToString(), out var _);
              SessionData.Rooms.TryAdd(room.ToString(), room);
          });

               Connection.On<Line>("NewLine", (line) =>
          {
              SessionData.Lines.Remove(line.ToString(), out var _);
              SessionData.Lines.TryAdd(line.ToString(), line);
          });

            Connection.On("RefreshPlayers", () =>
         {
             if (!string.IsNullOrWhiteSpace(SessionData.SessionName))
             {
                 Connection?.SendAsync("UpdatePosition", SessionData.SessionName, SessionData.SessionId, SessionData.Players.First(p => p.UserId == int.Parse(_authenticateResponse.Id)));
             }
         });

            Connection.On<Player>("RemovePlayer", (player) =>
         {
             var p = SessionData.Players.FirstOrDefault(m => m.UserId == player.UserId);
             if (p != null)
             {
                 SessionData.Players.Remove(p);
             }
         });

            Connection.On<Wall>("NewWall", (tile) =>
           {
               SessionData.Walls.Remove(tile.ToString(), out var _);
               SessionData.Walls.TryAdd(tile.ToString(), tile);
           });

            Connection.On<Overlay>("NewOverlay", (tile) =>
            {
                SessionData.Overlays.Remove(tile.ToString(), out var _);
                SessionData.Overlays.TryAdd(tile.ToString(), tile);
            });

            Connection.On<Note>("NewNote", (note) =>
            {
                //SessionData.Notes.Remove(note.ToString(), out var _);
                SessionData.Notes.AddOrUpdate(note.ToString(), note, (key, oldnote) => note);
            });

            Connection.On<Player>("NewPlayer", (player) =>
            {
                var p = SessionData.Players.FirstOrDefault(m => m.UserId == player.UserId);
                if (p is null)
                {
                    SessionData.Players.Add(player);
                }
                else
                {
                    p.Color = player.Color;
                    p.Position = player.Position;
                }
            });

            Connection.On<Ping>("Ping", (ping) =>
            {
                SessionData.Pings.TryAdd(Guid.NewGuid(), ping);
            });
        }

        private Task<string> GetToken()
        {
            return Task.FromResult(_authenticateResponse.Token);
        }

        public async Task<HttpResponseMessage> Register(RegisterModel registerModel)
        {
            var result = await Api.Register(registerModel).ConfigureAwait(false);
            return result;
        }

        public async Task<AuthenticateResponse> Login(AuthenticateModel authenticateModel)
        {
            _authenticateResponse = await Api.Authenticate(authenticateModel).ConfigureAwait(false);
            return _authenticateResponse;
        }

        private async Task Execute(Func<Task> call)
        {
            await Policy
                      .Handle<ApiException>(ex => ex.StatusCode == HttpStatusCode.RequestTimeout)

                      .RetryForeverAsync()
                      //.RetryAsync(Polly.RetrySyntax., async (exception, retryCount) => await Task.Delay(500))
                      .ExecuteAsync(async () => await call().ConfigureAwait(false))
                      .ConfigureAwait(false);
        }

        public void Enqueue(BaseMapEntity entity, TileAction action)
        {
            switch (action)
            {
                case TileAction.Add:
                    switch (entity)
                    {
                        case Tile tile:
                            Queue.Enqueue(async () => await Execute(async () => await Api.NewTile(tile, SessionData.SessionName).ConfigureAwait(false)));
                            break;
                        case Overlay overlay:
                            Queue.Enqueue(async () => await Execute(async () => await Api.NewOverlay(overlay, SessionData.SessionName).ConfigureAwait(false)));
                            break;
                        case Wall wall:
                            Queue.Enqueue(async () => await Execute(async () => await Api.NewWall(wall, SessionData.SessionName).ConfigureAwait(false)));
                            break;
                        case Note note:
                            Queue.Enqueue(async () => await Execute(async () => await Api.NewNote(note, SessionData.SessionName).ConfigureAwait(false)));
                            break;
                        case Room room:
                            Queue.Enqueue(async () => await Execute(async () => await Api.NewRoom(room, SessionData.SessionName).ConfigureAwait(false)));
                            break;
                        case Line line:
                            Queue.Enqueue(async () => await Execute(async () => await Api.NewLine(line, SessionData.SessionName).ConfigureAwait(false)));
                            break;
                    }
                    break;

                case TileAction.Delete:
                    switch (entity)
                    {
                        case Tile tile:
                            Queue.Enqueue(async () => await Execute(async () => await Api.DeleteTile(tile, SessionData.SessionName).ConfigureAwait(false)));
                            break;
                        case Overlay overlay:
                            Queue.Enqueue(async () => await Execute(async () => await Api.DeleteOverlay(overlay, SessionData.SessionName).ConfigureAwait(false)));
                            break;
                        case Wall wall:
                            Queue.Enqueue(async () => await Execute(async () => await Api.DeleteWall(wall, SessionData.SessionName).ConfigureAwait(false)));
                            break;
                        case Note note:
                            Queue.Enqueue(async () => await Execute(async () => await Api.DeleteNote(note, SessionData.SessionName).ConfigureAwait(false)));
                            break;
                    }
                    break;
            }

        }

        internal async Task Ping(Tile location)
        {
            if (Connection!=null && Connection.State == HubConnectionState.Connected)
            {
                await Connection.InvokeAsync("Ping",SessionData.SessionName, location);
            }
        }
    }

    class AuthenticatedHttpClientHandler : HttpClientHandler
    {
        private readonly Func<Task<string>> getToken;

        public AuthenticatedHttpClientHandler(Func<Task<string>> getToken)
        {
            if (getToken == null) throw new ArgumentNullException(nameof(getToken));
            this.getToken = getToken;

            //if (myConfigurationService.VerifySslCertificate == false)
            //{
            ServerCertificateCustomValidationCallback =
                (message, certificate, chain, sslPolicyErrors) => true;
            //}
        }

        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            // See if the request has an authorize header
            var auth = request.Headers.Authorization;
            if (auth != null)
            {
                var token = await getToken().ConfigureAwait(false);
                request.Headers.Authorization = new AuthenticationHeaderValue(auth.Scheme, token);
            }

            return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
        }
    }
}