package builder

import (
	"bytes"
	"encoding/xml"
	"io"
	"strings"
	"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",
	}
)

type QuerySelection struct {
	*goquery.Selection
}

type QueryDocument struct {
	*goquery.Document
}

func NewDocumentFromReader(r io.Reader) (*QueryDocument, error) {
	doc, err := goquery.NewDocumentFromReader(r)

	return &QueryDocument{doc}, errors.WithMessage(err, "could not create query document")
}

func (q *QueryDocument) Find(selector string) *QuerySelection {
	return &QuerySelection{q.Document.Find(selector)}
}

func renderRobotsTXT(config *config.Config) (io.Reader, error) {
	r, w := io.Pipe()
	tpl, err := template.ParseFS(templates.Files, "robots.tmpl")
	if err != nil {
		return nil, err
	}
	go func() {
		err = tpl.Execute(w, map[string]interface{}{
			"BaseURL": config.BaseURL,
		})
		if err != nil {
			w.CloseWithError(err)
		}
		w.Close()
	}()

	return r, 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, 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)
	err = enc.Encode(feed)
	if err != nil {
		return nil, err
	}

	return buf, nil
}

func renderFeedStyles() (*strings.Reader, error) {
	tpl, err := template.ParseFS(templates.Files, "feed-styles.xsl")
	if err != nil {
		return nil, err
	}

	esc := &strings.Builder{}
	err = xml.EscapeText(esc, []byte(templates.CSS))

	if err != nil {
		return nil, err
	}

	w := &strings.Builder{}
	err = tpl.Execute(w, map[string]interface{}{
		"css": esc.String(),
	})
	if err != nil {
		return nil, err
	}

	return strings.NewReader(w.String()), nil
}

func getFeedStylesHash(r io.Reader) (string, error) {
	doc, err := xmlquery.Parse(r)
	if err != nil {
		return "", 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, error) {
	doc, err := NewDocumentFromReader(r)
	if err != nil {
		return "", err
	}
	html := doc.Find("head > style").Text()

	return hash(html), nil
}