package main

import (
  "bytes"
  "fmt"
  "html/template"
  "io/ioutil"
  "os"
  "path/filepath"
  "regexp"
  "strings"
  "time"

  "github.com/russross/blackfriday/v2"
  "gopkg.in/yaml.v3"
)

type NavItem struct {
  Title string
  URL   string
}

type PageMeta struct {
  Title       string   `yaml:"title"`
  Description string   `yaml:"description"`
  Date        string   `yaml:"date"`
  Categories  []string `yaml:"categories"`
  Slug        string
}

var slugRegex = regexp.MustCompile(`[^a-z0-9]+`)

func main() {
  contentDir := "./content"
  outputDir := "./public"

  // Load all templates in the templates folder
  tpl, err := template.New("").Funcs(templateFuncs()).ParseGlob("templates/*.html")
  if err != nil {
    fmt.Printf("Template parsing error: %v\n", err)
    return
  }

  files, err := ioutil.ReadDir(contentDir)
  if err != nil {
    fmt.Printf("Failed to read content directory: %v\n", err)
    return
  }

  var nav []NavItem
  for _, file := range files {
    if filepath.Ext(file.Name()) == ".md" {
      name := strings.TrimSuffix(file.Name(), filepath.Ext(file.Name()))
      url := "/"
      if name != "index" {
        url = "/" + name + "/"
      }
      nav = append(nav, NavItem{Title: strings.Title(name), URL: url})
    }
  }

  // Add blog to main nav
  nav = append(nav, NavItem{Title: "Blog", URL: "/blog/"})

  // Static page rendering
  for _, file := range files {
    if filepath.Ext(file.Name()) == ".md" {
      name := strings.TrimSuffix(file.Name(), filepath.Ext(file.Name()))
      title := strings.Title(name)
      mdPath := filepath.Join(contentDir, file.Name())
      rawContent, err := ioutil.ReadFile(mdPath)
      if err != nil {
        fmt.Printf("Failed to read %s: %v\n", file.Name(), err)
        continue
      }

      meta, content := parseFrontMatter(rawContent)
      htmlContent := blackfriday.Run(content)
      if meta.Title == "" {
        meta.Title = title
      }

      var outPath string
      if name == "index" {
        outPath = filepath.Join(outputDir, "index.html")
      } else {
        subDir := filepath.Join(outputDir, name)
        os.MkdirAll(subDir, os.ModePerm)
        outPath = filepath.Join(subDir, "index.html")
      }

      outFile, err := os.Create(outPath)
      if err != nil {
        fmt.Printf("Failed to create %s: %v\n", outPath, err)
        continue
      }

      tpl.ExecuteTemplate(outFile, "static_page", map[string]interface{}{
        "Title":        meta.Title,
        "Description":  meta.Description,
        "Date":         meta.Date,
        "Categories":   meta.Categories,
        "Content":      template.HTML(htmlContent),
        "Nav":          nav,
        "Year":         time.Now().Year(),
        "PageTemplate": "static",
      })

      fmt.Printf("Generated: %s\n", outPath)
    }
  }

  var blogPosts []PageMeta
  categoryMap := make(map[string][]PageMeta)

  blogDir := filepath.Join(contentDir, "blog")
  blogFiles, _ := ioutil.ReadDir(blogDir)

  for _, file := range blogFiles {
    if filepath.Ext(file.Name()) != ".md" {
      continue
    }

    slug := strings.TrimSuffix(file.Name(), filepath.Ext(file.Name()))
    blogPath := filepath.Join(blogDir, file.Name())
    rawContent, err := ioutil.ReadFile(blogPath)
    if err != nil {
      fmt.Printf("Failed to read blog post %s: %v\n", file.Name(), err)
      continue
    }

    meta, content := parseFrontMatter(rawContent)
    html := blackfriday.Run(content)
    meta.Slug = slug
    if meta.Title == "" {
      meta.Title = strings.Title(slug)
    }

    for _, cat := range meta.Categories {
      slug := slugify(cat)
      categoryMap[slug] = append(categoryMap[slug], meta)
    }

    outPath := filepath.Join(outputDir, "blog", slug, "index.html")
    os.MkdirAll(filepath.Dir(outPath), os.ModePerm)

    outFile, err := os.Create(outPath)
    if err != nil {
      fmt.Printf("Failed to create blog file %s: %v\n", outPath, err)
      continue
    }

    tpl.ExecuteTemplate(outFile, "blog_post_page", map[string]interface{}{
      "Title":        meta.Title,
      "Description":  meta.Description,
      "Date":         meta.Date,
      "Categories":   meta.Categories,
      "Content":      template.HTML(html),
      "Nav":          nav,
      "Year":         time.Now().Year(),
      "PageTemplate": "blog_post",
    })

    blogPosts = append(blogPosts, meta)
  }

  buildBlogIndex(blogPosts, tpl, outputDir, nav)

  for catSlug, posts := range categoryMap {
    outDir := filepath.Join(outputDir, "blog", "category", catSlug)
    os.MkdirAll(outDir, os.ModePerm)

    outPath := filepath.Join(outDir, "index.html")
    outFile, err := os.Create(outPath)
    if err != nil {
      fmt.Printf("Failed to create category page for %s: %v\n", catSlug, err)
      continue
    }

    tpl.ExecuteTemplate(outFile, "category_page", map[string]interface{}{
      "Title":        "Category: " + strings.Title(strings.ReplaceAll(catSlug, "-", " ")),
      "Posts":        posts,
      "Nav":          nav,
      "Year":         time.Now().Year(),
      "PageTemplate": "category_page",
    })

    fmt.Printf("Generated category: /blog/category/%s/\n", catSlug)
  }

  fmt.Println("✅ Site generation complete.")
}

func parseFrontMatter(raw []byte) (PageMeta, []byte) {
  var meta PageMeta
  raw = bytes.ReplaceAll(raw, []byte("\r\n"), []byte("\n"))

  if bytes.HasPrefix(raw, []byte("---\n")) {
    parts := bytes.SplitN(raw, []byte("---\n"), 3)
    if len(parts) == 3 {
      err := yaml.Unmarshal(parts[1], &meta)
      if err != nil {
        fmt.Printf("⚠️ Failed to parse front matter: %v\n", err)
      }
      return meta, parts[2]
    }
  }

  return meta, raw
}

func buildBlogIndex(posts []PageMeta, tpl *template.Template, outputDir string, nav []NavItem) {
  outPath := filepath.Join(outputDir, "blog", "index.html")
  os.MkdirAll(filepath.Dir(outPath), os.ModePerm)

  outFile, err := os.Create(outPath)
  if err != nil {
    fmt.Println("Failed to create blog index:", err)
    return
  }

  fmt.Printf("Rendering blog index: %d posts\n", len(posts))
  tpl.ExecuteTemplate(outFile, "blog_index_page", map[string]interface{}{
    "Title":        "Blog Index",
    "Posts":        posts,
    "Nav":          nav,
    "Year":         time.Now().Year(),
    "PageTemplate": "blog_index",
  })
}

func slugify(s string) string {
  s = strings.ToLower(s)
  s = slugRegex.ReplaceAllString(s, "-")
  return strings.Trim(s, "-")
}

func templateFuncs() template.FuncMap {
  return template.FuncMap{
    "lower":    strings.ToLower,
    "slugify":  slugify,
    "urlquery": template.URLQueryEscaper,
  }
}