namespace Greencore.platform.validators;

public enum DataState { Idle, Pending, Ready, Failed, Canceled }
public sealed record DataSnapshot<T>(long Version, DataState State, T? Value = default, Exception? Error = null);
/// <summary>Resultado propio de una operación; la publicación visual puede seguir encolada.</summary>
public sealed record DataOperationResult<T>(DataSnapshot<T> Snapshot, bool IsCurrentAtCompletion)
{
    /// <summary>Estado de la operación sin navegar por la instantánea.</summary>
    public DataState State => Snapshot.State;

    /// <summary>Valor calculado cuando el estado es Ready.</summary>
    public T? Value => Snapshot.Value;

    /// <summary>Error técnico cuando el estado es Failed.</summary>
    public Exception? Error => Snapshot.Error;
}

/// <summary>Publica solamente la versión vigente; el dispatcher permite aplicar estados en el hilo de UI.</summary>
public sealed class AsyncDataSession<T> : IDisposable
{
    private readonly object _gate = new();
    private readonly object _notifications = new();
    private readonly Action<Action> _dispatch;
    private CancellationTokenSource? _active;
    private long _version;
    private bool _disposed;
    private DataSnapshot<T> _snapshot = new(0, DataState.Idle);

    public DataSnapshot<T> Snapshot { get { lock (_gate) return _snapshot; } }
    public event Action<DataSnapshot<T>>? Changed;

    public AsyncDataSession(Action<Action>? dispatch = null)
    {
        var context = SynchronizationContext.Current;
        _dispatch = dispatch ?? (context is null ? action => action() : action => context.Post(_ => action(), null));
    }

    public async ValueTask RunAsync(Func<CancellationToken, ValueTask<T>> load, CancellationToken cancellationToken = default)
        => _ = await RunWithResultAsync(load, cancellationToken).ConfigureAwait(false);

    public ValueTask<DataOperationResult<T>> RunWithResultAsync(Func<CancellationToken, ValueTask<T>> load, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(load);
        return RunRequestAsync(Begin(cancellationToken), load);
    }

    // Registrar una petición no ejecuta callbacks del consumidor bajo bloqueos ajenos.
    internal Request Begin(CancellationToken cancellationToken)
    {
        lock (_gate)
        {
            ObjectDisposedException.ThrowIf(_disposed, this);
            var previous = _active;
            var source = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
            _active = source;
            return new(source, previous, ++_version);
        }
    }

    internal async ValueTask<DataOperationResult<T>> RunRequestAsync(Request request, Func<CancellationToken, ValueTask<T>> load)
    {
        var (source, previous, version) = request;
        try
        {
            Cancel(previous);
            Publish(new(version, DataState.Pending));
            DataSnapshot<T> completed;
            try
            {
                source.Token.ThrowIfCancellationRequested();
                var value = await load(source.Token).ConfigureAwait(false);
                source.Token.ThrowIfCancellationRequested();
                completed = new(version, DataState.Ready, value);
            }
            catch (OperationCanceledException) when (source.IsCancellationRequested)
            {
                completed = new(version, DataState.Canceled);
            }
            catch (Exception exception)
            {
                completed = new(version, DataState.Failed, Error: exception);
            }
            Publish(completed);
            lock (_gate) return new(completed, !_disposed && version == _version);
        }
        finally
        {
            lock (_gate)
            {
                if (ReferenceEquals(_active, source)) _active = null;
                source.Dispose();
            }
        }
    }

    public void Dispose()
    {
        CancellationTokenSource? active;
        lock (_gate)
        {
            if (_disposed) return;
            _disposed = true;
            ++_version;
            active = _active;
            Changed = null;
        }
        Cancel(active);
    }

    private void Publish(DataSnapshot<T> snapshot) => _dispatch(() =>
    {
        lock (_notifications)
        {
            Action<DataSnapshot<T>>? changed;
            lock (_gate)
            {
                if (_disposed || snapshot.Version != _version) return;
                // Un dispatcher personalizado puede entregar callbacks en un orden distinto.
                if (_snapshot.Version == snapshot.Version && _snapshot.State != DataState.Pending && snapshot.State == DataState.Pending) return;
                _snapshot = snapshot;
                changed = Changed;
            }
            // Serializar notificaciones sin ejecutar código externo bajo el bloqueo de peticiones.
            changed?.Invoke(snapshot);
        }
    });

    private static void Cancel(CancellationTokenSource? source)
    {
        try { source?.Cancel(); }
        catch (ObjectDisposedException) { /* La consulta anterior terminó antes de cancelar. */ }
    }

    internal sealed record Request(CancellationTokenSource Source, CancellationTokenSource? Previous, long Version);
}