using Greencore.platform.rules;

namespace Greencore.platform.validators;

/// <summary>Contrato de una regla completa, independiente de su aparición en el árbol.</summary>
public interface IValidationDefinition<T, C>
{
    RuleDefinition<T, C> Definition { get; }
    RuleDiagnosticDefinition Diagnostic { get; }
}

/// <summary>Marca una regla que puede utilizarse con cualquier contexto de ejecución.</summary>
public interface ILocalValidationDefinition<T> : IValidationDefinition<T, NoRuleContext> { }

public class ValidationDefinition<T, C> : IValidationDefinition<T, C>
{
    public RuleDefinition<T, C> Definition { get; }
    public RuleDiagnosticDefinition Diagnostic { get; }

    public ValidationDefinition(RuleDefinition<T, C> definition, RuleDiagnosticDefinition diagnostic)
    {
        ArgumentNullException.ThrowIfNull(definition);
        ArgumentNullException.ThrowIfNull(diagnostic);
        Definition = definition;
        Diagnostic = diagnostic;
    }
}

public sealed class LocalValidationDefinition<T> : ValidationDefinition<T, NoRuleContext>, ILocalValidationDefinition<T>
{
    public LocalValidationDefinition(RuleDefinition<T, NoRuleContext> definition, RuleDiagnosticDefinition diagnostic) : base(definition, diagnostic) { }
}

/// <summary>Vincula condición y evidencia por tipo antes de construir el mensaje.</summary>
public sealed record ConditionResult<TEvidence>(bool IsSatisfied, TEvidence Evidence);

public static class ValidationRule
{
    public static LocalValidationDefinition<T> ForAsync<T>(string id, Func<T, CancellationToken, ValueTask<bool>> condition, string code, string message)
    {
        ArgumentNullException.ThrowIfNull(condition);
        return new(RuleDefinition.ForAsync<T, NoRuleContext>(id, (value, _, token) => condition(value, token)), new(code, message));
    }

    /// <summary>Adapta directamente una regla asíncrona local a una definición diagnosticable.</summary>
    public static LocalValidationDefinition<T> ForAsync<T>(string id, IAsyncRule<T> condition, string code, string message)
    {
        ArgumentNullException.ThrowIfNull(condition);
        return ForAsync<T>(id, condition.IsSatisfiedByAsync, code, message);
    }

    public static ValidationDefinition<T, C> WithEvidence<T, C, E>(string id, Func<T, C, ConditionResult<E>> condition, string code, Func<E, string> message)
    {
        ArgumentNullException.ThrowIfNull(condition);
        ArgumentNullException.ThrowIfNull(message);
        return new(new(id, (value, context) =>
        {
            var result = condition(value, context) ?? throw new InvalidOperationException("The condition returned no result.");
            return new(result.IsSatisfied, result.Evidence);
        }), new(code, evaluation => message((E)evaluation.Evidence!)));
    }

    public static LocalValidationDefinition<T> WithEvidenceAsync<T, E>(string id, Func<T, CancellationToken, ValueTask<ConditionResult<E>>> condition, string code, Func<E, string> message)
    {
        ArgumentNullException.ThrowIfNull(condition);
        var definition = WithEvidenceAsync<T, NoRuleContext, E>(id, (value, _, token) => condition(value, token), code, message);
        return new(definition.Definition, definition.Diagnostic);
    }

    public static LocalValidationDefinition<T> For<T>(string id, IRule<T> condition, string code, string message) => new(RuleDefinition.For(id, condition), new(code, message));

    public static LocalValidationDefinition<T> For<T>(string id, Func<T, bool> condition, string code, string message) => For(id, new PredicateRule<T>(condition), code, message);

    public static ValidationDefinition<T, C> For<T, C>(string id, Func<T, C, bool> condition, string code, string message) => new(RuleDefinition.For(id, condition), new(code, message));

    public static ValidationDefinition<T, C> ForAsync<T, C>(string id, Func<T, C, CancellationToken, ValueTask<bool>> condition, string code, string message) => new(RuleDefinition.ForAsync(id, condition), new(code, message));

    /// <summary>Adapta directamente una regla asíncrona que recibe contexto.</summary>
    public static ValidationDefinition<T, C> ForAsync<T, C>(string id, IContextRule<T, C> condition, string code, string message)
    {
        ArgumentNullException.ThrowIfNull(condition);
        return ForAsync<T, C>(id, condition.IsSatisfiedByAsync, code, message);
    }

    public static LocalValidationDefinition<T> WithEvidence<T, E>(string id, Func<T, ConditionResult<E>> condition, string code, Func<E, string> message)
    {
        ArgumentNullException.ThrowIfNull(condition);
        ArgumentNullException.ThrowIfNull(message);
        return new(new(id, (value, _) =>
        {
            var result = condition(value) ?? throw new InvalidOperationException("The condition returned no result.");
            return new(result.IsSatisfied, result.Evidence);
        }), new(code, evaluation => message((E)evaluation.Evidence!)));
    }

    public static ValidationDefinition<T, C> WithEvidenceAsync<T, C, E>(string id, Func<T, C, CancellationToken, ValueTask<ConditionResult<E>>> condition, string code, Func<E, string> message)
    {
        ArgumentNullException.ThrowIfNull(condition);
        ArgumentNullException.ThrowIfNull(message);
        return new(new(id, async (value, context, token) =>
        {
            var result = await condition(value, context, token).ConfigureAwait(false) ?? throw new InvalidOperationException("The condition returned no result.");
            return new(result.IsSatisfied, result.Evidence);
        }), new(code, evaluation => message((E)evaluation.Evidence!)));
    }
}