/// Custom DotLiquid filters and tags
module MyWebLog.DotLiquidBespoke

open System
open System.IO
open System.Web
open DotLiquid
open Giraffe.ViewEngine
open MyWebLog.ViewModels
open MyWebLog.Views

/// Extensions on the DotLiquid Context object
type Context with
    
    /// Get the current web log from the DotLiquid context
    member this.WebLog =
        this.Environments[0].["web_log"] :?> WebLog


/// Does an asset exist for the current theme?
let assetExists fileName (webLog: WebLog) =
    ThemeAssetCache.get webLog.ThemeId |> List.exists (fun it -> it = fileName)

/// Obtain the link from known types
let permalink (item: obj) (linkFunc: Permalink -> string) =
    match item with
    | :? String       as link  -> Some link
    | :? DisplayPage  as page  -> Some page.Permalink
    | :? PostListItem as post  -> Some post.Permalink
    | :? DropProxy    as proxy -> Option.ofObj proxy["Permalink"] |> Option.map string
    | _ -> None
    |> function
    | Some link -> linkFunc (Permalink link)
    | None      -> $"alert('unknown item type {item.GetType().Name}')"


/// A filter to generate an absolute link
type AbsoluteLinkFilter() =
    static member AbsoluteLink(ctx: Context, item: obj) =
        permalink item ctx.WebLog.AbsoluteUrl


/// A filter to generate a link with posts categorized under the given category
type CategoryLinkFilter() =
    static member CategoryLink(ctx: Context, catObj: obj) =
        match catObj with
        | :? DisplayCategory as cat   -> Some cat.Slug
        | :? DropProxy       as proxy -> Option.ofObj proxy["Slug"] |> Option.map string
        | _ -> None
        |> function
        | Some slug -> ctx.WebLog.RelativeUrl(Permalink $"category/{slug}/")
        | None      -> $"alert('unknown category object type {catObj.GetType().Name}')"


/// A filter to generate a link that will edit a page
type EditPageLinkFilter() =
    static member EditPageLink(ctx: Context, pageObj: obj) =
        match pageObj with
        | :? DisplayPage as page  -> Some page.Id
        | :? DropProxy   as proxy -> Option.ofObj proxy["Id"] |> Option.map string
        | :? String      as theId -> Some theId
        | _ -> None
        |> function
        | Some pageId -> ctx.WebLog.RelativeUrl(Permalink $"admin/page/{pageId}/edit")
        | None        -> $"alert('unknown page object type {pageObj.GetType().Name}')"


/// A filter to generate a link that will edit a post
type EditPostLinkFilter() =
    static member EditPostLink(ctx: Context, postObj: obj) =
        match postObj with
        | :? PostListItem as post  -> Some post.Id
        | :? DropProxy    as proxy -> Option.ofObj proxy["Id"] |> Option.map string
        | :? String       as theId -> Some theId
        | _ -> None
        |> function
        | Some postId -> ctx.WebLog.RelativeUrl(Permalink $"admin/post/{postId}/edit")
        | None        -> $"alert('unknown post object type {postObj.GetType().Name}')"
 
    
/// A filter to generate nav links, highlighting the active link (exact match)
type NavLinkFilter() =
    static member NavLink(ctx: Context, url: string, text: string) =
        let extraPath = ctx.WebLog.ExtraPath
        let path = if extraPath = "" then "" else $"{extraPath[1..]}/"
        seq {
            "<li class=nav-item><a class=\"nav-link"
            if (string ctx.Environments[0].["current_page"]).StartsWith $"{path}{url}" then " active"
            "\" href=\""
            ctx.WebLog.RelativeUrl(Permalink url)
            "\">"
            text
            "</a>"
        }
        |> String.concat ""


/// A filter to generate a link for theme asset (image, stylesheet, script, etc.)
type ThemeAssetFilter() =
    static member ThemeAsset(ctx: Context, asset: string) =
        ctx.WebLog.RelativeUrl(Permalink $"themes/{ctx.WebLog.ThemeId}/{asset}")


/// Create various items in the page header based on the state of the page being generated
type PageHeadTag() =
    inherit Tag()
    
    override this.Render(context: Context, result: TextWriter) =
        let webLog = context.WebLog
        // spacer
        let s      = "    "
        let getBool name =
            defaultArg (context.Environments[0].[name] |> Option.ofObj |> Option.map Convert.ToBoolean) false
        
        result.WriteLine $"""<meta name=generator content="{context.Environments[0].["generator"]}">"""
        
        // Theme assets
        if assetExists "style.css" webLog then
            result.WriteLine $"""{s}<link rel=stylesheet href="{ThemeAssetFilter.ThemeAsset(context, "style.css")}">"""
        if assetExists "favicon.ico" webLog then
            result.WriteLine $"""{s}<link rel=icon href="{ThemeAssetFilter.ThemeAsset(context, "favicon.ico")}">"""
        
        // RSS feeds and canonical URLs
        let feedLink title url =
            let escTitle = HttpUtility.HtmlAttributeEncode title
            let relUrl   = webLog.RelativeUrl(Permalink url)
            $"""{s}<link rel=alternate type="application/rss+xml" title="{escTitle}" href="{relUrl}">"""
        
        if webLog.Rss.IsFeedEnabled && getBool "is_home" then
            result.WriteLine(feedLink webLog.Name webLog.Rss.FeedName)
            result.WriteLine $"""{s}<link rel=canonical href="{webLog.AbsoluteUrl Permalink.Empty}">"""
        
        if webLog.Rss.IsCategoryEnabled && getBool "is_category_home" then
            let slug = context.Environments[0].["slug"] :?> string
            result.WriteLine(feedLink webLog.Name $"category/{slug}/{webLog.Rss.FeedName}")
            
        if webLog.Rss.IsTagEnabled && getBool "is_tag_home" then
            let slug = context.Environments[0].["slug"] :?> string
            result.WriteLine(feedLink webLog.Name $"tag/{slug}/{webLog.Rss.FeedName}")
            
        if getBool "is_post" then
            let post = context.Environments[0].["model"] :?> PostDisplay
            let url  = webLog.AbsoluteUrl (Permalink post.Posts[0].Permalink)
            result.WriteLine $"""{s}<link rel=canonical href="{url}">"""
        
        if getBool "is_page" then
            let page = context.Environments[0].["page"] :?> DisplayPage
            let url  = webLog.AbsoluteUrl (Permalink page.Permalink)
            result.WriteLine $"""{s}<link rel=canonical href="{url}">"""


/// Create various items in the page header based on the state of the page being generated
type PageFootTag() =
    inherit Tag()
    
    override this.Render(context: Context, result: TextWriter) =
        let webLog = context.WebLog
        // spacer
        let s = "    "
        
        if webLog.AutoHtmx then
            result.WriteLine $"{s}{RenderView.AsString.htmlNode Htmx.Script.minified}"
        
        if assetExists "script.js" webLog then
            result.WriteLine $"""{s}<script src="{ThemeAssetFilter.ThemeAsset(context, "script.js")}"></script>"""


/// A filter to generate a relative link
type RelativeLinkFilter() =
    static member RelativeLink(ctx: Context, item: obj) =
        permalink item ctx.WebLog.RelativeUrl


/// A filter to generate a link with posts tagged with the given tag
type TagLinkFilter() =
    static member TagLink(ctx: Context, tag: string) =
        ctx.Environments[0].["tag_mappings"] :?> TagMap list
        |> List.tryFind (fun it -> it.Tag = tag)
        |> function
        | Some tagMap -> tagMap.UrlValue
        | None        -> tag.Replace(" ", "+")
        |> function tagUrl -> ctx.WebLog.RelativeUrl(Permalink $"tag/{tagUrl}/")


/// Create links for a user to log on or off, and a dashboard link if they are logged off
type UserLinksTag() =
    inherit Tag()
    
    override this.Render(context: Context, result: TextWriter) =
        let link it = context.WebLog.RelativeUrl(Permalink it)
        seq {
            """<ul class="navbar-nav flex-grow-1 justify-content-end">"""
            match Convert.ToBoolean context.Environments[0].["is_logged_on"] with
            | true ->
                $"""<li class=nav-item><a class=nav-link href="{link "admin/dashboard"}">Dashboard</a>"""
                $"""<li class=nav-item><a class=nav-link href="{link "user/log-off"}">Log Off</a>"""
            | false ->
                $"""<li class=nav-item><a class=nav-link href="{link "user/log-on"}">Log On</a>"""
            "</ul>"
        }
        |> Seq.iter result.WriteLine

/// A filter to retrieve the value of a meta item from a list
//    (shorter than `{% assign item = list | where: "Name", [name] | first %}{{ item.value }}`)
type ValueFilter() =
    static member Value(_: Context, items: MetaItem list, name: string) =
        match items |> List.tryFind (fun it -> it.Name = name) with
        | Some item -> item.Value
        | None -> $"-- {name} not found --"


open System.Collections.Generic
open Microsoft.AspNetCore.Antiforgery

/// Register custom filters/tags and safe types
let register () =
    [ typeof<AbsoluteLinkFilter>; typeof<CategoryLinkFilter>; typeof<EditPageLinkFilter>; typeof<EditPostLinkFilter>
      typeof<NavLinkFilter>;      typeof<RelativeLinkFilter>; typeof<TagLinkFilter>;      typeof<ThemeAssetFilter>
      typeof<ValueFilter>
    ]
    |> List.iter Template.RegisterFilter
    
    Template.RegisterTag<PageHeadTag>  "page_head"
    Template.RegisterTag<PageFootTag>  "page_foot"
    Template.RegisterTag<UserLinksTag> "user_links"
    
    [ // Domain types
      typeof<CustomFeed>; typeof<Episode>; typeof<Episode option>; typeof<MetaItem>; typeof<Page>; typeof<RssOptions>
      typeof<TagMap>;     typeof<WebLog>
      // View models
      typeof<AppViewContext>; typeof<DisplayCategory>; typeof<DisplayPage>; typeof<EditPageModel>; typeof<PostDisplay>
      typeof<PostListItem>;   typeof<UserMessage>
      // Framework types
      typeof<AntiforgeryTokenSet>; typeof<DateTime option>; typeof<int option>;    typeof<KeyValuePair>
      typeof<MetaItem list>;       typeof<string list>;     typeof<string option>; typeof<TagMap list>
    ]
    |> List.iter (fun it -> Template.RegisterSafeType (it, [| "*" |]))