using Dpz.Core.Public.ViewModel.Response;
using Dpz.Core.Shard.Service;
using Dpz.Core.WebApi.Models.Request;
using Color = System.Drawing.Color;

namespace Dpz.Core.WebApi.Controllers;

/// <summary>
/// 视频
/// </summary>
[ApiController, Route("api/[controller]")]
public class VideoController(
    IBarrageService barrageService,
    IVideoService videoService,
    IFusionCache fusionCache,
    IVideoShardService videoShardService,
    IVideoCloudService videoCloudService
) : ControllerBase
{
    /// <summary>
    /// 获取视频列表
    /// </summary>
    /// <returns></returns>
    [HttpGet]
    [ProducesResponseType<List<VmVideo>>(StatusCodes.Status200OK)]
    public async Task<IActionResult> GetVideos()
    {
        var videos = await videoShardService.GetVideosAsync();
        return Ok(videos);
    }

    /// <summary>
    /// 发送弹幕
    /// </summary>
    /// <param name="danmaku"></param>
    /// <returns></returns>
    [HttpPost("danmaku")]
    [ProducesResponseType<VmBarrage>(StatusCodes.Status200OK)]
    public async Task<IActionResult> Danmaku([FromBody] VideoDanmakuDto danmaku)
    {
        var vmBarrage = new VmBarrage
        {
            Color = danmaku.Color.ToString(),
            Group = danmaku.Id,
            Position = (int)danmaku.Type,
            SendTime = DateTime.Now,
            Size = 0,
            Text = danmaku.Text,
            Time = danmaku.Time,
        };
        await barrageService.AddBarrageAsync(vmBarrage);
        return Ok(vmBarrage);
    }

    /// <summary>
    /// 获取视频弹幕
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet("danmaku")]
    [ProducesResponseType<List<VmBarrage>>(StatusCodes.Status200OK)]
    public async Task<IActionResult> Danmaku(string id)
    {
        var danmakuList = await barrageService.GetGroupBarragesAsync(id);
        danmakuList.ForEach(x =>
        {
            if (int.TryParse(x.Color, out var color))
            {
                var colorRgb = Color.FromArgb(color);
                x.Color = $"rgb({colorRgb.R},{colorRgb.G},{colorRgb.B})";
            }
        });
        return Ok(danmakuList);
    }

    /// <summary>
    /// 获取视频详情列表
    /// </summary>
    /// <returns></returns>
    [HttpGet("details"), Authorize(Policy = "System")]
    [ProducesResponseType<List<VmVideo>>(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> GetVideoListDetails()
    {
        var videos = await videoShardService.GetVideosAsync();

        return Ok(videos);
    }

    /// <summary>
    /// 保存视频信息
    /// </summary>
    /// <returns></returns>
    [HttpPost, Authorize(Policy = "System")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> SaveInformation([FromBody] VmVideo video)
    {
        await videoService.SaveInformationAsync(video);
        await fusionCache.RemoveByTagAsync(CacheKey.VideoListKey);
        return NoContent();
    }

    /// <summary>
    /// 添加一次播放次数
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpPatch("play/{id}")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    public async Task<IActionResult> AddPlayer(string id)
    {
        await videoShardService.AddPlayAsync(id);
        return NoContent();
    }

    /// <summary>
    /// 获取视频元数据
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet("meta/{id}"), Authorize(Policy = "System")]
    [ProducesResponseType<VideoMetaDataResponse>(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> GetVideoMetaData(string id)
    {
        var videMetaKey = $"Video-Meta:{id}";
        var cacheValue = await fusionCache.TryGetAsync<VideoMetaDataResponse>(videMetaKey);
        if (cacheValue is { HasValue: true, Value: not null })
        {
            return Ok(cacheValue.Value);
        }
        var video = await videoShardService.GetVideoAsync(id);
        if (video == null)
        {
            return NotFound();
        }

        var meta = await videoCloudService.GetVideoMetaAsync(
            $"/Video/{video.Title}/1080p.m3u8",
            HttpContext.RequestAborted
        );
        if (meta.Success)
        {
            await fusionCache.SetAsync(videMetaKey, meta.Data, TimeSpan.FromDays(90));
            return Ok(meta.Data);
        }
        return BadRequest(meta.Message);
    }

    /// <summary>
    /// 设置视频缩略图
    /// </summary>
    /// <param name="id"></param>
    /// <param name="request"></param>
    /// <returns></returns>
    [HttpPatch("screenshot/{id}"), Authorize(Policy = "System")]
    [ProducesResponseType<string>(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> SetVideoScreenshot(
        string id,
        [FromBody] ScreenshotRequest request
    )
    {
        var video = await videoShardService.GetVideoAsync(id);
        if (video == null)
        {
            return NotFound();
        }

        var meta = await videoCloudService.GetVideoMetaAsync(
            $"/Video/{video.Title}/1080p.m3u8",
            HttpContext.RequestAborted
        );
        if (!meta.Success)
        {
            return BadRequest(meta.Message);
        }

        if (request.Seconds > meta.Data?.Duration || request.Seconds < 0)
        {
            return BadRequest("时间超出范围");
        }

        var screenshot = await videoCloudService.VideoScreenshotAsync(
            $"/Video/{video.Title}/1080p.m3u8",
            TimeSpan.FromSeconds(request.Seconds),
            HttpContext.RequestAborted
        );
        if (!screenshot.Success)
        {
            return BadRequest(screenshot.Message);
        }

        return Ok(screenshot.Data);
    }
}