using System.Linq;

using Google.Protobuf;

using FrostFS.Object;
using FrostFS.Refs;
using FrostFS.SDK.ClientV2.Mappers.GRPC;
using FrostFS.SDK.Cryptography;
using FrostFS.SDK.ModelsV2;

namespace FrostFS.SDK.ClientV2;

internal class ObjectTools(ClientEnvironment ctx) : ContextAccessor (ctx)
{
    internal ObjectId CalculateObjectId(ObjectHeader header)
    { 
        var grpcHeader = CreateHeader(header, []);

        return new ObjectID { Value = grpcHeader.Sha256() }.ToModel();        
    }

    internal Object.Object CreateObject(FrostFsObject @object)
    {
        var grpcHeader = @object.Header.ToGrpcMessage();
       
        grpcHeader.OwnerId = Context.Owner.ToGrpcMessage();
        grpcHeader.Version = Context.Version.ToGrpcMessage();
        grpcHeader.PayloadLength = (ulong)@object.Payload.Length;
        grpcHeader.PayloadHash = Sha256Checksum(@object.Payload);
        
        var split = @object.Header.Split;
        if (split != null)
        {
            grpcHeader.Split = new Header.Types.Split
            {
                SplitId = split.SplitId != null ? ByteString.CopyFrom(split.SplitId.ToBinary()) : null                    
            };

            if (split.Children != null && split.Children.Count != 0)
                grpcHeader.Split.Children.AddRange(split.Children.Select(id => id.ToGrpcMessage()));

            if (split.ParentHeader is not null)
            {
                var grpcParentHeader = CreateHeader(split.ParentHeader, []);

                grpcHeader.Split.Parent = new ObjectID { Value = grpcParentHeader.Sha256() };
                grpcHeader.Split.ParentHeader = grpcParentHeader;
                grpcHeader.Split.ParentSignature = new Refs.Signature
                {
                    Key = ByteString.CopyFrom(Context.Key.PublicKey()),
                    Sign = ByteString.CopyFrom(Context.Key.SignData(grpcHeader.Split.Parent.ToByteArray())),
                };

                split.Parent = grpcHeader.Split.Parent.ToModel();
            }

            grpcHeader.Split.Previous = split.Previous?.ToGrpcMessage(); 
        }

        var obj = new Object.Object
        {
            Header = grpcHeader,
            ObjectId = new ObjectID { Value = grpcHeader.Sha256() },
            Payload = ByteString.CopyFrom(@object.Payload)
        };

        obj.Signature = new Refs.Signature
        {
            Key = ByteString.CopyFrom(Context.Key.PublicKey()),
            Sign = ByteString.CopyFrom(Context.Key.SignData(obj.ObjectId.ToByteArray())),
        };        
      
        return obj;
    }

    internal Header CreateHeader(ObjectHeader header, byte[]? payload)
    {
        var grpcHeader = header.ToGrpcMessage();
       
        grpcHeader.OwnerId = Context.Owner.ToGrpcMessage();
        grpcHeader.Version = Context.Version.ToGrpcMessage();

        if (header.PayloadCheckSum != null)
            grpcHeader.PayloadHash = Sha256Checksum(header.PayloadCheckSum);
        else if (payload != null)    
            grpcHeader.PayloadHash = Sha256Checksum(payload);
       
        return grpcHeader;
    }

    internal static Checksum Sha256Checksum(byte[] data)
    {
        return new Checksum
        {
            Type = ChecksumType.Sha256,
            Sum = ByteString.CopyFrom(data.Sha256())
        };
    }
}