using System;
using System.Collections.Generic;
using System.Threading.Tasks;

using FrostFS.SDK.Client.Interfaces;
using FrostFS.SDK.Client.Services;
using FrostFS.SDK.Cryptography;
using FrostFS.Session;

using Grpc.Core;
using Grpc.Core.Interceptors;

using Microsoft.Extensions.Options;

using static Frostfs.V2.Apemanager.APEManagerService;
using static FrostFS.Accounting.AccountingService;
using static FrostFS.Container.ContainerService;
using static FrostFS.Netmap.NetmapService;
using static FrostFS.Object.ObjectService;
using static FrostFS.Session.SessionService;

namespace FrostFS.SDK.Client;

public class FrostFSClient : IFrostFSClient
{
    internal ContainerServiceClient? ContainerServiceClient { get; set; }
    internal ContainerServiceProvider? ContainerServiceProvider { get; set; }

    internal NetmapServiceClient? NetmapServiceClient { get; set; }
    internal NetmapServiceProvider? NetmapServiceProvider { get; set; }

    internal APEManagerServiceClient? ApeManagerServiceClient { get; set; }
    internal ApeManagerServiceProvider? ApeManagerServiceProvider { get; set; }

    internal SessionServiceClient? SessionServiceClient { get; set; }
    internal SessionServiceProvider? SessionServiceProvider { get; set; }

    internal ObjectServiceClient? ObjectServiceClient { get; set; }
    internal ObjectServiceProvider? ObjectServiceProvider { get; set; }

    internal AccountingServiceClient? AccountingServiceClient { get; set; }
    internal AccountingServiceProvider? AccountingServiceProvider { get; set; }

    internal ClientContext ClientCtx { get; set; }

    public static IFrostFSClient GetInstance(IOptions<ClientSettings> clientOptions, Func<string, ChannelBase> grpcChannelFactory)
    {
        if (clientOptions is null)
        {
            throw new ArgumentNullException(nameof(clientOptions));
        }

        if (grpcChannelFactory is null)
        {
            throw new ArgumentNullException(nameof(grpcChannelFactory));
        }

        return new FrostFSClient(clientOptions, grpcChannelFactory);
    }

    /// <summary>
    /// For test only. Provide custom implementation or mock object to inject required logic instead of internal gRPC client.
    /// </summary>
    /// <param name="clientOptions">Global setting for client</param>
    /// <param name="channelOptions">Setting for gRPC channel</param>
    /// <param name="containerService">ContainerService.ContainerServiceClient implementation</param>
    /// <param name="netmapService">Netmap.NetmapService.NetmapServiceClient implementation</param>
    /// <param name="sessionService">Session.SessionService.SessionServiceClient implementation</param>
    /// <param name="objectService">Object.ObjectService.ObjectServiceClient implementation</param>
    /// <returns></returns>
    public static IFrostFSClient GetTestInstance(
        IOptions<ClientSettings> settings,
        Func<string, ChannelBase> grpcChannelFactory,
        NetmapServiceClient netmapService,
        SessionServiceClient sessionService,
        ContainerServiceClient containerService,
        ObjectServiceClient objectService)
    {
        if (settings is null)
        {
            throw new ArgumentNullException(nameof(settings));
        }

        if (grpcChannelFactory is null)
        {
            throw new ArgumentNullException(nameof(grpcChannelFactory));
        }

        if (netmapService is null)
        {
            throw new ArgumentNullException(nameof(netmapService));
        }

        if (sessionService is null)
        {
            throw new ArgumentNullException(nameof(sessionService));
        }

        if (containerService is null)
        {
            throw new ArgumentNullException(nameof(containerService));
        }

        if (objectService is null)
        {
            throw new ArgumentNullException(nameof(objectService));
        }

        return new FrostFSClient(
            settings, channel: grpcChannelFactory(settings.Value.Host), containerService, netmapService, sessionService, objectService);
    }

    private FrostFSClient(
      IOptions<ClientSettings> settings,
      ChannelBase channel,
      ContainerServiceClient containerService,
      NetmapServiceClient netmapService,
      SessionServiceClient sessionService,
      ObjectServiceClient objectService)
    {
        if (settings is null)
        {
            throw new ArgumentNullException(nameof(settings));
        }

        var ecdsaKey = settings.Value.Key.LoadWif();

        ClientCtx = new ClientContext(
           client: this,
           key: new ClientKey(ecdsaKey),
           owner: FrostFsOwner.FromKey(ecdsaKey),
           channel: channel,
           version: new FrostFsVersion(2, 13))
        {
            SessionCache = new SessionCache(0),
            Callback = settings.Value.Callback,
            Interceptors = settings.Value.Interceptors
        };

        ContainerServiceClient = containerService ?? throw new ArgumentNullException(nameof(containerService));
        NetmapServiceClient = netmapService ?? throw new ArgumentNullException(nameof(netmapService));
        SessionServiceClient = sessionService ?? throw new ArgumentNullException(nameof(sessionService));
        ObjectServiceClient = objectService ?? throw new ArgumentNullException(nameof(objectService));
    }

    private FrostFSClient(IOptions<ClientSettings> settings, Func<string, ChannelBase> grpcChannelFactory)
    {
        var clientSettings = (settings?.Value) ?? throw new ArgumentNullException(nameof(settings), "Options value must be initialized");

        clientSettings.Validate();

        var ecdsaKey = clientSettings.Key.LoadWif();

        ClientCtx = new ClientContext(
            this,
            key: new ClientKey(ecdsaKey),
            owner: FrostFsOwner.FromKey(ecdsaKey),
            channel: grpcChannelFactory(settings.Value.Host),
            version: new FrostFsVersion(2, 13))
        {
            SessionCache = new SessionCache(0),
            Callback = settings.Value.Callback,
            Interceptors = settings.Value.Interceptors
        };

        // TODO: define timeout logic
        // CheckFrostFsVersionSupport(new Context { Timeout = TimeSpan.FromSeconds(20) });
    }

    internal FrostFSClient(WrapperPrm prm, SessionCache cache)
    {
        ClientCtx = new ClientContext(
           client: this,
           key: new ClientKey(prm.Key),
           owner: FrostFsOwner.FromKey(prm.Key!),
           channel: prm.GrpcChannelFactory(prm.Address),
           version: new FrostFsVersion(2, 13))
        {
            SessionCache = cache,
            Interceptors = prm.Interceptors,
            Callback = prm.Callback
        };
    }

    #region ApeManagerImplementation
    public Task<ReadOnlyMemory<byte>> AddChainAsync(PrmApeChainAdd args, CallContext ctx)
    {
        return GetApeManagerService().AddChainAsync(args, ctx);
    }

    public Task RemoveChainAsync(PrmApeChainRemove args, CallContext ctx)
    {
        return GetApeManagerService().RemoveChainAsync(args, ctx);
    }

    public Task<FrostFsChain[]> ListChainAsync(PrmApeChainList args, CallContext ctx)
    {
        return GetApeManagerService().ListChainAsync(args, ctx);
    }
    #endregion

    #region ContainerImplementation
    public Task<FrostFsContainerInfo> GetContainerAsync(PrmContainerGet args, CallContext ctx)
    {
        return GetContainerService().GetContainerAsync(args, ctx);
    }

    public IAsyncEnumerable<FrostFsContainerId> ListContainersAsync(PrmContainerGetAll args, CallContext ctx)
    {
        return GetContainerService().ListContainersAsync(args, ctx);
    }

    [Obsolete("Use PutContainerAsync method")]
    public Task<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args, CallContext ctx)
    {
        return GetContainerService().PutContainerAsync(args, ctx);
    }

    public Task<FrostFsContainerId> PutContainerAsync(PrmContainerCreate args, CallContext ctx)
    {
        return GetContainerService().PutContainerAsync(args, ctx);
    }

    public Task DeleteContainerAsync(PrmContainerDelete args, CallContext ctx)
    {
        return GetContainerService().DeleteContainerAsync(args, ctx);
    }
    #endregion

    #region NetworkImplementation
    public Task<FrostFsNetmapSnapshot> GetNetmapSnapshotAsync(CallContext ctx)
    {
        return GetNetmapService().GetNetmapSnapshotAsync(ctx);
    }

    public Task<FrostFsNodeInfo> GetNodeInfoAsync(CallContext ctx)
    {
        return GetNetmapService().GetLocalNodeInfoAsync(ctx);
    }

    public Task<NetworkSettings> GetNetworkSettingsAsync(CallContext ctx)
    {
        return GetNetmapService().GetNetworkSettingsAsync(ctx);
    }
    #endregion

    #region ObjectImplementation
    public Task<FrostFsHeaderResult> GetObjectHeadAsync(PrmObjectHeadGet args, CallContext ctx)
    {
        return GetObjectService().GetObjectHeadAsync(args, ctx);
    }

    public Task<FrostFsObject> GetObjectAsync(PrmObjectGet args, CallContext ctx)
    {
        return GetObjectService().GetObjectAsync(args, ctx);
    }

    public Task<RangeReader> GetRangeAsync(PrmRangeGet args, CallContext ctx)
    {
        return GetObjectService().GetRangeAsync(args, ctx);
    }

    public Task<ReadOnlyMemory<byte>[]> GetRangeHashAsync(PrmRangeHashGet args, CallContext ctx)
    {
        return GetObjectService().GetRangeHashAsync(args, ctx);
    }

    public Task<IObjectWriter> PutObjectAsync(PrmObjectPut args, CallContext ctx)
    {
        return GetObjectService().PutStreamObjectAsync(args, ctx);
    }

    public Task<FrostFsObjectId> PutClientCutObjectAsync(PrmObjectClientCutPut args, CallContext ctx)
    {
        return GetObjectService().PutClientCutObjectAsync(args, ctx);
    }

    public Task<FrostFsObjectId> PutSingleObjectAsync(PrmSingleObjectPut args, CallContext ctx)
    {
        return GetObjectService().PutSingleObjectAsync(args, ctx);
    }

    public Task<FrostFsObjectId> PatchObjectAsync(PrmObjectPatch args, CallContext ctx)
    {
        return GetObjectService().PatchObjectAsync(args, ctx);
    }

    public Task DeleteObjectAsync(PrmObjectDelete args, CallContext ctx)
    {
        return GetObjectService().DeleteObjectAsync(args, ctx);
    }

    public IAsyncEnumerable<FrostFsObjectId> SearchObjectsAsync(PrmObjectSearch args, CallContext ctx)
    {
        return GetObjectService().SearchObjectsAsync(args, ctx);
    }
    #endregion

    #region Session Implementation
    public async Task<FrostFsSessionToken> CreateSessionAsync(PrmSessionCreate args, CallContext ctx)
    {
        var token = await CreateSessionInternalAsync(args, ctx).ConfigureAwait(false);

        return new FrostFsSessionToken(token);
    }

    internal Task<SessionToken> CreateSessionInternalAsync(PrmSessionCreate args, CallContext ctx)
    {
        var service = GetSessionService();
        return service.CreateSessionAsync(args, ctx);
    }
    #endregion

    #region Accounting Implementation
    public async Task<Accounting.Decimal> GetBalanceAsync(CallContext ctx)
    {
        return await GetAccouningService().GetBallance(ctx).ConfigureAwait(false);
    }
    #endregion

    private CallInvoker? CreateInvoker()
    {
        CallInvoker? callInvoker = null;

        if (ClientCtx.Interceptors != null)
        {
            foreach (var interceptor in ClientCtx.Interceptors)
                callInvoker = AddInvoker(callInvoker, interceptor);
        }

        if (ClientCtx.Callback != null)
            callInvoker = AddInvoker(callInvoker, new MetricsInterceptor(ClientCtx.Callback));

        if (ClientCtx.PoolErrorHandler != null)
            callInvoker = AddInvoker(callInvoker, new ErrorInterceptor(ClientCtx.PoolErrorHandler));

        return callInvoker;

        CallInvoker AddInvoker(CallInvoker? callInvoker, Interceptor interceptor)
        {
            if (callInvoker == null)
                callInvoker = ClientCtx.Channel.Intercept(interceptor);
            else
                callInvoker = callInvoker.Intercept(interceptor);

            return callInvoker;
        }
    }

    private NetmapServiceProvider GetNetmapService()
    {
        if (NetmapServiceProvider == null)
        {
            var invoker = CreateInvoker();

            NetmapServiceClient ??= (
                invoker != null
                ? new NetmapServiceClient(invoker)
                : new NetmapServiceClient(ClientCtx.Channel));

            NetmapServiceProvider = new NetmapServiceProvider(NetmapServiceClient, ClientCtx);
        }

        return NetmapServiceProvider;
    }

    private SessionServiceProvider GetSessionService()
    {
        if (SessionServiceProvider == null)
        {
            var invoker = CreateInvoker();

            SessionServiceClient ??= (
                invoker != null
                ? new SessionServiceClient(invoker)
                : new SessionServiceClient(ClientCtx.Channel));

            SessionServiceProvider = new SessionServiceProvider(SessionServiceClient, ClientCtx);
        }

        return SessionServiceProvider;
    }

    private ApeManagerServiceProvider GetApeManagerService()
    {
        if (ApeManagerServiceProvider == null)
        {
            var invoker = CreateInvoker();

            ApeManagerServiceClient ??= (
                invoker != null
                ? new APEManagerServiceClient(invoker)
                : new APEManagerServiceClient(ClientCtx.Channel));

            ApeManagerServiceProvider = new ApeManagerServiceProvider(ApeManagerServiceClient, ClientCtx);
        }

        return ApeManagerServiceProvider;
    }

    private AccountingServiceProvider GetAccouningService()
    {
        if (this.AccountingServiceProvider == null)
        {
            var invoker = CreateInvoker();

            AccountingServiceClient ??= (
                invoker != null
                ? new AccountingServiceClient(invoker)
                : new AccountingServiceClient(ClientCtx.Channel));

            AccountingServiceProvider = new AccountingServiceProvider(AccountingServiceClient, ClientCtx);
        }

        return AccountingServiceProvider;
    }

    private ContainerServiceProvider GetContainerService()
    {
        if (this.ContainerServiceProvider == null)
        {
            var invoker = CreateInvoker();

            ContainerServiceClient ??= (
                invoker != null
                ? new ContainerServiceClient(invoker)
                : new ContainerServiceClient(ClientCtx.Channel));

            ContainerServiceProvider = new ContainerServiceProvider(ContainerServiceClient, ClientCtx);
        }

        return ContainerServiceProvider;
    }

    private ObjectServiceProvider GetObjectService()
    {
        if (this.ObjectServiceProvider == null)
        {
            var invoker = CreateInvoker();

            ObjectServiceClient ??= (
                invoker != null
                ? new ObjectServiceClient(invoker)
                : new ObjectServiceClient(ClientCtx.Channel));

            ObjectServiceProvider = new ObjectServiceProvider(ObjectServiceClient, ClientCtx);
        }

        return ObjectServiceProvider;
    }

    public async Task<string?> Dial(CallContext ctx)
    {
        var service = GetAccouningService();
        _ = await service.GetBallance(ctx).ConfigureAwait(false);

        return null;
    }

    public bool RestartIfUnhealthy(CallContext ctx)
    {
        throw new NotImplementedException();
    }
}