using System.ComponentModel;

namespace Greencore.platform.validators;

public enum FormValidationState { Idle, Pending, Valid, Invalid, Failed, Canceled }
public sealed record FormValidationSnapshot(long Version, FormValidationState State, ValidationReport? Report = null, Exception? Error = null);
/// <summary>Resultado de una evaluación de formulario sin exponer el vocabulario interno de datos.</summary>
public sealed record FormValidationOperationResult(long Version, FormValidationState State, ValidationReport? Report, Exception? Error, bool IsCurrentAtCompletion);

/// <summary>Coordina estados y respuestas del formulario sin publicar resultados de ediciones anteriores.</summary>
public sealed class FormValidationSession<T, C> : IDisposable
{
    private readonly ValidationPlan<T, C> _plan;
    private readonly AsyncDataSession<ValidationReport> _session;

    public TimeSpan Debounce { get; }
    public FormValidationSnapshot Snapshot => Map(_session.Snapshot);
    public event Action<FormValidationSnapshot>? Changed;

    public FormValidationSession(ValidationPlan<T, C> plan, Action<Action>? dispatch = null)
        : this(plan, TimeSpan.Zero, dispatch) { }

    public FormValidationSession(ValidationPlan<T, C> plan, TimeSpan debounce, Action<Action>? dispatch = null)
    {
        ArgumentNullException.ThrowIfNull(plan);
        if (debounce < TimeSpan.Zero) throw new ArgumentOutOfRangeException(nameof(debounce));
        Debounce = debounce;
        _plan = plan;
        _session = new(dispatch);
        _session.Changed += snapshot => Changed?.Invoke(Map(snapshot));
    }

    /// <summary>Recibe una instantánea del formulario y un contexto por ejecución; el retraso es cancelable.</summary>
    /// <remarks>Para código nuevo, usar UpdateWithResultAsync para recibir FormValidationOperationResult.</remarks>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public ValueTask<DataOperationResult<ValidationReport>> UpdateAsync(T candidate, C context, CancellationToken cancellationToken = default) => ValidateWithResultAsync(candidate, context, Debounce, cancellationToken);

    /// <summary>Actualiza el formulario y devuelve un resultado con estados de validación.</summary>
    public ValueTask<FormValidationOperationResult> UpdateWithResultAsync(T candidate, C context, CancellationToken cancellationToken = default) => EvaluateAsync(candidate, context, Debounce, cancellationToken);

    /// <summary>Evalúa inmediatamente salvo que se indique un retraso explícito.</summary>
    /// <remarks>Para código nuevo que necesita el resultado, usar EvaluateAsync.</remarks>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public ValueTask ValidateAsync(T candidate, C context, TimeSpan delay = default, CancellationToken cancellationToken = default)
    {
        if (delay < TimeSpan.Zero) throw new ArgumentOutOfRangeException(nameof(delay));
        return _session.RunAsync(async token =>
        {
            if (delay > TimeSpan.Zero) await Task.Delay(delay, token).ConfigureAwait(false);
            return await _plan.ValidateAsync(candidate, context, token).ConfigureAwait(false);
        }, cancellationToken);
    }

    /// <summary>Devuelve el resultado calculado sin esperar al dispatcher de la UI.</summary>
    /// <remarks>Para código nuevo, usar EvaluateAsync para recibir estados de formulario.</remarks>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public ValueTask<DataOperationResult<ValidationReport>> ValidateWithResultAsync(T candidate, C context, TimeSpan delay = default, CancellationToken cancellationToken = default)
    {
        if (delay < TimeSpan.Zero) throw new ArgumentOutOfRangeException(nameof(delay));
        return _session.RunWithResultAsync(async token =>
        {
            if (delay > TimeSpan.Zero) await Task.Delay(delay, token).ConfigureAwait(false);
            return await _plan.ValidateAsync(candidate, context, token).ConfigureAwait(false);
        }, cancellationToken);
    }

    /// <summary>Evalúa y devuelve el informe con el mismo vocabulario que usa el formulario.</summary>
    public async ValueTask<FormValidationOperationResult> EvaluateAsync(T candidate, C context, TimeSpan delay = default, CancellationToken cancellationToken = default)
    {
        var operation = await ValidateWithResultAsync(candidate, context, delay, cancellationToken).ConfigureAwait(false);
        return Map(operation);
    }

    public void Dispose() { _session.Dispose(); Changed = null; }

    private static FormValidationSnapshot Map(DataSnapshot<ValidationReport> snapshot) => new(snapshot.Version, snapshot.State switch
    {
        DataState.Idle => FormValidationState.Idle,
        DataState.Pending => FormValidationState.Pending,
        DataState.Ready => snapshot.Value!.IsValid ? FormValidationState.Valid : FormValidationState.Invalid,
        DataState.Failed => FormValidationState.Failed,
        _ => FormValidationState.Canceled
    }, snapshot.Value, snapshot.Error);

    private static FormValidationOperationResult Map(DataOperationResult<ValidationReport> operation)
    {
        var snapshot = Map(operation.Snapshot);
        return new(snapshot.Version, snapshot.State, snapshot.Report, snapshot.Error, operation.IsCurrentAtCompletion);
    }
}