package template

import (
	"bytes"
	"encoding/xml"
	"io"
	"io/fs"
	"text/template"

	"alin.ovh/gomponents"
	"github.com/Southclaws/fault"
	"github.com/Southclaws/fault/fmsg"

	"alin.ovh/homestead/domain/content"
	"alin.ovh/homestead/domain/indieweb/atom"
	"alin.ovh/homestead/domain/web/templates"
	"alin.ovh/homestead/shared/config"
)

func RenderRobotsTXT(baseURL config.URL) (gomponents.NodeWriter, error) {
	tpl, err := template.ParseFS(templates.Files, "robots.tmpl")
	if err != nil {
		return nil, fault.Wrap(err)
	}

	return gomponents.NodeWriterFunc(func(w io.Writer) (int64, error) {
		err = tpl.Execute(w, map[string]any{
			"BaseURL": baseURL,
		})
		if err != nil {
			return 0, fault.Wrap(err)
		}

		return 0, nil
	}), nil
}

func RenderFeed(
	title string,
	config *config.Config,
	posts []*content.Post,
	specific string,
) (io.WriterTo, error) {
	buf := &bytes.Buffer{}
	datetime := posts[0].Date.UTC()

	buf.WriteString(xml.Header)
	err := atom.LinkXSL(buf, "/feed-styles.xsl")
	if err != nil {
		return nil, err
	}
	feed := &atom.Feed{
		Title:   title,
		Link:    atom.MakeLink(config.BaseURL.URL),
		ID:      atom.MakeTagURI(config, specific),
		Updated: datetime,
		Entries: make([]*atom.FeedEntry, len(posts)),
	}

	for i, post := range posts {
		html, err := post.RenderString()
		if err != nil {
			return nil, fault.Wrap(err, fmsg.With("could not render post"))
		}
		feed.Entries[i] = &atom.FeedEntry{
			Title:   post.Title,
			Link:    atom.MakeLink(config.BaseURL.JoinPath(post.URL)),
			ID:      atom.MakeTagURI(config, post.Basename),
			Updated: post.Date.UTC(),
			Summary: post.Description,
			Author:  config.Title,
			Content: atom.FeedContent{
				Content: html,
				Type:    "html",
			},
		}
	}
	enc := xml.NewEncoder(buf)
	if err := enc.Encode(feed); err != nil {
		return nil, fault.Wrap(err)
	}

	return buf, nil
}

func ListFiles() ([]fs.DirEntry, error) {
	kodataStaticFiles, err := templates.Files.(fs.ReadDirFS).ReadDir(".")
	if err != nil {
		return nil, fault.Wrap(err, fmsg.With("could not read kodata static files"))
	}

	return kodataStaticFiles, nil
}

func CopyFile(filename string, w io.Writer) error {
	f, err := templates.Files.Open(filename)
	if err != nil {
		return fault.Wrap(err)
	}
	defer f.Close()

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

	return nil
}