weiro/providers/sitebuilder/builder.go

package sitebuilder

import (
	"bytes"
	"context"
	"fmt"
	"html/template"
	"io"
	"io/fs"
	"iter"
	"log"
	"os"
	"path/filepath"
	"strings"
	"time"

	"github.com/PuerkitoBio/goquery"
	"github.com/gopherlibs/feedhub/feedhub"
	"golang.org/x/sync/errgroup"
	"lmika.dev/lmika/weiro/models"
	"lmika.dev/lmika/weiro/models/pubmodel"
	"lmika.dev/lmika/weiro/providers/markdown"
)

type Builder struct {
	site             pubmodel.Site
	mdRenderer       *markdown.Renderer
	opts             Options
	tmpls            *template.Template
	postMDProcessors []postMDProcessor
}

func New(site pubmodel.Site, opts Options) (*Builder, error) {
	tmpls, err := template.New("").
		Funcs(templateFns(site, opts)).
		ParseFS(opts.TemplatesFS, "*.html")
	if err != nil {
		return nil, err
	}

	for _, t := range tmpls.Templates() {
		log.Printf("Loaded template %s", t.Name())
	}

	return &Builder{
		site:       site,
		opts:       opts,
		tmpls:      tmpls,
		mdRenderer: markdown.NewRendererForSite(),
		postMDProcessors: []postMDProcessor{
			uploadAbsoluteURL,
		},
	}, nil
}

func (b *Builder) BuildSite(outDir string) error {
	buildCtx := buildContext{outDir: outDir}

	if err := os.RemoveAll(outDir); err != nil {
		return err
	}

	eg, ctx := errgroup.WithContext(context.Background())

	eg.Go(func() error {
		for mp := range b.site.PostIter(ctx) {
			post, err := mp.Get()
			if err != nil {
				return err
			}
			rp, err := b.renderPostWithCategories(ctx, post)
			if err != nil {
				return err
			}
			if err := b.createAtPath(buildCtx, rp.Path, func(f io.Writer) error {
				return b.renderTemplate(f, tmplNamePostSingle, rp)
			}); err != nil {
				return err
			}
		}
		return nil
	})

	eg.Go(func() error {
		return b.renderPostListWithCategories(buildCtx, ctx)
	})

	eg.Go(func() error {
		if err := b.renderFeeds(buildCtx, b.site.PostIter(ctx), feedOptions{
			targetNamePrefix: "/feed",
			titlePrefix:      "",
		}); err != nil {
			return err
		}

		if err := b.renderFeeds(buildCtx, b.site.PostIter(ctx), feedOptions{
			targetNamePrefix: "/feeds/microblog-crosspost",
			titlePrefix:      "Devlog: ",
		}); err != nil {
			return err
		}
		return nil
	})

	// Category pages
	eg.Go(func() error {
		if err := b.renderCategoryList(buildCtx); err != nil {
			return err
		}
		return b.renderCategoryPages(buildCtx, ctx)
	})

	// Copy uploads
	eg.Go(func() error {
		return b.writeUploads(buildCtx, b.site.Uploads)
	})

	// Build static assets
	eg.Go(func() error { return b.writeStaticAssets(buildCtx) })

	return eg.Wait()
}

func (b *Builder) renderPostListWithCategories(bctx buildContext, ctx context.Context) error {
	// Collect all posts
	var allPosts []postSingleData
	for mp := range b.site.PostIter(ctx) {
		post, err := mp.Get()
		if err != nil {
			return err
		}
		rp, err := b.renderPostWithCategories(ctx, post)
		if err != nil {
			return err
		}
		allPosts = append(allPosts, rp)
	}

	postsPerPage := b.site.PostsPerPage
	if postsPerPage < 1 {
		postsPerPage = 10
	}

	totalPages := (len(allPosts) + postsPerPage - 1) / postsPerPage
	if totalPages < 1 {
		totalPages = 1
	}

	for page := 1; page <= totalPages; page++ {
		start := (page - 1) * postsPerPage
		end := start + postsPerPage
		if end > len(allPosts) {
			end = len(allPosts)
		}

		pageInfo := models.PageInfo{
			CurrentPage:  page,
			TotalPages:   totalPages,
			PostsPerPage: postsPerPage,
		}

		var prevURL, nextURL string
		if page > 1 {
			if page == 2 {
				prevURL = "/posts/"
			} else {
				prevURL = fmt.Sprintf("/posts/page/%d/", page-1)
			}
		}
		if page < totalPages {
			nextURL = fmt.Sprintf("/posts/page/%d/", page+1)
		}

		pl := postListData{
			commonData: commonData{Site: b.site},
			Posts:      allPosts[start:end],
			PageInfo:   pageInfo,
			PrevURL:    prevURL,
			NextURL:    nextURL,
		}

		// Page 1 renders at both root and /posts/
		var paths []string
		if page == 1 {
			paths = []string{"", "/posts"}
		} else {
			paths = []string{fmt.Sprintf("/posts/page/%d", page)}
		}

		for _, path := range paths {
			if err := b.createAtPath(bctx, path, func(f io.Writer) error {
				return b.renderTemplate(f, tmplNamePostList, pl)
			}); err != nil {
				return err
			}
		}
	}

	return nil
}

func (b *Builder) renderFeeds(ctx buildContext, postIter iter.Seq[models.Maybe[*models.Post]], opts feedOptions) error {
	now := time.Now()
	feed := &feedhub.Feed{
		Title:       b.site.Title,
		Link:        &feedhub.Link{Href: b.site.BaseURL},
		Description: b.site.Tagline,
		// TO FIX: Author
		Created: now,
	}

	items := 0
	for mp := range postIter {
		post, err := mp.Get()
		if err != nil {
			return fmt.Errorf("failed to get post: %w", err)
		}

		renderedPost, err := b.renderPost(post)
		if err != nil {
			return err
		}

		var catName string
		if b.site.CategoriesOfPost != nil {
			cats, err := b.site.CategoriesOfPost(context.Background(), post.ID)
			if err == nil && len(cats) > 0 {
				names := make([]string, len(cats))
				for i, c := range cats {
					names[i] = c.Name
				}
				catName = strings.Join(names, ", ")
			}
		}

		postTitle := post.Title
		if postTitle != "" {
			postTitle = opts.titlePrefix + postTitle
		}

		feed.Items = append(feed.Items, &feedhub.Item{
			Id:      filepath.Join(b.site.BaseURL, post.GUID),
			Title:   postTitle,
			Link:    &feedhub.Link{Href: renderedPost.PostURL},
			Content: string(renderedPost.HTML),
			// TO FIX: Why the heck does this only include the first category?
			Category: catName,
			// TO FIX: Created should be first published
			Created: post.PublishedAt,
			Updated: post.UpdatedAt,
		})

		items++
		if items >= b.opts.FeedItems {
			break
		}
	}

	if err := b.createAtPath(ctx, opts.targetNamePrefix+".xml", func(f io.Writer) error {
		rss, err := feed.ToRss()
		if err != nil {
			return fmt.Errorf("failed to convert feed to RSS: %w", err)
		}
		_, err = io.WriteString(f, rss)
		return err
	}); err != nil {
		return err
	}

	if err := b.createAtPath(ctx, opts.targetNamePrefix+".json", func(f io.Writer) error {
		rss, err := feed.ToJSON()
		if err != nil {
			return fmt.Errorf("failed to convert feed to JSON feed: %w", err)
		}
		_, err = io.WriteString(f, rss)
		return err
	}); err != nil {
		return err
	}
	return nil
}

func (b *Builder) renderPost(post *models.Post) (postSingleData, error) {
	postPath := post.Slug
	if b.opts.BasePosts != "" {
		postPath = filepath.Join(b.opts.BasePosts, strings.TrimPrefix(postPath, "/"))
	}

	var md bytes.Buffer
	if err := b.mdRenderer.RenderTo(context.Background(), &md, post.Body); err != nil {
		return postSingleData{}, fmt.Errorf("failed to write post %s: %w", post.Slug, err)
	}

	if len(b.postMDProcessors) > 0 {
		dom, err := goquery.NewDocumentFromReader(&md)
		if err != nil {
			return postSingleData{}, fmt.Errorf("failed to parse post %s: %w", post.Slug, err)
		}

		for _, processor := range b.postMDProcessors {
			if err := processor(b.site, dom); err != nil {
				return postSingleData{}, fmt.Errorf("failed to process post %s: %w", post.Slug, err)
			}
		}

		outHTML, err := dom.Find("body").Html()
		if err != nil {
			return postSingleData{}, fmt.Errorf("failed to render post %s: %w", post.Slug, err)
		}
		md.Reset()
		md.WriteString(outHTML)
	}

	postURL := strings.TrimSuffix(b.site.BaseURL, "/") + "/" + strings.TrimPrefix(postPath, "/")

	return postSingleData{
		commonData: commonData{Site: b.site},
		Path:       postPath,
		Post:       post,
		PostURL:    postURL,
		HTML:       template.HTML(md.String()),
	}, nil
}

// renderPostWithCategories renders a post and attaches its categories.
func (b *Builder) renderPostWithCategories(ctx context.Context, post *models.Post) (postSingleData, error) {
	rp, err := b.renderPost(post)
	if err != nil {
		return postSingleData{}, err
	}

	if b.site.CategoriesOfPost != nil {
		cats, err := b.site.CategoriesOfPost(ctx, post.ID)
		if err != nil {
			return postSingleData{}, err
		}
		rp.Categories = cats
	}

	return rp, nil
}

func (b *Builder) renderCategoryList(ctx buildContext) error {
	var items []categoryListItem
	for _, cwc := range b.site.Categories {
		if cwc.PostCount == 0 {
			continue
		}
		items = append(items, categoryListItem{
			CategoryWithCount: cwc,
			Path:              fmt.Sprintf("/categories/%s", cwc.Slug),
		})
	}

	if len(items) == 0 {
		return nil
	}

	data := categoryListData{
		commonData: commonData{Site: b.site},
		Categories: items,
	}

	return b.createAtPath(ctx, "/categories", func(f io.Writer) error {
		return b.renderTemplate(f, tmplNameCategoryList, data)
	})
}

func (b *Builder) renderCategoryPages(ctx buildContext, goCtx context.Context) error {
	for _, cwc := range b.site.Categories {
		if cwc.PostCount == 0 {
			continue
		}

		// Collect all posts for this category
		var allPosts []postSingleData
		for mp := range b.site.PostIterByCategory(goCtx, cwc.ID) {
			post, err := mp.Get()
			if err != nil {
				return err
			}
			rp, err := b.renderPostWithCategories(goCtx, post)
			if err != nil {
				return err
			}
			allPosts = append(allPosts, rp)
		}

		var descHTML bytes.Buffer
		if cwc.Description != "" {
			if err := b.mdRenderer.RenderTo(goCtx, &descHTML, cwc.Description); err != nil {
				return err
			}
		}

		postsPerPage := b.site.PostsPerPage
		if postsPerPage < 1 {
			postsPerPage = 10
		}

		totalPages := (len(allPosts) + postsPerPage - 1) / postsPerPage
		if totalPages < 1 {
			totalPages = 1
		}

		basePath := fmt.Sprintf("/categories/%s", cwc.Slug)

		for page := 1; page <= totalPages; page++ {
			start := (page - 1) * postsPerPage
			end := start + postsPerPage
			if end > len(allPosts) {
				end = len(allPosts)
			}

			pageInfo := models.PageInfo{
				CurrentPage:  page,
				TotalPages:   totalPages,
				PostsPerPage: postsPerPage,
			}

			var prevURL, nextURL string
			if page > 1 {
				if page == 2 {
					prevURL = basePath + "/"
				} else {
					prevURL = fmt.Sprintf("%s/page/%d/", basePath, page-1)
				}
			}
			if page < totalPages {
				nextURL = fmt.Sprintf("%s/page/%d/", basePath, page+1)
			}

			path := basePath
			if page > 1 {
				path = fmt.Sprintf("%s/page/%d", basePath, page)
			}

			data := categorySingleData{
				commonData:      commonData{Site: b.site},
				Category:        &cwc.Category,
				DescriptionHTML: template.HTML(descHTML.String()),
				Posts:           allPosts[start:end],
				Path:            path,
				PageInfo:        pageInfo,
				PrevURL:         prevURL,
				NextURL:         nextURL,
			}

			if err := b.createAtPath(ctx, path, func(f io.Writer) error {
				return b.renderTemplate(f, tmplNameCategorySingle, data)
			}); err != nil {
				return err
			}
		}

		// Per-category feeds (use all posts, not paginated)
		if err := b.renderCategoryFeed(ctx, cwc, allPosts); err != nil {
			return err
		}
	}

	return nil
}

func (b *Builder) renderCategoryFeed(ctx buildContext, cwc models.CategoryWithCount, posts []postSingleData) error {
	now := time.Now()
	feed := &feedhub.Feed{
		Title:       b.site.Title + " - " + cwc.Name,
		Link:        &feedhub.Link{Href: b.site.BaseURL},
		Description: cwc.DescriptionBrief,
		Created:     now,
	}

	for i, rp := range posts {
		if i >= b.opts.FeedItems {
			break
		}
		feed.Items = append(feed.Items, &feedhub.Item{
			Id:      filepath.Join(b.site.BaseURL, rp.Post.GUID),
			Title:   rp.Post.Title,
			Link:    &feedhub.Link{Href: rp.PostURL},
			Content: string(rp.HTML),
			Created: rp.Post.PublishedAt,
			Updated: rp.Post.UpdatedAt,
		})
	}

	prefix := fmt.Sprintf("/categories/%s/feed", cwc.Slug)

	if err := b.createAtPath(ctx, prefix+".xml", func(f io.Writer) error {
		rss, err := feed.ToRss()
		if err != nil {
			return err
		}
		_, err = io.WriteString(f, rss)
		return err
	}); err != nil {
		return err
	}

	return b.createAtPath(ctx, prefix+".json", func(f io.Writer) error {
		j, err := feed.ToJSON()
		if err != nil {
			return err
		}
		_, err = io.WriteString(f, j)
		return err
	})
}

func (b *Builder) createAtPath(ctx buildContext, path string, fn func(f io.Writer) error) error {
	outFile := filepath.Join(ctx.outDir, strings.TrimPrefix(path, "/"))
	if filepath.Ext(outFile) == "" {
		outFile = filepath.Join(outFile, "index.html")
	}

	// Render it within the template
	if err := os.MkdirAll(filepath.Dir(outFile), 0755); err != nil {
		return err
	}

	f, err := os.Create(outFile)
	if err != nil {
		return err
	}
	defer f.Close()

	return fn(f)
}

func (b *Builder) renderTemplate(w io.Writer, name string, data interface{}) error {
	var buf bytes.Buffer
	if err := b.tmpls.ExecuteTemplate(&buf, name, data); err != nil {
		return err
	}

	return b.tmpls.ExecuteTemplate(w, tmplNameLayoutMain, layoutData{
		commonData: commonData{Site: b.site},
		Body:       template.HTML(buf.String()),
	})
}

func (b *Builder) writeUploads(ctx buildContext, uploads []models.Upload) error {
	for _, u := range uploads {
		fullPath := filepath.Join(ctx.outDir, b.opts.BaseUploads, u.Slug)
		if err := os.MkdirAll(filepath.Dir(fullPath), 0755); err != nil {
			return err
		}

		if err := func() error {
			r, err := b.site.OpenUpload(u)
			if err != nil {
				return err
			}
			defer r.Close()

			w, err := os.Create(fullPath)
			if err != nil {
				return err
			}
			defer w.Close()

			if _, err := io.Copy(w, r); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			return err
		}
	}
	return nil
}

func (b *Builder) writeStaticAssets(ctx buildContext) error {
	if b.opts.StaticFS == nil {
		return nil
	}
	return fs.WalkDir(b.opts.StaticFS, ".", func(path string, d os.DirEntry, err error) error {
		if err != nil {
			return err
		} else if d.IsDir() {
			return nil
		}

		fullPath := filepath.Join(ctx.outDir, b.opts.BaseStatic, path)
		if err := os.MkdirAll(filepath.Dir(fullPath), 0755); err != nil {
			return err
		}

		return func() error {
			r, err := b.opts.StaticFS.Open(path)
			if err != nil {
				return err
			}
			defer r.Close()

			w, err := os.Create(fullPath)
			if err != nil {
				return err
			}
			defer w.Close()

			if _, err := io.Copy(w, r); err != nil {
				return err
			}
			return nil
		}()
	})
}