namespace Greencore.platform.rules;

/// <summary>Una aparición de una regla o un operador dentro de un árbol.</summary>
public sealed class RuleNode<T, TContext>
{
    public string NodeId { get; }
    public string? Path { get; }
    public RuleNodeKind Kind { get; }
    public RuleDefinition<T, TContext>? Definition { get; }
    public IReadOnlyList<RuleNode<T, TContext>> Children { get; }
    public bool IsAsync => Definition?.IsAsync == true || Children.Any(child => child.IsAsync);

    public RuleNode(string nodeId, RuleNodeKind kind, IEnumerable<RuleNode<T, TContext>> children, RuleDefinition<T, TContext>? definition = null, string? path = null)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(nodeId);
        ArgumentNullException.ThrowIfNull(children);
        if (!Enum.IsDefined(kind)) throw new ArgumentOutOfRangeException(nameof(kind));
        var copy = children.ToArray();
        foreach (var child in copy) ArgumentNullException.ThrowIfNull(child);
        var valid = kind switch
        {
            RuleNodeKind.Leaf => definition is not null && copy.Length == 0,
            RuleNodeKind.Not => definition is null && copy.Length == 1,
            RuleNodeKind.When or RuleNodeKind.Prerequisite => definition is null && copy.Length == 2,
            _ => definition is null && copy.Length > 0
        };
        if (!valid) throw new ArgumentException("Invalid children or definition for this operator.");
        NodeId = nodeId;
        Kind = kind;
        Definition = definition;
        Path = path;
        Children = Array.AsReadOnly(copy);
        var ids = new HashSet<string>(StringComparer.Ordinal);
        ValidateIds(this, ids);
    }

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

/// <summary>Construcción explícita de operadores sin precedencia implícita.</summary>
public static class RuleTree
{
    public static RuleNode<T, C> AllOf<T, C>(string id, params RuleNode<T, C>[] children) => new(id, RuleNodeKind.AllOf, children);
    public static RuleNode<T, C> AnyOf<T, C>(string id, params RuleNode<T, C>[] children) => new(id, RuleNodeKind.AnyOf, children);
    public static RuleNode<T, C> Not<T, C>(string id, RuleNode<T, C> child) => new(id, RuleNodeKind.Not, [child]);
    public static RuleNode<T, C> When<T, C>(string id, RuleNode<T, C> condition, RuleNode<T, C> child) => new(id, RuleNodeKind.When, [condition, child]);
    public static RuleNode<T, C> Require<T, C>(string id, RuleNode<T, C> condition, RuleNode<T, C> child) => new(id, RuleNodeKind.Prerequisite, [condition, child]);
}

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

/// <summary>Constructor fluido; cada operación devuelve una configuración independiente.</summary>
public sealed class RuleTreeBuilder<T, C>
{
    private readonly RuleNode<T, C>? _root;

    public RuleTreeBuilder() { }
    private RuleTreeBuilder(RuleNode<T, C> root) => _root = root;

    public RuleTreeBuilder<T, C> Add(RuleNode<T, C> node)
    {
        ArgumentNullException.ThrowIfNull(node);
        if (_root is not null) throw new InvalidOperationException("Use an explicit group to combine nodes.");
        return new(node);
    }

    public RuleTreeBuilder<T, C> Require(RuleNode<T, C> node) => Add(node);
    public RuleTreeBuilder<T, C> Then(string id, RuleNode<T, C> node) => new(RuleTree.Require(id, Build(), node));
    public RuleTreeBuilder<T, C> AllOf(string id, params RuleNode<T, C>[] nodes) => Add(RuleTree.AllOf(id, nodes));
    public RuleTreeBuilder<T, C> AnyOf(string id, params RuleNode<T, C>[] nodes) => Add(RuleTree.AnyOf(id, nodes));
    public RuleTreeBuilder<T, C> When(string id, RuleNode<T, C> condition) => new(RuleTree.When(id, condition, Build()));
    public RuleTreeBuilder<T, C> Unless(string id, RuleNode<T, C> condition) => When(id, RuleTree.Not(id + ".condition", condition));
    public RuleNode<T, C> Build() => _root ?? throw new InvalidOperationException("An empty tree cannot be built.");
}