namespace Dpz.Core.WebApi.Controllers;

/// <summary>
/// 弹幕管理
/// </summary>
[ApiController, Route("api/[controller]"), Authorize(Policy = "System")]
public class DanmakuController(IBarrageService barrageService, ILogger<DanmakuController> logger)
    : ControllerBase
{
    /// <summary>
    /// 获取弹幕
    /// </summary>
    /// <param name="query"></param>
    /// <returns></returns>
    [HttpGet]
    [ProducesResponseType<List<VmBarrage>>(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> GetDanmaku([FromQuery] DanmakuQueryDto query)
    {
        var list = await barrageService.GetPageAsync(
            query.PageIndex,
            query.PageSize,
            query.Text,
            query.Group
        );
        list.AddPaginationMetadata(Response.Headers);
        return Ok(list);
    }

    /// <summary>
    /// 获取弹幕分组
    /// </summary>
    /// <returns></returns>
    [HttpGet("group")]
    [ProducesResponseType<List<string>>(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> GetGroups()
    {
        var groups = await barrageService.GetGroupsAsync();
        return Ok(groups);
    }

    /// <summary>
    /// 删除弹幕
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpDelete]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> Delete([FromBody] [Required] string[] id)
    {
        await barrageService.DeleteAsync(id);
        return NoContent();
    }

    /// <summary>
    /// 导入A站弹幕
    /// </summary>
    /// <returns></returns>
    [HttpPost("import/acfun")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> ImportAcFun([FromForm] ImportDanmaku import)
    {
        var extensionName = Path.GetExtension(import.File.FileName);
        if (extensionName != ".json")
            return NoContent();
        try
        {
            var danmakus = await JsonSerializer.DeserializeAsync<List<AcFunDanmaku>>(
                import.File.OpenReadStream(),
                new JsonSerializerOptions { PropertyNameCaseInsensitive = true }
            );
            var source =
                danmakus
                    ?.Select(x => new VmBarrage
                    {
                        Group = import.Group,
                        Color = x.Color.ToString(),
                        Position = x.Mode == 5 ? 1 : 0,
                        SendTime = x.GetCreateTime(),
                        Size = x.Size,
                        Text = x.Body,
                        Time = x.Position / (decimal)1e3
                    })
                    ?.ToArray() ?? [];
            await barrageService.ImportAsync(source);
            return NoContent();
        }
        catch (Exception e)
        {
            logger.LogError(e, "import acfun danmaku fail");
            return BadRequest(e.Message);
        }
    }

    /// <summary>
    /// 导入B站弹幕
    /// </summary>
    /// <returns></returns>
    [HttpPost("import/bilibili")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> ImportBilibili([FromForm] ImportDanmaku import)
    {
        var extensionName = Path.GetExtension(import.File.FileName);
        if (extensionName != ".xml")
            return NoContent();
        try
        {
            var source = await XElement.LoadAsync(
                import.File.OpenReadStream(),
                LoadOptions.None,
                CancellationToken.None
            );
            var bilibiliDanmakus = (
                from x in source.Elements("d")
                let p = x.Attribute("p")
                where p != null && !string.IsNullOrEmpty(p.Value)
                let props = p.Value.Split(",")
                where props.Length >= 5
                let type = props[1] switch
                {
                    "1" => DanmakuType.Rolling,
                    "4" => DanmakuType.Bottom,
                    "5" => DanmakuType.Top,
                    _ => DanmakuType.Rolling
                }
                select new VmBarrage
                {
                    Group = import.Group,
                    Color = props[3],
                    Position = (int)type,
                    SendTime = long.Parse(props[4]).ToDateTime(),
                    Size = int.Parse(props[2]),
                    Text = x.Value,
                    Time = decimal.Parse(props[0]),
                }
            ).ToArray();
            await barrageService.ImportAsync(bilibiliDanmakus);
            return NoContent();
        }
        catch (Exception e)
        {
            logger.LogError(e, "import bilibili danmaku fail");
            return BadRequest(e.Message);
        }
    }

    /// <summary>
    /// AcFun弹幕
    /// </summary>
    private record AcFunDanmaku
    {
        public int Color { get; set; }

        public int Mode { get; set; }

        public long CreateTime { get; set; }

        public string Body { get; set; }

        public int Position { get; set; }

        public int Size { get; set; }

        public DateTime GetCreateTime()
        {
            var time = CreateTime / 1000D;
            var utcTime = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).AddSeconds(time);
            return utcTime.LocalDateTime;
        }
    }

    private enum DanmakuType
    {
        Rolling = 0,
        Top = 1,
        Bottom = 2
    }
}