using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;
using Amazon.S3;
using Amazon.S3.Model;
using Dpz.Core.Service.ObjectStorage;
using Dpz.Core.Service.ObjectStorage.Services.Impl;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using NUnit.Framework;

namespace Dpz.Core.Server.ObjectStorage.Test;

/// <summary>
/// COS 视频服务的轻量单元测试
/// </summary>
[TestFixture]
public class CosVideoCloudServiceTest
{
    [Test]
    public void ParsePlaylist_WhenMediaPlaylist_ReturnsDurations()
    {
        const string playlist = """
            #EXTM3U
            #EXT-X-TARGETDURATION:6
            #EXTINF:5.100,
            segment-1.ts
            #EXTINF:4.9,
            segment-2.ts
            #EXT-X-ENDLIST
            """;

        var result = CosVideoCloudService.ParsePlaylist(playlist);

        Assert.Multiple(() =>
        {
            Assert.That(result.Duration, Is.EqualTo(10).Within(0.0001));
            Assert.That(result.Points, Is.EqualTo(new[] { 5.1, 4.9 }).Within(0.0001));
            Assert.That(result.Variants, Is.Empty);
        });
    }

    [Test]
    public void ParsePlaylist_WhenMasterPlaylist_ReturnsHighestBandwidthFirst()
    {
        const string playlist = """
            #EXTM3U
            #EXT-X-STREAM-INF:BANDWIDTH=1280000,RESOLUTION=1280x720
            720p/index.m3u8
            #EXT-X-STREAM-INF:BANDWIDTH=2560000,RESOLUTION=1920x1080
            1080p/index.m3u8
            """;

        var result = CosVideoCloudService.ParsePlaylist(playlist);

        Assert.Multiple(() =>
        {
            Assert.That(result.Variants, Has.Length.EqualTo(2));
            Assert.That(result.Variants[0], Is.EqualTo("1080p/index.m3u8"));
        });
    }

    [Test]
    public void ParseMediaInfo_WhenDurationExists_ReturnsMetadata()
    {
        var document = XDocument.Parse(
            """
            <Response>
              <MediaInfo>
                <Format>
                  <Duration>12.345000</Duration>
                </Format>
              </MediaInfo>
            </Response>
            """
        );

        var result = CosVideoCloudService.ParseMediaInfo(document);

        Assert.That(result, Is.Not.Null);
        Assert.That(result!.Duration, Is.EqualTo(12.345).Within(0.0001));
    }

    [Test]
    public async Task GetVideoMetaAsync_WhenMasterPlaylist_SelectsHighestBandwidthMediaPlaylist()
    {
        var service = CreateService(
            new Dictionary<string, string>
            {
                ["Video/demo/master.m3u8"] = """
                #EXTM3U
                #EXT-X-STREAM-INF:BANDWIDTH=100
                low/index.m3u8
                #EXT-X-STREAM-INF:BANDWIDTH=200
                high/index.m3u8
                """,
                ["Video/demo/high/index.m3u8"] = """
                #EXTM3U
                #EXTINF:3.5,
                1.ts
                #EXTINF:4,
                2.ts
                #EXT-X-ENDLIST
                """,
            }
        );

        var result = await service.GetVideoMetaAsync("/Video/demo/master.m3u8");

        Assert.That(result.Success, Is.True, result.Message);
        Assert.That(result.Data, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(result.Data!.Duration, Is.EqualTo(7.5).Within(0.0001));
            Assert.That(result.Data.Points, Is.EqualTo(new[] { 3.5, 4 }).Within(0.0001));
        });
    }

    [Test]
    public async Task VideoScreenshotAsync_WhenSnapshotSucceeds_UploadsWebpCover()
    {
        var uploaded = new MemoryStream();
        string? uploadedKey = null;
        string? uploadedContentType = null;
        var service = CreateService(
            new Dictionary<string, string>
            {
                ["Video/demo/1080p.m3u8"] = """
                #EXTM3U
                #EXTINF:10,
                1.ts
                #EXT-X-ENDLIST
                """,
            },
            _ => new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new ByteArrayContent([1, 2, 3, 4]),
            },
            request =>
            {
                uploadedKey = request.Key;
                uploadedContentType = request.ContentType;
                request.InputStream.CopyTo(uploaded);
            }
        );

        var result = await service.VideoScreenshotAsync(
            "/Video/demo/1080p.m3u8",
            TimeSpan.FromSeconds(5)
        );

        Assert.That(result.Success, Is.True, result.Message);
        Assert.Multiple(() =>
        {
            Assert.That(uploadedKey, Is.EqualTo("Video/demo/video.webp"));
            Assert.That(uploadedContentType, Is.EqualTo("image/jpeg"));
            Assert.That(uploaded.Length, Is.GreaterThan(0));
            Assert.That(result.Data, Is.EqualTo("https://cdn.example.com/Video/demo/video.webp"));
        });
    }

    private static CosVideoCloudService CreateService(
        Dictionary<string, string> objects,
        Func<HttpRequestMessage, HttpResponseMessage>? responseFactory = null,
        Action<PutObjectRequest>? uploadCallback = null
    )
    {
        var s3 = new Mock<IAmazonS3>();
        s3.Setup(x => x.GetObjectAsync(It.IsAny<GetObjectRequest>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(
                (GetObjectRequest request, CancellationToken _) =>
                    new GetObjectResponse
                    {
                        BucketName = request.BucketName,
                        Key = request.Key,
                        ResponseStream = new MemoryStream(
                            Encoding.UTF8.GetBytes(objects[request.Key])
                        ),
                    }
            );
        s3.Setup(x => x.PutObjectAsync(It.IsAny<PutObjectRequest>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(
                (PutObjectRequest request, CancellationToken _) =>
                {
                    uploadCallback?.Invoke(request);
                    return new PutObjectResponse { HttpStatusCode = HttpStatusCode.OK };
                }
            );

        var options = new S3ObjectStorageOptions
        {
            Endpoint = "https://cos.ap-guangzhou.myqcloud.com",
            SecretId = "secret-id",
            SecretKey = "secret-key",
            Bucket = "bucket-123",
            CdnHost = "https://cdn.example.com",
            Region = "ap-guangzhou",
        }.Validate();
        var httpClient = new HttpClient(new StubHttpMessageHandler(responseFactory));

        return new CosVideoCloudService(
            s3.Object,
            options,
            new CosRequestSigner(options),
            httpClient,
            NullLogger<CosVideoCloudService>.Instance
        );
    }

    private sealed class StubHttpMessageHandler(
        Func<HttpRequestMessage, HttpResponseMessage>? responseFactory
    ) : HttpMessageHandler
    {
        protected override Task<HttpResponseMessage> SendAsync(
            HttpRequestMessage request,
            CancellationToken cancellationToken
        )
        {
            return Task.FromResult(
                responseFactory?.Invoke(request)
                    ?? new HttpResponseMessage(HttpStatusCode.OK)
                    {
                        Content = new StringContent(
                            """
                            <Response>
                              <MediaInfo>
                                <Format>
                                  <Duration>10</Duration>
                                </Format>
                              </MediaInfo>
                            </Response>
                            """
                        ),
                    }
            );
        }
    }
}