using Dpz.Core.Public.ViewModel.Response;

namespace Dpz.Core.WebApi.Controllers;

/// <summary>
/// 其他的
/// </summary>
[ApiController, Route("api/[controller]")]
public class CommunityController(
    IPictureRecordService pictureRecordService,
    IArticleService articleService,
    IAppOptionService appOptionService,
    IAppLogEntryService logEntryService,
    IFusionCache fusionCache,
    IConfiguration configuration
) : ControllerBase
{
    /// <summary>
    /// 获取banner
    /// </summary>
    /// <returns></returns>
    [HttpGet("getBanners")]
    [ProducesResponseType<List<PictureRecordResponse>>(StatusCodes.Status200OK)]
    public async Task<IActionResult> GetBanners()
    {
        var banners = await GetBannerAsync();
        return Ok(banners);
    }

    /// <summary>
    /// 获取汇总信息
    /// </summary>
    /// <returns></returns>
    [HttpGet("summary")]
    [Authorize(Policy = "System")]
    [ProducesResponseType<SummaryInformation>(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> GetSummary()
    {
        const string summaryKey = "community-summary";
        var cache = await fusionCache.TryGetAsync<SummaryInformation>(summaryKey);
        if (cache.HasValue)
        {
            return Ok(cache.Value);
        }

        var banner = await GetBannerAsync();

        var summary = new SummaryInformation
        {
            ArticleTotalCount = await articleService.GetTotalCountAsync(),
            Banner = banner,
            LatestArticles = await articleService.GetLatestAsync(),
            TodayArticleCount = await articleService.GetTodayCountAsync(),
        };
        if (
            configuration["AgileConfig:env"]?.Equals("PROD", StringComparison.OrdinalIgnoreCase)
            == false
        )
        {
            SetRandomData(summary);
        }
        else
        {
            summary.LatestLogs = await GetTop100LogsAsync();
            summary.TodayAccessNumber = await logEntryService.GetLatestAccessNumberAsync();
            summary.WeekAccessNumber = await logEntryService.GetLatestAccessNumberAsync(-7);
        }

        await fusionCache.SetAsync(summaryKey, summary, TimeSpan.FromHours(3));
        return Ok(summary);
    }

    [NonAction]
    private static void SetRandomData(SummaryInformation summary)
    {
        summary.TodayAccessNumber = [];
        summary.WeekAccessNumber = [];
        summary.LatestLogs = $"[{DateTime.Now:HH:mm:ss} INF] this is test log";
        var random = new Random();
        for (var i = 0; i < 7; i++)
        {
            if (i == 0)
            {
                summary.TodayAccessNumber.Add(
                    new AccessSummary
                    {
                        Date = DateTime.Now.ToString("yyyy/MM/dd"),
                        Count = random.Next(100, 100000),
                    }
                );
            }
            summary.WeekAccessNumber.Add(
                new AccessSummary
                {
                    Date = DateTime.Now.AddDays(-(i + 1)).ToString("yyyy/MM/dd"),
                    Count = random.Next(100, 100000),
                }
            );
        }
    }

    private async Task<List<PictureRecordResponse>> GetBannerAsync()
    {
        var cache = await fusionCache.TryGetAsync<List<PictureRecordResponse>>(CacheKey.BannerKey);
        if (cache.HasValue)
        {
            return cache.Value;
        }

        var banner = await pictureRecordService.GetBannerAsync();

        await fusionCache.SetAsync(CacheKey.BannerKey, banner, TimeSpan.FromHours(12));
        return banner.ToList();
    }

    [NonAction]
    private async Task<string> GetTop100LogsAsync()
    {
        var logs = await logEntryService.GetPageAsync(pageSize: 100);
        return string.Join(
            "\n",
            logs?.Events.Select(x =>
            {
                var recordTime = Convert.ToDateTime(x.Timestamp);
                return $"[{recordTime:HH:mm:ss} {x.Level}] {x.RenderedMessage}";
            }) ?? new List<string>()
        );
    }

    /// <summary>
    /// 获取壁纸
    /// </summary>
    /// <param name="bingWallpaper"></param>
    /// <returns></returns>
    [HttpGet("wallpaper")]
    public async Task<ActionResult<List<Wallpaper>>> Wallpaper(
        [FromServices] IBingWallpaper bingWallpaper
    )
    {
        var wallpapers = await bingWallpaper.GetTodayWallpapersAsync();
        return Ok(wallpapers);
    }

    /// <summary>
    /// 获取页脚内容
    /// </summary>
    /// <returns></returns>
    [HttpGet("footer")]
    [ProducesResponseType<string>(StatusCodes.Status200OK)]
    public async Task<IActionResult> GetFooter()
    {
        var content = await appOptionService.GetFooterContentAsync();
        return Ok(content);
    }

    /// <summary>
    /// 保存页脚内容
    /// </summary>
    /// <param name="footer"></param>
    /// <returns></returns>
    [HttpPost("footer"), Authorize(Policy = "System")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> SaveFooter([FromBody] SaveFooterDto footer)
    {
        await appOptionService.SaveFooterContentAsync(footer.Content);
        return NoContent();
    }
    
    
    /// <summary>
    /// 获取robots.txt
    /// </summary>
    /// <returns></returns>
    [HttpGet("robots.txt"), Authorize(Policy = "System")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> GetRobots()
    {
        var robots = await appOptionService.GetRobotsAsync();
        return Ok(robots);
    }
    
    /// <summary>
    /// 保存robots.txt
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    [HttpPost("robots.txt"), Authorize(Policy = "System")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> SaveRobots([FromBody] SvaeRobotsRequest request)
    {
        await appOptionService.SaveRobotsAsync(request.Content);
        return NoContent();
    }

    /// <summary>
    /// 获取友链
    /// </summary>
    /// <returns></returns>
    [HttpGet("friends")]
    public async Task<ActionResult<List<VmFriends>>> GetFriends()
    {
        var friends = await appOptionService.GetFriendsAsync();
        return Ok(friends);
    }

#if DEBUG
    private static HubConnection? _connection;

    /// <summary>
    ///
    /// </summary>
    /// <param name="message"></param>
    /// <returns></returns>
    [HttpPost("send")]
    public async Task<IActionResult> SendMessage([FromBody] string message)
    {
        if (_connection == null || _connection.State == HubConnectionState.Disconnected)
        {
            _connection = new HubConnectionBuilder()
                .WithUrl("https://localhost:37701/notification")
                .WithAutomaticReconnect()
                .Build();
            await _connection.StartAsync();
        }

        await _connection.InvokeCoreAsync("SendSystemNotification", [message]);

        return NoContent();
    }
#endif
}