package template

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

	"go.alanpearce.eu/homestead/internal/atom"
	"go.alanpearce.eu/homestead/internal/config"
	"go.alanpearce.eu/homestead/internal/content"
	"go.alanpearce.eu/homestead/templates"

	"github.com/PuerkitoBio/goquery"
	"github.com/antchfx/xmlquery"
	"github.com/antchfx/xpath"
	"gitlab.com/tozd/go/errors"
)

var (
	nsMap = map[string]string{
		"xsl":   "http://www.w3.org/1999/XSL/Transform",
		"atom":  "http://www.w3.org/2005/Atom",
		"xhtml": "http://www.w3.org/1999/xhtml",
	}
)

func RenderRobotsTXT(baseURL config.URL, w io.Writer) errors.E {
	tpl, err := template.ParseFS(templates.Files, "robots.tmpl")
	if err != nil {
		return errors.WithStack(err)
	}
	err = tpl.Execute(w, map[string]any{
		"BaseURL": baseURL,
	})
	if err != nil {
		return errors.WithStack(err)
	}

	return nil
}

func RenderFeed(
	title string,
	config *config.Config,
	posts []*content.Post,
	specific string,
) (io.WriterTo, errors.E) {
	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, errors.WithMessage(err, "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, errors.WithStack(err)
	}

	return buf, nil
}

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

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

	return nil
}

func GetFeedStyleHash(r io.Reader) (string, errors.E) {
	doc, err := xmlquery.Parse(r)
	if err != nil {
		return "", errors.WithStack(err)
	}
	expr, err := xpath.CompileWithNS("//xhtml:style", nsMap)
	if err != nil {
		return "", errors.WithMessage(err, "could not parse XPath")
	}
	style := xmlquery.QuerySelector(doc, expr)

	return Hash(style.InnerText()), nil
}

func GetHTMLStyleHash(r io.Reader) (string, errors.E) {
	doc, err := goquery.NewDocumentFromReader(r)
	if err != nil {
		return "", errors.WithStack(err)
	}
	html := doc.Find("head > style").Text()

	return Hash(html), nil
}