using System.Net.Http;
using System.ServiceModel.Syndication;
using System.Xml;
using AngleSharp;
using AngleSharp.Html;
using Dpz.Core.EnumLibrary;
using Dpz.Core.Web.Library.Api;
using Microsoft.AspNetCore.SignalR;
using OpenIddict.Client.AspNetCore;
using IConfiguration = Microsoft.Extensions.Configuration.IConfiguration;
// ReSharper disable UnusedVariable
#pragma warning disable CS0162

namespace Dpz.Core.Web.Controllers;

public class HomeController(
    IBingWallpaper bingWallpaper,
    IConfiguration configuration,
    IFusionCache fusionCache,
    IHomeCacheService cacheService
) : Controller
{
    /// <summary>
    /// home
    /// </summary>
    /// <returns></returns>
    public async Task<IActionResult> Index()
    {
        ViewBag.Menu = MenuItem.Home;
        this.SetTitle("首页");
        var model = await cacheService.GetCacheDataAsync();
        return View(model);
    }

    [Route(("news.html"))]
    public async Task<IActionResult> News(string mode = "")
    {
        var news = await cacheService.GetTodayNewsAsync();
        if (mode == "content")
        {
            return Content(
                news == null
                    ? ""
                    : string.Join(
                        "\n",
                        (news.NewsList ?? []).Select(x =>
                            $"{(news.NewsList ?? []).IndexOf(x) + 1}. {x.Title}"
                        )
                    )
            );
        }

        return View(news);
    }

    public async Task<IActionResult> TodayNews()
    {
        var news = await cacheService.GetTodayNewsAsync();
        return PartialView("_TodayNews", news);
    }

    public async Task<IActionResult> SystemNotifications(
        [FromServices] ISystemNotificationHistoryService notificationService
    )
    {
        var notifications = await notificationService.GetRecentAsync();
        return PartialView("_SystemNotificationsPartial", notifications);
    }

    [HttpGet, Route("datetime")]
    public async Task<IActionResult> Date()
    {
        return await Task.FromResult(View());
    }

#if DEBUG
    public IActionResult Demo(string? msg = null)
    {
        var s = User;
        return Json(new { time = DateTime.Now, message = msg });
    }

    public IActionResult Demo2()
    {
        throw new ArgumentException("param is null");
    }

    public async Task<IActionResult> Demo3(
        [FromServices] IHubContext<Dpz.Core.Web.Library.Hub.Notification> hubContext
    )
    {
        var s = new ProgressMessage
        {
            Message = "测试消息",
            Type = MessageType.Success,
            ProgressValues = [100m, 100m],
        };
        await hubContext.Clients.All.SendCoreAsync("hotTopicMessage", [s]);
        return View();
    }

    public IActionResult LayDemo()
    {
        return View();
    }

    public async Task<IActionResult> Demo4([FromServices] IHttpClientFactory httpClientFactory)
    {
        var httpClient = httpClientFactory.CreateClient("edge");
        var request = new HttpRequestMessage(HttpMethod.Get, "https://api.dpangzi.com/api/Article");

        var response = await httpClient.SendAsync(request);
        var json = await response.Content.ReadAsStringAsync();
        return Content(json, "application/json");
    }
#endif

    [HttpGet("~/connect/oidc")]
    public IActionResult Login(string fromUrl = "/")
    {
        if (User.Authenticated)
        {
            return Redirect(string.IsNullOrWhiteSpace(fromUrl) ? "/" : fromUrl);
        }

        return Challenge(
            new AuthenticationProperties { RedirectUri = fromUrl },
            OpenIddictClientAspNetCoreDefaults.AuthenticationScheme
        );
        //return View(model: fromUrl);
    }

    [Route("markdown-guide.html")]
    public async Task<IActionResult> Markdown(
        [FromServices] IHttpClientFactory httpClientFactory,
        string version = ""
    )
    {
        ViewBag.Menu = MenuItem.Markdown;
        this.SetTitle("Markdown 语法示例");

        var client = httpClientFactory.CreateClient("edge");
        var cdnHost = configuration["S3:CdnHost"];

        var markdown = await fusionCache.GetOrSetAsync<string>(
            "markdown-guide:content",
            async (_, cancellationToken) =>
            {
                var request = new HttpRequestMessage(
                    HttpMethod.Get,
                    $"{cdnHost}/markdown-guide.md"
                );
                var response = await client.SendAsync(request, cancellationToken);
                return await response.Content.ReadAsStringAsync(cancellationToken);
            },
            options => options.SetDuration(TimeSpan.FromDays(1))
        );
        return View(model: markdown);
    }

    [Route("act/{id}")]
    public async Task<IActionResult> Activity(
        [FromServices] IDynamicPageService dynamicPageService,
        string id = ""
    )
    {
        var cache = await fusionCache.TryGetAsync<ActivityModel>(CacheKey.DynamicPageKey(id));
        if (cache.HasValue)
        {
            Response.ContentType = cache.Value.ContentType;
            return View(model: cache.Value.Content);
        }

        var page = await dynamicPageService.FindAsync(id);
        if (page == null)
        {
            return NotFound();
        }

        var content = page.Content ?? "";

        if (page.ContentType == PageContentType.Html)
        {
            var htmlContext = BrowsingContext.New(Configuration.Default);
            var document = await htmlContext.OpenAsync(x => x.Content(content));
            if (page.Styles.Count > 0)
            {
                foreach (var item in page.Styles)
                {
                    var link = document.CreateElement("link");
                    link.SetAttribute("href", Url.Action("Activity", new { id = item.Name }));
                    link.SetAttribute("rel", "stylesheet");
                    document.Head?.Append(link);
                }
            }

            if (page.Scripts.Count > 0)
            {
                foreach (var item in page.Scripts)
                {
                    var script = document.CreateElement("script");
                    script.SetAttribute("src", Url.Action("Activity", new { id = item.Name }));
                    document.Body?.Append(script);
                }
            }

            await using var writer = new StringWriter();
            document.ToHtml(writer, new PrettyMarkupFormatter());
            content = writer.ToString();
        }

        var contentType = (page.ContentType ?? PageContentType.Html).GetDescription();
        Response.ContentType = contentType;

        var cacheValue = new ActivityModel(content, contentType);
        await fusionCache.SetAsync(CacheKey.DynamicPageKey(id), cacheValue, TimeSpan.FromDays(30));

        return View(model: content);
    }

    public async Task<IActionResult> GroupBarrages(
        [FromServices] IBarrageService barrageService,
        string group
    )
    {
        var list = await barrageService.GetGroupBarragesAsync(group);
        return Json(list);
    }

    public async Task<IActionResult> Wallpaper(bool clear = false)
    {
        if (clear)
        {
            await bingWallpaper.ClearCacheAsync();
        }

        var data = await bingWallpaper.GetRandomWallpaperAsync();
        return Json(data);
    }

    public async Task<IActionResult> TodayWallpaper(bool clear = false)
    {
        if (clear)
        {
            await bingWallpaper.ClearCacheAsync();
        }

        var data = await bingWallpaper.GetTodayWallpapersAsync();
        return Json(data);
    }

    [Route("friends.html")]
    public async Task<IActionResult> Friends([FromServices] IAppOptionService service)
    {
        this.SetTitle("友情链接");
        ViewBag.Menu = MenuItem.Friends;
        var list = await service.GetFriendsAsync();
        return View(list);
    }

    [Route("feed.rss")]
    public async Task<IActionResult> Rss([FromServices] IArticleService articleService)
    {
        var cdnHost = configuration["S3:CdnHost"];
        var feed = new SyndicationFeed(
            "叫我阿胖",
            "追赶大佬脚步的阿胖",
            new Uri("https://core.dpangzi.com/feed.rss"),
            "feed.rss",
            DateTime.Now
        )
        {
            ImageUrl = new Uri($"{cdnHost}/logo.png"),
            Copyright = new TextSyndicationContent($"© {DateTime.Now.Year} 叫我阿胖"),
            Language = "zh-Hans",
        };

        var articles = await articleService.GetLatestAsync(50);
        feed.Items = articles
            .Select(x =>
            {
                var content = new TextSyndicationContent(x.Introduction);
                var addr = Url.Action(
                    "Read",
                    "Article",
                    new { id = x.Id },
                    HttpContext.Request.Scheme
                );
                var uri = new Uri(addr!);
                return new SyndicationItem(x.Title, content, uri, x.Id, x.CreateTime)
                {
                    Authors = { new SyndicationPerson(x.Author.Name) },
                    LastUpdatedTime = x.LastUpdateTime,
                };
            })
            .ToList();

        var settings = new XmlWriterSettings
        {
            Encoding = Encoding.UTF8,
            NewLineHandling = NewLineHandling.Entitize,
            NewLineOnAttributes = true,
            Indent = true,
            Async = true,
        };

        using var stream = new MemoryStream();
        await using var xmlWriter = XmlWriter.Create(stream, settings);
        var rssFormatter = new Rss20FeedFormatter(feed, false);
        rssFormatter.WriteTo(xmlWriter);
        await xmlWriter.FlushAsync();
        return File(stream.ToArray(), "text/xml; charset=utf-8"); //application/rss+xml
    }

    [HttpGet("sitemap")]
    public IActionResult Sitemap()
    {
        return RedirectPermanent("/sitemap.xml");
    }

    [HttpGet, Route("blacklist.html")]
    public async Task<IActionResult> GetBlacklist([FromServices] IBlockService blockService)
    {
        var blockAccessThreshold = configuration.GetValue("BlockAccessThreshold", 0);
        var blocks = await blockService.GetBlocksAsync(blockAccessThreshold);
        return View(blocks);
    }

    [HttpGet, Route("dialog-demo.html")]
    public IActionResult DialogDemo()
    {
        this.SetTitle("Dialog 测试演示");
        ViewBag.Menu = MenuItem.Home;
        return View();
    }

    [HttpGet, Route("robots.txt")]
    public async Task<IActionResult> Robots([FromServices] IAppOptionService service)
    {
        var content = await service.GetRobotsAsync();
        return Content(content, "text/plain; charset=utf-8");
    }
}