using System;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Dpz.Core.Entity.Base;
using Dpz.Core.Entity.Base.Image;
using Dpz.Core.Infrastructure;
using Dpz.Core.Service.ObjectStorage;
using Dpz.Core.Shard.Service;
using Microsoft.Extensions.Logging.Abstractions;
using NUnit.Framework;

namespace Dpz.Core.Server.ObjectStorage.Test;

[TestFixture]
public class UpyunUploadMetadataTest
{
    [Test]
    public async Task UploadAsync_ImageHeaders_ReturnsImageMetadata()
    {
        using var httpClient = CreateHttpClient(() =>
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new ByteArrayContent([]),
            };
            response.Headers.Add("x-upyun-file-type", "png");
            response.Headers.Add("x-upyun-width", "640");
            response.Headers.Add("x-upyun-height", "480");
            response.Headers.Add("x-upyun-frames", "1");
            return response;
        });
        var upload = new UpyunUpload(httpClient, NullLogger<UpyunUpload>.Instance);

        var result = await upload.UploadAsync(
            ["images", "demo.png"],
            () => new ByteArrayContent([1, 2, 3]),
            CreateOperator(),
            size: 3,
            hash: "local-md5"
        );

        Assert.That(result, Is.TypeOf<ImageMetadata>());
        var image = (ImageMetadata)result;
        Assert.Multiple(() =>
        {
            Assert.That(image.Url, Is.EqualTo("https://cdn.example.com/images/demo.png"));
            Assert.That(image.Width, Is.EqualTo(640));
            Assert.That(image.Height, Is.EqualTo(480));
            Assert.That(image.Frames, Is.EqualTo(1));
            Assert.That(image.Hash, Is.EqualTo("local-md5"));
            Assert.That(image.Size, Is.EqualTo(3));
            Assert.That(image.Format.Kind, Is.EqualTo(ImageFormatKind.Png));
        });
    }

    [Test]
    public async Task UploadAsync_NonImageHeaders_ReturnsFileMetadata()
    {
        using var httpClient = CreateHttpClient(() =>
            new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent([]) }
        );
        var upload = new UpyunUpload(httpClient, NullLogger<UpyunUpload>.Instance);

        var result = await upload.UploadAsync(
            ["files", "readme.txt"],
            () => new StringContent("hello"),
            CreateOperator(),
            size: 5,
            hash: "local-md5"
        );

        Assert.That(result, Is.TypeOf<FileMetadata>());
        var file = (FileMetadata)result;
        Assert.Multiple(() =>
        {
            Assert.That(file.Url, Is.EqualTo("https://cdn.example.com/files/readme.txt"));
            Assert.That(file.Size, Is.EqualTo(5));
            Assert.That(file.Hash, Is.EqualTo("local-md5"));
        });
    }

    [Test]
    public async Task UploadFileAsync_SmallFile_UsesMetadataUrl()
    {
        using var httpClient = CreateHttpClient(() => throw new InvalidOperationException());
        var uploader = new ParallelChunkBreakpointUpload<UpyunOperator>(
            NullLogger<ParallelChunkBreakpointUpload<UpyunOperator>>.Instance,
            httpClient,
            CreateOperator()
        );
        await using var stream = new MemoryStream([1, 2, 3]);
        var cloudFile = new CloudFile(stream, ["files", "small.txt"]);

        var result = await uploader.UploadFileAsync(
            cloudFile,
            (_, _, size, hash, _, _) =>
                Task.FromResult<IFileMetadata>(
                    new FileMetadata("https://cdn.example.com/files/small.txt", size, hash)
                )
        );

        Assert.That(result, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(result!.Value.Url, Is.EqualTo("https://cdn.example.com/files/small.txt"));
            Assert.That(result.Value.Md5, Is.Not.Null.And.Not.Empty);
        });
    }

    private static UpyunOperator CreateOperator() =>
        new()
        {
            Bucket = "bucket",
            Host = "https://cdn.example.com",
            Operator = "operator",
            Password = "password",
        };

    private static HttpClient CreateHttpClient(Func<HttpResponseMessage> responseFactory) =>
        new(new StubHttpMessageHandler(responseFactory))
        {
            BaseAddress = new Uri("https://v0.api.upyun.com"),
        };

    private sealed class StubHttpMessageHandler(Func<HttpResponseMessage> responseFactory)
        : HttpMessageHandler
    {
        protected override Task<HttpResponseMessage> SendAsync(
            HttpRequestMessage request,
            CancellationToken cancellationToken
        )
        {
            return Task.FromResult(responseFactory());
        }
    }
}