package frontend

import (
	"fmt"
	"html/template"
	"log"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"

	b "streifling.com/jason/cpolis/cmd/backend"
)

const (
	EditMode = iota
	PreviewMode
)

type EditorHTMLData struct {
	Selected     map[int64]bool
	Content      string
	Action       string
	ActionTitle  string
	ActionButton string
	BannerImage  string
	HTMLContent  template.HTML
	Article      *b.Article
	Tags         []*b.Tag
}

func WriteArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := getSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		var data *EditorHTMLData
		if session.Values["article"] == nil {
			data = &EditorHTMLData{Action: "submit", Article: new(b.Article)}
		} else {
			data = session.Values["article"].(*EditorHTMLData)
		}

		data.Tags, err = db.GetTagList()
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/editor.html")
		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func SubmitArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := getSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		session.Values["article"] = nil
		if err = session.Save(r, w); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		article := &b.Article{
			Title:         r.PostFormValue("article-title"),
			BannerLink:    r.PostFormValue("article-banner-url"),
			Summary:       r.PostFormValue("article-summary"),
			Published:     false,
			Rejected:      false,
			AuthorID:      session.Values["id"].(int64),
			IsInIssue:     r.PostFormValue("issue") == "on",
			AutoGenerated: false,
		}

		if len(article.Title) == 0 {
			http.Error(w, "Bitte den Titel eingeben.", http.StatusBadRequest)
			return
		}
		if len(article.BannerLink) == 0 {
			http.Error(w, "Bitte ein Titelbild einfügen.", http.StatusBadRequest)
			return
		}
		if len(article.Summary) == 0 {
			http.Error(w, "Bitte die Beschreibung eingeben.", http.StatusBadRequest)
			return
		}

		article.ID, err = db.AddArticle(article)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		content := []byte(r.PostFormValue("article-content"))
		if len(content) == 0 {
			http.Error(w, "Bitte den Artikel eingeben.", http.StatusBadRequest)
			return
		}

		articleAbsName := fmt.Sprint(c.ArticleDir, "/", article.ID, ".md")
		if err = os.WriteFile(articleAbsName, content, 0644); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		article.ContentLink = fmt.Sprint(c.Domain, "/article/serve/", article.ID)
		if err = db.UpdateAttributes(&b.Attribute{Table: "articles", ID: article.ID, AttName: "content_link", Value: article.ContentLink}); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		r.ParseForm()
		tags := make([]int64, 0)
		for _, tag := range r.Form["tags"] {
			tagID, err := strconv.ParseInt(tag, 10, 64)
			if err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
			tags = append(tags, tagID)
		}
		if err = db.WriteArticleTags(article.ID, tags); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct{ Role int })
		data.Role = session.Values["role"].(int)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ResubmitArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := getSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		title := r.PostFormValue("article-title")
		if len(title) == 0 {
			http.Error(w, "Bitte den Titel eingeben.", http.StatusBadRequest)
			return
		}

		summary := r.PostFormValue("article-summary")
		if len(summary) == 0 {
			http.Error(w, "Bitte die Beschreibung eingeben.", http.StatusBadRequest)
			return
		}

		content := r.PostFormValue("article-content")
		if len(content) == 0 {
			http.Error(w, "Bitte den Artikel eingeben.", http.StatusBadRequest)
			return
		}

		contentLink := fmt.Sprint(c.ArticleDir, "/", id, ".md")
		if err = os.WriteFile(contentLink, []byte(content), 0644); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.UpdateAttributes(
			&b.Attribute{Table: "articles", ID: id, AttName: "title", Value: title},
			&b.Attribute{Table: "articles", ID: id, AttName: "summary", Value: summary},
			&b.Attribute{Table: "articles", ID: id, AttName: "rejected", Value: false},
			&b.Attribute{Table: "articles", ID: id, AttName: "is_in_issue", Value: r.PostFormValue("issue") == "on"},
		); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		r.ParseForm()
		tags := make([]int64, 0)
		for _, tag := range r.Form["tags"] {
			tagID, err := strconv.ParseInt(tag, 10, 64)
			if err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
			tags = append(tags, tagID)
		}
		if err = db.UpdateArticleTags(id, tags); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct{ Role int })
		data.Role = session.Values["role"].(int)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ShowUnpublishedUnrejectedAndPublishedRejectedArticles(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if _, err := getSession(w, r, c, s); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		rejectedArticles, err := db.GetCertainArticles("rejected", true)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		articles := make([]*b.Article, 0)
		for _, article := range rejectedArticles {
			if article.Published {
				articles = append(articles, article)
			}
		}

		unpublishedArticles, err := db.GetCertainArticles("published", false)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		for _, article := range unpublishedArticles {
			if !article.Rejected {
				articles = append(articles, article)
			}
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/unpublished-articles.html")
		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", articles); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ShowRejectedArticles(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := getSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct {
			MyIDs            map[int64]bool
			RejectedArticles []*b.Article
		})

		data.RejectedArticles, err = db.GetCertainArticles("rejected", true)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data.MyIDs = make(map[int64]bool)
		for _, article := range data.RejectedArticles {
			if article.AuthorID == session.Values["id"].(int64) {
				data.MyIDs[article.ID] = true
			}
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/rejected-articles.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ReviewRejectedArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if _, err := getSession(w, r, c, s); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(EditorHTMLData)
		data.Article, err = db.GetArticle(id)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		imgURL := strings.Split(data.Article.BannerLink, "/")
		imgFileName := imgURL[len(imgURL)-1]
		data.BannerImage, err = serveBase64Image(c, imgFileName)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		articleAbsName := fmt.Sprint(c.ArticleDir, "/", data.Article.ID, ".md")
		content, err := os.ReadFile(articleAbsName)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.Content = string(content)

		data.Tags, err = db.GetTagList()
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		selectedTags, err := db.GetArticleTags(id)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.Selected = make(map[int64]bool)
		for _, tag := range selectedTags {
			data.Selected[tag.ID] = true
		}

		data.Action = fmt.Sprint("resubmit/", data.Article.ID)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/editor.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func PublishArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := getSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}

		article, err := db.GetArticle(id)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.AddArticleToCurrentIssue(article.ID); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.UpdateAttributes(
			&b.Attribute{Table: "articles", ID: id, AttName: "published", Value: true},
			&b.Attribute{Table: "articles", ID: id, AttName: "rejected", Value: false},
			&b.Attribute{Table: "articles", ID: id, AttName: "created", Value: time.Now().Format("2006-01-02 15:04:05")},
		); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if article.EditedID != 0 {
			oldArticle, err := db.GetArticle(article.EditedID)
			if err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}

			if err = db.DeleteArticle(oldArticle.ID); err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}

			if err = os.Remove(fmt.Sprint(c.ArticleDir, "/", oldArticle.ID, ".md")); err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}

			if err = db.UpdateAttributes(
				&b.Attribute{Table: "articles", ID: id, AttName: "content_link", Value: fmt.Sprint(c.Domain, "/article/serve/", article.ID)},
				&b.Attribute{Table: "articles", ID: id, AttName: "edited_id", Value: 0},
			); err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
		}

		feed, err := b.GenerateAtomFeed(c, db)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		if err = b.SaveAtomFeed(c.AtomFeed, feed); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct{ Role int })
		data.Role = session.Values["role"].(int)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func RejectArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := getSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.UpdateAttributes(&b.Attribute{Table: "articles", ID: id, AttName: "rejected", Value: true}); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct{ Role int })
		data.Role = session.Values["role"].(int)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ShowCurrentIssue(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if _, err := getSession(w, r, c, s); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		articles, err := db.GetCurrentIssueArticles()
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/current-issue.html")
		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", articles); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ShowPublishedArticles(c *b.Config, db *b.DB, s *b.CookieStore, action string) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if _, err := getSession(w, r, c, s); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct {
			Action   string
			Articles []*b.Article
		})
		data.Action = action

		publishedArticles, err := db.GetCertainArticles("published", true)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		for _, article := range publishedArticles {
			if !article.AutoGenerated {
				data.Articles = append(data.Articles, article)
			}
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/published-articles.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ReviewArticle(c *b.Config, db *b.DB, s *b.CookieStore, action, title, button string) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if _, err := getSession(w, r, c, s); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		article, err := db.GetArticle(id)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := &EditorHTMLData{
			Article: &b.Article{
				ID:        id,
				IsInIssue: article.IsInIssue,
			},
			Action:       action,
			ActionTitle:  title,
			ActionButton: button,
		}

		data.Article.Title, err = b.ConvertToPlain(article.Title)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		imgURL := strings.Split(article.BannerLink, "/")
		imgFileName := imgURL[len(imgURL)-1]
		data.BannerImage, err = serveBase64Image(c, imgFileName)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data.Article.Summary, err = b.ConvertToPlain(article.Summary)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		articleAbsName := fmt.Sprint(c.ArticleDir, "/", article.ID, ".md")
		content, err := os.ReadFile(articleAbsName)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.Content, err = b.ConvertToHTML(string(content))
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.HTMLContent = template.HTML(data.Content)

		data.Tags, err = db.GetArticleTags(id)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/review-article.html")
		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func DeleteArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := getSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.DeleteArticle(id); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = os.Remove(fmt.Sprint(c.ArticleDir, "/", id, ".md")); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		feed, err := b.GenerateAtomFeed(c, db)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		if err = b.SaveAtomFeed(c.AtomFeed, feed); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct{ Role int })
		data.Role = session.Values["role"].(int)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func AllowEditArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := getSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		oldID, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		oldArticle, err := db.GetArticle(oldID)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		newArticle := oldArticle
		newArticle.Published = false
		newArticle.Rejected = true
		newArticle.EditedID = oldArticle.ID

		newID, err := db.AddArticle(newArticle)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.UpdateAttributes(&b.Attribute{Table: "articles", ID: oldID, AttName: "edited_id", Value: newID}); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = b.CopyFile(fmt.Sprint(c.ArticleDir, "/", oldID, ".md"), fmt.Sprint(c.ArticleDir, "/", newID, ".md")); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct{ Role int })
		data.Role = session.Values["role"].(int)

		tmpl := template.Must(template.ParseFiles(c.WebDir + "/templates/hub.html"))
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func EditArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if _, err := getSession(w, r, c, s); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(EditorHTMLData)

		data.Article, err = db.GetArticle(id)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		imgURL := strings.Split(data.Article.BannerLink, "/")
		imgFileName := imgURL[len(imgURL)-1]
		data.BannerImage, err = serveBase64Image(c, imgFileName)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		content, err := os.ReadFile(fmt.Sprint(c.ArticleDir, "/", data.Article.ID, ".md"))
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.Content = string(content)

		data.Tags, err = db.GetArticleTags(data.Article.ID)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		selectedTags, err := db.GetArticleTags(id)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.Selected = make(map[int64]bool)
		for _, tag := range selectedTags {
			data.Selected[tag.ID] = true
		}

		data.Action = fmt.Sprint("save/", data.Article.ID)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/editor.html")
		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}