using AcDream.Core.Physics;
using AcDream.Headless.Configuration;
using AcDream.Headless.Hosting;

namespace AcDream.Headless.Tests;

/// <summary>
/// #365 Step 1: the audit's refusal rationale is multi-root attribution
/// ambiguity, which does not hold for a process that owns exactly one
/// session. These tests mutate <see cref="PhysicsDiagnostics"/> process-
/// global probe flags and swap <see cref="Console.Out"/>, so they run in
/// their own non-parallel collection — see
/// <see cref="HeadlessStaticStateAuditCollection"/>.
/// </summary>
[CollectionDefinition(
    HeadlessStaticStateAuditCollection.Name,
    DisableParallelization = true)]
public sealed class HeadlessStaticStateAuditCollection
{
    public const string Name = "Headless static-state audit";
}

[Collection(HeadlessStaticStateAuditCollection.Name)]
public sealed class HeadlessStaticStateAuditTests : IDisposable
{
    public HeadlessStaticStateAuditTests() => PhysicsDiagnostics.ResetForTest();

    public void Dispose() => PhysicsDiagnostics.ResetForTest();

    [Fact]
    public void SingleSessionWithProbeEnabledIsAllowedAndLoggedLoudly()
    {
        PhysicsDiagnostics.ProbeParkEnabled = true;
        var originalOut = Console.Out;
        using var captured = new StringWriter();
        Console.SetOut(captured);
        try
        {
            HeadlessStaticStateAudit.ValidateProcessIsolation(sessionCount: 1);
        }
        finally
        {
            Console.SetOut(originalOut);
        }

        Assert.Contains(
            nameof(PhysicsDiagnostics.ProbeParkEnabled),
            captured.ToString(),
            StringComparison.Ordinal);
    }

    [Fact]
    public void SingleSessionWithNoProbesEnabledIsSilent()
    {
        var originalOut = Console.Out;
        using var captured = new StringWriter();
        Console.SetOut(captured);
        try
        {
            HeadlessStaticStateAudit.ValidateProcessIsolation(sessionCount: 1);
        }
        finally
        {
            Console.SetOut(originalOut);
        }

        Assert.Equal(string.Empty, captured.ToString());
    }

    [Fact]
    public void MultiSessionWithProbeEnabledStillThrowsNamingTheProbe()
    {
        PhysicsDiagnostics.ProbeParkEnabled = true;

        HeadlessConfigurationException exception = Assert.Throws<
            HeadlessConfigurationException>(
                () => HeadlessStaticStateAudit.ValidateProcessIsolation(
                    sessionCount: 2));

        Assert.Contains(
            nameof(PhysicsDiagnostics.ProbeParkEnabled),
            exception.Message,
            StringComparison.Ordinal);
    }

    [Fact]
    public void MultiSessionWithNoProbesEnabledIsAllowed()
    {
        Exception? exception = Record.Exception(
            () => HeadlessStaticStateAudit.ValidateProcessIsolation(
                sessionCount: 3));

        Assert.Null(exception);
    }
}