// Package render turns a bundle into bytes: Markdown to HTML, then a template set. It knows content and
// nothing about HTTP.
//
// The embedded templates and stylesheet are the reference theme (ADR-0026) — a demonstration of
// docs/theme-contract.md, not a design. Fields a template may rely on are listed there.
package render

import (
	"bytes"
	"embed"
	"fmt"
	"html/template"
	"time"

	"github.com/yuin/goldmark"

	"khosra/internal/content"
)

//go:embed templates
var themeFS embed.FS

// head is what every kind of page shares: the document shell the base template needs. Absence is the
// zero value — a template reads what exists and never fails on a missing field (invariant 1).
type head struct {
	// Title may be empty for a bundle; a listing always has one.
	Title string
	// Lang is the locale being served.
	Lang string
	// Canonical is the permalink of what was actually served, which differs from the URL requested when
	// the fallback chain supplied another language (ADR-0009).
	Canonical string
	// Alternates lists every language this key exists in, for hreflang.
	Alternates []Alternate
	// Style is the reference theme's stylesheet, inlined so a bare site root needs no asset route.
	Style template.CSS
}

// Page is one bundle rendered.
type Page struct {
	head
	// Key is the bundle's identity, useful for building links.
	Key string
	// HTML is the rendered body.
	HTML template.HTML
	// Extra carries every frontmatter key the parser does not name (ADR-0002).
	Extra map[string]any
}

// List is a collection page: the result of a Query, one page of it.
type List struct {
	head
	// Items are the entries on this page, in the Query's order.
	Items []Item
	// Page is 1-based; Pages is the total, at least 1 even when empty.
	Page, Pages int
	// PrevURL and NextURL are empty at the ends. Newer is "prev" because the order is newest first.
	PrevURL, NextURL string
}

// Item is one entry in a listing.
type Item struct {
	Title string
	Key   string
	URL   string
	Date  time.Time
}

// Alternate is one language a bundle exists in.
type Alternate struct {
	Lang string
	URL  string
}

// Renderer holds the parsed template set and the Markdown converter. Templates are parsed once, never
// per request (conventions.md).
type Renderer struct {
	// Two sets, not one: base plus the block that kind of page defines. A single set would have two
	// definitions of "main" fighting, which is why per-type sets are the shape (ADR-0019).
	page  *template.Template
	list  *template.Template
	md    goldmark.Markdown
	style template.CSS
}

// New parses the reference theme and prepares the Markdown converter.
//
// A malformed embedded template is a programming error caught at startup, not at request time, so this
// returns an error and the caller is expected to treat it as fatal.
func New() (*Renderer, error) {
	page, err := template.ParseFS(themeFS, "templates/base.html", "templates/page.html")
	if err != nil {
		return nil, fmt.Errorf("parse bundle templates: %w", err)
	}
	list, err := template.ParseFS(themeFS, "templates/base.html", "templates/list.html")
	if err != nil {
		return nil, fmt.Errorf("parse listing templates: %w", err)
	}
	css, err := themeFS.ReadFile("templates/theme.css")
	if err != nil {
		return nil, fmt.Errorf("read reference stylesheet: %w", err)
	}
	return &Renderer{page: page, list: list, md: goldmark.New(), style: template.CSS(css)}, nil
}

// Bundle renders one bundle into a complete page.
//
// served is the language actually chosen by the fallback chain, and variants every language the key
// exists in; both feed canonical and hreflang, which a theme must not construct itself.
func (r *Renderer) Bundle(b content.Bundle, served string, variants []string) ([]byte, error) {
	var body bytes.Buffer
	if err := r.md.Convert(b.Body, &body); err != nil {
		return nil, fmt.Errorf("markdown %s: %w", b.Path, err)
	}
	title := b.Title
	if title == "" {
		title = b.Key
	}
	p := Page{
		head:  head{Title: title, Lang: served, Canonical: content.URL(b.Key, served), Style: r.style},
		Key:   b.Key,
		HTML:  template.HTML(body.String()),
		Extra: b.Extra,
	}
	for _, l := range variants {
		p.Alternates = append(p.Alternates, Alternate{Lang: l, URL: content.URL(b.Key, l)})
	}
	return r.execute(r.page, p, b.Key)
}

// Listing renders one page of a Query result for a section.
func (r *Renderer) Listing(section, lang string, all []content.Bundle, page int) ([]byte, error) {
	pages := (len(all) + content.PerPage - 1) / content.PerPage
	if pages < 1 {
		pages = 1
	}
	start := (page - 1) * content.PerPage
	end := min(start+content.PerPage, len(all))
	l := List{
		head: head{
			Title:     section,
			Lang:      lang,
			Canonical: content.PageURL(section, lang, page),
			Style:     r.style,
		},
		Page:  page,
		Pages: pages,
	}
	for _, b := range all[start:end] {
		l.Items = append(l.Items, Item{Title: b.Title, Key: b.Key, URL: content.URL(b.Key, lang), Date: b.Date})
	}
	if page > 1 {
		l.PrevURL = content.PageURL(section, lang, page-1)
	}
	if page < pages {
		l.NextURL = content.PageURL(section, lang, page+1)
	}
	return r.execute(r.list, l, section)
}

// execute runs a template set and wraps a failure with what was being rendered.
func (r *Renderer) execute(set *template.Template, data any, what string) ([]byte, error) {
	var out bytes.Buffer
	if err := set.ExecuteTemplate(&out, "base", data); err != nil {
		return nil, fmt.Errorf("template %s: %w", what, err)
	}
	return out.Bytes(), nil
}