using System.Net.Sockets;
using Xunit;
using Xunit.Sdk;
using ZB.MOM.WW.OtOpcUa.Driver.AbLegacy.PlcFamilies;

namespace ZB.MOM.WW.OtOpcUa.Driver.AbLegacy.IntegrationTests;

/// <summary>
///     Reachability probe for the <c>ab_server</c> Docker container running in a PCCC
///     plc mode (<c>SLC500</c> / <c>Micrologix</c> / <c>PLC/5</c>). Same container image
///     the AB CIP integration suite uses — libplctag's <c>ab_server</c> supports both
///     CIP + PCCC families from one binary. Tests skip via
///     <see cref="AbLegacyFactAttribute"/> / <see cref="AbLegacyTheoryAttribute"/> when
///     the port isn't live, so <c>dotnet test</c> stays green on a fresh clone without
///     Docker running.
/// </summary>
/// <remarks>
///     Env-var overrides:
///     <list type="bullet">
///       <item><c>AB_LEGACY_ENDPOINT</c> — <c>host:port</c> of the PCCC-mode simulator.
///         Defaults to <c>10.100.0.35:44818</c> — the shared Docker host (EtherNet/IP port; ab_server's PCCC
///         emulation exposes PCCC-over-CIP on the same port as CIP itself).</item>
///       <item><c>AB_LEGACY_CIP_PATH</c> — routing path appended to the <c>ab://host:port/</c>
///         URI. Defaults to <c>1,0</c> (port-1/slot-0 backplane), required by ab_server
///         which rejects unconnected Send_RR_Data with an empty path at the CIP layer
///         before the PCCC dispatcher runs. Real SLC 5/05 / MicroLogix / PLC-5 hardware
///         use an empty path — set <c>AB_LEGACY_CIP_PATH=</c> (empty) when pointing at
///         real hardware.</item>
///     </list>
///     Distinct from <c>AB_SERVER_ENDPOINT</c> used by the AB CIP fixture so both
///     can point at different containers simultaneously during a combined test run.
/// </remarks>
public sealed class AbLegacyServerFixture : IAsyncLifetime
{
    private const string EndpointEnvVar = "AB_LEGACY_ENDPOINT";
    private const string CipPathEnvVar = "AB_LEGACY_CIP_PATH";

    /// <summary>Standard EtherNet/IP port. PCCC-over-CIP rides on the same port as
    /// native CIP; the differentiator is the <c>--plc</c> flag ab_server was started
    /// with, not a different TCP listener.</summary>
    public const int DefaultPort = 44818;

    /// <summary>
    ///     ab_server rejects unconnected Send_RR_Data with an empty CIP routing path
    ///     at the CIP layer — the PCCC dispatcher never runs. <c>1,0</c> is the generic
    ///     port-1/slot-0 backplane path; any well-formed path passes the gate. Real
    ///     hardware (SLC 5/05 / MicroLogix / PLC-5) uses an empty path because there's
    ///     no backplane to cross, so point <c>AB_LEGACY_CIP_PATH=</c> (empty) at real
    ///     hardware to exercise the authentic wire semantics.
    /// </summary>
    public const string DefaultCipPath = "1,0";

    // 10.100.0.35 = the shared Docker host (see CLAUDE.md "Docker Workflow"). Migrated
    // off this VM's 127.0.0.1 on 2026-04-28 alongside the rest of the Docker-host move.
    // Override via AB_LEGACY_ENDPOINT to point at a real PLC or a locally-running container.
    /// <summary>Gets the server host address.</summary>
    public string Host { get; } = "10.100.0.35";

    /// <summary>Gets the server TCP port.</summary>
    public int Port { get; } = DefaultPort;

    /// <summary>CIP routing path portion of the device URI (after the <c>/</c> separator).
    /// May be empty when targeting real hardware; non-empty against ab_server.</summary>
    public string CipPath { get; } = DefaultCipPath;

    /// <summary>Gets the skip reason if the server is unavailable, or null if available.</summary>
    public string? SkipReason { get; }

    /// <summary>Initializes the AB Legacy server fixture by reading environment overrides.</summary>
    public AbLegacyServerFixture()
    {
        if (Environment.GetEnvironmentVariable(EndpointEnvVar) is { Length: > 0 } raw)
        {
            var parts = raw.Split(':', 2);
            Host = parts[0];
            if (parts.Length == 2 && int.TryParse(parts[1], out var p)) Port = p;
        }

        // Empty override is intentional (real hardware); treat `null` as "not set, use
        // default" but preserve an explicit empty-string override.
        var cipOverride = Environment.GetEnvironmentVariable(CipPathEnvVar);
        if (cipOverride is not null) CipPath = cipOverride;

        SkipReason = ResolveSkipReason(Host, Port);
    }

    /// <summary>Initializes the fixture asynchronously.</summary>
    public ValueTask InitializeAsync() => ValueTask.CompletedTask;

    /// <summary>Disposes the fixture asynchronously.</summary>
    public ValueTask DisposeAsync() => ValueTask.CompletedTask;

    /// <summary>
    ///     Used by <see cref="AbLegacyFactAttribute"/> + <see cref="AbLegacyTheoryAttribute"/>
    ///     during test-class construction — gates whether the test runs at all. Duplicates the
    ///     fixture logic because attribute ctors fire before the collection fixture instance
    ///     exists.
    /// </summary>
    public static bool IsServerAvailable()
    {
        var (host, port) = ResolveEndpoint();
        return ResolveSkipReason(host, port) is null;
    }

    private static string? ResolveSkipReason(string host, int port)
    {
        if (!TcpProbe(host, port))
        {
            return $"AB Legacy PCCC endpoint at {host}:{port} not reachable within 2 s. " +
                   $"Start the Docker container (docker compose -f Docker/docker-compose.yml " +
                   $"--profile slc500 up -d), attach real hardware, or override {EndpointEnvVar}.";
        }
        return null;
    }

    private static (string Host, int Port) ResolveEndpoint()
    {
        var raw = Environment.GetEnvironmentVariable(EndpointEnvVar);
        if (raw is null) return ("10.100.0.35", DefaultPort);
        var parts = raw.Split(':', 2);
        var port = parts.Length == 2 && int.TryParse(parts[1], out var p) ? p : DefaultPort;
        return (parts[0], port);
    }

    private static bool TcpProbe(string host, int port)
    {
        try
        {
            using var client = new TcpClient();
            var task = client.ConnectAsync(host, port);
            return task.Wait(TimeSpan.FromSeconds(2)) && client.Connected;
        }
        catch { return false; }
    }
}

/// <summary>
///     Per-family marker for the PCCC-mode compose profile a given test targets. The
///     compose file (<c>Docker/docker-compose.yml</c>) is the canonical source of truth
///     for which <c>--plc</c> mode + tags each family seeds; this record just ties a
///     family enum to its compose-profile name + operator-facing notes.
/// </summary>
public sealed record AbLegacyServerProfile(
    AbLegacyPlcFamily Family,
    string ComposeProfile,
    string Notes);

/// <summary>Canonical profiles covering every PCCC family the driver supports.</summary>
public static class KnownProfiles
{
    public static readonly AbLegacyServerProfile Slc500 = new(
        Family: AbLegacyPlcFamily.Slc500,
        ComposeProfile: "slc500",
        Notes: "SLC 500 / 5/05 family. ab_server SLC500 mode covers N/F/B/L files.");

    public static readonly AbLegacyServerProfile MicroLogix = new(
        Family: AbLegacyPlcFamily.MicroLogix,
        ComposeProfile: "micrologix",
        Notes: "MicroLogix 1000 / 1100 / 1400. Shares N/F/B file-type coverage with SLC500; ST (ASCII strings) included.");

    public static readonly AbLegacyServerProfile Plc5 = new(
        Family: AbLegacyPlcFamily.Plc5,
        ComposeProfile: "plc5",
        Notes: "PLC-5 family. ab_server PLC/5 mode covers N/F/B; per-family quirks on ST / timer file layouts unit-tested only.");

    /// <summary>Gets all known profiles.</summary>
    public static IReadOnlyList<AbLegacyServerProfile> All { get; } =
        [Slc500, MicroLogix, Plc5];

    /// <summary>Gets the profile for the specified PLC family.</summary>
    /// <param name="family">The PLC family.</param>
    public static AbLegacyServerProfile ForFamily(AbLegacyPlcFamily family) =>
        All.FirstOrDefault(p => p.Family == family)
        ?? throw new ArgumentOutOfRangeException(nameof(family), family, "No integration profile for this family.");
}

[Xunit.CollectionDefinition(Name)]
public sealed class AbLegacyServerCollection : Xunit.ICollectionFixture<AbLegacyServerFixture>
{
    public const string Name = "AbLegacyServer";
}

/// <summary>
///     <c>[Fact]</c>-equivalent that skips when the PCCC endpoint isn't reachable.
///     See <see cref="AbLegacyServerFixture"/> for the exact skip semantics.
/// </summary>
public sealed class AbLegacyFactAttribute : FactAttribute
{
    /// <summary>Initializes the attribute, skipping the test if the server is unavailable.</summary>
    public AbLegacyFactAttribute()
    {
        if (!AbLegacyServerFixture.IsServerAvailable())
            Skip = "AB Legacy PCCC endpoint not reachable. Start the Docker fixture " +
                   "(docker compose -f Docker/docker-compose.yml --profile slc500 up -d) " +
                   "or point AB_LEGACY_ENDPOINT at real hardware.";
    }
}

/// <summary>
///     <c>[Theory]</c>-equivalent with the same gate as <see cref="AbLegacyFactAttribute"/>.
/// </summary>
public sealed class AbLegacyTheoryAttribute : TheoryAttribute
{
    /// <summary>Initializes the attribute, skipping the test if the server is unavailable.</summary>
    public AbLegacyTheoryAttribute()
    {
        if (!AbLegacyServerFixture.IsServerAvailable())
            Skip = "AB Legacy PCCC endpoint not reachable. Start the Docker fixture " +
                   "(docker compose -f Docker/docker-compose.yml --profile slc500 up -d) " +
                   "or point AB_LEGACY_ENDPOINT at real hardware.";
    }
}
