using System;
using System.Linq;
using FrostFS.Object;
using FrostFS.SDK.Cryptography;
using FrostFS.SDK.ModelsV2;
using Google.Protobuf;
using MatchType = FrostFS.Object.MatchType;
using ObjectType = FrostFS.Object.ObjectType;

namespace FrostFS.SDK.ClientV2.Mappers.GRPC;

public static class ObjectAttributeMapper
{
    public static Header.Types.Attribute ToGrpcMessage(this ObjectAttribute attribute)
    {
        return new Header.Types.Attribute
        {
            Key = attribute.Key,
            Value = attribute.Value
        };
    }

    public static ObjectAttribute ToModel(this Header.Types.Attribute attribute)
    {
        return new ObjectAttribute(attribute.Key, attribute.Value);
    }
}

public static class ObjectFilterMapper
{
    public static SearchRequest.Types.Body.Types.Filter ToGrpcMessage(this ObjectFilter filter)
    {
        var objMatchTypeName = filter.MatchType switch
        {
            ModelsV2.Enums.ObjectMatchType.Unspecified => MatchType.Unspecified,
            ModelsV2.Enums.ObjectMatchType.Equals => MatchType.StringEqual,
            ModelsV2.Enums.ObjectMatchType.NotEquals => MatchType.StringNotEqual,
            ModelsV2.Enums.ObjectMatchType.KeyAbsent => MatchType.NotPresent,
            ModelsV2.Enums.ObjectMatchType.StartsWith => MatchType.CommonPrefix,

            _ => throw new ArgumentException($"Unknown MatchType. Value: '{filter.MatchType}'.")
        };

        return new SearchRequest.Types.Body.Types.Filter
        {
            MatchType = objMatchTypeName,
            Key = filter.Key,
            Value = filter.Value
        };
    }    
}

public static class ObjectHeaderMapper
{
    public static Header ToGrpcMessage(this ObjectHeader header)
    {
        var objTypeName = header.ObjectType switch
        {
            ModelsV2.Enums.ObjectType.Regular => ObjectType.Regular,
            ModelsV2.Enums.ObjectType.Lock => ObjectType.Lock,
            ModelsV2.Enums.ObjectType.Tombstone => ObjectType.Tombstone,
            _ => throw new ArgumentException($"Unknown ObjectType. Value: '{header.ObjectType}'.")
        };

        var head = new Header
        {         
            ContainerId = header.ContainerId.ToGrpcMessage(),
            ObjectType = objTypeName,
            PayloadLength = header.PayloadLength
        };

        foreach (var attribute in header.Attributes)
        {
            head.Attributes.Add(attribute.ToGrpcMessage());
        }

        var split = header.Split;
        if (split != null)
        {
            head.Split = new Header.Types.Split
            {
                Parent = split.Parent?.ToGrpcMessage(),
                ParentSignature = split.ParentSignature?.ToGrpcMessage(),
                ParentHeader = split.ParentHeader?.ToGrpcMessage(),
                Previous = split.Previous?.ToGrpcMessage(),
                SplitId = split.SplitId != null ? ByteString.CopyFrom(split.SplitId.ToBinary()) : null
            };

            if (split.Children != null && split.Children.Any())
                head.Split.Children.AddRange(split.Children.Select(id => id.ToGrpcMessage()));
        }
        
        return head;
    }

    public static ObjectHeader ToModel(this Header header)
    {
        var objTypeName = header.ObjectType switch
        {
            ObjectType.Regular => ModelsV2.Enums.ObjectType.Regular,
            ObjectType.Lock => ModelsV2.Enums.ObjectType.Lock,
            ObjectType.Tombstone => ModelsV2.Enums.ObjectType.Tombstone,
            _ => throw new ArgumentException($"Unknown ObjectType. Value: '{header.ObjectType}'.")
        };

        var model = new ObjectHeader(
            new ContainerId(Base58.Encode(header.ContainerId.Value.ToByteArray())),
            objTypeName,
            header.Attributes.Select(attribute => attribute.ToModel()).ToArray()
        )
        {
            PayloadLength = header.PayloadLength,
            Version = header.Version.ToModel(),
            OwnerId = header.OwnerId.ToModel()          
        };

        if (header.Split != null)
        {
            model.Split = new Split(SplitId.CrateFromBinary(header.Split.SplitId.ToByteArray()))
            {
                Parent = header.Split.Parent?.ToModel(),
                ParentHeader = header.Split.ParentHeader?.ToModel(),
                Previous = header.Split.Previous?.ToModel()
            };

            if (header.Split.Children.Any())
                model.Split.Children.AddRange(header.Split.Children.Select(x => x.ToModel()));
        }

        return model;
    }
}

public static class ObjectMapper
{
    public static ModelsV2.Object ToModel(this Object.Object obj)
    {
        return new ModelsV2.Object()
        {
            Header = obj.Header.ToModel(),
            ObjectId = ObjectId.FromHash(obj.ObjectId.Value.ToByteArray()),
            Payload = obj.Payload.ToByteArray()
        };
    }    
}

public static class SignatureMapper
{
    public static Refs.Signature ToGrpcMessage(this Signature signature)
    {
        var scheme = signature.Scheme switch
        {
            SignatureScheme.EcdsaRfc6979Sha256 => Refs.SignatureScheme.EcdsaRfc6979Sha256,
            SignatureScheme.EcdsaRfc6979Sha256WalletConnect => Refs.SignatureScheme.EcdsaRfc6979Sha256WalletConnect,
            SignatureScheme.EcdsaSha512 => Refs.SignatureScheme.EcdsaSha512,
            _ => throw new ArgumentException(message: $"Unexpected enum value: {signature.Scheme}", paramName: nameof(signature.Scheme))
        };

        return new Refs.Signature
        {
            Key = ByteString.CopyFrom(signature.Key),
            Scheme = scheme,
            Sign = ByteString.CopyFrom(signature.Sign)
        };
    }
}