package website

import (
	"errors"
	"html/template"
	"net/http"

	"git.handmade.network/hmn/hmn/src/db"
	"git.handmade.network/hmn/hmn/src/hmndata"
	"git.handmade.network/hmn/hmn/src/models"
	"git.handmade.network/hmn/hmn/src/templates"
)

func EducationIndex(c *RequestContext) ResponseData {
	type indexData struct {
		templates.BaseData
	}

	tmpl := indexData{
		BaseData: getBaseData(c, "Handmade Education", nil),
	}

	var res ResponseData
	res.MustWriteTemplate("education_index.html", tmpl, c.Perf)
	return res
}

func EducationGlossary(c *RequestContext) ResponseData {
	type glossaryData struct {
		templates.BaseData
	}

	tmpl := glossaryData{
		BaseData: getBaseData(c, "Handmade Education", nil),
	}

	var res ResponseData
	res.MustWriteTemplate("education_glossary.html", tmpl, c.Perf)
	return res
}

func EducationArticle(c *RequestContext) ResponseData {
	type articleData struct {
		templates.BaseData

		Content template.HTML
	}

	type articleResult struct {
		Article        models.EduArticle        `db:"a"`
		CurrentVersion models.EduArticleVersion `db:"v"`
	}

	article, err := db.QueryOne[articleResult](c, c.Conn,
		`
		SELECT $columns
		FROM
			education_article AS a
			JOIN education_article_version AS v ON a.current_version = v.id
		WHERE
			slug = $1
			AND type = $2
		`,
		c.PathParams["slug"],
		models.EduArticleTypeArticle,
	)
	if errors.Is(err, db.NotFound) {
		return FourOhFour(c)
	} else if err != nil {
		return c.ErrorResponse(http.StatusInternalServerError, err)
	}

	tmpl := articleData{
		BaseData: getBaseData(c, "Handmade Education", nil),
		Content:  template.HTML(article.CurrentVersion.ContentHTML),
	}

	var res ResponseData
	res.MustWriteTemplate("education_article.html", tmpl, c.Perf)
	return res
}

func EducationAdmin(c *RequestContext) ResponseData {
	articles, err := hmndata.FetchEduArticles(c, c.Conn, c.CurrentUser, hmndata.EduArticleQuery{})
	if err != nil {
		return c.ErrorResponse(http.StatusInternalServerError, err)
	}

	var tmplArticles []templates.EduArticle
	var tmplGlossaryTerms []templates.EduArticle
	for _, a := range articles {
		tmpl := templates.EducationArticleToTemplate(&a.Article, &a.CurrentVersion)
		switch a.Article.Type {
		case models.EduArticleTypeArticle:
			tmplArticles = append(tmplArticles, tmpl)
		case models.EduArticleTypeGlossary:
			tmplGlossaryTerms = append(tmplGlossaryTerms, tmpl)
		}
	}

	type adminData struct {
		templates.BaseData
		Articles      []templates.EduArticle
		GlossaryTerms []templates.EduArticle
	}

	tmpl := adminData{
		BaseData:      getBaseData(c, "Education Admin", nil),
		Articles:      tmplArticles,
		GlossaryTerms: tmplGlossaryTerms,
	}

	var res ResponseData
	res.MustWriteTemplate("education_admin.html", tmpl, c.Perf)
	return res
}

func EducationArticleEdit(c *RequestContext) ResponseData {
	// TODO
	panic("not implemented yet")
}

func EducationArticleDelete(c *RequestContext) ResponseData {
	// TODO
	panic("not implemented yet")
}