using JetBrains.Annotations;

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();
        }

        List<AcFunDanmaku> danmakus;
        try
        {
            danmakus =
                await JsonSerializer.DeserializeAsync<List<AcFunDanmaku>>(
                    import.File.OpenReadStream(),
                    new JsonSerializerOptions { PropertyNameCaseInsensitive = true }
                ) ?? [];
        }
        catch (Exception e)
        {
            logger.LogError(e, "import acfun danmaku fail");
            return BadRequest(e.Message);
        }

        if (danmakus.Count == 0)
        {
            return BadRequest("no danmaku");
        }

        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();
    }

    /// <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>
    [UsedImplicitly]
    private record AcFunDanmaku(
        int Color,
        int Mode,
        long CreateTime,
        string? Body,
        int Position,
        int Size
    )
    {
        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,
    }
}