using System;
using System.Security.Cryptography;

using FrostFS.Refs;
using FrostFS.SDK.Client.Mappers.GRPC;
using FrostFS.SDK.Cryptography;
using FrostFS.SDK.Proto.Interfaces;
using FrostFS.Session;

using Google.Protobuf;

namespace FrostFS.SDK.Client;

public static class Verifier
{
    public const int RFC6979SignatureSize = 64;

    public static bool VerifyData(this ECDsa key, IMessage data, ByteString sig)
    {
        if (key is null)
            throw new ArgumentNullException(nameof(key));

        if (sig is null)
            throw new ArgumentNullException(nameof(sig));

        var signature = sig.Span.Slice(1).ToArray();
        using var sha = SHA512.Create();

        if (data is null)
        {
            return key.VerifyHash(DataHasher.Sha512(new Span<byte>([])), signature);
        }

        using var stream = new HashStream(sha);
        data.WriteTo(stream);

        return key.VerifyHash(stream.Hash(), signature);
    }

    public static bool VerifyMessagePart(this Signature sig, IMessage data)
    {
        if (sig is null || sig.Key is null || sig.Sign is null)
            return false;

        using var key = sig.Key.ToByteArray().LoadPublicKey();

        return key.VerifyData(data, sig.Sign);
    }

    internal static bool VerifyMatryoskaLevel(IMessage body, IMetaHeader meta, IVerificationHeader verification)
    {
        if (!verification.MetaSignature.VerifyMessagePart(meta))
            return false;

        var origin = verification.GetOrigin();

        if (!verification.OriginSignature.VerifyMessagePart(origin))
            return false;

        if (origin is null)
            return verification.BodySignature.VerifyMessagePart(body);

        return verification.BodySignature is null && VerifyMatryoskaLevel(body, meta.GetOrigin(), origin);
    }

    public static bool Verify(this IVerifiableMessage message)
    {
        if (message is null)
        {
            throw new ArgumentNullException(nameof(message));
        }

        return VerifyMatryoskaLevel(message.GetBody(), message.GetMetaHeader(), message.GetVerificationHeader());
    }

    internal static void CheckResponse(IResponse resp)
    {
        if (!resp.Verify())
        {
            throw new FormatException($"invalid response, type={resp.GetType()}");
        }

        if (resp.MetaHeader != null)
        {
            var status = resp.MetaHeader.Status.ToModel();

            if (status != null && !status.IsSuccess)
            {
                throw new FrostFsResponseException(status);
            }
        }
    }

    /// <summary>
    /// This method is intended for unit tests for request verification.
    /// </summary>
    /// <param name="request">Created by SDK request to gRpc proxy</param>
    public static void CheckRequest(IRequest request)
    {
        if (request is null)
        {
            throw new ArgumentNullException(nameof(request));
        }

        if (!request.Verify())
        {
            throw new FrostFsResponseException($"invalid response, type={request.GetType()}");
        }
    }
}