using FrostFS.Refs;
using FrostFS.SDK.ClientV2;
using FrostFS.SDK.ClientV2.Interfaces;
using FrostFS.SDK.ClientV2.Mappers.GRPC;
using FrostFS.SDK.ClientV2.Parameters;
using FrostFS.SDK.Cryptography;
using FrostFS.SDK.ModelsV2;
using FrostFS.SDK.ModelsV2.Enums;
using FrostFS.SDK.ModelsV2.Netmap;
using Google.Protobuf;
using Microsoft.Extensions.Options;
using System.Security.Cryptography;
using System.Text;

namespace FrostFS.SDK.Tests;

public abstract class ObjectTestsBase
{
    protected static readonly string key = "KwHDAJ66o8FoLBjVbjP2sWBmgBMGjt7Vv4boA7xQrBoAYBE397Aq";

    protected IOptions<ClientSettings> Settings { get; set; }
    protected ContainerId ContainerId { get; set; }

    protected NetworkMocker NetworkMocker { get; set; } = new NetworkMocker(key);
    protected SessionMocker SessionMocker { get; set; } = new SessionMocker(key);
    protected ContainerMocker ContainerMocker { get; set; } = new ContainerMocker(key);
    protected ObjectMocker Mocker { get; set; }

    protected ObjectTestsBase()
    {
        var ecdsaKey = key.LoadWif();
        
        Settings = Options.Create(new ClientSettings
        {
            Key = key,
            Host = "http://localhost:8080"
        });

        Mocker = new ObjectMocker(key)
        {
            PlacementPolicy = new PlacementPolicy(true, new Replica(1)),
            Version = new ModelsV2.Version(2, 13),
            ContainerGuid = Guid.NewGuid()
        };

        ContainerId = new ContainerId(Base58.Encode(Mocker.ContainerGuid.ToBytes()));

        Mocker.ObjectHeader = new(ContainerId, ModelsV2.Enums.ObjectType.Regular, [new ObjectAttribute("k", "v")])
        {           
            Version = new ModelsV2.Version(2, 13),
            OwnerId = OwnerId.FromKey(ecdsaKey)
        };
    }

    protected IFrostFSClient GetClient()
    {   
        return Client.GetTestInstance(
            Settings,
            null,
            NetworkMocker.GetMock().Object,
            SessionMocker.GetMock().Object,
            ContainerMocker.GetMock().Object,
            Mocker.GetMock().Object);
    }
}

public class ObjectTest : ObjectTestsBase
{
    [Fact]
    public async void GetObjectTest()
    {
        var client = GetClient();
        var objectId = client.CalculateObjectId(Mocker.ObjectHeader!);

        var context = new Context
        {
            Timeout = TimeSpan.FromSeconds(2)
        };

        var result = await client.GetObjectAsync(new PrmObjectGet(ContainerId, objectId) { Context = context });

        Assert.NotNull(result);

        Assert.Equal(Mocker.ObjectHeader!.ContainerId.Value, result.Header.ContainerId.Value);
        Assert.Equal(Mocker.ObjectHeader!.OwnerId!.ToGrpcMessage().ToString(), result.Header.OwnerId!.Value);
        Assert.Equal(Mocker.ObjectHeader.PayloadLength, result.Header.PayloadLength);
        Assert.Single(result.Header.Attributes);
        Assert.Equal(Mocker.ObjectHeader.Attributes[0].Key, result.Header.Attributes[0].Key);
        Assert.Equal(Mocker.ObjectHeader.Attributes[0].Value,result.Header.Attributes[0].Value);
    }

    [Fact]
    public async void PutObjectTest()
    {
        Mocker.ResultObjectId = SHA256.HashData([]);
       
        Random rnd = new();
        var bytes = new byte[1024];
        rnd.NextBytes(bytes);

        var param = new PrmObjectPut
        {
            Header = Mocker.ObjectHeader,
            Payload = new MemoryStream(bytes),
            ClientCut = false
        };

        var result = await GetClient().PutObjectAsync(param);

        var sentMessages = Mocker.ClientStreamWriter!.Messages;

        var body1 = sentMessages.ElementAt(0).GetBody() as Object.PutRequest.Types.Body;
        var body2 = sentMessages.ElementAt(1).GetBody() as Object.PutRequest.Types.Body;

        Assert.NotNull(result);
        Assert.Equal(Mocker.ResultObjectId, result.ToHash());
       
        Assert.True(Mocker.ClientStreamWriter.CompletedTask);

        Assert.Equal(0, body1!.Chunk.Length);
        Assert.Equal(Object.PutRequest.Types.Body.ObjectPartOneofCase.Init, body1!.ObjectPartCase);

        Assert.Equal(1024, body2!.Chunk.Length);
        Assert.Equal(Object.PutRequest.Types.Body.ObjectPartOneofCase.Chunk, body2!.ObjectPartCase);       
    }

    [Fact]
    public async void ClientCutTest()
    {
        NetworkMocker.Parameters = new Dictionary<string, byte[]>() { { "MaxObjectSize", [0x0, 0xa] } }; 

        var blockSize = 2560;
        byte[] bytes = File.ReadAllBytes(@".\..\..\..\TestData\cat.jpg");
        var fileLength = bytes.Length;

        var param = new PrmObjectPut
        {
            Header = Mocker.ObjectHeader,
            Payload = new MemoryStream(bytes),
            ClientCut = true
        };

        var result = await GetClient().PutObjectAsync(param);

        var sentMessages = Mocker.PutSingleRequests.ToArray();

        Assert.Equal(4, sentMessages.Length);

        var object_0 = sentMessages[0].Body.Object;
        var object_1 = sentMessages[1].Body.Object;
        var object_2 = sentMessages[2].Body.Object;
        var object_3 = sentMessages[3].Body.Object;

        Assert.NotNull(object_0.Header.Split.SplitId);
        Assert.Null(object_0.Header.Split.Previous);
        Assert.Equal(blockSize, (int)object_0.Header.PayloadLength);
        Assert.Equal(bytes[..blockSize], object_0.Payload);
        Assert.True(object_0.Header.Attributes.Count == 0);

        Assert.Equal(object_0.Header.Split.SplitId, object_1.Header.Split.SplitId);
        Assert.Equal(object_0.ObjectId, object_1.Header.Split.Previous);
        Assert.Equal(blockSize, (int)object_1.Header.PayloadLength);
        Assert.Equal(bytes[blockSize..(blockSize * 2)], object_1.Payload);
        Assert.True(object_1.Header.Attributes.Count == 0);

        // last part
        Assert.NotNull(object_2.Header.Split.Parent);
        Assert.NotNull(object_2.Header.Split.ParentHeader);
        Assert.NotNull(object_2.Header.Split.ParentSignature);
        Assert.Equal(object_1.Header.Split.SplitId, object_2.Header.Split.SplitId);
        Assert.Equal(object_1.ObjectId, object_2.Header.Split.Previous);
        Assert.Equal(fileLength%blockSize, (int)object_2.Header.PayloadLength);
        Assert.Equal(bytes[((fileLength/blockSize) * blockSize)..fileLength], object_2.Payload);
        Assert.True(object_2.Header.Attributes.Count == 0);

        // link object
        Assert.Equal(object_2.Header.Split.Parent, object_3.Header.Split.Parent);
        Assert.Equal(object_2.Header.Split.ParentHeader, object_3.Header.Split.ParentHeader);
        Assert.Equal(object_2.Header.Split.SplitId, object_3.Header.Split.SplitId);
        Assert.Equal(0, (int)object_3.Header.PayloadLength);
        Assert.Contains(object_0.ObjectId, object_3.Header.Split.Children);
        Assert.Contains(object_2.ObjectId, object_3.Header.Split.Children);
        Assert.Contains(object_2.ObjectId, object_3.Header.Split.Children);
        Assert.True(object_2.Header.Attributes.Count == 0);

        Assert.Single(object_3.Header.Split.ParentHeader.Attributes);
        Assert.Equal("k", object_3.Header.Split.ParentHeader.Attributes[0].Key);
        Assert.Equal("v", object_3.Header.Split.ParentHeader.Attributes[0].Value);

        var modelObjId = ObjectId.FromHash(object_3.Header.Split.Parent.Value.ToByteArray());

        Assert.Equal(result.Value, modelObjId.ToString());
    }

    [Fact]
    public async void DeleteObject()
    {
        Mocker.ObjectId = new ObjectID { Value = ByteString.CopyFrom(SHA256.HashData(Encoding.UTF8.GetBytes("test"))) }.ToModel();

        await GetClient().DeleteObjectAsync(new PrmObjectDelete(ContainerId, Mocker.ObjectId));

        var request = Mocker.DeleteRequests.FirstOrDefault();
        Assert.NotNull(request);
        Assert.Equal(ContainerId.ToGrpcMessage(), request.Body.Address.ContainerId);
        Assert.Equal(Mocker.ObjectId.ToGrpcMessage(), request.Body.Address.ObjectId);
    }

    [Fact]
    public async void GetHeaderTest()
    {
        Mocker.ObjectId = new ObjectID { Value = ByteString.CopyFrom(SHA256.HashData(Encoding.UTF8.GetBytes("test"))) }.ToModel();

        var response = await GetClient().GetObjectHeadAsync(new PrmObjectHeadGet(ContainerId, Mocker.ObjectId));

        var request = Mocker.HeadRequests.FirstOrDefault();
        Assert.NotNull(request);
        Assert.Equal(ContainerId.ToGrpcMessage(), request.Body.Address.ContainerId);
        Assert.Equal(Mocker.ObjectId.ToGrpcMessage(), request.Body.Address.ObjectId);

        Assert.NotNull(response);
        Assert.Equal(ContainerId.Value, response.ContainerId.Value);

        Assert.Equal(Mocker.ObjectHeader!.OwnerId!.ToGrpcMessage().ToString(), response.OwnerId!.Value);
        Assert.Equal(Mocker.ObjectHeader!.Version!.ToString(), response.Version!.ToString());
     
        Assert.Equal(Mocker.HeadResponse!.PayloadLength, response.PayloadLength);

        Assert.Equal(ObjectType.Regular, response.ObjectType);

        Assert.Single(response.Attributes);

        Assert.Equal(Mocker.HeadResponse.Attributes[0].Key, response.Attributes.First().Key);
        Assert.Equal(Mocker.HeadResponse.Attributes[0].Value, response.Attributes.First().Value);

        Assert.Null(response.Split);
    }
}