using Moq;
using FrostFS.Object;
using Grpc.Core;
using FrostFS.SDK.ClientV2;
using FrostFS.Session;
using Google.Protobuf;
using System.Security.Cryptography;
using FrostFS.SDK.Cryptography;
using FrostFS.SDK.ClientV2.Mappers.GRPC;
using FrostFS.SDK.ModelsV2;

namespace FrostFS.SDK.Tests;

public class ObjectMockFactory(string key) : ObjectServiceBase(key)
{
    public override Mock<ObjectService.ObjectServiceClient> GetMock()
    {
        var mock = new Mock<ObjectService.ObjectServiceClient>();

        GetResponse response = new() 
        {
            Body = new GetResponse.Types.Body
            {                 
            },
            MetaHeader = ResponseMetaHeader
        };

        response.VerifyHeader = GetResponseVerificationHeader(response);

        mock.Setup(x => x.Get(
            It.IsAny<GetRequest>(),
            It.IsAny<Metadata>(),
            It.IsAny<DateTime?>(),
            It.IsAny<CancellationToken>()))
             .Returns((GetRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
                {
                    Verifier.CheckRequest(r);

                     return new AsyncServerStreamingCall<GetResponse>(
                        new AsyncStreamReaderMock(key, ObjectHeader),
                        Task.FromResult(ResponseMetaData),
                        () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
                        () => ResponseMetaData,
                        () => { });
                });

        return mock;
    }

    public ObjectHeader ObjectHeader { get; set; }
}

public class AsyncStreamReaderMock(string key, ObjectHeader objectHeader) : ServiceBase(key), IAsyncStreamReader<GetResponse>
{
    public GetResponse Current
    {
        get
        {
            var ecdsaKey = key.LoadWif();

            var header = new Header
            {
                ContainerId =  objectHeader.ContainerId.ToGrpcMessage(),
                PayloadLength = objectHeader.PayloadLength,
                Version = objectHeader.Version!.ToGrpcMessage(),
                OwnerId = objectHeader.OwnerId!.ToGrpcMessage()
            };

            foreach (var attr in objectHeader.Attributes)
                header.Attributes.Add(attr.ToGrpcMessage());

            var response = new GetResponse
            {
                Body = new GetResponse.Types.Body
                {
                    Init = new GetResponse.Types.Body.Types.Init
                    {
                        Header = header,
                        ObjectId = new Refs.ObjectID { Value = ByteString.CopyFrom(SHA256.HashData(Array.Empty<byte>())) },
                        Signature = new Refs.Signature
                        {
                            Key = ByteString.CopyFrom(ecdsaKey.PublicKey()),
                            Sign = ByteString.CopyFrom(ecdsaKey.SignData(header.ToByteArray())),
                        }
                    }
                },
                MetaHeader = new ResponseMetaHeader()
            };

            response.VerifyHeader = GetResponseVerificationHeader(response);

            return response;
        }
    }

    public Task<bool> MoveNext(CancellationToken cancellationToken)
    {
        return Task.FromResult(true);
    }
}