defmodule BDS.PostsTest do
  use ExUnit.Case, async: false

  setup do
    :ok = Ecto.Adapters.SQL.Sandbox.checkout(BDS.Repo)

    temp_dir = Path.join(System.tmp_dir!(), "bds-posts-#{System.unique_integer([:positive])}")
    File.mkdir_p!(temp_dir)

    on_exit(fn -> File.rm_rf(temp_dir) end)

    {:ok, project} = BDS.Projects.create_project(%{name: "Publishing", data_path: temp_dir})
    %{project: project, temp_dir: temp_dir}
  end

  test "create_post slugifies titles, stores list fields, and defaults draft fields", %{
    project: project
  } do
    assert {:ok, post} =
             BDS.Posts.create_post(%{
               project_id: project.id,
               title: "Über Café",
               content: "draft body",
               tags: ["elixir", "sqlite"],
               categories: ["notes"],
               author: "G",
               language: "de",
               template_slug: "article"
             })

    assert post.title == "Über Café"
    assert post.slug == "uber-cafe"
    assert post.status == :draft
    assert post.file_path == ""
    assert post.do_not_translate == false
    assert post.tags == ["elixir", "sqlite"]
    assert post.categories == ["notes"]
    assert post.author == "G"
    assert post.language == "de"
    assert post.template_slug == "article"
    assert post.project_id == project.id
    assert is_integer(post.created_at)
    assert is_integer(post.updated_at)

    assert {:ok, duplicate_slug_post} =
             BDS.Posts.create_post(%{project_id: project.id, title: "Über Café"})

    assert duplicate_slug_post.slug == "uber-cafe-2"
    assert duplicate_slug_post.tags == []
    assert duplicate_slug_post.categories == []
  end

  test "create_post falls back to untitled and keeps slug uniqueness scoped to a project", %{
    project: project,
    temp_dir: temp_dir
  } do
    assert {:ok, first} = BDS.Posts.create_post(%{project_id: project.id, title: nil})
    assert first.title == ""
    assert first.slug == "untitled"

    assert {:ok, second} = BDS.Posts.create_post(%{project_id: project.id, title: nil})
    assert second.slug == "untitled-2"

    other_temp_dir = Path.join(temp_dir, "elsewhere")
    File.mkdir_p!(other_temp_dir)

    assert {:ok, other_project} =
             BDS.Projects.create_project(%{name: "Elsewhere", data_path: other_temp_dir})

    assert {:ok, other_post} = BDS.Posts.create_post(%{project_id: other_project.id, title: nil})
    assert other_post.slug == "untitled"
  end

  test "update_post rejects slug changes after first publish and reopens published posts when content changes",
       %{project: project} do
    assert {:ok, post} =
             BDS.Posts.create_post(%{
               project_id: project.id,
               title: "Stable Slug",
               content: "first body"
             })

    published_at = System.system_time(:second) - 5

    {:ok, published} =
      BDS.Posts.update_post(post.id, %{
        status: :published,
        published_at: published_at,
        content: nil,
        file_path: "posts/2026/04/stable-slug.md"
      })

    assert published.status == :published
    assert published.published_at == published_at

    assert {:error, changeset} = BDS.Posts.update_post(post.id, %{slug: "new-slug"})
    assert "cannot change slug after first publish" in errors_on(changeset).slug

    assert {:ok, reopened} = BDS.Posts.update_post(post.id, %{content: "revised draft"})
    assert reopened.status == :draft
    assert reopened.slug == "stable-slug"
    assert reopened.published_at == published_at
    assert reopened.content == "revised draft"
    assert reopened.updated_at >= published.updated_at
  end

  test "publish_post writes frontmatter to the project data directory and clears draft content" do
    temp_dir =
      Path.join(System.tmp_dir!(), "bds-post-publish-#{System.unique_integer([:positive])}")

    File.mkdir_p!(temp_dir)
    on_exit(fn -> File.rm_rf(temp_dir) end)

    assert {:ok, project} =
             BDS.Projects.create_project(%{name: "Filesystem", data_path: temp_dir})

    assert {:ok, post} =
             BDS.Posts.create_post(%{
               project_id: project.id,
               title: "Published Post",
               excerpt: "Summary",
               content: "Hello from markdown",
               tags: ["alpha"],
               categories: ["notes"],
               author: "Writer",
               language: "en",
               template_slug: "article"
             })

    assert {:ok, post} = BDS.Posts.update_post(post.id, %{do_not_translate: true})
    assert {:ok, published} = BDS.Posts.publish_post(post.id)

    assert published.status == :published
    assert published.content == nil
    assert published.file_path =~ ~r/^posts\/\d{4}\/\d{2}\/published-post\.md$/
    assert is_integer(published.published_at)

    full_path = Path.join(temp_dir, published.file_path)
    assert File.exists?(full_path)

    file_contents = File.read!(full_path)

    assert file_contents =~ "---\nid: #{published.id}\n"
    assert file_contents =~ "title: Published Post\n"
    assert file_contents =~ "slug: published-post\n"
    assert file_contents =~ "status: published\n"
    assert file_contents =~ "excerpt: Summary\n"
    assert file_contents =~ "author: Writer\n"
    assert file_contents =~ "language: en\n"
    assert file_contents =~ "doNotTranslate: true\n"
    assert file_contents =~ "templateSlug: article\n"
    assert file_contents =~ "tags:\n  - alpha\n"
    assert file_contents =~ "categories:\n  - notes\n"
    assert file_contents =~ ~r/createdAt: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\n/
    assert file_contents =~ ~r/updatedAt: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\n/
    assert file_contents =~ ~r/publishedAt: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\n/
    assert file_contents =~ "\n---\nHello from markdown\n"

    refute File.exists?(full_path <> ".tmp")
  end

  test "delete_post removes the database row and published markdown file when present" do
    temp_dir =
      Path.join(System.tmp_dir!(), "bds-post-delete-#{System.unique_integer([:positive])}")

    File.mkdir_p!(temp_dir)
    on_exit(fn -> File.rm_rf(temp_dir) end)

    assert {:ok, project} = BDS.Projects.create_project(%{name: "Delete", data_path: temp_dir})

    assert {:ok, post} =
             BDS.Posts.create_post(%{
               project_id: project.id,
               title: "Delete Me",
               content: "Body"
             })

    assert {:ok, published} = BDS.Posts.publish_post(post.id)
    full_path = Path.join(temp_dir, published.file_path)
    assert File.exists?(full_path)

    assert {:ok, :deleted} = BDS.Posts.delete_post(published.id)

    assert BDS.Repo.get(BDS.Posts.Post, published.id) == nil
    refute File.exists?(full_path)
  end

  test "archive_post transitions draft and published posts to archived", %{project: project} do
    assert {:ok, draft_post} =
             BDS.Posts.create_post(%{
               project_id: project.id,
               title: "Draft Archive",
               content: "Body"
             })

    assert {:ok, archived_draft} = BDS.Posts.archive_post(draft_post.id)
    assert archived_draft.status == :archived

    temp_dir =
      Path.join(System.tmp_dir!(), "bds-post-archive-#{System.unique_integer([:positive])}")

    File.mkdir_p!(temp_dir)
    on_exit(fn -> File.rm_rf(temp_dir) end)

    assert {:ok, publish_project} =
             BDS.Projects.create_project(%{name: "Archive Published", data_path: temp_dir})

    assert {:ok, published_post} =
             BDS.Posts.create_post(%{
               project_id: publish_project.id,
               title: "Published Archive",
               content: "Body"
             })

    assert {:ok, published_post} = BDS.Posts.publish_post(published_post.id)
    assert {:ok, archived_published} = BDS.Posts.archive_post(published_post.id)

    assert archived_published.status == :archived
    assert archived_published.file_path == published_post.file_path
    assert archived_published.published_at == published_post.published_at
  end

  test "publish_post republishes archived posts without losing the existing body or original published_at" do
    temp_dir =
      Path.join(System.tmp_dir!(), "bds-post-republish-#{System.unique_integer([:positive])}")

    File.mkdir_p!(temp_dir)
    on_exit(fn -> File.rm_rf(temp_dir) end)

    assert {:ok, project} = BDS.Projects.create_project(%{name: "Republish", data_path: temp_dir})

    assert {:ok, post} =
             BDS.Posts.create_post(%{
               project_id: project.id,
               title: "Republish Me",
               content: "Body"
             })

    assert {:ok, published} = BDS.Posts.publish_post(post.id)
    assert {:ok, archived} = BDS.Posts.archive_post(published.id)
    assert archived.status == :archived
    assert archived.content == nil

    assert {:ok, republished} = BDS.Posts.publish_post(archived.id)
    assert republished.status == :published
    assert republished.published_at == published.published_at

    contents = File.read!(Path.join(temp_dir, republished.file_path))
    assert contents =~ "\n---\nBody\n"
  end

  test "rebuild_posts_from_files recreates published posts from disk" do
    temp_dir =
      Path.join(System.tmp_dir!(), "bds-post-rebuild-#{System.unique_integer([:positive])}")

    File.mkdir_p!(temp_dir)
    on_exit(fn -> File.rm_rf(temp_dir) end)

    assert {:ok, project} = BDS.Projects.create_project(%{name: "Rebuild", data_path: temp_dir})

    posts_dir = Path.join([BDS.Projects.project_data_dir(project), "posts", "2026", "04"])
    File.mkdir_p!(posts_dir)

    file_path = Path.join(posts_dir, "recovered-post.md")

    File.write!(
      file_path,
      [
        "---",
        "id: post-from-file",
        "title: Recovered Post",
        "slug: recovered-post",
        "excerpt: Summary",
        "status: published",
        "author: Writer",
        "language: en",
        "doNotTranslate: true",
        "templateSlug: article",
        "createdAt: 2024-03-30T21:20:00.000Z",
        "updatedAt: 2024-03-31T21:20:00.000Z",
        "publishedAt: 2024-04-01T21:20:00.000Z",
        "tags:",
        "  - alpha",
        "categories:",
        "  - notes",
        "---",
        "Restored body",
        ""
      ]
      |> Enum.join("\n")
    )

    assert {:ok, posts} = BDS.Posts.rebuild_posts_from_files(project.id)
    assert length(posts) == 1

    [post] = posts
    assert post.id == "post-from-file"
    assert post.project_id == project.id
    assert post.title == "Recovered Post"
    assert post.slug == "recovered-post"
    assert post.excerpt == "Summary"
    assert post.status == :published
    assert post.author == "Writer"
    assert post.language == "en"
    assert post.do_not_translate == true
    assert post.template_slug == "article"
    assert post.created_at == 1_711_833_600_000
    assert post.updated_at == 1_711_920_000_000
    assert post.published_at == 1_712_006_400_000
    assert post.tags == ["alpha"]
    assert post.categories == ["notes"]
    assert post.file_path == "posts/2026/04/recovered-post.md"
    assert post.content == nil
  end

  test "rebuild_posts_from_files imports canonical bDS translation files alongside canonical posts" do
    temp_dir =
      Path.join(System.tmp_dir!(), "bds-post-rebuild-legacy-#{System.unique_integer([:positive])}")

    File.mkdir_p!(temp_dir)
    on_exit(fn -> File.rm_rf(temp_dir) end)

    assert {:ok, project} =
             BDS.Projects.create_project(%{name: "Legacy Rebuild", data_path: temp_dir})

    posts_dir = Path.join([BDS.Projects.project_data_dir(project), "posts", "2026", "04"])
    File.mkdir_p!(posts_dir)

    File.write!(
      Path.join(posts_dir, "chimera.md"),
      [
        "---",
        "id: post-from-old-app",
        "title: Chimera Source",
        "slug: chimera",
        "status: published",
        "language: de",
        "createdAt: 2024-03-30T21:20:00.000Z",
        "updatedAt: 2024-03-31T21:20:00.000Z",
        "publishedAt: 2024-04-01T21:20:00.000Z",
        "---",
        "Quelle",
        ""
      ]
      |> Enum.join("\n")
    )

    File.write!(
      Path.join(posts_dir, "chimera.en.md"),
      [
        "---",
        "id: translation-from-old-app",
        "translationFor: post-from-old-app",
        "language: en",
        "title: Chimera",
        "excerpt: Imported translation",
        "---",
        "Translated body",
        ""
      ]
      |> Enum.join("\n")
    )

    assert {:ok, posts} = BDS.Posts.rebuild_posts_from_files(project.id)
    assert length(posts) == 1

    [post] = posts
    assert post.id == "post-from-old-app"
    assert post.slug == "chimera"
    assert post.language == "de"

    assert {:ok, translations} = BDS.Posts.list_post_translations(post.id)
    assert length(translations) == 1

    [translation] = translations
    assert translation.id == "translation-from-old-app"
    assert translation.translation_for == post.id
    assert translation.project_id == project.id
    assert translation.language == "en"
    assert translation.title == "Chimera"
    assert translation.excerpt == "Imported translation"
    assert translation.status == :published
    assert translation.file_path == "posts/2026/04/chimera.en.md"
    assert translation.content == nil
  end

  defp errors_on(changeset) do
    Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
      Regex.replace(~r"%{(\w+)}", message, fn _, key ->
        opts |> Keyword.get(String.to_existing_atom(key), key) |> to_string()
      end)
    end)
  end
end