using Opc.Ua;
using ZB.MOM.WW.LmxOpcUa.Client.Shared.Adapters;

namespace ZB.MOM.WW.LmxOpcUa.Client.Shared.Tests.Fakes;

/// <summary>
/// Test double for <see cref="ISessionAdapter" /> used to simulate reads, writes, browsing, history, and failover callbacks.
/// </summary>
internal sealed class FakeSessionAdapter : ISessionAdapter
{
    private readonly List<FakeSubscriptionAdapter> _createdSubscriptions = [];
    private Action<bool>? _keepAliveCallback;

    /// <summary>
    /// Gets a value indicating whether the fake session has been closed through the client disconnect path.
    /// </summary>
    public bool Closed { get; private set; }

    /// <summary>
    /// Gets a value indicating whether the fake session has been disposed.
    /// </summary>
    public bool Disposed { get; private set; }
    public int ReadCount { get; private set; }
    public int WriteCount { get; private set; }
    public int BrowseCount { get; private set; }
    public int BrowseNextCount { get; private set; }
    public int HasChildrenCount { get; private set; }
    public int HistoryReadRawCount { get; private set; }
    public int HistoryReadAggregateCount { get; private set; }

    // Configurable responses
    public DataValue? ReadResponse { get; set; }
    public Func<NodeId, DataValue>? ReadResponseFunc { get; set; }
    public StatusCode WriteResponse { get; set; } = StatusCodes.Good;
    public bool ThrowOnRead { get; set; }
    public bool ThrowOnWrite { get; set; }
    public bool ThrowOnBrowse { get; set; }

    public ReferenceDescriptionCollection BrowseResponse { get; set; } = [];
    public byte[]? BrowseContinuationPoint { get; set; }
    public ReferenceDescriptionCollection BrowseNextResponse { get; set; } = [];
    public byte[]? BrowseNextContinuationPoint { get; set; }
    public bool HasChildrenResponse { get; set; } = false;

    public List<DataValue> HistoryReadRawResponse { get; set; } = [];
    public List<DataValue> HistoryReadAggregateResponse { get; set; } = [];
    public bool ThrowOnHistoryReadRaw { get; set; }
    public bool ThrowOnHistoryReadAggregate { get; set; }

    /// <summary>
    /// Gets or sets the next fake subscription returned when the client creates a monitored-item subscription.
    /// If unset, the fake builds a new subscription automatically.
    /// </summary>
    public FakeSubscriptionAdapter? NextSubscription { get; set; }

    /// <summary>
    /// Gets the fake subscriptions created by this session so tests can inspect replay and cleanup behavior.
    /// </summary>
    public IReadOnlyList<FakeSubscriptionAdapter> CreatedSubscriptions => _createdSubscriptions;

    /// <inheritdoc />
    public bool Connected { get; set; } = true;

    /// <inheritdoc />
    public string SessionId { get; set; } = "ns=0;i=12345";

    /// <inheritdoc />
    public string SessionName { get; set; } = "FakeSession";

    /// <inheritdoc />
    public string EndpointUrl { get; set; } = "opc.tcp://localhost:4840";

    /// <inheritdoc />
    public string ServerName { get; set; } = "FakeServer";

    /// <inheritdoc />
    public string SecurityMode { get; set; } = "None";

    /// <inheritdoc />
    public string SecurityPolicyUri { get; set; } = "http://opcfoundation.org/UA/SecurityPolicy#None";

    /// <inheritdoc />
    public NamespaceTable NamespaceUris { get; set; } = new();

    /// <inheritdoc />
    public void RegisterKeepAliveHandler(Action<bool> callback)
    {
        _keepAliveCallback = callback;
    }

    /// <inheritdoc />
    public Task<DataValue> ReadValueAsync(NodeId nodeId, CancellationToken ct)
    {
        ReadCount++;
        if (ThrowOnRead)
            throw new ServiceResultException(StatusCodes.BadNodeIdUnknown, "Node not found");

        if (ReadResponseFunc != null)
            return Task.FromResult(ReadResponseFunc(nodeId));

        return Task.FromResult(ReadResponse ?? new DataValue(new Variant(0), StatusCodes.Good));
    }

    /// <inheritdoc />
    public Task<StatusCode> WriteValueAsync(NodeId nodeId, DataValue value, CancellationToken ct)
    {
        WriteCount++;
        if (ThrowOnWrite)
            throw new ServiceResultException(StatusCodes.BadNodeIdUnknown, "Node not found");
        return Task.FromResult(WriteResponse);
    }

    /// <inheritdoc />
    public Task<(byte[]? ContinuationPoint, ReferenceDescriptionCollection References)> BrowseAsync(
        NodeId nodeId, uint nodeClassMask, CancellationToken ct)
    {
        BrowseCount++;
        if (ThrowOnBrowse)
            throw new ServiceResultException(StatusCodes.BadNodeIdUnknown, "Node not found");
        return Task.FromResult((BrowseContinuationPoint, BrowseResponse));
    }

    /// <inheritdoc />
    public Task<(byte[]? ContinuationPoint, ReferenceDescriptionCollection References)> BrowseNextAsync(
        byte[] continuationPoint, CancellationToken ct)
    {
        BrowseNextCount++;
        return Task.FromResult((BrowseNextContinuationPoint, BrowseNextResponse));
    }

    /// <inheritdoc />
    public Task<bool> HasChildrenAsync(NodeId nodeId, CancellationToken ct)
    {
        HasChildrenCount++;
        return Task.FromResult(HasChildrenResponse);
    }

    /// <inheritdoc />
    public Task<IReadOnlyList<DataValue>> HistoryReadRawAsync(
        NodeId nodeId, DateTime startTime, DateTime endTime, int maxValues, CancellationToken ct)
    {
        HistoryReadRawCount++;
        if (ThrowOnHistoryReadRaw)
            throw new ServiceResultException(StatusCodes.BadHistoryOperationUnsupported, "History not supported");
        return Task.FromResult<IReadOnlyList<DataValue>>(HistoryReadRawResponse);
    }

    /// <inheritdoc />
    public Task<IReadOnlyList<DataValue>> HistoryReadAggregateAsync(
        NodeId nodeId, DateTime startTime, DateTime endTime, NodeId aggregateId, double intervalMs,
        CancellationToken ct)
    {
        HistoryReadAggregateCount++;
        if (ThrowOnHistoryReadAggregate)
            throw new ServiceResultException(StatusCodes.BadHistoryOperationUnsupported, "History not supported");
        return Task.FromResult<IReadOnlyList<DataValue>>(HistoryReadAggregateResponse);
    }

    /// <inheritdoc />
    public Task<ISubscriptionAdapter> CreateSubscriptionAsync(int publishingIntervalMs, CancellationToken ct)
    {
        var sub = NextSubscription ?? new FakeSubscriptionAdapter();
        NextSubscription = null;
        _createdSubscriptions.Add(sub);
        return Task.FromResult<ISubscriptionAdapter>(sub);
    }

    /// <inheritdoc />
    public Task<IList<object>?> CallMethodAsync(NodeId objectId, NodeId methodId, object[] inputArguments,
        CancellationToken ct = default)
    {
        return Task.FromResult<IList<object>?>(null);
    }

    /// <inheritdoc />
    public Task CloseAsync(CancellationToken ct)
    {
        Closed = true;
        Connected = false;
        return Task.CompletedTask;
    }

    /// <summary>
    /// Marks the fake session as disposed so tests can verify cleanup after disconnect or failover.
    /// </summary>
    public void Dispose()
    {
        Disposed = true;
        Connected = false;
    }

    /// <summary>
    ///     Simulates a keep-alive event.
    /// </summary>
    public void SimulateKeepAlive(bool isGood)
    {
        _keepAliveCallback?.Invoke(isGood);
    }
}