using Dpz.Core.MessageQueue.Abstractions;
using Dpz.Core.Public.ViewModel.Messages;
using MapsterMapper;

namespace Dpz.Core.WebApi.Controllers;

/// <summary>
/// 书签
/// </summary>
[ApiController, Route("api/[controller]")]
public class BookmarkController(
    IBookmarkService bookmarkService,
    IHttpClientFactory httpClientFactory,
    IObjectStorageOperation objectStorageService,
    ILogger<BookmarkController> logger,
    IMapper mapper,
    OwnerService ownerService,
    IMessagePublisher<RemoveImagesMessage> removeImageMessagePublisher
) : ControllerBase
{
    /// <summary>
    /// 获取书签
    /// </summary>
    /// <param name="title">标题</param>
    /// <param name="categories">分类</param>
    /// <returns></returns>
    [HttpGet]
    [ProducesResponseType<List<VmBookmark>>(StatusCodes.Status200OK)]
    public async Task<IActionResult> GetBookmarks(
        [FromQuery] string title = "",
        [FromQuery] string[]? categories = null
    )
    {
        var list = await bookmarkService.GetBookmarksAsync(title, categories);
        return Ok(list);
    }

    /// <summary>
    /// 获取所有分类
    /// </summary>
    /// <returns></returns>
    [HttpGet("categories")]
    [ProducesResponseType<List<string>>(StatusCodes.Status200OK)]
    public async Task<IActionResult> GetAllCategories()
    {
        var list = await bookmarkService.GetCategoriesAsync();
        return Ok(list);
    }

    /// <summary>
    /// 搜索书签
    /// </summary>
    /// <param name="title">标题</param>
    /// <param name="categories">分类</param>
    /// <returns></returns>
    [HttpGet("search")]
    [ProducesResponseType<List<string>>(StatusCodes.Status200OK)]
    public async Task<IActionResult> Search(
        [FromQuery] string title = "",
        [FromQuery] string[]? categories = null
    )
    {
        var list = await bookmarkService.SearchAsync(title, categories);
        return Ok(list);
    }

    /// <summary>
    /// 书签详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet("{id}")]
    [ProducesResponseType<VmBookmark>(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> GetBookmark(string id)
    {
        var bookmark = await bookmarkService.GetBookmarkAsync(id);
        if (bookmark == null)
        {
            return NotFound();
        }

        return Ok(bookmark);
    }

    /// <summary>
    /// 新建书签
    /// </summary>
    /// <param name="bookmark"></param>
    /// <returns></returns>
    [HttpPost, Authorize(Policy = "System")]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    public async Task<IActionResult> CreateBookmark(CreateBookmarkDto bookmark)
    {
        var viewModel = mapper.Map<VmCreateBookmark>(bookmark);
        viewModel.UploadIcon = UploadIconAsync;
        viewModel.UploadImage = UploadImageAsync;
        await bookmarkService.CreateBookmarkAsync(viewModel);
        return NoContent();
    }

    /// <summary>
    /// 删除书签
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpDelete("{id}"), Authorize(nameof(Permissions.System))]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    public async Task<IActionResult> Delete(string id)
    {
        await bookmarkService.DeleteAsync(
            id,
            async x =>
            {
                if (ownerService.IsOwnCdnImage(x.Icon))
                {
                    await objectStorageService.DeleteAsync(x.Icon);
                }

                if (ownerService.IsOwnCdnImage(x.Image))
                {
                    await objectStorageService.DeleteAsync(x.Image);
                }
            }
        );
        return NoContent();
    }

    /// <summary>
    /// 更新标签
    /// </summary>
    /// <param name="bookmark"></param>
    /// <returns></returns>
    [HttpPut, Authorize(Policy = "System")]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    public async Task<IActionResult> UpdateBookmark(UpdateBookmarkDto bookmark)
    {
        var viewModel = mapper.Map<VmUpdateBookmark>(bookmark);
        viewModel.UploadIcon = UploadIconAsync;
        viewModel.UploadImage = UploadImageAsync;
        viewModel.DeleteIcon = DeleteObjectStorageAsync;
        viewModel.DeleteImage = DeleteObjectStorageAsync;
        await bookmarkService.UpdateAsync(viewModel);
        return NoContent();
    }

    [NonAction]
    async Task<string?> UploadIconAsync(string url)
    {
        if (string.IsNullOrEmpty(url))
        {
            return null;
        }

        var uri = new Uri(url);
        var extensionName = Path.GetExtension(uri.AbsolutePath);
        var httpClient = httpClientFactory.CreateClient("edge");
        var request = new HttpRequestMessage(HttpMethod.Get, uri);
        try
        {
            var response = await httpClient.SendAsync(request);
            var stream = await response.Content.ReadAsStreamAsync();
            var result = await objectStorageService.UploadAsync(
                stream,
                ["images", "bookmark", "icon"],
                $"{ObjectId.GenerateNewId()}{extensionName}"
            );
            return result.Url;
        }
        catch (Exception e)
        {
            logger.LogError(e, "download icon fail");
            return null;
        }
    }

    [NonAction]
    async Task<string?> UploadImageAsync(string url)
    {
        if (string.IsNullOrEmpty(url))
        {
            return null;
        }

        var uri = new Uri(url);
        var extensionName = Path.GetExtension(uri.AbsolutePath);
        var httpClient = httpClientFactory.CreateClient("edge");
        var request = new HttpRequestMessage(HttpMethod.Get, uri);
        try
        {
            var response = await httpClient.SendAsync(request);
            var stream = await response.Content.ReadAsStreamAsync();
            var result = await objectStorageService.UploadAsync(
                stream,
                ["images", "bookmark", "image"],
                $"{ObjectId.GenerateNewId()}{extensionName}"
            );
            return result.Url;
        }
        catch (Exception e)
        {
            logger.LogError(e, "download image fail");
            return null;
        }
    }

    [NonAction]
    async Task DeleteObjectStorageAsync(string url)
    {
        await removeImageMessagePublisher.PublishAsync(new RemoveImagesMessage { ImageUrl = url });
    }
}