using FrostFS.Netmap;

using Google.Protobuf;

using Grpc.Core;

using Moq;

namespace FrostFS.SDK.Tests;

public class NetworkMocker(string key) : ServiceBase(key)
{
    internal static readonly string[] ParameterKeys = [
        "AuditFee",
        "BasicIncomeRate",
        "ContainerFee",
        "ContainerAliasFee",
        "EpochDuration",
        "InnerRingCandidateFee",
        "MaxECDataCount",
        "MaxECParityCount",
        "MaxObjectSize",
        "WithdrawFee",
        "HomomorphicHashingDisabled",
        "MaintenanceModeAllowed"
    ];

    public Dictionary<string, byte[]>? Parameters { get; set; }

    public LocalNodeInfoResponse NodeInfoResponse { get; set; }

    public LocalNodeInfoRequest LocalNodeInfoRequest { get; set; }

    public NetworkInfoRequest NetworkInfoRequest { get; set; }

    public NetmapSnapshotResponse NetmapSnapshotResponse { get; set; }

    public NetmapSnapshotRequest NetmapSnapshotRequest { get; set; }


    public Mock<NetmapService.NetmapServiceClient> GetMock()
    {
        var mock = new Mock<NetmapService.NetmapServiceClient>();

        var networkInfoResponse = new NetworkInfoResponse();

        var networkConfig = new NetworkConfig();

        foreach (var key in ParameterKeys)
        {
            networkConfig.Parameters.Add(new NetworkConfig.Types.Parameter
            {
                Key = ByteString.CopyFromUtf8(key),
                Value = (Parameters != null && Parameters.TryGetValue(key, out byte[]? value)) ? ByteString.CopyFrom(value) : ByteString.CopyFrom(0)
            });
        }

        var response = new NetworkInfoResponse
        {
            Body = new NetworkInfoResponse.Types.Body
            {
                NetworkInfo = new NetworkInfo
                {
                    CurrentEpoch = 99,
                    MagicNumber = 13,
                    MsPerBlock = 999,
                    NetworkConfig = networkConfig
                }
            },
            MetaHeader = ResponseMetaHeader
        };

        response.VerifyHeader = GetResponseVerificationHeader(response);

        mock.Setup(x => x.NetworkInfoAsync(
                It.IsAny<NetworkInfoRequest>(),
                It.IsAny<Metadata>(),
                It.IsAny<DateTime?>(),
                It.IsAny<CancellationToken>()))
                .Returns((NetworkInfoRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
                {
                    NetworkInfoRequest = r;
                    Metadata = m;
                    DateTime = dt;
                    CancellationToken = ct;

                    return new AsyncUnaryCall<NetworkInfoResponse>(
                        Task.FromResult(response),
                        Task.FromResult(ResponseMetaData),
                        () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
                        () => ResponseMetaData,
                        () => { });
                });

        if (NodeInfoResponse != null)
        {
            NodeInfoResponse.MetaHeader = ResponseMetaHeader;
            NodeInfoResponse.VerifyHeader = GetResponseVerificationHeader(NodeInfoResponse);

            mock.Setup(x => x.LocalNodeInfoAsync(
                    It.IsAny<LocalNodeInfoRequest>(),
                    It.IsAny<Metadata>(),
                    It.IsAny<DateTime?>(),
                    It.IsAny<CancellationToken>()))
                    .Returns((LocalNodeInfoRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
                    {
                        LocalNodeInfoRequest = r;
                        Metadata = m;
                        DateTime = dt;
                        CancellationToken = ct;

                        return new AsyncUnaryCall<LocalNodeInfoResponse>(
                            Task.FromResult(NodeInfoResponse),
                            Task.FromResult(ResponseMetaData),
                            () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
                            () => ResponseMetaData,
                            () => { });
                    });
        }

        if (NetmapSnapshotResponse != null)
        {
            NetmapSnapshotResponse.MetaHeader = ResponseMetaHeader;
            NetmapSnapshotResponse.VerifyHeader = GetResponseVerificationHeader(NetmapSnapshotResponse);

            mock.Setup(x => x.NetmapSnapshotAsync(
                   It.IsAny<NetmapSnapshotRequest>(),
                   It.IsAny<Metadata>(),
                   It.IsAny<DateTime?>(),
                   It.IsAny<CancellationToken>()))
                   .Returns((NetmapSnapshotRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
                   {
                       NetmapSnapshotRequest = r;
                       Metadata = m;
                       DateTime = dt;
                       CancellationToken = ct;

                       return new AsyncUnaryCall<NetmapSnapshotResponse>(
                           Task.FromResult(NetmapSnapshotResponse),
                           Task.FromResult(ResponseMetaData),
                           () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
                           () => ResponseMetaData,
                           () => { });
                   });
        }

        return mock;
    }
}