using FrostFS.Session;
using Google.Protobuf;
using Grpc.Core;
using Moq;

namespace FrostFS.SDK.Tests;

public class SessionMocker(string key) : ServiceBase(key)
{
    public byte[]? SessionId { get; set; }

    public byte[]? SessionKey { get; set; }

    public CreateRequest CreateSessionRequest { get; private set; }

    public Mock<SessionService.SessionServiceClient> GetMock()
    {
        var mock = new Mock<SessionService.SessionServiceClient>();

        Random rand = new();

        if (SessionId == null)
        {
            SessionId = new byte[32];
            rand.NextBytes(SessionId);
        }

        if (SessionKey == null)
        {
            SessionKey = new byte[32];
            rand.NextBytes(SessionKey);
        }

        CreateResponse response = new()
        {
            Body = new CreateResponse.Types.Body
            {
                Id = ByteString.CopyFrom(SessionId),
                SessionKey = ByteString.CopyFrom(SessionKey)
            },
            MetaHeader = ResponseMetaHeader
        };

        response.VerifyHeader = GetResponseVerificationHeader(response);

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

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

        return mock;
    }
}