using System.ComponentModel;
using Greencore.platform.rules;

namespace Greencore.platform.validators;

/// <summary>Selecciona resúmenes por campo, detalles terminales o el árbol completo.</summary>
public enum DiagnosticView { Summary, Details, All }

public sealed record ValidationReport(RuleEvaluation Evaluation, IReadOnlyList<RuleDiagnostic> Diagnostics)
{
    public bool IsValid => Evaluation.Status != RuleStatus.Unsatisfied;

    /// <summary>Recorre el árbol sin perder la distinción entre grupos y detalles.</summary>
    public IEnumerable<RuleDiagnostic> EnumerateDiagnostics(bool includeGroups = true)
    {
        var pending = new Stack<RuleDiagnostic>(Diagnostics.Reverse());
        while (pending.TryPop(out var diagnostic))
        {
            if (includeGroups || diagnostic.Children.Count == 0) yield return diagnostic;
            foreach (var child in diagnostic.Children.Reverse()) pending.Push(child);
        }
    }

    public IReadOnlyList<RuleDiagnostic> ForField(string path, bool includeGroups = false)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
        return EnumerateDiagnostics(includeGroups).Where(item => item.Path == path).ToArray();
    }

    public IReadOnlyList<RuleDiagnostic> ForField<T, V>(System.Linq.Expressions.Expression<Func<T, V>> property, bool includeGroups = false) => ForField(ValidationPath.Get(property), includeGroups);

    /// <summary>Devuelve mensajes del campo sin repetir resúmenes y detalles de la misma rama.</summary>
    public IReadOnlyList<RuleDiagnostic> ForField(string path, DiagnosticView view)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
        if (!Enum.IsDefined(view)) throw new ArgumentOutOfRangeException(nameof(view));
        if (view != DiagnosticView.Summary) return ForField(path, view == DiagnosticView.All);
        var result = new List<RuleDiagnostic>();
        var pending = new Stack<RuleDiagnostic>(Diagnostics.Reverse());
        while (pending.TryPop(out var item))
        {
            if (item.Path == path) result.Add(item);
            else foreach (var child in item.Children.Reverse()) pending.Push(child);
        }
        return result.AsReadOnly();
    }

    public IReadOnlyList<RuleDiagnostic> ForField<T, V>(System.Linq.Expressions.Expression<Func<T, V>> property, DiagnosticView view) => ForField(ValidationPath.Get(property), view);
}

/// <summary>Plan listo para evaluar, con árbol y diagnósticos comprobados al construir.</summary>
public sealed class ValidationPlan<T, C>
{
    public RuleNode<T, C> Tree { get; }
    public RuleDiagnostics Diagnostics { get; }

    public FormValidationSession<T, C> CreateSession(Action<Action>? dispatch = null) => new(this, dispatch);

    public FormValidationSession<T, C> CreateSession(TimeSpan debounce, Action<Action>? dispatch = null) => new(this, debounce, dispatch);

    public ValidationPlan(RuleNode<T, C> tree, RuleDiagnostics diagnostics)
    {
        ArgumentNullException.ThrowIfNull(tree);
        ArgumentNullException.ThrowIfNull(diagnostics);
        diagnostics.Validate(tree);
        Tree = tree;
        Diagnostics = diagnostics;
    }

    public ValidationReport Validate(T value, C context, RuleEvaluationOptions? options = null, CancellationToken cancellationToken = default)
    {
        var result = RuleEvaluator.Evaluate(Tree, value, context, options, cancellationToken);
        return new(result, Diagnostics.Project(result));
    }

    public async ValueTask<ValidationReport> ValidateAsync(T value, C context, CancellationToken cancellationToken = default, RuleEvaluationOptions? options = null)
    {
        var result = await RuleEvaluator.EvaluateAsync(Tree, value, context, options, cancellationToken).ConfigureAwait(false);
        return new(result, Diagnostics.Project(result));
    }
}

public static class LocalValidationExtensions
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static ValueTask<DataOperationResult<ValidationReport>> UpdateAsync<T>(this FormValidationSession<T, NoRuleContext> session, T candidate, CancellationToken cancellationToken = default) => session.UpdateAsync(candidate, default, cancellationToken);
    public static ValueTask<FormValidationOperationResult> UpdateWithResultAsync<T>(this FormValidationSession<T, NoRuleContext> session, T candidate, CancellationToken cancellationToken = default) => session.UpdateWithResultAsync(candidate, default, cancellationToken);
    public static ValueTask<FormValidationOperationResult> EvaluateAsync<T>(this FormValidationSession<T, NoRuleContext> session, T candidate, TimeSpan delay = default, CancellationToken cancellationToken = default) => session.EvaluateAsync(candidate, default, delay, cancellationToken);
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static ValueTask<DataOperationResult<ValidationReport>> ValidateWithResultAsync<T>(this FormValidationSession<T, NoRuleContext> session, T candidate, TimeSpan delay = default, CancellationToken cancellationToken = default) => session.ValidateWithResultAsync(candidate, default, delay, cancellationToken);
    public static ValidationBuilder<T, C> Include<T, C>(this ValidationBuilder<T, C> builder, ValidationPlan<T, NoRuleContext> plan)
    {
        ArgumentNullException.ThrowIfNull(plan);
        RuleNode<T, C> Lift(RuleNode<T, NoRuleContext> node) => new(node.NodeId, node.Kind, node.Children.Select(Lift), node.Definition?.WithContext<T, C>(), node.Path);
        return builder.Include(new ValidationPlan<T, C>(Lift(plan.Tree), plan.Diagnostics));
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public static ValueTask ValidateAsync<T>(this FormValidationSession<T, NoRuleContext> session, T candidate, TimeSpan delay = default, CancellationToken cancellationToken = default) => session.ValidateAsync(candidate, default, delay, cancellationToken);

    public static ValidationReport Validate<T>(this ValidationPlan<T, NoRuleContext> plan, T value, RuleEvaluationOptions? options = null, CancellationToken cancellationToken = default) => plan.Validate(value, default, options, cancellationToken);
    public static ValueTask<ValidationReport> ValidateAsync<T>(this ValidationPlan<T, NoRuleContext> plan, T value, CancellationToken cancellationToken = default) => plan.ValidateAsync(value, default, cancellationToken);
    public static ValueTask<ValidationReport> ValidateAsync<T>(this ValidationPlan<T, NoRuleContext> plan, T value, RuleEvaluationOptions options, CancellationToken cancellationToken = default) => plan.ValidateAsync(value, default, cancellationToken, options);
}