namespace Greencore.platform.rules;

/// <summary>Resultado explícito de una condición; la evidencia pertenece a esta ejecución.</summary>
public sealed record ConditionResult(bool IsSatisfied, object? Evidence = null);

public enum RuleNodeKind { Leaf, AllOf, AnyOf, Not, When, Prerequisite }

/// <summary>Definición identificable e inmutable, sin referencias a datos de una ejecución.</summary>
public sealed class RuleDefinition<T, TContext>
{
    public string Id { get; }
    public bool IsAsync { get; }
    public Func<T, TContext, ConditionResult>? Condition { get; }
    public Func<T, TContext, CancellationToken, ValueTask<ConditionResult>> AsyncCondition { get; }

    public RuleDefinition(string id, Func<T, TContext, ConditionResult> condition)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(id);
        ArgumentNullException.ThrowIfNull(condition);
        Id = id;
        Condition = condition;
        AsyncCondition = (value, context, _) => ValueTask.FromResult(condition(value, context));
    }

    public RuleDefinition(string id, Func<T, TContext, CancellationToken, ValueTask<ConditionResult>> condition)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(id);
        ArgumentNullException.ThrowIfNull(condition);
        Id = id;
        IsAsync = true;
        AsyncCondition = condition;
    }

    public RuleNode<T, TContext> At(string nodeId, string? path = null) => new(nodeId, RuleNodeKind.Leaf, [], this, path);

    public RuleDefinition<TParent, TContext> Select<TParent>(Func<TParent, T> selector)
    {
        ArgumentNullException.ThrowIfNull(selector);
        return Condition is { } sync
            ? new(Id, (parent, context) => sync(selector(parent), context))
            : new(Id, (parent, context, token) => AsyncCondition(selector(parent), context, token));
    }
}

public readonly record struct NoRuleContext;

public static class RuleDefinition
{
    public static RuleDefinition<T, C> WithContext<T, C>(this RuleDefinition<T, NoRuleContext> definition)
    {
        ArgumentNullException.ThrowIfNull(definition);
        return definition.Condition is { } sync
            ? new(definition.Id, (value, _) => sync(value, default))
            : new(definition.Id, (value, _, token) => definition.AsyncCondition(value, default, token));
    }

    public static RuleDefinition<T, NoRuleContext> For<T>(string id, IRule<T> condition)
    {
        ArgumentNullException.ThrowIfNull(condition);
        return new(id, (value, _) => new(condition.IsSatisfiedBy(value)));
    }

    public static RuleDefinition<T, TContext> For<T, TContext>(string id, Func<T, TContext, bool> condition)
    {
        ArgumentNullException.ThrowIfNull(condition);
        return new(id, (value, context) => new(condition(value, context)));
    }

    public static RuleDefinition<T, TContext> ForAsync<T, TContext>(string id, Func<T, TContext, CancellationToken, ValueTask<bool>> condition)
    {
        ArgumentNullException.ThrowIfNull(condition);
        return new(id, async (value, context, token) => new(await condition(value, context, token).ConfigureAwait(false)));
    }
}