using Dpz.Core.Entity.Base.Image;
using Dpz.Core.Infrastructure.Imaging;
using Dpz.Core.Public.ViewModel.Request;
using Dpz.Core.Public.ViewModel.Response;

namespace Dpz.Core.WebApi.Controllers;

/// <summary>
/// 图片管理
/// </summary>
[ApiController, Route("api/[controller]")]
public class PictureController(
    IPictureRecordService pictureRecordService,
    IObjectStorageOperation objectStorageService,
    ILogger<PictureController> logger,
    IHttpCurrentUserService currentUserService,
    IImageFormatDetector imageFormatDetector
) : ControllerBase
{
    /// <summary>
    /// 图片列表
    /// </summary>
    /// <returns></returns>
    [HttpGet]
    [ProducesResponseType<List<PictureRecordResponse>>(StatusCodes.Status200OK)]
    public async Task<IActionResult> GetPictures([FromQuery] PictureQueryParameterDto parameter)
    {
        var list = await pictureRecordService.GetPagesAsync(
            parameter.Tag == null ? null : [parameter.Tag],
            parameter.Description,
            parameter.PageIndex,
            parameter.PageSize
        );
        list.AddPaginationMetadata(Response.Headers);
        return Ok(list);
    }

    /// <summary>
    /// 上传图片
    /// </summary>
    /// <returns></returns>
    [HttpPost]
    [Authorize(Policy = "System")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> CreatePicture([FromForm] PictureCreateDto model)
    {
        if (model.Image.Length <= 0 || !model.Image.ContentType.Contains("image"))
        {
            return BadRequest("please select image to upload");
        }

        model.Tags = model.Tags.Select(x => x.Trim()).Where(x => !string.IsNullOrEmpty(x)).ToList();
        var userInfo = await currentUserService.GetRequiredUserInfoAsync();

        using var memoryStream = new MemoryStream();
        await model.Image.CopyToAsync(memoryStream);
        var bytes = memoryStream.ToArray();

        var path = new[] { "images", "album", DateTime.Now.ToString("yyyy-MM") };
        var filename = $"{ObjectId.GenerateNewId()}.{GetImageFormat(bytes) ?? "jpg"}";
        var result = await objectStorageService.UploadAsync(
            model.Image.OpenReadStream(),
            path,
            filename
        );
        if (result is not ImageMetadata imageMetadata)
        {
            return BadRequest("image metadata not found after upload");
        }

        var createRequest = new CreatePictureRecordRequest
        {
            Creator = userInfo,
            UploadTime = DateTime.Now,
            Tags = model.Tags,
            Description = model.Description,
            Category = PictureCategory.Album,
            AccessUrl = imageMetadata.Url,
            Length = imageMetadata.Size,
            ObjectStorageUploadTime = DateTime.Now,
            Md5 = imageMetadata.Hash ?? CalculateMd5(bytes),
            Width = imageMetadata.Width,
            Height = imageMetadata.Height,
        };
        await pictureRecordService.CreateRecordAsync(createRequest);

        return NoContent();
    }

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

    [NonAction]
    private string? GetImageFormat(byte[] bytes)
    {
        try
        {
            var info = imageFormatDetector.Detect(bytes);
            return info.IsKnown ? info.DefaultExtension : null;
        }
        catch (Exception e)
        {
            logger.LogError(e, "get image format fail");
            return null;
        }
    }

    /// <summary>
    /// 修改图像、图像信息
    /// </summary>
    /// <returns></returns>
    [HttpPatch]
    [Authorize(Policy = "System")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> EditPicture([FromBody] PictureEditDto model)
    {
        model.Tags = model.Tags.Select(x => x.Trim()).Where(x => !string.IsNullOrEmpty(x)).ToList();

        var recordChange = new EditPictureRecordRequest
        {
            Category = PictureCategory.Album,
            Description = model.Description,
            Tags = model.Tags,
            Id = model.Id,
        };

        await pictureRecordService.ChangeInformationAsync(recordChange);
        return NoContent();
    }

    /// <summary>
    /// 获取图片信息
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet("{id}")]
    [ProducesResponseType<PictureRecordResponse>(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> GetPicture(string id)
    {
        var picture = await pictureRecordService.GetPictureRecordAsync(id);
        if (picture == null)
        {
            return NotFound();
        }
        return Ok(picture);
    }

    /// <summary>
    /// 删除图像
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpDelete("{id}")]
    [Authorize(Policy = "System")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> Delete(string id)
    {
        var pictureRecord = await pictureRecordService.GetPictureRecordAsync(id);
        if (pictureRecord == null)
        {
            return NotFound();
        }
        await pictureRecordService.DeleteAsync(id);
        await objectStorageService.DeleteAsync(pictureRecord.AccessUrl);
        return NoContent();
    }

    /// <summary>
    /// 获取所有标签
    /// </summary>
    /// <returns></returns>
    [HttpGet("tags")]
    [ProducesResponseType<List<string>>(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> GetPictureTags()
    {
        var tags = await pictureRecordService.GetTagsAsync();
        return Ok(tags);
    }
}