import gleam/dict
import gleam/int
import gleam/list
import gleam/result
import lustre/ssg/djot
import simplifile
import tom

pub type Post {
  Post(
    title: String,
    slug: String,
    image: String,
    preview: String,
    content: String,
    tags: List(String),
    time: Int,
  )
}

pub fn all() -> List(#(String, Post)) {
  let assert Ok(postdir) = simplifile.get_files("data/posts/")

  postdir
  |> list.map(build_post)
}

pub fn build_post(path: String) -> #(String, Post) {
  echo path
  let assert Ok(file) = simplifile.read(path)
  let assert Ok(toml) = djot.metadata(file)

  let meta_fields =
    ["title", "slug", "image", "preview", "time"]
    |> list.map(fn(field) {
      echo field
      let assert Ok(val) = tom.get_string(toml, [field])
      #(field, val)
    })

  let assert Ok(tags) = tom.get_array(toml, ["tags"])
  let tags =
    list.map(tags, fn(x) {
      let assert Ok(str) = tom.as_string(x)
      str
    })

  let content = djot.content(file)

  let p =
    Post(
      // TODO: unwrap hell. 
      title: list.key_find(meta_fields, "title") |> result.unwrap("title error"),
      slug: list.key_find(meta_fields, "slug") |> result.unwrap("slug error"),
      image: list.key_find(meta_fields, "image") |> result.unwrap("image error"),
      preview: list.key_find(meta_fields, "preview")
        |> result.unwrap("preview error"),
      content: content,
      tags: tags,
      time: list.key_find(meta_fields, "time")
        |> result.unwrap("time error")
        |> int.parse
        |> result.unwrap(000),
    )

  #(p.slug, p)
}

pub fn filtered_posts(
  post_list: dict.Dict(String, Post),
  target_tag: String,
) -> dict.Dict(String, Post) {
  post_list
  |> dict.filter(fn(_k, v) { list.contains(v.tags, target_tag) })
}