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 MusicController(
    IMusicService musicService,
    IObjectStorageOperation objectStorageService,
    ILogger<MusicController> logger,
    IImageFormatDetector imageFormatDetector,
    IFusionCache fusionCache
) : ControllerBase
{
    /// <summary>
    /// 音乐列表
    /// </summary>
    /// <returns></returns>
    [HttpGet]
    [ProducesResponseType<List<MusicResponse>>(StatusCodes.Status200OK)]
    public async Task<IActionResult> GetMusics([FromQuery] MusicQueryParameterDto parameter)
    {
        var musics = await musicService.GetPagesAsync(
            parameter.PageIndex,
            parameter.PageSize,
            parameter.Title
        );
        musics.AddPaginationMetadata(Response.Headers);
        return Ok(musics);
    }

    /// <summary>
    /// 单个音乐
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet("{id}")]
    [ProducesResponseType<MusicResponse>(StatusCodes.Status200OK)]
    public async Task<IActionResult> GetMusic(string id)
    {
        var music = await musicService.GetAsync(id);
        return Ok(music);
    }

    /// <summary>
    /// 获取所有分组
    /// </summary>
    /// <returns></returns>
    [HttpGet("groups")]
    [ProducesResponseType<List<string>>(StatusCodes.Status200OK)]
    public async Task<ActionResult<List<string>>> GetGroups()
    {
        var groups = await musicService.GetGroupsAsync();
        return Ok(groups);
    }

    /// <summary>
    /// 获取歌词
    /// </summary>
    /// <param name="id"></param>
    /// <param name="httpClientFactory"></param>
    /// <returns></returns>
    [HttpGet("lrc/{id}")]
    [ProducesResponseType<string>(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    public async Task<IActionResult> GetLyric(
        string id,
        [FromServices] IHttpClientFactory httpClientFactory
    )
    {
        var lrcCacheKey = $"music-lrc:{id}";
        var cacheValue = await fusionCache.TryGetAsync<string>(lrcCacheKey);
        if (cacheValue.HasValue)
        {
            return Content(cacheValue.Value, "application/lrc;charset=utf-8;");
        }
        if (string.IsNullOrEmpty(id))
        {
            return NotFound();
        }

        var music = await musicService.GetAsync(id);
        if (music == null)
        {
            return NotFound();
        }

        if (string.IsNullOrEmpty(music.LyricUrl))
        {
            return NoContent();
        }

        string lrc;
        var httpClient = httpClientFactory.CreateClient("edge");
        try
        {
            var request = new HttpRequestMessage(HttpMethod.Get, music.LyricUrl);
            var response = await httpClient.SendAsync(request);
            if (!response.IsSuccessStatusCode)
            {
                return NoContent();
            }
            lrc = await response.Content.ReadAsStringAsync();
        }
        catch (Exception e)
        {
            logger.LogError(e, "get lrc fail");
            lrc = music.LyricContent ?? "";
        }
        return Content(lrc, "application/lrc;charset=utf-8;");
    }

    /// <summary>
    /// 更改音乐信息
    /// </summary>
    /// <param name="model"></param>
    /// <returns></returns>
    [HttpPatch("information"), Authorize(Policy = "System")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> EditInformation([FromForm] ChangeMusicRequest model)
    {
        var information = new EditMusicInformationRequest
        {
            Id = model.Id,
            Lyric = model.Lyric,
            Cover = model.Cover,
            Group = model.Group,
            UploadLyric = async (bytes, music) =>
            {
                if (!string.IsNullOrEmpty(music.LyricUrl))
                {
                    await objectStorageService.DeleteAsync(music.LyricUrl);
                }

                return await HandleUploadAsync(bytes, $"{Guid.NewGuid():N}.lrc,", "lyric");
            },
            UploadCover = async (bytes, music) =>
            {
                if (!string.IsNullOrEmpty(music.CoverUrl))
                {
                    await objectStorageService.DeleteAsync(music.CoverUrl);
                }

                string coverExt;
                try
                {
                    var info = imageFormatDetector.Detect(bytes);
                    coverExt = info.IsKnown ? info.DefaultExtension : "jpg";
                }
                catch (Exception ex)
                {
                    coverExt = "jpg";
                    logger.LogError(ex, "get image format fail");
                }
                return await HandleUploadAsync(bytes, $"{Guid.NewGuid():N}.{coverExt}", "cover");
            },
        };
        await musicService.EditMusicInformationAsync(information);
        return NoContent();
    }

    /// <summary>
    /// 新增音乐
    /// </summary>
    /// <param name="upload"></param>
    /// <returns></returns>
    [HttpPost, Authorize(Policy = "System")]
    [RequestSizeLimit(104_857_600)]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> Save([FromForm] UploadMusicRequest upload)
    {
        var from = string.IsNullOrWhiteSpace(upload.From) ? "Web Api" : upload.From;
        var request = new MusicUploadActionRequest
        {
            From = from,
            Lyric = upload.Lyrics,
            Cover = upload.Cover,
            Music = upload.Music,
            UploadMusic = async (bytes, filename) => await HandleUploadAsync(bytes, filename, null),
            UploadCover = async (bytes, filename) =>
                await HandleUploadAsync(bytes, filename, "cover"),
            UploadLyric = async (bytes, filename) =>
                await HandleUploadAsync(bytes, filename, "lyric"),
            Group = upload.Group,
        };
        await musicService.SaveAsync(request);
        return NoContent();
    }

    [NonAction]
    private async Task<string> HandleUploadAsync(byte[] bytes, string filename, string? type)
    {
#if DEBUG
        var list = new List<string> { "Test", "music" };
#else
        var list = new List<string> { "music" };
#endif
        if (!string.IsNullOrEmpty(type))
        {
            list.Add(type);
        }

        var result = await objectStorageService.UploadAsync(bytes, list, filename);
        return result.Url;
    }

    /// <summary>
    /// 删除音乐
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpDelete("{id}"), Authorize(Policy = "System")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> Delete(string id)
    {
        await musicService.DeleteAsync(
            id,
            async x => await objectStorageService.DeleteMusicAsync(x)
        );
        return NoContent();
    }
}