lmxopcua/tests/ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Tests/FakeFocasClient.cs

using ZB.MOM.WW.OtOpcUa.Driver.FOCAS;

namespace ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Tests;

internal class FakeFocasClient : IFocasClient
{
    public bool IsConnected { get; private set; }
    public int ConnectCount { get; private set; }
    public int DisposeCount { get; private set; }
    public bool ThrowOnConnect { get; set; }
    public bool ThrowOnRead { get; set; }
    public bool ThrowOnWrite { get; set; }
    public bool ProbeResult { get; set; } = true;
    public Exception? Exception { get; set; }

    public Dictionary<string, object?> Values { get; } = new(StringComparer.OrdinalIgnoreCase);
    public Dictionary<string, uint> ReadStatuses { get; } = new(StringComparer.OrdinalIgnoreCase);
    public Dictionary<string, uint> WriteStatuses { get; } = new(StringComparer.OrdinalIgnoreCase);
    public List<(FocasAddress addr, FocasDataType type, object? value)> WriteLog { get; } = new();

    public virtual Task ConnectAsync(FocasHostAddress address, TimeSpan timeout, CancellationToken ct)
    {
        ConnectCount++;
        if (ThrowOnConnect) throw Exception ?? new InvalidOperationException();
        IsConnected = true;
        return Task.CompletedTask;
    }

    public virtual Task<(object? value, uint status)> ReadAsync(
        FocasAddress address, FocasDataType type, CancellationToken ct)
    {
        if (ThrowOnRead) throw Exception ?? new InvalidOperationException();
        var key = address.Canonical;
        var status = ReadStatuses.TryGetValue(key, out var s) ? s : FocasStatusMapper.Good;
        var value = Values.TryGetValue(key, out var v) ? v : null;
        return Task.FromResult((value, status));
    }

    public virtual Task<uint> WriteAsync(
        FocasAddress address, FocasDataType type, object? value, CancellationToken ct)
    {
        if (ThrowOnWrite) throw Exception ?? new InvalidOperationException();
        WriteLog.Add((address, type, value));
        Values[address.Canonical] = value;
        var status = WriteStatuses.TryGetValue(address.Canonical, out var s) ? s : FocasStatusMapper.Good;
        return Task.FromResult(status);
    }

    public List<(int number, int axis, FocasDataType type)> DiagnosticReads { get; } = new();

    public virtual Task<(object? value, uint status)> ReadDiagnosticAsync(
        int diagNumber, int axisOrZero, FocasDataType type, CancellationToken ct)
    {
        if (ThrowOnRead) throw Exception ?? new InvalidOperationException();
        DiagnosticReads.Add((diagNumber, axisOrZero, type));
        var key = axisOrZero == 0 ? $"DIAG:{diagNumber}" : $"DIAG:{diagNumber}/{axisOrZero}";
        var status = ReadStatuses.TryGetValue(key, out var s) ? s : FocasStatusMapper.Good;
        var value = Values.TryGetValue(key, out var v) ? v : null;
        return Task.FromResult((value, status));
    }

    public virtual Task<bool> ProbeAsync(CancellationToken ct) => Task.FromResult(ProbeResult);

    /// <summary>
    ///     Configurable path count surfaced via <see cref="GetPathCountAsync"/> — defaults to
    ///     1 (single-path controller). Tests asserting multi-path behaviour set this to 2..N
    ///     so the driver's PathId validation + cnc_setpath dispatch can be exercised
    ///     without a live CNC (issue #264).
    /// </summary>
    public int PathCount { get; set; } = 1;

    /// <summary>Ordered log of <c>cnc_setpath</c> calls observed on this fake session.</summary>
    public List<int> SetPathLog { get; } = new();

    public virtual Task<int> GetPathCountAsync(CancellationToken ct) => Task.FromResult(PathCount);

    public virtual Task SetPathAsync(int pathId, CancellationToken ct)
    {
        SetPathLog.Add(pathId);
        return Task.CompletedTask;
    }

    public virtual void Dispose()
    {
        DisposeCount++;
        IsConnected = false;
    }
}

internal sealed class FakeFocasClientFactory : IFocasClientFactory
{
    public List<FakeFocasClient> Clients { get; } = new();
    public Func<FakeFocasClient>? Customise { get; set; }

    public IFocasClient Create()
    {
        var c = Customise?.Invoke() ?? new FakeFocasClient();
        Clients.Add(c);
        return c;
    }
}