using System;
using System.Buffers;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;

using FrostFS.Object;
using FrostFS.Refs;
using FrostFS.SDK.Client;
using FrostFS.SDK.Client.Interfaces;
using FrostFS.SDK.Client.Mappers.GRPC;
using FrostFS.Session;

using Google.Protobuf;

namespace FrostFS.SDK.Client;

internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient client, ClientContext clientCtx)
    : ContextAccessor(clientCtx)
{
    private SessionProvider? sessions;
    private readonly ObjectService.ObjectServiceClient client = client;

    public async ValueTask<FrostFsSessionToken> GetDefaultSession(ISessionToken args, CallContext ctx)
    {
        sessions ??= new(ClientContext);

        if (!ClientContext.SessionCache!.TryGetValue(ClientContext.SessionCacheKey, out var token))
        {
            var protoToken = await sessions.GetDefaultSession(args, ctx).ConfigureAwait(false);

            token = new FrostFsSessionToken(protoToken);

            ClientContext.SessionCache.SetValue(ClientContext.SessionCacheKey, token);
        }

        if (token == null)
        {
            throw new FrostFsException("Cannot create session");
        }

        return token;
    }

    internal async Task<FrostFsHeaderResult> GetObjectHeadAsync(PrmObjectHeadGet args, CallContext ctx)
    {
        var request = new HeadRequest
        {
            Body = new HeadRequest.Types.Body
            {
                Address = new Address
                {
                    ContainerId = args.ContainerId.GetContainerID(),
                    ObjectId = args.ObjectId.ToMessage()
                },
                Raw = args.Raw
            }
        };

        var sessionToken = args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false);

        var protoToken = sessionToken.CreateObjectTokenContext(
            request.Body.Address,
            ObjectSessionContext.Types.Verb.Head,
            ClientContext.Key);

        request.AddMetaHeader(args.XHeaders, protoToken);

        request.Sign(ClientContext.Key.ECDsaKey);

        var response = await client!.HeadAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken).ConfigureAwait(false);

        Verifier.CheckResponse(response);

        var result = new FrostFsHeaderResult();

        if (response.Body.Header != null)
        {
            result.HeaderInfo = response.Body.Header?.Header.ToModel();
        }

        if (response.Body.SplitInfo != null)
        {
            result.SplitInfo = new FrostFsSplitInfo(response.Body.SplitInfo);
        }

        return result;
    }

    internal async Task<FrostFsObject> GetObjectAsync(PrmObjectGet args, CallContext ctx)
    {
        var request = new GetRequest
        {
            Body = new GetRequest.Types.Body
            {
                Address = new Address
                {
                    ContainerId = args.ContainerId.ToMessage(),
                    ObjectId = args.ObjectId.ToMessage()
                }
            }
        };

        var sessionToken = args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false);

        var protoToken = sessionToken.CreateObjectTokenContext(
            request.Body.Address,
            ObjectSessionContext.Types.Verb.Get,
            ClientContext.Key);

        request.AddMetaHeader(args.XHeaders, protoToken);

        request.Sign(ClientContext.Key.ECDsaKey);

        return await GetObject(request, ctx).ConfigureAwait(false);
    }

    internal async Task<RangeReader> GetRangeAsync(PrmRangeGet args, CallContext ctx)
    {
        var request = new GetRangeRequest
        {
            Body = new GetRangeRequest.Types.Body
            {
                Address = new Address
                {
                    ContainerId = args.ContainerId.ToMessage(),
                    ObjectId = args.ObjectId.ToMessage()
                },
                Range = new Object.Range
                {
                    Offset = args.Range.Offset,
                    Length = args.Range.Length
                },
                Raw = args.Raw
            }
        };

        var sessionToken = args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false);

        var protoToken = sessionToken.CreateObjectTokenContext(
            request.Body.Address,
            ObjectSessionContext.Types.Verb.Range,
            ClientContext.Key);

        request.AddMetaHeader(args.XHeaders, protoToken);

        request.Sign(ClientContext.Key.ECDsaKey);

        var call = client.GetRange(request, null, ctx.GetDeadline(), ctx.CancellationToken);
        return new RangeReader(call);
    }

    internal async Task<ReadOnlyMemory<byte>[]> GetRangeHashAsync(PrmRangeHashGet args, CallContext ctx)
    {
        var request = new GetRangeHashRequest
        {
            Body = new GetRangeHashRequest.Types.Body
            {
                Address = new Address
                {
                    ContainerId = args.ContainerId.ToMessage(),
                    ObjectId = args.ObjectId.ToMessage()
                },
                Type = ChecksumType.Sha256,
                Salt = ByteString.CopyFrom(args.Salt) // TODO: create a type with calculated cashed ByteString inside
            }
        };

        foreach (var range in args.Ranges)
        {
            request.Body.Ranges.Add(new Object.Range
            {
                Length = range.Length,
                Offset = range.Offset
            });
        }

        var sessionToken = args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false);

        var protoToken = sessionToken.CreateObjectTokenContext(
            request.Body.Address,
            ObjectSessionContext.Types.Verb.Rangehash,
            ClientContext.Key);

        request.AddMetaHeader(args.XHeaders, protoToken);

        request.Sign(ClientContext.Key.ECDsaKey);

        var response = await client.GetRangeHashAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);

        Verifier.CheckResponse(response);

        var hashCollection = response.Body.HashList.Select(h => h.Memory).ToArray();

        return hashCollection;
    }

    internal async Task DeleteObjectAsync(PrmObjectDelete args, CallContext ctx)
    {
        var request = new DeleteRequest
        {
            Body = new DeleteRequest.Types.Body
            {
                Address = new Address
                {
                    ContainerId = args.ContainerId.ToMessage(),
                    ObjectId = args.ObjectId.ToMessage()
                }
            }
        };

        var sessionToken = args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false);

        var protoToken = sessionToken.CreateObjectTokenContext(
            request.Body.Address,
            ObjectSessionContext.Types.Verb.Delete,
            ClientContext.Key);

        request.AddMetaHeader(args.XHeaders, protoToken);
        request.Sign(ClientContext.Key.ECDsaKey);

        var response = await client.DeleteAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);

        Verifier.CheckResponse(response);
    }

    internal async IAsyncEnumerable<FrostFsObjectId> SearchObjectsAsync(PrmObjectSearch args, CallContext ctx)
    {
        var request = new SearchRequest
        {
            Body = new SearchRequest.Types.Body
            {
                ContainerId = args.ContainerId.ToMessage(),
                Version = 1  // TODO: clarify this param
            }
        };

        request.Body.Filters.AddRange(args.Filters.Select(f => f.ToMessage()));

        var sessionToken = args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false);

        var protoToken = sessionToken.CreateObjectTokenContext(
            new Address { ContainerId = request.Body.ContainerId },
            ObjectSessionContext.Types.Verb.Search,
            ClientContext.Key);

        request.AddMetaHeader(args.XHeaders, protoToken);

        request.Sign(ClientContext.Key.ECDsaKey);

        using var stream = GetSearchReader(request, ctx);

        while (true)
        {
            var ids = await stream.Read(ctx.CancellationToken).ConfigureAwait(false);

            if (ids == null)
                yield break;

            foreach (var oid in ids)
            {
                yield return FrostFsObjectId.FromHash(oid.Value.Span);
            }
        }
    }

    internal async Task<FrostFsObjectId> PutSingleObjectAsync(PrmSingleObjectPut args, CallContext ctx)
    {
        var grpcObject = ObjectTools.CreateSingleObject(args.FrostFsObject, ClientContext);

        var request = new PutSingleRequest
        {
            Body = new() { Object = grpcObject }
        };

        var sessionToken = args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false);

        var protoToken = sessionToken.CreateObjectTokenContext(
            new Address { ContainerId = grpcObject.Header.ContainerId },
            ObjectSessionContext.Types.Verb.Put,
            ClientContext.Key);

        request.AddMetaHeader(args.XHeaders, protoToken);

        request.Sign(ClientContext.Key.ECDsaKey);

        var response = await client.PutSingleAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken).ConfigureAwait(false);

        Verifier.CheckResponse(response);

        return FrostFsObjectId.FromHash(grpcObject.ObjectId.Value.Span);
    }

    internal async Task<FrostFsObjectId> PatchObjectAsync(PrmObjectPatch args, CallContext ctx)
    {
        var chunkSize = args.MaxChunkLength;
        Stream payload = args.Payload ?? throw new ArgumentNullException(nameof(args), "Stream parameter is null");
  
        var call = client.Patch(null, ctx.GetDeadline(), ctx.CancellationToken);

        byte[]? chunkBuffer = null;
        try
        {
            // common 
            chunkBuffer = ArrayPool<byte>.Shared.Rent(chunkSize);

            bool isFirstChunk = true;
            ulong currentPos = args.Range.Offset;
            
            var address = new Address
            {
                ObjectId = args.Address.ObjectId,
                ContainerId = args.Address.ContainerId
            };

            while (true)
            {
                var bytesCount = await payload.ReadAsync(chunkBuffer, 0, chunkSize, ctx.CancellationToken).ConfigureAwait(false);

                if (bytesCount == 0)
                {
                    break;
                }

                var request = new PatchRequest()
                {
                    Body = new()
                    {
                        Address = address,
                        Patch = new PatchRequest.Types.Body.Types.Patch
                        {
                            Chunk = ByteString.CopyFrom(chunkBuffer, 0, bytesCount),
                            SourceRange = new Object.Range { Offset = currentPos, Length = (ulong)bytesCount }
                        }
                    }
                };

                if (isFirstChunk)
                {
                    var sessionToken = args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false);

                    var protoToken = sessionToken.CreateObjectTokenContext(
                        address,
                        ObjectSessionContext.Types.Verb.Patch,
                        ClientContext.Key);

                    request.AddMetaHeader(args.XHeaders, protoToken);

                    if (args.NewAttributes != null && args.NewAttributes.Length > 0)
                    {
                        foreach (var attr in args.NewAttributes)
                        {
                            request.Body.NewAttributes.Add(attr.ToMessage());
                            request.Body.ReplaceAttributes = args.ReplaceAttributes;
                        }
                    }

                    isFirstChunk = false;
                }
                else
                {
                    request.AddMetaHeader(args.XHeaders);
                }

                request.Sign(ClientContext.Key.ECDsaKey);

                await call.RequestStream.WriteAsync(request).ConfigureAwait(false);

                currentPos += (ulong)bytesCount;
            }
        }
        finally
        {
            if (chunkBuffer != null)
            {
                ArrayPool<byte>.Shared.Return(chunkBuffer);
            }
        }

        await call.RequestStream.CompleteAsync().ConfigureAwait(false);
        var response = await call.ResponseAsync.ConfigureAwait(false);

        Verifier.CheckResponse(response);

        return response.Body.ObjectId.ToModel();
    }

    internal async Task<FrostFsObjectId> PutClientCutObjectAsync(PrmObjectClientCutPut args, CallContext ctx)
    {
        var payloadStream = args.Payload!;
        var header = args.Header!;

        if (header.PayloadLength > 0)
            args.PutObjectContext.FullLength = header.PayloadLength;
        else if (payloadStream.CanSeek)
            args.PutObjectContext.FullLength = (ulong)payloadStream.Length;
        else
            throw new ArgumentException("The stream does not have a length and payload length is not defined");

        if (args.PutObjectContext.MaxObjectSizeCache == 0)
        {
            var networkSettings = await ClientContext.Client.GetNetworkSettingsAsync(ctx)
                .ConfigureAwait(false);

            args.PutObjectContext.MaxObjectSizeCache = (int)networkSettings.MaxObjectSize;
        }

        var restBytes = args.PutObjectContext.FullLength - args.PutObjectContext.CurrentStreamPosition;
        var objectSize = restBytes > 0 ? (int)Math.Min((ulong)args.PutObjectContext.MaxObjectSizeCache, restBytes) : args.PutObjectContext.MaxObjectSizeCache;

        //define collection capacity
        var restPart = (restBytes % (ulong)objectSize) > 0 ? 1 : 0;
        var objectsCount = args.PutObjectContext.FullLength > 0 ? (int)(restBytes / (ulong)objectSize) + restPart : 0;

        List<FrostFsObjectId> sentObjectIds = new(objectsCount);

        FrostFsSplit? split = null;
        SplitId splitId = new();

        // keep attributes for the large object
        var attributes = args.Header!.Attributes;
        args.Header!.Attributes = null;

        // send all parts except the last one as separate Objects
        while (restBytes > (ulong)args.PutObjectContext.MaxObjectSizeCache)
        {
            split = new FrostFsSplit(splitId, sentObjectIds.LastOrDefault());

            args.Header!.Split = split;

            var result = await PutMultipartStreamObjectAsync(args, default).ConfigureAwait(false);

            sentObjectIds.Add(result.ObjectId);

            restBytes -= (ulong)result.ObjectSize;
        }

        // send the last part and create linkObject
        if (sentObjectIds.Count > 0)
        {
            var largeObjectHeader = new FrostFsObjectHeader(
                header.ContainerId,
                FrostFsObjectType.Regular,
                attributes != null ? [.. attributes] : [])
            {
                PayloadLength = args.PutObjectContext.FullLength,
            };

            args.Header.Split!.ParentHeader = largeObjectHeader;

            var result = await PutMultipartStreamObjectAsync(args, default).ConfigureAwait(false);

            sentObjectIds.Add(result.ObjectId);

            var linkObject = new FrostFsLinkObject(header.ContainerId, split!.SplitId, largeObjectHeader, sentObjectIds);

            _ = await PutSingleObjectAsync(new PrmSingleObjectPut(linkObject), ctx).ConfigureAwait(false);

            var parentHeader = args.Header.GetHeader();

            return parentHeader.Split!.Parent.ToModel();
        }

        // We are here if the payload is placed to one Object. It means no cut action, just simple PUT.
        args.Header!.Attributes = attributes;

        var singlePartResult = await PutMultipartStreamObjectAsync(args, default).ConfigureAwait(false);

        return singlePartResult.ObjectId;
    }

    struct PutObjectResult(FrostFsObjectId objectId, int objectSize)
    {
        public FrostFsObjectId ObjectId = objectId;
        public int ObjectSize = objectSize;
    }

    private async Task<PutObjectResult> PutMultipartStreamObjectAsync(PrmObjectClientCutPut args, CallContext ctx)
    {
        var payload = args.Payload!;

        var chunkSize = args.BufferMaxSize > 0 ? args.BufferMaxSize : Constants.ObjectChunkSize;

        var restBytes = args.PutObjectContext.FullLength - args.PutObjectContext.CurrentStreamPosition;

        chunkSize = (int)Math.Min(restBytes, (ulong)chunkSize);

        bool isRentBuffer = false;
        byte[]? chunkBuffer = null;

        try
        {
            // 0 means no limit from client, so server side cut is performed
            var objectLimitSize = args.PutObjectContext.MaxObjectSizeCache;

            if (args.CustomBuffer != null)
            {
                if (args.CustomBuffer.Length < chunkSize)
                {
                    throw new ArgumentException($"Buffer size is too small. At least {chunkSize} required");
                }

                chunkBuffer = args.CustomBuffer;
            }
            else
            {
                chunkBuffer = ArrayPool<byte>.Shared.Rent(chunkSize);
                isRentBuffer = true;
            }

            var sentBytes = 0;

            using var stream = await GetUploadStream(args, ctx).ConfigureAwait(false);

            while (objectLimitSize == 0 || sentBytes < objectLimitSize)
            {
                // send chunks limited to default or user's settings
                var bufferSize = objectLimitSize > 0 ?
                    Math.Min(objectLimitSize - sentBytes, chunkSize)
                    : chunkSize;

                var bytesCount = await payload.ReadAsync(chunkBuffer, 0, bufferSize, ctx.CancellationToken).ConfigureAwait(false);

                if (bytesCount == 0)
                    break;

                sentBytes += bytesCount;

                var chunkRequest = new PutRequest
                {
                    Body = new PutRequest.Types.Body
                    {
                        Chunk = ByteString.CopyFrom(chunkBuffer, 0, bytesCount)
                    }
                };

                chunkRequest.AddMetaHeader(args.XHeaders);

                chunkRequest.Sign(ClientContext.Key.ECDsaKey);

                await stream.Write(chunkRequest).ConfigureAwait(false);
            }

            var response = await stream.Close().ConfigureAwait(false);
            Verifier.CheckResponse(response);

            return new PutObjectResult(FrostFsObjectId.FromHash(response.Body.ObjectId.Value.Span), sentBytes);
        }
        finally
        {
            if (isRentBuffer && chunkBuffer != null)
            {
                ArrayPool<byte>.Shared.Return(chunkBuffer);
            }
        }
    }

    internal async Task<IObjectWriter> PutStreamObjectAsync(PrmObjectPutBase args, CallContext ctx)
    {
        var stream = await GetUploadStream(args, ctx).ConfigureAwait(false);

        return new ObjectWriter(ClientContext, args, stream);
    }

    private async Task<ObjectStreamer<PutRequest, PutResponse>> GetUploadStream(PrmObjectPutBase args, CallContext ctx)
    {
        var header = args.Header!;

        header.OwnerId ??= ClientContext.Owner;
        header.Version ??= ClientContext.Version;

        var grpcHeader = header.GetHeader();

        if (header.Split != null)
        {
            ObjectTools.SetSplitValues(grpcHeader, header.Split, ClientContext.Owner, ClientContext.Version, ClientContext.Key);
        }

        var initRequest = new PutRequest
        {
            Body = new PutRequest.Types.Body
            {
                Init = new PutRequest.Types.Body.Types.Init
                {
                    Header = grpcHeader
                }
            }
        };

        var sessionToken = args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false);

        var protoToken = sessionToken.CreateObjectTokenContext(
            new Address { ContainerId = grpcHeader.ContainerId },
            ObjectSessionContext.Types.Verb.Put,
            ClientContext.Key);

        initRequest.AddMetaHeader(args.XHeaders, protoToken);

        initRequest.Sign(ClientContext.Key.ECDsaKey);

        return await PutObjectInit(initRequest, ctx).ConfigureAwait(false);
    }

    private async Task<ObjectStreamer<PutRequest, PutResponse>> PutObjectInit(PutRequest initRequest, CallContext ctx)
    {
        if (initRequest is null)
        {
            throw new ArgumentNullException(nameof(initRequest));
        }

        var call = client.Put(null, ctx.GetDeadline(), ctx.CancellationToken);

        await call.RequestStream.WriteAsync(initRequest).ConfigureAwait(false);

        return new ObjectStreamer<PutRequest, PutResponse>(call);
    }

    private async Task<FrostFsObject> GetObject(GetRequest request, CallContext ctx)
    {
        var reader = GetObjectInit(request, ctx);

        var grpcObject = await reader.ReadHeader().ConfigureAwait(false);
        var modelObject = grpcObject.ToModel();

        modelObject.ObjectReader = reader;

        return modelObject;
    }

    private ObjectReader GetObjectInit(GetRequest initRequest, CallContext ctx)
    {
        if (initRequest is null)
            throw new ArgumentNullException(nameof(initRequest));

        var call = client.Get(initRequest, null, ctx.GetDeadline(), ctx.CancellationToken);

        return new ObjectReader(call);
    }

    private SearchReader GetSearchReader(SearchRequest initRequest, CallContext ctx)
    {
        if (initRequest is null)
        {
            throw new ArgumentNullException(nameof(initRequest));
        }

        var call = client.Search(initRequest, null, ctx.GetDeadline(), ctx.CancellationToken);

        return new SearchReader(call);
    }
}