using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using LightlessSync.API.Data.Enum;
using LightlessSync.API.Data.Extensions;
using LightlessSync.API.Dto.CharaData;
using LightlessSync.API.Dto.User;
using Microsoft.Extensions.Logging;

namespace LightlessSync.PlayerData.Pairs;

public sealed class PairHandlerRegistry : IDisposable
{
    private readonly object _gate = new();
    private readonly Dictionary<string, IPairHandlerAdapter> _identToHandler = new(StringComparer.Ordinal);
    private readonly Dictionary<IPairHandlerAdapter, HashSet<PairUniqueIdentifier>> _handlerToPairs = new();
    private readonly Dictionary<string, CancellationTokenSource> _waitingRequests = new(StringComparer.Ordinal);

    private readonly IPairHandlerAdapterFactory _handlerFactory;
    private readonly PairManager _pairManager;
    private readonly PairStateCache _pairStateCache;
    private readonly ILogger<PairHandlerRegistry> _logger;

    private readonly TimeSpan _deletionGracePeriod = TimeSpan.FromMinutes(5);
    private readonly TimeSpan _waitForHandlerGracePeriod = TimeSpan.FromMinutes(2);

    public PairHandlerRegistry(
        IPairHandlerAdapterFactory handlerFactory,
        PairManager pairManager,
        PairStateCache pairStateCache,
        ILogger<PairHandlerRegistry> logger)
    {
        _handlerFactory = handlerFactory;
        _pairManager = pairManager;
        _pairStateCache = pairStateCache;
        _logger = logger;
    }

    public int GetVisibleUsersCount()
    {
        lock (_gate)
        {
            return _handlerToPairs.Keys.Count(handler => handler.IsVisible);
        }
    }

    public bool IsIdentVisible(string ident)
    {
        lock (_gate)
        {
            return _identToHandler.TryGetValue(ident, out var handler) && handler.IsVisible;
        }
    }

    public PairOperationResult<PairUniqueIdentifier> RegisterOnlinePair(PairRegistration registration)
    {
        if (registration.CharacterIdent is null)
        {
            return PairOperationResult<PairUniqueIdentifier>.Fail($"Registration for {registration.PairIdent.UserId} missing ident.");
        }

        IPairHandlerAdapter handler;
        lock (_gate)
        {
            handler = GetOrAddHandler(registration.CharacterIdent);
            handler.ScheduledForDeletion = false;

            if (!_handlerToPairs.TryGetValue(handler, out var set))
            {
                set = new HashSet<PairUniqueIdentifier>();
                _handlerToPairs[handler] = set;
            }

            set.Add(registration.PairIdent);
        }

        ApplyPauseStateForHandler(handler);

        if (handler.LastReceivedCharacterData is null)
        {
            var cachedData = _pairStateCache.TryLoad(registration.CharacterIdent);
            if (cachedData is not null)
            {
                handler.LoadCachedCharacterData(cachedData);
            }
        }

        if (handler.LastReceivedCharacterData is not null &&
            (handler.LastAppliedApproximateVRAMBytes < 0 || handler.LastAppliedDataTris < 0))
        {
            handler.ApplyLastReceivedData(forced: true);
        }

        return PairOperationResult<PairUniqueIdentifier>.Ok(registration.PairIdent);
    }

    public PairOperationResult<PairUniqueIdentifier> DeregisterOfflinePair(PairRegistration registration, bool forceDisposal = false)
    {
        if (registration.CharacterIdent is null)
        {
            return PairOperationResult<PairUniqueIdentifier>.Fail($"Deregister for {registration.PairIdent.UserId} missing ident.");
        }

        IPairHandlerAdapter? handler = null;
        bool shouldScheduleRemoval = false;
        bool shouldDisposeImmediately = false;

        lock (_gate)
        {
            if (!_identToHandler.TryGetValue(registration.CharacterIdent, out handler))
            {
                return PairOperationResult<PairUniqueIdentifier>.Fail($"Ident {registration.CharacterIdent} not registered.");
            }

            if (_handlerToPairs.TryGetValue(handler, out var set))
            {
                set.Remove(registration.PairIdent);
                if (set.Count == 0)
                {
                    if (forceDisposal)
                    {
                        shouldDisposeImmediately = true;
                    }
                    else
                    {
                        shouldScheduleRemoval = true;
                        handler.ScheduledForDeletion = true;
                    }
                }
            }
        }

        if (shouldDisposeImmediately && handler is not null)
        {
            if (TryFinalizeHandlerRemoval(handler))
            {
                handler.Dispose();
            }
        }
        else if (shouldScheduleRemoval && handler is not null)
        {
            _ = RemoveAfterGracePeriodAsync(handler);
        }

        return PairOperationResult<PairUniqueIdentifier>.Ok(registration.PairIdent);
    }

    public PairOperationResult ApplyCharacterData(PairRegistration registration, OnlineUserCharaDataDto dto)
    {
        if (registration.CharacterIdent is null)
        {
            return PairOperationResult.Fail($"Character data received without ident for {registration.PairIdent.UserId}.");
        }

        IPairHandlerAdapter? handler;
        lock (_gate)
        {
            _identToHandler.TryGetValue(registration.CharacterIdent, out handler);
        }

        if (handler is null)
        {
            var registerResult = RegisterOnlinePair(registration);
            if (!registerResult.Success)
            {
                return PairOperationResult.Fail(registerResult.Error);
            }

            lock (_gate)
            {
                _identToHandler.TryGetValue(registration.CharacterIdent, out handler);
            }
        }

        if (handler is null)
        {
            return PairOperationResult.Fail($"Handler not ready for {registration.PairIdent.UserId}.");
        }

        handler.ApplyData(dto.CharaData);
        return PairOperationResult.Ok();
    }

    public PairOperationResult ApplyLastReceivedData(PairUniqueIdentifier pairIdent, string ident, bool forced = false)
    {
        IPairHandlerAdapter? handler;
        lock (_gate)
        {
            _identToHandler.TryGetValue(ident, out handler);
        }

        if (handler is null)
        {
            return PairOperationResult.Fail($"Cannot reapply data: handler for {pairIdent.UserId} not found.");
        }

        handler.ApplyLastReceivedData(forced);
        return PairOperationResult.Ok();
    }

    public PairOperationResult SetUploading(PairUniqueIdentifier pairIdent, string ident, bool uploading)
    {
        IPairHandlerAdapter? handler;
        lock (_gate)
        {
            _identToHandler.TryGetValue(ident, out handler);
        }

        if (handler is null)
        {
            return PairOperationResult.Fail($"Cannot set uploading for {pairIdent.UserId}: handler not found.");
        }

        handler.SetUploading(uploading);
        return PairOperationResult.Ok();
    }

    public PairOperationResult SetPausedState(PairUniqueIdentifier pairIdent, string ident, bool paused)
    {
        IPairHandlerAdapter? handler;
        lock (_gate)
        {
            _identToHandler.TryGetValue(ident, out handler);
        }

        if (handler is null)
        {
            return PairOperationResult.Fail($"Cannot update pause state for {pairIdent.UserId}: handler not found.");
        }

        _ = paused; // value reflected in pair manager already
        // Recalculate pause state against all registered pairs to ensure consistency across contexts.
        ApplyPauseStateForHandler(handler);
        return PairOperationResult.Ok();
    }

    public PairOperationResult<IReadOnlyList<(PairUniqueIdentifier Ident, PairConnection Pair)>> GetPairConnections(string ident)
    {
        IPairHandlerAdapter? handler;
        HashSet<PairUniqueIdentifier>? identifiers = null;

        lock (_gate)
        {
            _identToHandler.TryGetValue(ident, out handler);
            if (handler is not null)
            {
                _handlerToPairs.TryGetValue(handler, out identifiers);
            }
        }

        if (handler is null || identifiers is null)
        {
            return PairOperationResult<IReadOnlyList<(PairUniqueIdentifier Ident, PairConnection Pair)>>.Fail($"No handler registered for {ident}.");
        }

        var list = new List<(PairUniqueIdentifier, PairConnection)>();
        foreach (var pairIdent in identifiers)
        {
            var result = _pairManager.GetPair(pairIdent.UserId);
            if (result.Success)
            {
                list.Add((pairIdent, result.Value));
            }
        }

        return PairOperationResult<IReadOnlyList<(PairUniqueIdentifier Ident, PairConnection Pair)>>.Ok(list);
    }

    private void ApplyPauseStateForHandler(IPairHandlerAdapter handler)
    {
        var pairs = _pairManager.GetPairsByIdent(handler.Ident);
        bool paused = pairs.Any(p => p.SelfToOtherPermissions.IsPaused() || p.OtherToSelfPermissions.IsPaused());
        handler.SetPaused(paused);
    }

    internal bool TryGetHandler(string ident, out IPairHandlerAdapter? handler)
    {
        lock (_gate)
        {
            var success = _identToHandler.TryGetValue(ident, out var resolved);
            handler = resolved;
            return success;
        }
    }

    internal IReadOnlyList<IPairHandlerAdapter> GetHandlerSnapshot()
    {
        lock (_gate)
        {
            return _identToHandler.Values.Distinct().ToList();
        }
    }

    internal IReadOnlyCollection<PairUniqueIdentifier> GetRegisteredPairs(IPairHandlerAdapter handler)
    {
        lock (_gate)
        {
            if (_handlerToPairs.TryGetValue(handler, out var pairs))
            {
                return pairs.ToList();
            }
        }

        return Array.Empty<PairUniqueIdentifier>();
    }

    internal void ReapplyAll(bool forced = false)
    {
        var handlers = GetHandlerSnapshot();
        foreach (var handler in handlers)
        {
            try
            {
                handler.ApplyLastReceivedData(forced);
            }
            catch (Exception ex)
            {
                if (_logger.IsEnabled(LogLevel.Debug))
                {
                    _logger.LogDebug(ex, "Failed to reapply cached data for {Ident}", handler.Ident);
                }
            }
        }
    }

    internal void ResetAllHandlers()
    {
        List<IPairHandlerAdapter> handlers;
        lock (_gate)
        {
            handlers = _identToHandler.Values.Distinct().ToList();
            _identToHandler.Clear();
            _handlerToPairs.Clear();

            foreach (var pending in _waitingRequests.Values)
            {
                pending.Cancel();
                pending.Dispose();
            }

            _waitingRequests.Clear();
        }

        foreach (var handler in handlers)
        {
            try
            {
                handler.Dispose();
            }
            catch (Exception ex)
            {
                if (_logger.IsEnabled(LogLevel.Debug))
                {
                    _logger.LogDebug(ex, "Failed to dispose handler for {Ident}", handler.Ident);
                }
            }
        }
    }

    public void Dispose()
    {
        List<IPairHandlerAdapter> handlers;
        lock (_gate)
        {
            handlers = _identToHandler.Values.Distinct().ToList();
            _identToHandler.Clear();
            _handlerToPairs.Clear();
            foreach (var kv in _waitingRequests.Values)
            {
                kv.Cancel();
            }
            _waitingRequests.Clear();
        }

        foreach (var handler in handlers)
        {
            handler.Dispose();
        }
    }

    private IPairHandlerAdapter GetOrAddHandler(string ident)
    {
        if (_identToHandler.TryGetValue(ident, out var handler))
        {
            return handler;
        }

        handler = _handlerFactory.Create(ident);
        _identToHandler[ident] = handler;
        _handlerToPairs[handler] = new HashSet<PairUniqueIdentifier>();
        return handler;
    }

    private void EnsureInitialized(IPairHandlerAdapter handler)
    {
        if (handler.Initialized)
        {
            return;
        }

        try
        {
            handler.Initialize();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to initialize handler for {Ident}", handler.Ident);
        }
    }

    private async Task RemoveAfterGracePeriodAsync(IPairHandlerAdapter handler)
    {
        try
        {
            await Task.Delay(_deletionGracePeriod).ConfigureAwait(false);
        }
        catch (TaskCanceledException)
        {
            return;
        }

        if (TryFinalizeHandlerRemoval(handler))
        {
            handler.Dispose();
        }
    }

    private bool TryFinalizeHandlerRemoval(IPairHandlerAdapter handler)
    {
        lock (_gate)
        {
            if (!_handlerToPairs.TryGetValue(handler, out var set) || set.Count > 0)
            {
                handler.ScheduledForDeletion = false;
                return false;
            }

            _handlerToPairs.Remove(handler);
            _identToHandler.Remove(handler.Ident);

            if (_waitingRequests.TryGetValue(handler.Ident, out var cts))
            {
                cts.Cancel();
                cts.Dispose();
                _waitingRequests.Remove(handler.Ident);
            }

            return true;
        }
    }

    private async Task WaitThenApplyDataAsync(PairRegistration registration, OnlineUserCharaDataDto dto, CancellationTokenSource cts)
    {
        var token = cts.Token;
        try
        {
            while (!token.IsCancellationRequested)
            {
                IPairHandlerAdapter? handler;
                lock (_gate)
                {
                    _identToHandler.TryGetValue(registration.CharacterIdent!, out handler);
                }

                if (handler is not null && handler.Initialized)
                {
                    handler.ApplyData(dto.CharaData);
                    break;
                }

                await Task.Delay(TimeSpan.FromMilliseconds(500), token).ConfigureAwait(false);
            }
        }
        catch (OperationCanceledException)
        {
            // expected
        }
        finally
        {
            lock (_gate)
            {
                if (_waitingRequests.TryGetValue(registration.CharacterIdent!, out var existing) && existing == cts)
                {
                    _waitingRequests.Remove(registration.CharacterIdent!);
                }
            }

            cts.Dispose();
        }
    }
}