using Dpz.Core.Public.ViewModel.Response;
using SixLabors.ImageSharp;

namespace Dpz.Core.Service.Mediator.Features.Media.Commands;

/// <summary>
/// 处理相册照片发布与信息更新请求。
/// </summary>
public class PublishPhotoEventHandler(
    IRepository<PictureRecord> pictureRecordRepository,
    IMapper mapper,
    IConfiguration configuration,
    ILogger<PublishPhotoEventHandler> logger
) : IRequestHandler<PublishPhotoRequest, ResponseResult>
{
    /// <summary>
    /// 根据是否存在记录 ID 分派到创建或更新流程。
    /// </summary>
    public async ValueTask<ResponseResult> 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<ResponseResult> CreatePhotoRecordAsync(
        PublishPhotoRequest request,
        CancellationToken cancellationToken = default
    )
    {
        var validateMessage = ValidateCreate(request);
        if (!string.IsNullOrWhiteSpace(validateMessage))
        {
            return ResponseResult.Fail(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 request.UploadAsync(bytes, path, filename, cancellationToken);

        var entity = new PictureRecord
        {
            Creator = mapper.Map<UserInfo>(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,
        };
        await pictureRecordRepository.InsertAsync(entity, cancellationToken);
        await ClearPictureRecordCachesAsync(request, entity.Tags, cancellationToken);

        var photo = mapper.Map<PictureRecordResponse>(entity);
        return ResponseResult<PictureRecordResponse>.Ok(photo);
    }

    private async Task<string?> ValidateUpdateInformationAsync(PublishPhotoRequest request)
    {
        if (string.IsNullOrWhiteSpace(request.Id))
        {
            return "参数错误";
        }
        if (!ObjectId.TryParse(request.Id, out var oid))
        {
            return "参数错误";
        }

        var pictureRecord = await pictureRecordRepository.FindAsync(oid);
        if (pictureRecord == null)
        {
            return "该照片记录不存在";
        }
        if (pictureRecord.Creator.Id != request.Creator.Id)
        {
            return "没有权限修改该照片信息";
        }
        if (request.Tags is not { Count: > 0 })
        {
            return "请选择标签";
        }

        if (request.Photo?.Length > 0)
        {
            return "选择修改相片为什么不选择删除后再重新上传呢？不支持修改！";
        }

        return null;
    }

    private async Task<ResponseResult> UpdateInformationAsync(
        PublishPhotoRequest request,
        CancellationToken cancellationToken = default
    )
    {
        var validateMessage = await ValidateUpdateInformationAsync(request);
        if (!string.IsNullOrWhiteSpace(validateMessage))
        {
            return ResponseResult.Fail(validateMessage);
        }

        if (!ObjectId.TryParse(request.Id, out var oid))
        {
            return ResponseResult.Fail("参数错误");
        }

        var update = Builders<PictureRecord>
            .Update.Set(x => x.Category, PictureCategory.Album)
            .Set(x => x.Description, request.Description)
            .Set(x => x.Tags, request.Tags);
        await pictureRecordRepository.UpdateAsync(x => x.Id == oid, update, cancellationToken);
        await ClearPictureRecordCachesAsync(request, request.Tags, cancellationToken);

        var photoEntity = await pictureRecordRepository.FindAsync(oid, cancellationToken);
        if (photoEntity == null)
        {
            return ResponseResult.Fail("该照片记录不存在");
        }

        var photo = mapper.Map<PictureRecordResponse>(photoEntity);
        return ResponseResult<PictureRecordResponse>.Ok(photo);
    }

    private static async Task ClearPictureRecordCachesAsync(
        PublishPhotoRequest request,
        IReadOnlyCollection<string> tags,
        CancellationToken cancellationToken
    )
    {
        if (request.ClearCacheAsync != null)
        {
            await request.ClearCacheAsync(tags, cancellationToken);
        }
    }

    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";
        }
    }
}