namespace ClawdDotNet.Manager.Tests;

/// <summary>
/// Ein Instanzprozess, den der Test steuert.
///
/// <para>Ein echter Prozess ließe die Aufsicht nur oberflächlich prüfen: Ein Absturz zum
/// gewünschten Zeitpunkt, ein Prozess, der lebt und schweigt, eine wiederverwendete
/// Prozesskennung — das alles ist mit einem laufenden Programm entweder nicht oder nur
/// mit Wartezeiten herzustellen, und Tests mit Wartezeiten sind Tests, die man
/// irgendwann abschaltet.</para>
/// </summary>
internal sealed class FakeProcess(int id, DateTimeOffset startedAt) : IInstanceProcess
{
    public int Id { get; } = id;

    public DateTimeOffset StartedAt { get; } = startedAt;

    public bool HasExited { get; private set; }

    public int? ExitCode { get; private set; }

    public bool WasKilled { get; private set; }

    public bool Disposed { get; private set; }

    /// <summary>Der Prozess endet — mit oder ohne Zutun.</summary>
    public void Exit(int code)
    {
        HasExited = true;
        ExitCode = code;
    }

    public void Kill()
    {
        WasKilled = true;
        if (!HasExited) Exit(-1);
    }

    public void Dispose() => Disposed = true;
}

internal sealed class FakeLauncher : IInstanceLauncher
{
    private int _nextId = 1000;

    public FakeProcess? Last { get; private set; }

    public int Starts { get; private set; }

    /// <summary>Wenn gesetzt, scheitert der Start damit.</summary>
    public Exception? FailStartWith { get; set; }

    /// <summary>Was <see cref="Attach"/> liefern soll — bereits laufende Prozesse.</summary>
    public Dictionary<int, FakeProcess> Running { get; } = [];

    public DateTimeOffset Now { get; set; } = DateTimeOffset.UnixEpoch;

    public IInstanceProcess Start(string instanceDirectory)
    {
        Starts++;

        if (FailStartWith is not null) throw FailStartWith;

        Last = new FakeProcess(_nextId++, Now);
        Running[Last.Id] = Last;
        return Last;
    }

    public IInstanceProcess? Attach(int processId, DateTimeOffset startedAt)
    {
        if (!Running.TryGetValue(processId, out var process))
            return null;

        // Dieselbe Pruefung wie im Echtbetrieb: gleiche Kennung, aber andere Startzeit
        // heisst anderer Prozess.
        return (process.StartedAt - startedAt).Duration() > TimeSpan.FromSeconds(2)
            ? null
            : process;
    }
}

/// <summary>Der Socket, den der Test antworten oder schweigen lässt.</summary>
internal sealed class FakeChannel : IInstanceChannel
{
    /// <summary>Die Antwort für alle Verzeichnisse, sofern keine eigene hinterlegt ist.</summary>
    public InstanceIdentity? Answer { get; set; }

    /// <summary>
    /// Antworten je Instanzverzeichnis.
    ///
    /// <para>Nötig, sobald mehr als eine Instanz im Spiel ist: Eine Auskunft, die für jedes
    /// Verzeichnis dieselbe Instanz nennt, lässt Tests grün werden, die im Betrieb zwei
    /// verschiedene Instanzen verwechseln würden.</para>
    /// </summary>
    public Dictionary<string, InstanceIdentity?> AnswerFor { get; } =
        new(StringComparer.OrdinalIgnoreCase);

    public int Calls { get; private set; }

    /// <summary>Wie oft die Instanz gebeten wurde, sich zu beenden.</summary>
    public int StopRequests { get; private set; }

    /// <summary>Ob die Bitte ankommt. Falsch heisst: Die Instanz hoert gar nicht mehr zu.</summary>
    public bool StopRequestArrives { get; set; } = true;

    public Task<InstanceIdentity?> AskAsync(string instanceDirectory, CancellationToken ct = default)
    {
        Calls++;

        return Task.FromResult(
            AnswerFor.TryGetValue(Path.GetFullPath(instanceDirectory), out var eigene)
                ? eigene
                : Answer);
    }

    public Task<bool> RequestStopAsync(string instanceDirectory, CancellationToken ct = default)
    {
        StopRequests++;
        return Task.FromResult(StopRequestArrives);
    }
}