using System.Linq;
using System.Text;
using System.Threading.Tasks;
using FrostFS.Netmap;
using FrostFS.SDK.ClientV2.Mappers.GRPC.Netmap;
using NodeInfo = FrostFS.SDK.ModelsV2.Netmap.NodeInfo;

using FrostFS.SDK.ModelsV2.Netmap;
using static FrostFS.Netmap.NetworkConfig.Types;

namespace FrostFS.SDK.ClientV2;

internal class NetmapServiceProvider : ContextAccessor
{  
    private readonly NetmapService.NetmapServiceClient netmapServiceClient;
    
    internal NetmapServiceProvider(NetmapService.NetmapServiceClient netmapServiceClient, ClientEnvironment context) 
        : base(context) 
    {
        this.netmapServiceClient = netmapServiceClient;
    }

    internal async Task<NetworkSettings> GetNetworkSettingsAsync(Context ctx)
    {
        if (Context.NetworkSettings != null)
            return Context.NetworkSettings;

        var info = await GetNetworkInfoAsync(ctx);

        var settings = new NetworkSettings();

        foreach (var param in info.Body.NetworkInfo.NetworkConfig.Parameters)
        {
            SetNetworksParam(param, settings);
        }

        Context.NetworkSettings = settings;
        
        return settings;
    }

    internal async Task<NodeInfo> GetLocalNodeInfoAsync(Context ctx)
    {
        var request = new LocalNodeInfoRequest
        {
            Body = new LocalNodeInfoRequest.Types.Body { }
        };

        request.AddMetaHeader();
        request.Sign(Context.Key);
        
        var response = await netmapServiceClient.LocalNodeInfoAsync(request, null, ctx.Deadline, ctx.CancellationToken);

        Verifier.CheckResponse(response);

        return response.Body.ToModel();
    }

    internal async Task<NetworkInfoResponse> GetNetworkInfoAsync(Context ctx)
    {
        var request = new NetworkInfoRequest
        {
            Body = new NetworkInfoRequest.Types.Body { }
        };

        request.AddMetaHeader();
        request.Sign(Context.Key);
 
        var response = await netmapServiceClient.NetworkInfoAsync(request, null, ctx.Deadline, ctx.CancellationToken);

        Verifier.CheckResponse(response);

        return response;
    }

    internal async Task<NetmapSnapshot> GetNetmapSnapshotAsync(Context ctx)
    {
        var request = new NetmapSnapshotRequest
        {
            Body = new NetmapSnapshotRequest.Types.Body { }
        };

        request.AddMetaHeader();
        request.Sign(Context.Key);
 
        var response = await netmapServiceClient.NetmapSnapshotAsync(request, null, ctx.Deadline, ctx.CancellationToken);

        Verifier.CheckResponse(response);

        return response.ToModel();
    }

    private static bool GetBoolValue(byte[] bytes)
    {
        return bytes.Any(b => b != 0);
    }

    private static ulong GetLongValue(byte[] bytes)
    {
        ulong val = 0;
        for (var i = bytes.Length - 1; i >= 0; i--)
            val = (val << 8) + bytes[i];
        
        return val;
    }

    private static void SetNetworksParam(Parameter param, NetworkSettings settings)
    { 
        var key = Encoding.UTF8.GetString(param.Key.ToByteArray());

        var valueBytes = param.Value.ToByteArray();
        switch (key)
        {
            case "AuditFee": settings.AuditFee = GetLongValue(valueBytes); break;
            case "BasicIncomeRate": settings.BasicIncomeRate = GetLongValue(valueBytes); break;
            case "ContainerFee": settings.ContainerFee = GetLongValue(valueBytes); break;
            case "ContainerAliasFee": settings.ContainerAliasFee = GetLongValue(valueBytes); break;
            case "EpochDuration": settings.EpochDuration = GetLongValue(valueBytes); break;
            case "InnerRingCandidateFee": settings.InnerRingCandidateFee = GetLongValue(valueBytes); break;
            case "MaxECDataCount": settings.MaxECDataCount = GetLongValue(valueBytes); break;
            case "MaxECParityCount": settings.MaxECParityCount = GetLongValue(valueBytes); break;
            case "MaxObjectSize": settings.MaxObjectSize = GetLongValue(valueBytes); break;
            case "WithdrawFee": settings.WithdrawFee = GetLongValue(valueBytes); break;
            case "HomomorphicHashingDisabled": settings.HomomorphicHashingDisabled = GetBoolValue(valueBytes); break;
            case "MaintenanceModeAllowed": settings.MaintenanceModeAllowed = GetBoolValue(valueBytes); break;
            default: settings.UnnamedSettings.Add(key, valueBytes); break;
        }
    }
}