/// <summary>
/// Integration tests for <see cref="IPostData" /> implementations
/// </summary> 
module PostDataTests

open System
open Expecto
open MyWebLog
open MyWebLog.Data
open NodaTime

/// The ID of the root web log
let private rootId = CategoryDataTests.rootId

/// The ID of podcast episode 1
let private episode1 = PostId "osxMfWGlAkyugUbJ1-xD1g"

/// The published instant for episode 1
let private episode1Published = Instant.FromDateTimeOffset(DateTimeOffset.Parse "2024-01-20T22:24:01Z")

/// The ID of podcast episode 2
let episode2 = PostId "l4_Eh4aFO06SqqJjOymNzA"

/// The ID of "Something May Happen" post
let private something = PostId "QweKbWQiOkqqrjEdgP9wwg"

/// The published instant for "Something May Happen" post
let private somethingPublished = Instant.FromDateTimeOffset(DateTimeOffset.Parse "2024-01-20T22:32:59Z")

/// The ID of "An Incomplete Thought" post
let private incomplete = PostId "VweKbWQiOkqqrjEdgP9wwg"

/// The ID of "Test Post 1" post
let private testPost1 = PostId "RCsCU2puYEmkpzotoi8p4g"

/// The published instant for "Test Post 1" post
let private testPost1Published = Instant.FromDateTimeOffset(DateTimeOffset.Parse "2024-01-20T22:17:29Z")

/// The category IDs for "Spitball" (parent) and "Moonshot"
let private testCatIds = [ CategoryId "jw6N69YtTEWVHAO33jHU-w"; CategoryId "ScVpyu1e7UiP7bDdge3ZEw" ]

/// Ensure that a list of posts has text for each post
let private ensureHasText (posts: Post list) =
    for post in posts do Expect.isNotEmpty post.Text $"Text should not be blank (post ID {post.Id})"

/// Ensure that a list of posts has no revisions or prior permalinks
let private ensureEmpty posts =
    for post in posts do
        Expect.isEmpty post.Revisions $"There should have been no revisions (post ID {post.Id})"
        Expect.isEmpty post.PriorPermalinks $"There should have been no prior permalinks (post ID {post.Id})"

let ``Add succeeds`` (data: IData) = task {
    let post =
        { Id              = PostId "a-new-post"
          WebLogId        = WebLogId "test"
          AuthorId        = WebLogUserId "test-author"
          Status          = Published 
          Title           = "A New Test Post"
          Permalink       = Permalink "2020/test-post.html"
          PublishedOn     = Some (Noda.epoch + Duration.FromMinutes 1L)
          UpdatedOn       = Noda.epoch + Duration.FromMinutes 3L
          Template        = Some "fancy"
          Text            = "<p>Test text here"
          CategoryIds     = [ CategoryId "a"; CategoryId "b" ]
          Tags            = [ "x"; "y"; "zed" ]
          Episode         = Some { Episode.Empty with Media = "test-ep.mp3" }
          Metadata        = [ { Name = "Meta"; Value = "Data" } ]
          PriorPermalinks = [ Permalink "2020/test-post-a.html" ]
          Revisions       = [ { AsOf = Noda.epoch + Duration.FromMinutes 1L; Text = Html "<p>Test text here" } ] }
    do! data.Post.Add post
    let! stored = data.Post.FindFullById post.Id post.WebLogId
    Expect.isSome stored "The added post should have been retrieved"
    let it = stored.Value
    Expect.equal it.Id post.Id "ID not saved properly"
    Expect.equal it.WebLogId post.WebLogId "Web log ID not saved properly"
    Expect.equal it.AuthorId post.AuthorId "Author ID not saved properly"
    Expect.equal it.Status post.Status "Status not saved properly"
    Expect.equal it.Title post.Title "Title not saved properly"
    Expect.equal it.Permalink post.Permalink "Permalink not saved properly"
    Expect.equal it.PublishedOn post.PublishedOn "Published On not saved properly"
    Expect.equal it.UpdatedOn post.UpdatedOn "Updated On not saved properly"
    Expect.equal it.Template post.Template "Template not saved properly"
    Expect.equal it.Text post.Text "Text not saved properly"
    Expect.equal it.CategoryIds post.CategoryIds "Category IDs not saved properly"
    Expect.equal it.Tags post.Tags "Tags not saved properly"
    Expect.equal it.Episode post.Episode "Episode not saved properly"
    Expect.equal it.Metadata post.Metadata "Metadata items not saved properly"
    Expect.equal it.PriorPermalinks post.PriorPermalinks "Prior permalinks not saved properly"
    Expect.equal it.Revisions post.Revisions "Revisions not saved properly"
}

let ``CountByStatus succeeds`` (data: IData) = task {
    let! count = data.Post.CountByStatus Published rootId
    Expect.equal count 4 "There should be 4 published posts"
}

let ``FindById succeeds when a post is found`` (data: IData) = task {
    let! post = data.Post.FindById episode1 rootId
    Expect.isSome post "There should have been a post returned"
    let it = post.Value
    Expect.equal it.Id episode1 "An incorrect post was retrieved"
    Expect.equal it.WebLogId rootId "The post belongs to an incorrect web log"
    Expect.equal it.AuthorId (WebLogUserId "5EM2rimH9kONpmd2zQkiVA") "Author ID is incorrect"
    Expect.equal it.Status Published "Status is incorrect"
    Expect.equal it.Title "Episode 1" "Title is incorrect"
    Expect.equal it.Permalink (Permalink "2024/episode-1.html") "Permalink is incorrect"
    Expect.equal it.PublishedOn (Some episode1Published) "Published On is incorrect"
    Expect.equal it.UpdatedOn episode1Published "Updated On is incorrect"
    Expect.equal it.Text "<p>It's the launch of my new podcast - y'all come listen!" "Text is incorrect"
    Expect.equal it.CategoryIds [ CategoryId "S5JflPsJ9EG7gA2LD4m92A" ] "Category IDs are incorrect"
    Expect.equal it.Tags [ "general"; "podcast" ] "Tags are incorrect"
    Expect.isSome it.Episode "There should be an episode associated with this post"
    let ep = it.Episode.Value
    Expect.equal ep.Media "episode-1.mp3" "Episode media is incorrect"
    Expect.equal ep.Length 124302L "Episode length is incorrect"
    Expect.equal
        ep.Duration (Some (Duration.FromMinutes 12L + Duration.FromSeconds 22L)) "Episode duration is incorrect"
    Expect.equal ep.ImageUrl (Some "images/ep1-cover.png") "Episode image URL is incorrect"
    Expect.equal ep.Subtitle (Some "An introduction to this podcast") "Episode subtitle is incorrect"
    Expect.equal ep.Explicit (Some Clean) "Episode explicit rating is incorrect"
    Expect.equal ep.ChapterFile (Some "uploads/chapters.json") "Episode chapter file is incorrect"
    Expect.equal ep.TranscriptUrl (Some "uploads/transcript.srt") "Episode transcript URL is incorrect"
    Expect.equal ep.TranscriptType (Some "application/srt") "Episode transcript type is incorrect"
    Expect.equal ep.TranscriptLang (Some "en") "Episode transcript language is incorrect"
    Expect.equal ep.TranscriptCaptions (Some true) "Episode transcript caption flag is incorrect"
    Expect.equal ep.SeasonNumber (Some 1) "Episode season number is incorrect"
    Expect.equal ep.SeasonDescription (Some "The First Season") "Episode season description is incorrect"
    Expect.equal ep.EpisodeNumber (Some 1.) "Episode number is incorrect"
    Expect.equal ep.EpisodeDescription (Some "The first episode ever!") "Episode description is incorrect"
    Expect.equal
        it.Metadata
        [ { Name = "Density"; Value = "Non-existent" }; { Name = "Intensity"; Value = "Low" } ]
        "Metadata is incorrect"
    ensureEmpty [ it ]
}

let ``FindById succeeds when a post is not found (incorrect weblog)`` (data: IData) = task {
    let! post = data.Post.FindById episode1 (WebLogId "wrong")
    Expect.isNone post "The post should not have been retrieved"
}

let ``FindById succeeds when a post is not found (bad post ID)`` (data: IData) = task {
    let! post = data.Post.FindById (PostId "absent") rootId
    Expect.isNone post "The post should not have been retrieved"
}

let ``FindByPermalink succeeds when a post is found`` (data: IData) = task {
    let! post = data.Post.FindByPermalink (Permalink "2024/episode-1.html") rootId
    Expect.isSome post "A post should have been returned"
    let it = post.Value
    Expect.equal it.Id episode1 "The wrong post was retrieved"
    ensureEmpty [ it ]
}

let ``FindByPermalink succeeds when a post is not found (incorrect weblog)`` (data: IData) = task {
    let! post = data.Post.FindByPermalink (Permalink "2024/episode-1.html") (WebLogId "incorrect")
    Expect.isNone post "The post should not have been retrieved"
}

let ``FindByPermalink succeeds when a post is not found (no such permalink)`` (data: IData) = task {
    let! post = data.Post.FindByPermalink (Permalink "404") rootId
    Expect.isNone post "The post should not have been retrieved"
}

let ``FindCurrentPermalink succeeds when a post is found`` (data: IData) = task {
    let! link = data.Post.FindCurrentPermalink [ Permalink "2024/ep-1.html"; Permalink "2024/ep-1.html/" ] rootId
    Expect.isSome link "A permalink should have been returned"
    Expect.equal link (Some (Permalink "2024/episode-1.html")) "The wrong permalink was retrieved"
}

let ``FindCurrentPermalink succeeds when a post is not found`` (data: IData) = task {
    let! link = data.Post.FindCurrentPermalink [ Permalink "oops/"; Permalink "oops" ] rootId
    Expect.isNone link "A permalink should not have been returned"
}

let ``FindFullById succeeds when a post is found`` (data: IData) = task {
    let! post = data.Post.FindFullById episode1 rootId
    Expect.isSome post "A post should have been returned"
    let it = post.Value
    Expect.equal it.Id episode1 "The wrong post was retrieved"
    Expect.equal it.WebLogId rootId "The post's web log did not match the called parameter"
    Expect.equal
        it.Revisions
        [ { AsOf = episode1Published; Text = Html "<p>It's the launch of my new podcast - y'all come listen!" } ]
        "Revisions are incorrect"
    Expect.equal it.PriorPermalinks [ Permalink "2024/ep-1.html" ] "Prior permalinks are incorrect"
}

let ``FindFullById succeeds when a post is not found`` (data: IData) = task {
    let! post = data.Post.FindFullById (PostId "no-post") rootId
    Expect.isNone post "A page should not have been retrieved"
}

let ``FindFullByWebLog succeeds when posts are found`` (data: IData) = task {
    let! posts = data.Post.FindFullByWebLog rootId
    Expect.hasLength posts 5 "There should have been 5 posts returned"
    let allPosts = [ testPost1; episode1; episode2; something; incomplete ]
    posts |> List.iter (fun it ->
        Expect.contains allPosts it.Id $"Post ID {it.Id} unexpected"
        if it.Id = episode1 then
            Expect.isNonEmpty it.Metadata "Metadata should have been retrieved"
            Expect.isNonEmpty it.PriorPermalinks "Prior permalinks should have been retrieved"
        Expect.isNonEmpty it.Revisions "Revisions should have been retrieved")
}

let ``FindFullByWebLog succeeds when posts are not found`` (data: IData) = task {
    let! posts = data.Post.FindFullByWebLog (WebLogId "nonexistent")
    Expect.isEmpty posts "No posts should have been retrieved"
}

let ``FindPageOfCategorizedPosts succeeds when posts are found`` (data: IData) = task {
    let! posts = data.Post.FindPageOfCategorizedPosts rootId testCatIds 1 1
    Expect.hasLength posts 2 "There should be 2 posts returned"
    Expect.equal posts[0].Id something "The wrong post was returned for page 1"
    ensureEmpty posts
    let! posts = data.Post.FindPageOfCategorizedPosts rootId testCatIds 2 1
    Expect.hasLength posts 1 "There should be 1 post returned"
    Expect.equal posts[0].Id testPost1 "The wrong post was returned for page 2"
    ensureEmpty posts
}

let ``FindPageOfCategorizedPosts succeeds when finding a too-high page number`` (data: IData) = task {
    let! posts = data.Post.FindPageOfCategorizedPosts rootId testCatIds 17 2
    Expect.hasLength posts 0 "There should have been no posts returned (not enough posts)"
}

let ``FindPageOfCategorizedPosts succeeds when a category has no posts`` (data: IData) = task {
    let! posts = data.Post.FindPageOfCategorizedPosts rootId [ CategoryId "nope" ] 1 1
    Expect.hasLength posts 0 "There should have been no posts returned (none match)"
}

let ``FindPageOfPosts succeeds when posts are found`` (data: IData) = task {
    let ensureNoText (posts: Post list) =
        for post in posts do Expect.equal post.Text "" $"There should be no text (post ID {post.Id})"
    let! posts = data.Post.FindPageOfPosts rootId 1 2
    Expect.hasLength posts 3 "There should have been 3 posts returned for page 1"
    Expect.equal posts[0].Id incomplete "Page 1, post 1 is incorrect"
    Expect.equal posts[1].Id something "Page 1, post 2 is incorrect"
    Expect.equal posts[2].Id episode2 "Page 1, post 3 is incorrect"
    ensureNoText posts
    ensureEmpty posts
    let! posts = data.Post.FindPageOfPosts rootId 2 2
    Expect.hasLength posts 3 "There should have been 3 posts returned for page 2"
    Expect.equal posts[0].Id episode2 "Page 2, post 1 is incorrect"
    Expect.equal posts[1].Id episode1 "Page 2, post 2 is incorrect"
    Expect.equal posts[2].Id testPost1 "Page 2, post 3 is incorrect"
    ensureNoText posts
    ensureEmpty posts
    let! posts = data.Post.FindPageOfPosts rootId 3 2
    Expect.hasLength posts 1 "There should have been 1 post returned for page 3"
    Expect.equal posts[0].Id testPost1 "Page 3, post 1 is incorrect"
    ensureNoText posts
    ensureEmpty posts
}

let ``FindPageOfPosts succeeds when finding a too-high page number`` (data: IData) = task {
    let! posts = data.Post.FindPageOfPosts rootId 88 3
    Expect.isEmpty posts "There should have been no posts returned (not enough posts)"
}

let ``FindPageOfPosts succeeds when there are no posts`` (data: IData) = task {
    let! posts = data.Post.FindPageOfPosts (WebLogId "no-posts") 1 25
    Expect.isEmpty posts "There should have been no posts returned (no posts)"
}

let ``FindPageOfPublishedPosts succeeds when posts are found`` (data: IData) = task {
    let! posts = data.Post.FindPageOfPublishedPosts rootId 1 3
    Expect.hasLength posts 4 "There should have been 4 posts returned for page 1"
    Expect.equal posts[0].Id something "Page 1, post 1 is incorrect"
    Expect.equal posts[1].Id episode2 "Page 1, post 2 is incorrect"
    Expect.equal posts[2].Id episode1 "Page 1, post 3 is incorrect"
    Expect.equal posts[3].Id testPost1 "Page 1, post 4 is incorrect"
    ensureHasText posts
    ensureEmpty posts
    let! posts = data.Post.FindPageOfPublishedPosts rootId 2 2
    Expect.hasLength posts 2 "There should have been 2 posts returned for page 2"
    Expect.equal posts[0].Id episode1 "Page 2, post 1 is incorrect"
    Expect.equal posts[1].Id testPost1 "Page 2, post 2 is incorrect"
    ensureHasText posts
    ensureEmpty posts
}

let ``FindPageOfPublishedPosts succeeds when finding a too-high page number`` (data: IData) = task {
    let! posts = data.Post.FindPageOfPublishedPosts rootId 7 22
    Expect.isEmpty posts "There should have been no posts returned (not enough posts)"
}

let ``FindPageOfPublishedPosts succeeds when there are no posts`` (data: IData) = task {
    let! posts = data.Post.FindPageOfPublishedPosts (WebLogId "empty") 1 8
    Expect.isEmpty posts "There should have been no posts returned (no posts)"
}

let ``FindPageOfTaggedPosts succeeds when posts are found`` (data: IData) = task {
    let! posts = data.Post.FindPageOfTaggedPosts rootId "f#" 1 1
    Expect.hasLength posts 2 "There should have been 2 posts returned"
    Expect.equal posts[0].Id something "Page 1, post 1 is incorrect"
    Expect.equal posts[1].Id testPost1 "Page 1, post 2 is incorrect"
    ensureHasText posts
    ensureEmpty posts
    let! posts = data.Post.FindPageOfTaggedPosts rootId "f#" 2 1
    Expect.hasLength posts 1 "There should have been 1 posts returned"
    Expect.equal posts[0].Id testPost1 "Page 2, post 1 is incorrect"
    ensureHasText posts
    ensureEmpty posts
}

let ``FindPageOfTaggedPosts succeeds when posts are found (excluding drafts)`` (data: IData) = task {
    let! posts = data.Post.FindPageOfTaggedPosts rootId "speculation" 1 10
    Expect.hasLength posts 1 "There should have been 1 post returned"
    Expect.equal posts[0].Id something "Post 1 is incorrect"
    ensureHasText posts
    ensureEmpty posts
}

let ``FindPageOfTaggedPosts succeeds when finding a too-high page number`` (data: IData) = task {
    let! posts = data.Post.FindPageOfTaggedPosts rootId "f#" 436 18
    Expect.isEmpty posts "There should have been no posts returned (not enough posts)"
}

let ``FindPageOfTaggedPosts succeeds when there are no posts`` (data: IData) = task {
    let! posts = data.Post.FindPageOfTaggedPosts rootId "non-existent-tag" 1 8
    Expect.isEmpty posts "There should have been no posts returned (no posts)"
}

let ``FindSurroundingPosts succeeds when there is no next newer post`` (data: IData) = task {
    let! older, newer = data.Post.FindSurroundingPosts rootId somethingPublished
    Expect.isSome older "There should have been an older post"
    Expect.equal older.Value.Id episode2 "The next older post is incorrect"
    ensureHasText [ older.Value ]
    ensureEmpty [ older.Value ]
    Expect.isNone newer "There should not have been a newer post"
}

let ``FindSurroundingPosts succeeds when there is no next older post`` (data: IData) = task {
    let! older, newer = data.Post.FindSurroundingPosts rootId testPost1Published
    Expect.isNone older "There should not have been an older post"
    Expect.isSome newer "There should have been a newer post"
    Expect.equal newer.Value.Id episode1 "The next newer post is incorrect"
    ensureHasText [ newer.Value ]
    ensureEmpty [ newer.Value ]
}

let ``FindSurroundingPosts succeeds when older and newer exist`` (data: IData) = task {
    let! older, newer = data.Post.FindSurroundingPosts rootId episode1Published
    Expect.isSome older "There should have been an older post"
    Expect.equal older.Value.Id testPost1 "The next older post is incorrect"
    Expect.isSome newer "There should have been a newer post"
    Expect.equal newer.Value.Id episode2 "The next newer post is incorrect"
    ensureHasText [ older.Value; newer.Value ]
    ensureEmpty [ older.Value; newer.Value ]
}

let ``Update succeeds when the post exists`` (data: IData) = task {
    let! before = data.Post.FindFullById (PostId "a-new-post") (WebLogId "test")
    Expect.isSome before "The post to be updated should have been found"
    do! data.Post.Update
            { before.Value with
                AuthorId        = WebLogUserId "someone-else"
                Status          = Draft
                Title           = "An Updated Test Post"
                Permalink       = Permalink "2021/updated-post.html"
                PublishedOn     = None
                UpdatedOn       = Noda.epoch + Duration.FromDays 4
                Template        = Some "other"
                Text            = "<p>Updated text here"
                CategoryIds     = [ CategoryId "c"; CategoryId "d"; CategoryId "e" ]
                Tags            = [ "alpha"; "beta"; "nu"; "zeta" ]
                Episode         = None
                Metadata        = [ { Name = "Howdy"; Value = "Pardner" } ]
                PriorPermalinks = Permalink "2020/test-post.html" :: before.Value.PriorPermalinks
                Revisions       =
                    { AsOf = Noda.epoch + Duration.FromDays 4; Text = Html "<p>Updated text here" }
                        :: before.Value.Revisions }
    let! after = data.Post.FindFullById (PostId "a-new-post") (WebLogId "test")
    Expect.isSome after "The updated post should have been found"
    let post = after.Value
    Expect.equal post.AuthorId (WebLogUserId "someone-else") "Updated author is incorrect"
    Expect.equal post.Status Draft "Updated status is incorrect"
    Expect.equal post.Title "An Updated Test Post" "Updated title is incorrect"
    Expect.equal post.Permalink (Permalink "2021/updated-post.html") "Updated permalink is incorrect"
    Expect.isNone post.PublishedOn "Updated post should not have had a published-on date/time"
    Expect.equal post.UpdatedOn (Noda.epoch + Duration.FromDays 4) "Updated updated-on date/time is incorrect"
    Expect.equal post.Template (Some "other") "Updated template is incorrect"
    Expect.equal post.Text "<p>Updated text here" "Updated text is incorrect"
    Expect.equal
        post.CategoryIds [ CategoryId "c"; CategoryId "d"; CategoryId "e" ] "Updated category IDs are incorrect"
    Expect.equal post.Tags [ "alpha"; "beta"; "nu"; "zeta" ] "Updated tags are incorrect"
    Expect.isNone post.Episode "Update episode is incorrect"
    Expect.equal post.Metadata [ { Name = "Howdy"; Value = "Pardner" } ] "Updated metadata is incorrect"
    Expect.equal
        post.PriorPermalinks
        [ Permalink "2020/test-post.html"; Permalink "2020/test-post-a.html" ]
        "Updated prior permalinks are incorrect"
    Expect.equal
        post.Revisions
        [ { AsOf = Noda.epoch + Duration.FromDays 4; Text = Html "<p>Updated text here" }
          { AsOf = Noda.epoch + Duration.FromMinutes 1L; Text = Html "<p>Test text here" } ]
        "Updated revisions are incorrect"
}

let ``Update succeeds when the post does not exist`` (data: IData) = task {
    let postId = PostId "lost-post"
    do! data.Post.Update { Post.Empty with Id = postId; WebLogId = rootId }
    let! post = data.Post.FindById postId rootId
    Expect.isNone post "A post should not have been retrieved"
}

let ``UpdatePriorPermalinks succeeds when the post exists`` (data: IData) = task {
    let links = [ Permalink "2024/ep-1.html"; Permalink "2023/ep-1.html" ]
    let! found = data.Post.UpdatePriorPermalinks episode1 rootId links
    Expect.isTrue found "The permalinks should have been updated"
    let! post = data.Post.FindFullById episode1 rootId
    Expect.isSome post "The post should have been found"
    Expect.equal post.Value.PriorPermalinks links "The prior permalinks were not correct"
}

let ``UpdatePriorPermalinks succeeds when the post does not exist`` (data: IData) = task {
    let! found =
        data.Post.UpdatePriorPermalinks (PostId "silence") WebLogId.Empty [ Permalink "a.html"; Permalink "b.html" ]
    Expect.isFalse found "The permalinks should not have been updated"
}

let ``Delete succeeds when a post is deleted`` (data: IData) = task {
    let! deleted = data.Post.Delete episode2 rootId
    Expect.isTrue deleted "The post should have been deleted"
}

let ``Delete succeeds when a post is not deleted`` (data: IData) = task {
    let! deleted = data.Post.Delete episode2 rootId // this was deleted above
    Expect.isFalse deleted "A post should not have been deleted"
}