using System.Security.Cryptography;
using Dpz.Core.EnumLibrary;
using Dpz.Core.Public.ViewModel.V4;
using Dpz.Core.Service.ObjectStorage.Services;
using Dpz.Core.Service.V4.Services;
using Dpz.Core.Web.Models.EventRequest;
using SixLabors.ImageSharp;

namespace Dpz.Core.Web.EventHandlers;

public class PublishPhotoEventHandler(
    IPictureRecordService pictureRecordService,
    IObjectStorageOperation objectStorageService,
    IConfiguration configuration,
    ILogger<PublishPhotoEventHandler> logger
) : IRequestHandler<PublishPhotoRequest, IActionResult>
{
    public async Task<IActionResult> Handle(
        PublishPhotoRequest request,
        CancellationToken cancellationToken
    )
    {
        return string.IsNullOrWhiteSpace(request.Id)
            ? await CreatePhotoRecordAsync(request, cancellationToken)
            : await UpdateInformationAsync(request, cancellationToken);
    }

    private static string? ValidateCreate(PublishPhotoRequest request)
    {
        if (request.Photo is not { Length: > 0 } || !request.Photo.ContentType.Contains("image"))
        {
            return "请选择照片";
        }

        if (request.Tags is not { Count: > 0 })
        {
            return "请选择标签";
        }

        return null;
    }

    private async Task<IActionResult> CreatePhotoRecordAsync(
        PublishPhotoRequest request,
        CancellationToken cancellationToken = default
    )
    {
        var validateMessage = ValidateCreate(request);
        if (!string.IsNullOrWhiteSpace(validateMessage))
        {
            return new JsonResult(new ResultInfo(validateMessage));
        }

        using var memoryStream = new MemoryStream();
        await request.Photo!.CopyToAsync(memoryStream, cancellationToken);
        var bytes = memoryStream.ToArray();

        var path = new List<string> { "images", "album", DateTime.Now.ToString("yyyy-MM") };
        if (
            !string.Equals(
                configuration["AgileConfig:env"],
                "PROD",
                StringComparison.OrdinalIgnoreCase
            )
        )
        {
            path.Insert(0, "test");
        }
        var filename = $"{ObjectId.GenerateNewId()}.{await GetImageFormatAsync(bytes)}";
        var result = await objectStorageService.UploadAsync(
            bytes,
            path,
            filename,
            cancellationToken
        );

        var pictureRecord = new VmPictureRecord
        {
            Creator = request.Creator,
            UploadTime = DateTime.Now,
            Tags = request.Tags,
            Description = request.Description,
            Category = PictureCategory.Album,
            AccessUrl = result.AccessUrl,
            Length = bytes.Length,
            ObjectStorageUploadTime = DateTime.Now,
            Md5 = CalculateMd5(bytes),
            Width = result.Width,
            Height = result.Height,
        };
        var photo = await pictureRecordService.CreateRecordAsync(pictureRecord, cancellationToken);

        return new JsonResult(new ResultInfo(photo));
    }

    private async Task<string?> ValidateUpdateInformationAsync(PublishPhotoRequest request)
    {
        var pictureRecord = await pictureRecordService.GetPictureRecordAsync(request.Id!);
        if (pictureRecord == null)
        {
            return "该照片记录不存在";
        }
        if (pictureRecord.Creator.Id != request.Creator.Id)
        {
            return "没有权限修改该照片信息";
        }
        if (request.Tags is not { Count: > 0 })
        {
            return "请选择标签";
        }

        return null;
    }

    private async Task<IActionResult> UpdateInformationAsync(
        PublishPhotoRequest request,
        CancellationToken cancellationToken = default
    )
    {
        var validateMessage = await ValidateUpdateInformationAsync(request);
        if (!string.IsNullOrWhiteSpace(validateMessage))
        {
            return new JsonResult(new ResultInfo(validateMessage));
        }
        var recordChange = new VmPictureRecordChange
        {
            Category = PictureCategory.Album,
            Description = request.Description,
            Tags = request.Tags,
            Id = request.Id,
        };

        var photo = await pictureRecordService.ChangeInformationAsync(
            recordChange,
            cancellationToken
        );
        return new JsonResult(new ResultInfo(photo));
    }

    private static string CalculateMd5(byte[] bytes)
    {
        var hash = MD5.HashData(bytes);
        return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
    }

    private async Task<string> GetImageFormatAsync(byte[] bytes)
    {
        try
        {
            using var stream = new MemoryStream(bytes);
            using var image = await Image.LoadAsync(stream);
            return image.Metadata.DecodedImageFormat?.FileExtensions.FirstOrDefault() ?? "jpg";
        }
        catch (Exception e)
        {
            logger.LogError(e, "get image format fail");
            return "jpg";
        }
    }
}