using System.Linq.Expressions;
using System.Reflection;
using Greencore.platform.rules;

namespace Greencore.platform.validators;

public static class Validation
{
    public static ValidationBuilder<T, NoRuleContext> For<T>() => new();
    public static ValidationBuilder<T, C> For<T, C>() => new();
}

/// <summary>Constructor mutable de configuración; Build publica una instantánea independiente.</summary>
public sealed class ValidationBuilder<T, C>
{
    private readonly List<ConfiguredRule<T, C>> _nodes = [];

    public ValidationBuilder<T, C> Add(IValidationDefinition<T, C> rule, string? nodeId = null) => Append(Leaf(rule, nodeId));
    public ValidationBuilder<T, C> Add(ILocalValidationDefinition<T> rule, string? nodeId = null) => Add(Lift(rule), nodeId);
    public ValidationBuilder<T, C> Require(IValidationDefinition<T, C> rule, string? nodeId = null) => Add(rule, nodeId);
    public ValidationBuilder<T, C> Require(ILocalValidationDefinition<T> rule, string? nodeId = null) => Add(rule, nodeId);

    /// <summary>La nueva regla depende únicamente de la última rama registrada.</summary>
    public ValidationBuilder<T, C> Then(IValidationDefinition<T, C> rule, string? nodeId = null) => ThenNode(Leaf(rule, nodeId));
    public ValidationBuilder<T, C> Then(ILocalValidationDefinition<T> rule, string? nodeId = null) => Then(Lift(rule), nodeId);

    public ValidationBuilder<T, C> Then(Action<ValidationBuilder<T, C>> configure) => ThenNode(Group(RuleNodeKind.AllOf, configure));
    public ValidationBuilder<T, C> AllOf(Action<ValidationBuilder<T, C>> configure) => Append(Group(RuleNodeKind.AllOf, configure));

    /// <summary>Cada rama depende del éxito de todas las ramas anteriores de la secuencia.</summary>
    public ValidationBuilder<T, C> Sequence(Action<ValidationBuilder<T, C>> configure)
    {
        var nodes = Group(RuleNodeKind.AllOf, configure).Children;
        var chain = nodes[0];
        foreach (var node in nodes.Skip(1)) chain = new(RuleNodeKind.Prerequisite, [chain, node]);
        return Append(chain);
    }

    /// <summary>Incluye una composición con identidades nuevas por aparición, conservando las rutas.</summary>
    public ValidationBuilder<T, C> Include(ValidationPlan<T, C> plan)
    {
        ArgumentNullException.ThrowIfNull(plan);
        return Append(Import(plan.Tree, plan.Diagnostics));
    }

    public ValidationBuilder<T, C> OptionalObject<V>(Expression<Func<T, V?>> property, Action<ValidationBuilder<V, C>> configure) where V : class
    {
        var path = ValidationPath.Get(property);
        var select = property.Compile();
        var child = Map(ValidationBuilder<V, C>.Group(RuleNodeKind.AllOf, configure), value => select(value)!, path);
        var gate = new ConfiguredRule<T, C>(RuleNodeKind.Leaf, [], RuleDefinition.For<T, C>("object.present", (value, _) => select(value) is not null), Path: path);
        return Append(new(RuleNodeKind.When, [gate, child]));
    }

    public ValidationBuilder<T, C> RequiredObject<V>(Expression<Func<T, V?>> property, Action<ValidationBuilder<V, C>> configure, string code, string message) where V : class
    {
        var path = ValidationPath.Get(property);
        var select = property.Compile();
        var child = Map(ValidationBuilder<V, C>.Group(RuleNodeKind.AllOf, configure), value => select(value)!, path);
        var gate = new ConfiguredRule<T, C>(RuleNodeKind.Leaf, [], RuleDefinition.For<T, C>("object.required", (value, _) => select(value) is not null), new(code, message), Path: path);
        return Append(new(RuleNodeKind.Prerequisite, [gate, child]));
    }

    public ValidationBuilder<T, C> AnyOf(Action<ValidationBuilder<T, C>> configure, string code, string message) => Append(Group(RuleNodeKind.AnyOf, configure, new(code, message)));

    public ValidationBuilder<T, C> Not(Action<ValidationBuilder<T, C>> configure, string code, string message) => Append(new(RuleNodeKind.Not, [Group(RuleNodeKind.AllOf, configure)], Diagnostic: new(code, message)));

    /// <summary>La condición afecta solamente al contenido del callback.</summary>
    public ValidationBuilder<T, C> When(Func<T, bool> condition, Action<ValidationBuilder<T, C>> configure)
    {
        ArgumentNullException.ThrowIfNull(condition);
        return When((value, _) => condition(value), configure);
    }

    public ValidationBuilder<T, C> When(Func<T, C, bool> condition, Action<ValidationBuilder<T, C>> configure)
    {
        ArgumentNullException.ThrowIfNull(condition);
        var gate = new ConfiguredRule<T, C>(RuleNodeKind.Leaf, [], RuleDefinition.For<T, C>("condition", condition));
        return Append(new(RuleNodeKind.When, [gate, Group(RuleNodeKind.AllOf, configure)]));
    }

    public ValidationBuilder<T, C> Unless(Func<T, bool> condition, Action<ValidationBuilder<T, C>> configure)
    {
        ArgumentNullException.ThrowIfNull(condition);
        return When(value => !condition(value), configure);
    }

    public ValidationBuilder<T, C> Field<V>(Expression<Func<T, V>> property, Action<ValidationBuilder<V, C>> configure)
    {
        var path = ValidationPath.Get(property);
        var selector = property.Compile();
        var group = ValidationBuilder<V, C>.Group(RuleNodeKind.AllOf, configure);
        return Append(Map(group, selector, path));
    }

    /// <summary>Valida un campo en secuencia; cada regla depende del éxito de las anteriores.</summary>
    public ValidationBuilder<T, C> FieldSequence<V>(Expression<Func<T, V>> property, Action<ValidationBuilder<V, C>> configure)
    {
        ArgumentNullException.ThrowIfNull(configure);
        return Field(property, field => field.Sequence(configure));
    }

    public ValidationPlan<T, C> Build()
    {
        if (_nodes.Count == 0) throw new InvalidOperationException("Configure at least one rule.");
        var registrations = new Dictionary<string, RuleDiagnosticDefinition>(StringComparer.Ordinal);
        var root = new ConfiguredRule<T, C>(RuleNodeKind.AllOf, _nodes.ToArray());
        var explicitIds = new HashSet<string>(StringComparer.Ordinal);
        CollectIds(root, explicitIds);
        var next = 0;
        var tree = Materialize(root, registrations, explicitIds, ref next);
        return new(tree, new RuleDiagnostics(registrations));
    }

    private static void CollectIds(ConfiguredRule<T, C> node, HashSet<string> ids)
    {
        if (node.NodeId is { } id && !ids.Add(id)) throw new ArgumentException($"Duplicate node id: {id}.");
        foreach (var child in node.Children) CollectIds(child, ids);
    }

    private static ConfiguredRule<T, C> Import(RuleNode<T, C> node, RuleDiagnostics diagnostics) => new(node.Kind, node.Children.Select(child => Import(child, diagnostics)).ToArray(), node.Definition, diagnostics.Find(node.NodeId), Path: node.Path);

    private static RuleNode<T, C> Materialize(ConfiguredRule<T, C> node, Dictionary<string, RuleDiagnosticDefinition> diagnostics, HashSet<string> ids, ref int next)
    {
        var id = node.NodeId;
        if (id is null)
        {
            do { id = $"node.{next++}"; } while (!ids.Add(id));
        }
        if (node.Diagnostic is { } diagnostic) diagnostics.Add(id, diagnostic);
        var children = new List<RuleNode<T, C>>();
        foreach (var child in node.Children) children.Add(Materialize(child, diagnostics, ids, ref next));
        return new(id, node.Kind, children, node.Definition, node.Path);
    }

    private static ConfiguredRule<T, C> Map<V>(ConfiguredRule<V, C> node, Func<T, V> selector, string prefix) => new(node.Kind, node.Children.Select(child => Map(child, selector, prefix)).ToArray(), node.Definition?.Select(selector), node.Diagnostic, node.NodeId, node.Path is null ? prefix : $"{prefix}.{node.Path}");

    private static IValidationDefinition<T, C> Lift(ILocalValidationDefinition<T> rule)
    {
        ArgumentNullException.ThrowIfNull(rule);
        return new ValidationDefinition<T, C>(rule.Definition.WithContext<T, C>(), rule.Diagnostic);
    }

    private static ConfiguredRule<T, C> Leaf(IValidationDefinition<T, C> rule, string? nodeId)
    {
        ArgumentNullException.ThrowIfNull(rule);
        ArgumentNullException.ThrowIfNull(rule.Definition);
        ArgumentNullException.ThrowIfNull(rule.Diagnostic);
        if (nodeId is not null) ArgumentException.ThrowIfNullOrWhiteSpace(nodeId);
        return new(RuleNodeKind.Leaf, [], rule.Definition, rule.Diagnostic, nodeId);
    }

    private static ConfiguredRule<T, C> Group(RuleNodeKind kind, Action<ValidationBuilder<T, C>> configure, RuleDiagnosticDefinition? diagnostic = null)
    {
        ArgumentNullException.ThrowIfNull(configure);
        var builder = new ValidationBuilder<T, C>();
        configure(builder);
        if (builder._nodes.Count == 0) throw new ArgumentException("A group must contain at least one rule.", nameof(configure));
        return new(kind, builder._nodes.ToArray(), Diagnostic: diagnostic);
    }

    private ValidationBuilder<T, C> Append(ConfiguredRule<T, C> node) { _nodes.Add(node); return this; }

    private ValidationBuilder<T, C> ThenNode(ConfiguredRule<T, C> node)
    {
        if (_nodes.Count == 0) throw new InvalidOperationException("Then requires a preceding rule or group.");
        _nodes[^1] = new(RuleNodeKind.Prerequisite, [_nodes[^1], node]);
        return this;
    }
}

internal sealed record ConfiguredRule<T, C>(RuleNodeKind Kind, IReadOnlyList<ConfiguredRule<T, C>> Children, RuleDefinition<T, C>? Definition = null, RuleDiagnosticDefinition? Diagnostic = null, string? NodeId = null, string? Path = null);

internal static class ValidationPath
{
    internal static string Get<T, V>(Expression<Func<T, V>> property)
    {
        ArgumentNullException.ThrowIfNull(property);
        Expression? cursor = property.Body;
        while (cursor is UnaryExpression { NodeType: ExpressionType.Convert or ExpressionType.ConvertChecked } conversion) cursor = conversion.Operand;
        var names = new Stack<string>();
        while (cursor is MemberExpression { Member: PropertyInfo } member)
        {
            names.Push(member.Member.Name);
            cursor = member.Expression;
        }
        if (names.Count == 0 || cursor != property.Parameters[0]) throw new ArgumentException("Select a property path rooted in the candidate.", nameof(property));
        return string.Join(".", names);
    }
}