using Dpz.Core.Entity.Base.Image;
using Dpz.Core.Infrastructure;
using Microsoft.Extensions.Logging;

namespace Dpz.Core.Service.ObjectStorage;

public class UpyunUpload(HttpClient httpClient, ILogger<UpyunUpload> logger)
{
    internal async Task<IFileMetadata> UploadAsync<TOperator>(
        ICollection<string> pathToFile,
        Func<HttpContent> setContent,
        TOperator operatorConfiguration,
        long size = 0,
        string? hash = null,
        string? contentMd5 = null,
        CancellationToken cancellationToken = default
    )
        where TOperator : UpyunOperator
    {
        if (pathToFile.Count == 0)
        {
            throw new ArgumentException(
                "argument pathToFile does not any contain item.",
                nameof(pathToFile)
            );
        }

        if (string.IsNullOrEmpty(operatorConfiguration.Bucket))
        {
            throw new ArgumentException(
                "argument operatorConfiguration does not have bucket.",
                nameof(operatorConfiguration)
            );
        }

        var uploadAddress = string.Join("/", pathToFile.Select(Uri.EscapeDataString));

        var request = new HttpRequestMessage(
            HttpMethod.Put,
            $"/{operatorConfiguration.Bucket}/{uploadAddress}"
        )
        {
            Version = new Version(2, 0),
        };
        await request.SignatureAsync(
            operatorConfiguration,
            contentMd5,
            cancellationToken: cancellationToken
        );
        request.Content = setContent();
        using var response = await httpClient.SendAsync(request, cancellationToken);
        if (!response.IsSuccessStatusCode)
        {
            logger.LogError("upload fail,status code:{StatusCode}", response.StatusCode);
            throw new BusinessException($"upload fail,response status code:{response.StatusCode}");
        }

        #region upload result

        var accessUrl = GetAccessUrl(uploadAddress, operatorConfiguration);
        var fileType = response.Headers.GetResponseHeaderValue("x-upyun-file-type", "");

        var frames = response.Headers.GetResponseHeaderValue("x-upyun-frames", "0");
        _ = int.TryParse(frames, out var framesInt);

        var width = response.Headers.GetResponseHeaderValue("x-upyun-width", "0");
        _ = int.TryParse(width, out var widthInt);

        var height = response.Headers.GetResponseHeaderValue("x-upyun-height", "0");
        _ = int.TryParse(height, out var heightInt);

        if (response.Content.Headers.ContentMD5 != null)
        {
            var md5Value = BitConverter
                .ToString(response.Content.Headers.ContentMD5)
                .Replace("-", "")
                .ToLowerInvariant();
            logger.LogInformation(
                "upload file:{AccessUrl},MD5 value:{MD5Value}",
                accessUrl,
                md5Value
            );
            hash = md5Value;
        }

        #endregion

        var format = GetImageFormat(fileType);
        if (
            widthInt > 0
            || heightInt > 0
            || framesInt > 0
            || format.Kind != ImageFormatKind.Unknown
        )
        {
            return new ImageMetadata
            {
                Url = accessUrl,
                Width = widthInt,
                Height = heightInt,
                Frames = framesInt,
                Hash = hash,
                Size = size,
                Format = format,
            };
        }

        return new FileMetadata(accessUrl, size, hash);
    }

    private static ImageFormat GetImageFormat(string? fileType)
    {
        return fileType?.ToLowerInvariant() switch
        {
            "jpg" or "jpeg" or "image/jpeg" => ImageFormat.Jpeg,
            "png" or "image/png" => ImageFormat.Png,
            "gif" or "image/gif" => ImageFormat.Gif,
            "bmp" or "image/bmp" => ImageFormat.Bmp,
            "webp" or "image/webp" => ImageFormat.Webp,
            "tif" or "tiff" or "image/tiff" => ImageFormat.Tiff,
            "heic" or "image/heic" => ImageFormat.Heic,
            "avif" or "image/avif" => ImageFormat.Avif,
            "ico" or "image/x-icon" or "image/vnd.microsoft.icon" => ImageFormat.Ico,
            "svg" or "image/svg+xml" => ImageFormat.Svg,
            _ => ImageFormat.Unknown,
        };
    }

    private static string GetAccessUrl<TOperator>(string pathToFile, TOperator upyunOperator)
        where TOperator : UpyunOperator
    {
        return (
                upyunOperator.Host?.LastOrDefault() == '/'
                    ? upyunOperator.Host
                    : upyunOperator.Host + "/"
            ) + pathToFile;
    }
}