using FrostFS.Netmap;
using FrostFS.SDK.Client;

using Google.Protobuf;

namespace FrostFS.SDK.Tests.Unit;

public class NetmapSnapshotTests : NetworkTestsBase
{
    [Theory]
    [InlineData(false)]
    [InlineData(true)]

    public async void NetmapSnapshotTest(bool useContext)
    {
        var body = new NetmapSnapshotResponse.Types.Body
        {
            Netmap = new Netmap.Netmap { Epoch = 99 }
        };

        var nodeInfo1 = new NodeInfo
        {
            State = NodeInfo.Types.State.Online,
            PublicKey = ByteString.CopyFrom([1, 2, 3])
        };

        nodeInfo1.Addresses.Add("address1");
        nodeInfo1.Addresses.Add("address2");
        nodeInfo1.Attributes.Add(new NodeInfo.Types.Attribute { Key = "key1", Value = "value1" });
        nodeInfo1.Attributes.Add(new NodeInfo.Types.Attribute { Key = "key2", Value = "value2" });

        var nodeInfo2 = new NodeInfo
        {
            State = NodeInfo.Types.State.Offline,
            PublicKey = ByteString.CopyFrom([3, 4, 5])
        };

        nodeInfo2.Addresses.Add("address3");
        nodeInfo2.Attributes.Add(new NodeInfo.Types.Attribute { Key = "key3", Value = "value3" });

        body.Netmap.Nodes.Add(nodeInfo1);
        body.Netmap.Nodes.Add(nodeInfo2);

        Mocker.NetmapSnapshotResponse = new NetmapSnapshotResponse { Body = body };

        var ctx = useContext
            ? new CallContext(TimeSpan.FromSeconds(20), Mocker.CancellationTokenSource.Token)
            : default;

        var validTimeoutFrom = DateTime.UtcNow.AddSeconds(20);

        var result = await GetClient(DefaultSettings).GetNetmapSnapshotAsync(ctx);

        var validTimeoutTo = DateTime.UtcNow.AddSeconds(20);

        Assert.NotNull(result);

        Assert.Equal(99u, result.Epoch);
        Assert.Equal(2, result.NodeInfoCollection.Count);

        var node1 = result.NodeInfoCollection[0];
        Assert.Equal(NodeState.Online, node1.State);
        Assert.Equal(2, node1.Addresses.Count);
        Assert.Equal("address1", node1.Addresses.ElementAt(0));
        Assert.Equal("address2", node1.Addresses.ElementAt(1));

        Assert.Equal(2, node1.Attributes.Count);

        Assert.Equal("key1", node1.Attributes.ElementAt(0).Key);
        Assert.Equal("value1", node1.Attributes.ElementAt(0).Value);
        Assert.Equal("key2", node1.Attributes.ElementAt(1).Key);
        Assert.Equal("value2", node1.Attributes.ElementAt(1).Value);

        var node2 = result.NodeInfoCollection[1];
        Assert.Equal(NodeState.Offline, node2.State);
        Assert.Single(node2.Addresses);
        Assert.Equal("address3", node2.Addresses.ElementAt(0));

        Assert.Single(node2.Attributes);

        Assert.Equal("key3", node2.Attributes.ElementAt(0).Key);
        Assert.Equal("value3", node2.Attributes.ElementAt(0).Value);

        if (useContext)
        {
            Assert.NotNull(Mocker.NetmapSnapshotRequest);
            Assert.Empty(Mocker.NetmapSnapshotRequest.MetaHeader.XHeaders);

            Assert.Equal(Mocker.CancellationTokenSource.Token, Mocker.CancellationToken);
            Assert.NotNull(Mocker.DateTime);
            Assert.True(Mocker.DateTime.Value >= validTimeoutFrom);
            Assert.True(Mocker.DateTime.Value <= validTimeoutTo);
        }
        else
        {
            Assert.NotNull(Mocker.NetmapSnapshotRequest);
            Assert.Empty(Mocker.NetmapSnapshotRequest.MetaHeader.XHeaders);
            Assert.Null(Mocker.DateTime);
        }
    }
}