using TUnit.Mocks.Matchers;

namespace TUnit.Mocks.Arguments;

/// <summary>
/// Represents a typed argument matcher used in mock setup and verification expressions.
/// Implicitly converts from raw values for convenient inline usage.
/// Every Arg supports value capture — store it in a variable and read <see cref="Values"/>
/// after the mock is exercised.
/// </summary>
/// <typeparam name="T">The type of the argument being matched.</typeparam>
public readonly struct Arg<T>
{
    private readonly CapturingMatcher<T> _capturingMatcher;

    /// <summary>Gets the argument matcher. Public for generated code access. Not intended for direct use.</summary>
    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    public IArgumentMatcher Matcher => _capturingMatcher;

    /// <summary>Creates an Arg with a matcher. Public for generated code access. Not intended for direct use.</summary>
    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    public Arg(IArgumentMatcher matcher)
    {
        _capturingMatcher = new CapturingMatcher<T>(matcher);
    }

    /// <summary>Gets all captured values in order of capture.</summary>
    public IReadOnlyList<T?> Values => _capturingMatcher.CapturedValues;

    /// <summary>Gets the most recently captured value, or default if none captured.</summary>
    public T? Latest => _capturingMatcher.Latest;

    /// <summary>Implicitly converts a raw value to an <see cref="Arg{T}"/> using exact equality matching.</summary>
    /// <param name="value">The value to match against.</param>
    /// <exception cref="ArgumentException">
    /// When <paramref name="value"/> is itself a boxed <see cref="Arg{T}"/> — e.g. <c>Is(1)</c>
    /// converted into an <c>Arg&lt;object&gt;</c> slot, which could never match. Thrown by
    /// <see cref="ExactMatcher{T}"/>.
    /// </exception>
    public static implicit operator Arg<T>(T value) => new(new ExactMatcher<T>(value));

    /// <summary>Implicitly converts a predicate to an <see cref="Arg{T}"/> using predicate matching.</summary>
    /// <param name="predicate">The predicate that determines whether an argument matches.</param>
    public static implicit operator Arg<T>(Func<T, bool> predicate) => new(new PredicateMatcher<T>(predicate!));

    public static implicit operator Arg<T>(AnyArg _) => new(AnyMatcher<T>.Instance);

    /// <summary>Converts <see cref="Arg.IsOfType{TDerived}"/> into a type matcher for this parameter type.</summary>
    public static implicit operator Arg<T>(OfTypeArg ofType) => new(new TypeMatcher<T>(ofType.Type));

    /// <summary>Converts <see cref="Arg.IsSameAs(object)"/> into a reference-equality matcher for this parameter type.</summary>
    public static implicit operator Arg<T>(SameAsArg sameAs) => new(new ReferenceEqualsMatcher<T>(sameAs.Reference));
}