using System.Diagnostics.CodeAnalysis;
using System.Security.Cryptography;

using FrostFS.SDK.Client;
using FrostFS.SDK.Cryptography;

using Microsoft.Extensions.Options;

namespace FrostFS.SDK.SmokeTests;

[SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")]
[SuppressMessage("Security", "CA5394:Do not use insecure randomness", Justification = "No secure purpose")]
public class PoolSmokeTests : SmokeTestsBase
{
    private static readonly PrmWait lightWait = new(100, 1);

    private InitParameters GetDefaultParams()
    {
        return new InitParameters
        {
            Key = keyString.LoadWif(),

            NodeParams = [new(1, this.url, 100.0f)],
            ClientBuilder = null,
            GracefulCloseOnSwitchTimeout = 30_000_000,
            Logger = null
        };
    }

    [Fact]
    public async void NetworkMapTest()
    {
        var options = GetDefaultParams();

        using var pool = new Pool(options);

        var error = await pool.Dial(new CallContext());

        Assert.Null(error);

        var result = await pool.GetNetmapSnapshotAsync(default);

        Assert.True(result.Epoch > 0);
        Assert.Single(result.NodeInfoCollection);

        var item = result.NodeInfoCollection[0];
        Assert.Equal(2, item.Version.Major);
        Assert.Equal(13, item.Version.Minor);
        Assert.Equal(NodeState.Online, item.State);
        Assert.True(item.PublicKey.Length > 0);
        Assert.Single(item.Addresses);
        Assert.Equal(9, item.Attributes.Count);
    }

    [Fact]
    public async void NodeInfoTest()
    {
        var options = GetDefaultParams();

        using var pool = new Pool(options);

        var error = await pool.Dial(new CallContext());

        Assert.Null(error);

        var result = await pool.GetNodeInfoAsync();

        Assert.Equal(2, result.Version.Major);
        Assert.Equal(13, result.Version.Minor);
        Assert.Equal(NodeState.Online, result.State);
        Assert.Equal(33, result.PublicKey.Length);
        Assert.Single(result.Addresses);
        Assert.Equal(9, result.Attributes.Count);
    }

    [Fact]
    public async void NodeInfoStatisticsTwoNodesTest()
    {
        var callbackText = string.Empty;

        var options = new InitParameters
        {
            Key = keyString.LoadWif(),
            NodeParams = [
                new(1, this.url, 100.0f),
                new(2, this.url.Replace('0', '1'), 100.0f)
                ],
            ClientBuilder = null,
            GracefulCloseOnSwitchTimeout = 30_000_000,
            Logger = null,
            Callback = (cs) => callbackText = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds"
        };

        using var pool = new Pool(options);

        var ctx = new CallContext
        {
        };

        var error = await pool.Dial(ctx).ConfigureAwait(true);

        Assert.Null(error);

        using var client = FrostFSClient.GetSingleOwnerInstance(GetSingleOwnerOptions(this.keyString, this.url));

        var result = await client.GetNodeInfoAsync();

        var statistics = pool.Statistic();

        Assert.False(string.IsNullOrEmpty(callbackText));
        Assert.Contains(" took ", callbackText, StringComparison.Ordinal);
    }

    [Fact]
    public async void NodeInfoStatisticsTest()
    {
        var options = GetDefaultParams();

        var callbackText = string.Empty;
        options.Callback = (cs) => callbackText = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds";

        using var pool = new Pool(options);

        var ctx = new CallContext();

        var error = await pool.Dial(ctx).ConfigureAwait(true);

        Assert.Null(error);

        using var client = FrostFSClient.GetSingleOwnerInstance(GetSingleOwnerOptions(this.keyString, this.url));

        var result = await client.GetNodeInfoAsync();

        Assert.False(string.IsNullOrEmpty(callbackText));
        Assert.Contains(" took ", callbackText, StringComparison.Ordinal);
    }

    [Fact]
    public async void GetSessionTest()
    {
        var options = GetDefaultParams();

        using var pool = new Pool(options);

        var error = await pool.Dial(new CallContext()).ConfigureAwait(true);

        Assert.Null(error);

        var prm = new PrmSessionCreate(100);

        var token = await pool.CreateSessionAsync(prm).ConfigureAwait(true);

        var ownerHash = Base58.Decode(OwnerId!.Value);

        Assert.NotNull(token);
        Assert.NotEqual(Guid.Empty, token.Id);
        Assert.Equal(33, token.SessionKey.Length);
    }

    [Fact]
    public async void CreateObjectWithSessionToken()
    {
        var options = GetDefaultParams();

        using var pool = new Pool(options);

        var error = await pool.Dial(new CallContext()).ConfigureAwait(true);

        Assert.Null(error);

        await Cleanup(pool);

        var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue));

        var createContainerParam = new PrmContainerCreate(
            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))));

        createContainerParam.XHeaders.Add("key1", "value1");

        var containerId = await pool.CreateContainerAsync(createContainerParam);

        var bytes = GetRandomBytes(1024);

        var param = new PrmObjectPut
        {
            Header = new FrostFsObjectHeader(
                containerId: containerId,
                type: FrostFsObjectType.Regular,
                [new FrostFsAttributePair("fileName", "test")]),
            Payload = new MemoryStream(bytes),
            ClientCut = false,
            SessionToken = token
        };

        var objectId = await pool.PutObjectAsync(param).ConfigureAwait(true);

        var @object = await pool.GetObjectAsync(new PrmObjectGet(containerId, objectId));

        var downloadedBytes = new byte[@object.Header.PayloadLength];
        MemoryStream ms = new(downloadedBytes);

        ReadOnlyMemory<byte>? chunk = null;
        while ((chunk = await @object.ObjectReader!.ReadChunk()) != null)
        {
            ms.Write(chunk.Value.Span);
        }

        Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes));

        await Cleanup(pool);
    }

    [Fact]
    public async void FilterTest()
    {
        var options = GetDefaultParams();

        using var pool = new Pool(options);

        var error = await pool.Dial(new CallContext()).ConfigureAwait(true);

        Assert.Null(error);

        await Cleanup(pool);

        var createContainerParam = new PrmContainerCreate(
           new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))))
        {
            WaitParams = lightWait
        };

        var containerId = await pool.CreateContainerAsync(createContainerParam);

        var bytes = new byte[] { 1, 2, 3 };

        var ParentHeader = new FrostFsObjectHeader(
                containerId: containerId,
                type: FrostFsObjectType.Regular)
        {
            PayloadLength = 3
        };

        var param = new PrmObjectPut
        {
            Header = new FrostFsObjectHeader(
                containerId: containerId,
                type: FrostFsObjectType.Regular,
                [new FrostFsAttributePair("fileName", "test")],
                new FrostFsSplit()),
            Payload = new MemoryStream(bytes),
            ClientCut = false
        };

        var objectId = await pool.PutObjectAsync(param);

        var head = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId));

        var ecdsaKey = this.keyString.LoadWif();

        var networkInfo = await pool.GetNetmapSnapshotAsync();

        await CheckFilter(pool, containerId, new FilterByContainerId(FrostFsMatchType.Equals, containerId));

        await CheckFilter(pool, containerId, new FilterByOwnerId(FrostFsMatchType.Equals, FrostFsOwner.FromKey(ecdsaKey)));

        await CheckFilter(pool, containerId, new FilterBySplitId(FrostFsMatchType.Equals, param.Header.Split!.SplitId));

        await CheckFilter(pool, containerId, new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"));

        await CheckFilter(pool, containerId, new FilterByObjectId(FrostFsMatchType.Equals, objectId));

        await CheckFilter(pool, containerId, new FilterByVersion(FrostFsMatchType.Equals, networkInfo.NodeInfoCollection[0].Version));

        await CheckFilter(pool, containerId, new FilterByEpoch(FrostFsMatchType.Equals, networkInfo.Epoch));

        await CheckFilter(pool, containerId, new FilterByPayloadLength(FrostFsMatchType.Equals, 3));

        var checkSum = CheckSum.CreateCheckSum(bytes);

        await CheckFilter(pool, containerId, new FilterByPayloadHash(FrostFsMatchType.Equals, checkSum));

        await CheckFilter(pool, containerId, new FilterByPhysicallyStored());
    }

    private static async Task CheckFilter(Pool pool, FrostFsContainerId containerId, IObjectFilter filter)
    {
        var resultObjectsCount = 0;

        PrmObjectSearch searchParam = new(containerId) { Filters = [filter] };

        await foreach (var objId in pool.SearchObjectsAsync(searchParam))
        {
            resultObjectsCount++;
            var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objId));
        }

        Assert.True(0 < resultObjectsCount, $"Filter for {filter.Key} doesn't work");
    }

    [Theory]
    [InlineData(1)]
    [InlineData(3 * 1024 * 1024)]            // exactly one chunk size - 3MB
    [InlineData(6 * 1024 * 1024 + 100)]
    public async void SimpleScenarioTest(int objectSize)
    {
        bool callbackInvoked = false;

        var options = GetDefaultParams();

        options.Callback = new((CallStatistics cs) =>
        {
            callbackInvoked = true;
            Assert.True(cs.ElapsedMicroSeconds > 0);
        });

        using var pool = new Pool(options);

        var error = await pool.Dial(new CallContext()).ConfigureAwait(true);

        Assert.Null(error);

        await Cleanup(pool);

        var ctx = new CallContext { };

        var createContainerParam = new PrmContainerCreate(
            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)), [new("testKey", "testValue")]), ctx);

        var createdContainer = await pool.CreateContainerAsync(createContainerParam);

        var container = await pool.GetContainerAsync(new PrmContainerGet(createdContainer));
        Assert.NotNull(container);
        Assert.True(callbackInvoked);

        var bytes = GetRandomBytes(objectSize);

        var param = new PrmObjectPut()
        {
            Header = new FrostFsObjectHeader(
                containerId: createdContainer,
                type: FrostFsObjectType.Regular,
                [new FrostFsAttributePair("fileName", "test")]),
            Payload = new MemoryStream(bytes),
            ClientCut = false
        };

        var objectId = await pool.PutObjectAsync(param);

        var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");

        bool hasObject = false;
        await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(createdContainer) { Filters = [filter] }))
        {
            hasObject = true;

            var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId));
            Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength);
            Assert.NotNull(objHeader.Attributes);
            Assert.Single(objHeader.Attributes!);
            Assert.Equal("fileName", objHeader.Attributes!.First().Key);
            Assert.Equal("test", objHeader.Attributes!.First().Value);
        }

        Assert.True(hasObject);

        var @object = await pool.GetObjectAsync(new PrmObjectGet(createdContainer, objectId));

        var downloadedBytes = new byte[@object.Header.PayloadLength];
        MemoryStream ms = new(downloadedBytes);

        ReadOnlyMemory<byte>? chunk = null;
        while ((chunk = await @object.ObjectReader!.ReadChunk()) != null)
        {
            ms.Write(chunk.Value.Span);
        }

        Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes));

        await Cleanup(pool);

        await foreach (var _ in pool.ListContainersAsync())
        {
            Assert.Fail("Containers exist");
        }
    }

    [Theory]
    [InlineData(1)]
    [InlineData(3 * 1024 * 1024)]            // exactly one chunk size - 3MB
    [InlineData(6 * 1024 * 1024 + 100)]
    public async void SimpleScenarioWithSessionTest(int objectSize)
    {
        var options = GetDefaultParams();

        using var pool = new Pool(options);
        options.Callback = new((CallStatistics cs) => Assert.True(cs.ElapsedMicroSeconds > 0));

        var error = await pool.Dial(new CallContext()).ConfigureAwait(true);

        Assert.Null(error);

        var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue));

        await Cleanup(pool);

        var ctx = new CallContext
        {
            Timeout = TimeSpan.FromSeconds(20)
        };

        var createContainerParam = new PrmContainerCreate(
            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), ctx);

        var container = await pool.CreateContainerAsync(createContainerParam);

        var containerInfo = await pool.GetContainerAsync(new PrmContainerGet(container, ctx));
        Assert.NotNull(containerInfo);

        var bytes = GetRandomBytes(objectSize);

        var param = new PrmObjectPut(new CallContext())
        {
            Header = new FrostFsObjectHeader(
                containerId: container,
                type: FrostFsObjectType.Regular,
                [new FrostFsAttributePair("fileName", "test")]),
            Payload = new MemoryStream(bytes),
            ClientCut = false,
            SessionToken = token
        };

        var objectId = await pool.PutObjectAsync(param);

        var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");

        bool hasObject = false;
        await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(container) { Filters = [filter], SessionToken = token }))
        {
            hasObject = true;

            var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(container, objectId) { SessionToken = token });
            Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength);
            Assert.NotNull(objHeader.Attributes);
            Assert.Single(objHeader.Attributes);
            Assert.Equal("fileName", objHeader.Attributes.First().Key);
            Assert.Equal("test", objHeader.Attributes.First().Value);
        }

        Assert.True(hasObject);

        var @object = await pool.GetObjectAsync(new PrmObjectGet(container, objectId) { SessionToken = token });

        var downloadedBytes = new byte[@object.Header.PayloadLength];
        MemoryStream ms = new(downloadedBytes);

        ReadOnlyMemory<byte>? chunk = null;
        while ((chunk = await @object.ObjectReader!.ReadChunk()) != null)
        {
            ms.Write(chunk.Value.Span);
        }

        Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes));

        await Cleanup(pool);

        await foreach (var _ in pool.ListContainersAsync())
        {
            Assert.Fail("Containers exist");
        }
    }

    [Theory]
    [InlineData(1)]
    [InlineData(64 * 1024 * 1024)]      // exactly 1 block size - 64MB
    [InlineData(64 * 1024 * 1024 - 1)]
    [InlineData(64 * 1024 * 1024 + 1)]
    [InlineData(2 * 64 * 1024 * 1024 + 256)]
    [InlineData(200)]
    public async void ClientCutScenarioTest(int objectSize)
    {
        var options = GetDefaultParams();

        using var pool = new Pool(options);

        var error = await pool.Dial(new CallContext()).ConfigureAwait(true);

        Assert.Null(error);

        await Cleanup(pool);

        var createContainerParam = new PrmContainerCreate(new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))))
        {
            WaitParams = lightWait
        };

        var containerId = await pool.CreateContainerAsync(createContainerParam);

        var ctx = new CallContext
        {
            Timeout = TimeSpan.FromSeconds(10),
        };

        //  ctx.Interceptors.Add(new CallbackInterceptor());

        var container = await pool.GetContainerAsync(new PrmContainerGet(containerId, ctx));

        Assert.NotNull(container);

        byte[] bytes = GetRandomBytes(objectSize);

        var param = new PrmObjectPut
        {
            Header = new FrostFsObjectHeader(
                containerId: containerId,
                type: FrostFsObjectType.Regular,
                [new FrostFsAttributePair("fileName", "test")]),
            Payload = new MemoryStream(bytes),
            ClientCut = true
        };

        var objectId = await pool.PutObjectAsync(param);

        var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");

        bool hasObject = false;
        await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(containerId, null, filter)))
        {
            hasObject = true;

            var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId));
            Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength);
            Assert.NotNull(objHeader.Attributes);
            Assert.Single(objHeader.Attributes);
            Assert.Equal("fileName", objHeader.Attributes[0].Key);
            Assert.Equal("test", objHeader.Attributes[0].Value);
        }

        Assert.True(hasObject);

        var @object = await pool.GetObjectAsync(new PrmObjectGet(containerId, objectId));

        var downloadedBytes = new byte[@object.Header.PayloadLength];
        MemoryStream ms = new(downloadedBytes);

        ReadOnlyMemory<byte>? chunk = null;
        while ((chunk = await @object.ObjectReader!.ReadChunk()) != null)
        {
            ms.Write(chunk.Value.Span);
        }

        Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes));

        await CheckFilter(pool, containerId, new FilterByRootObject());

        await Cleanup(pool);

        await foreach (var cid in pool.ListContainersAsync())
        {
            Assert.Fail($"Container {cid.GetValue()} exist");
        }
    }

    private static byte[] GetRandomBytes(int size)
    {
        Random rnd = new();
        var bytes = new byte[size];
        rnd.NextBytes(bytes);
        return bytes;
    }

    private static IOptions<ClientSettings> GetSingleOwnerOptions(string key, string url)
    {
        return Options.Create(new ClientSettings
        {
            Key = key,
            Host = url
        });
    }

    private static IOptions<ClientSettings> GetOptions(string url)
    {
        return Options.Create(new ClientSettings
        {
            Host = url
        });
    }

    static async Task Cleanup(Pool pool)
    {
        await foreach (var cid in pool.ListContainersAsync())
        {
            await pool.DeleteContainerAsync(new PrmContainerDelete(cid) { WaitParams = lightWait }).ConfigureAwait(true);
        }
    }
}