namespace MyWebLog.Data.Postgres

open BitBadger.Documents
open BitBadger.Documents.Postgres
open Microsoft.Extensions.Logging
open MyWebLog
open MyWebLog.Data
open Npgsql.FSharp

/// PostgreSQL myWebLog page data implementation
type PostgresPageData(log: ILogger) =
    
    // SUPPORT FUNCTIONS
    
    /// Append revisions to a page
    let appendPageRevisions (page: Page) = backgroundTask {
        log.LogTrace "Page.appendPageRevisions"
        let! revisions = Revisions.findByEntityId Table.PageRevision Table.Page page.Id
        return { page with Revisions = revisions }
    }
    
    /// Return a page with no text or revisions
    let pageWithoutText (row: RowReader) =
        { fromData<Page> row with Text = "" }
    
    /// Update a page's revisions
    let updatePageRevisions (pageId: PageId) oldRevs newRevs =
        log.LogTrace "Page.updatePageRevisions"
        Revisions.update Table.PageRevision Table.Page pageId oldRevs newRevs
    
    /// Does the given page exist?
    let pageExists (pageId: PageId) webLogId =
        log.LogTrace "Page.pageExists"
        Document.existsByWebLog Table.Page pageId webLogId
    
    /// The query to get all pages ordered by title
    let sortedPages =
        selectWithCriteria Table.Page + Query.orderBy [ Field.Named $"i:{nameof Page.Empty.Title}" ] PostgreSQL
        
    // IMPLEMENTATION FUNCTIONS
    
    /// Add a page
    let add (page: Page) = backgroundTask {
        log.LogTrace "Page.add"
        do! insert Table.Page { page with Revisions = [] }
        do! updatePageRevisions page.Id [] page.Revisions
        ()
    }
    
    /// Get all pages for a web log (without text, metadata, revisions, or prior permalinks)
    let all webLogId =
        log.LogTrace "Page.all"
        Custom.list
            sortedPages
            [ webLogContains webLogId ]
            (fun row -> { fromData<Page> row with Text = ""; Metadata = []; PriorPermalinks = [] }) 
    
    /// Count all pages for the given web log
    let countAll webLogId =
        log.LogTrace "Page.countAll"
        Count.byContains Table.Page (webLogDoc webLogId)
    
    /// Count all pages shown in the page list for the given web log
    let countListed webLogId =
        log.LogTrace "Page.countListed"
        Count.byContains Table.Page {| webLogDoc webLogId with IsInPageList = true |}
    
    /// Find a page by its ID (without revisions or prior permalinks)
    let findById pageId webLogId = backgroundTask {
        log.LogTrace "Page.findById"
        match! Document.findByIdAndWebLog<PageId, Page> Table.Page pageId webLogId with
        | Some page -> return Some { page with PriorPermalinks = [] }
        | None -> return None
    }
    
    /// Find a complete page by its ID
    let findFullById pageId webLogId = backgroundTask {
        log.LogTrace "Page.findFullById"
        match! Document.findByIdAndWebLog<PageId, Page> Table.Page pageId webLogId with
        | Some page ->
            let! withMore = appendPageRevisions page
            return Some withMore
        | None -> return None
    }
    
    // TODO: need to handle when the page being deleted is the home page
    /// Delete a page by its ID
    let delete pageId webLogId = backgroundTask {
        log.LogTrace "Page.delete"
        match! pageExists pageId webLogId with
        | true ->
            do! Custom.nonQuery
                    $"""{Query.delete Table.PageRevision} WHERE page_id = @id;
                        {Query.delete Table.Page}         WHERE {Query.whereById "@id"}"""
                    [ idParam pageId ]
            return true
        | false -> return false
    }
    
    /// Find a page by its permalink for the given web log
    let findByPermalink (permalink: Permalink) webLogId = backgroundTask {
        log.LogTrace "Page.findByPermalink"
        let! page =
            Find.byContains<Page> Table.Page {| webLogDoc webLogId with Permalink = permalink |}
            |> tryHead
        return page |> Option.map (fun pg -> { pg with PriorPermalinks = [] })
    }
    
    /// Find the current permalink within a set of potential prior permalinks for the given web log
    let findCurrentPermalink (permalinks: Permalink list) webLogId = backgroundTask {
        log.LogTrace "Page.findCurrentPermalink"
        if List.isEmpty permalinks then return None
        else
            let linkField =
                Field.InArray (nameof Page.Empty.PriorPermalinks) Table.Page (List.map (string >> box) permalinks)
            let query =
                (Query.statementWhere
                     (Query.find Table.Page)
                     $"""{Query.whereDataContains "@criteria"} AND {Query.whereByFields All [ linkField ]}""")
                    .Replace("SELECT data", $"SELECT data->>'{nameof Page.Empty.Permalink}' AS permalink")
            return! Custom.single query (addFieldParams [ linkField ] [ webLogContains webLogId ]) Map.toPermalink
    }
    
    /// Get all complete pages for the given web log
    let findFullByWebLog webLogId = backgroundTask {
        log.LogTrace "Page.findFullByWebLog"
        let! pages     = Find.byContains<Page> Table.Page (webLogDoc webLogId)
        let! revisions = Revisions.findByWebLog Table.PageRevision Table.Page PageId webLogId 
        return
            pages
            |> List.map (fun it ->
                { it with Revisions = revisions |> List.filter (fun r -> fst r = it.Id) |> List.map snd })
    }
    
    /// Get all listed pages for the given web log (without revisions or text)
    let findListed webLogId =
        log.LogTrace "Page.findListed"
        Custom.list
            sortedPages [ jsonParam "@criteria" {| webLogDoc webLogId with IsInPageList = true |} ] pageWithoutText
    
    /// Get a page of pages for the given web log (without revisions)
    let findPageOfPages webLogId pageNbr =
        log.LogTrace "Page.findPageOfPages"
        Custom.list
            $"{sortedPages} LIMIT @pageSize OFFSET @toSkip"
            [ webLogContains webLogId; "@pageSize", Sql.int 26; "@toSkip", Sql.int ((pageNbr - 1) * 25) ]
            (fun row -> { fromData<Page> row with Metadata = []; PriorPermalinks = [] })
    
    /// Restore pages from a backup
    let restore (pages: Page list) = backgroundTask {
        log.LogTrace "Page.restore"
        let revisions = pages |> List.collect (fun p -> p.Revisions |> List.map (fun r -> p.Id, r))
        let! _ =
            Configuration.dataSource ()
            |> Sql.fromDataSource
            |> Sql.executeTransactionAsync
                [ Query.insert Table.Page,
                    pages |> List.map (fun page -> [ jsonParam "@data" { page with Revisions = [] } ])
                  Revisions.insertSql Table.PageRevision,
                    revisions |> List.map (fun (pageId, rev) -> Revisions.revParams pageId rev) ]
        ()
    }
    
    /// Update a page
    let update (page: Page) = backgroundTask {
        log.LogTrace "Page.update"
        match! findFullById page.Id page.WebLogId with
        | Some oldPage ->
            do! Update.byId Table.Page page.Id { page with Revisions = [] }
            do! updatePageRevisions page.Id oldPage.Revisions page.Revisions
        | None -> ()
        ()
    }
    
    /// Update a page's prior permalinks
    let updatePriorPermalinks pageId webLogId (permalinks: Permalink list) = backgroundTask {
        log.LogTrace "Page.updatePriorPermalinks"
        match! pageExists pageId webLogId with
        | true ->
            do! Patch.byId Table.Page pageId {| PriorPermalinks = permalinks |}
            return true
        | false -> return false
    }
    
    interface IPageData with
        member _.Add page = add page
        member _.All webLogId = all webLogId
        member _.CountAll webLogId = countAll webLogId
        member _.CountListed webLogId = countListed webLogId
        member _.Delete pageId webLogId = delete pageId webLogId
        member _.FindById pageId webLogId = findById pageId webLogId
        member _.FindByPermalink permalink webLogId = findByPermalink permalink webLogId
        member _.FindCurrentPermalink permalinks webLogId = findCurrentPermalink permalinks webLogId
        member _.FindFullById pageId webLogId = findFullById pageId webLogId
        member _.FindFullByWebLog webLogId = findFullByWebLog webLogId
        member _.FindListed webLogId = findListed webLogId
        member _.FindPageOfPages webLogId pageNbr = findPageOfPages webLogId pageNbr
        member _.Restore pages = restore pages
        member _.Update page = update page
        member _.UpdatePriorPermalinks pageId webLogId permalinks = updatePriorPermalinks pageId webLogId permalinks