using System;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.WebSockets;
using System.Reflection;
using System.Security.Authentication.ExtendedProtection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;

namespace HttpClientSnifferExample
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // DI просто для примера
            var services = new ServiceCollection();
            // настраиваем HTTP клиента
            services.AddHttpClient("test")
                // здесь добавляем наш супер-хендлер
                .AddHttpMessageHandler(() => new WrapperHandler())
                .ConfigureHttpClient(client =>
                {
                    client.BaseAddress = new Uri("https://postman-echo.com");
                });

            var serviceProvider = services.BuildServiceProvider();

            var factory = serviceProvider.GetRequiredService<IHttpClientFactory>();
            var client = factory.CreateClient("test");

            // выполняем тестовый запрос
            var response = await client.PostAsync("post", new StringContent("{\"test\": 123}", Encoding.UTF8, "application/json"));

            // получаем реальный размер запроса
            if (response.RequestMessage!.Options.TryGetValue(new HttpRequestOptionsKey<long>("RequestLength"),
                out var requestLength))
            {
                Console.WriteLine($"Real request length: {requestLength}");
            }

            // получаем реальный размер ответа (вообще он должен быть прочитан для начала)
            if (response.RequestMessage!.Options.TryGetValue(new HttpRequestOptionsKey<long>("ResponseLength"),
                out var responseLength))
            {
                Console.WriteLine($"Real response length: {responseLength}");
            }

            // просто посмотреть чё там
            var requestContent = await response.RequestMessage.Content.ReadAsStringAsync();
            var responseContent = await response.Content.ReadAsStringAsync();

            Console.WriteLine($"Request:\n{requestContent}\n\n");
            Console.WriteLine($"Response:\n{responseContent}\n\n");
        }
    }

    /// <summary>
    ///     Хендлер для обёртки содержимого запроса и ответа.
    /// </summary>
    public class WrapperHandler : DelegatingHandler
    {
        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            request.Content = new HttpContentWrapper(request.Content, request.Options, "RequestLength");
            var response = await base.SendAsync(request, cancellationToken);
            response.Content = new HttpContentWrapper(response.Content, request.Options, "ResponseLength");
            return response;
        }
    }

    /// <summary>
    ///     Обёртка для любого HttpContent, чтобы снифать содержимого и считать реальный размер.
    /// </summary>
    public class HttpContentWrapper : HttpContent
    {
        private readonly HttpContent _baseContent;
        private readonly HttpRequestOptions _options;
        private readonly string _optionsName;

        public HttpContentWrapper(HttpContent baseContent, HttpRequestOptions options, string optionsName)
        {
            _baseContent = baseContent;
            _options = options;
            _optionsName = optionsName;

            if (baseContent.Headers != null)
            {
                foreach (var (key, value) in baseContent.Headers)
                {
                    Headers.Add(key, value);
                }
            }
        }

        protected override async Task SerializeToStreamAsync(Stream stream, TransportContext? context)
        {
            var streamWrapper = new StreamLengthWrapper(stream);
            await _baseContent.CopyToAsync(streamWrapper, context);
            _options.Set(new HttpRequestOptionsKey<long>(_optionsName), streamWrapper.GetProcessedLength());
        }

        // ну это костыли конечно )) куда деваться
        protected override bool TryComputeLength(out long length)
        {
            var lengthParam = new object[] { null };
            var result = _baseContent.GetType().InvokeMember(nameof(TryComputeLength),
                BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod, null, _baseContent, lengthParam);
            length = (long)lengthParam[0];
            return (bool)result!;
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                _baseContent.Dispose();
            }
        }
    }

    /// <summary>
    ///     Простейшая обёртка любого Stream, конкретно данная обёртка нужна для подсчёта прочитанного/записанного объёма данных.
    /// </summary>
    public class StreamLengthWrapper : Stream
    {
        private readonly Stream _baseStream;
        private long _processedLength;

        public StreamLengthWrapper(Stream baseStream)
        {
            _baseStream = baseStream;
            _processedLength = 0L;
        }

        public long GetProcessedLength() => _processedLength;

        public override void Flush()
        {
            _baseStream.Flush();
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            _processedLength += count;
            return _baseStream.Read(buffer, offset, count);
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            throw new NotSupportedException("Seek not supported.");
        }

        public override void SetLength(long value)
        {
            throw new NotSupportedException("SetLength not supported.");
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            _processedLength += count;
            _baseStream.Write(buffer, offset, count);
        }

        public override bool CanRead => _baseStream.CanRead;

        public override bool CanSeek => false;

        public override bool CanWrite => _baseStream.CanWrite;

        public override long Length => _baseStream.Length;

        public override long Position
        {
            get => _baseStream.Position;
            set => throw new NotSupportedException("Set Position not supported.");
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                _baseStream.Dispose();
            }
        }

        public override ValueTask DisposeAsync()
        {
            return _baseStream.DisposeAsync();
        }
    }
}