package frontend

import (
	"encoding/json"
	"fmt"
	"html/template"
	"io"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"github.com/google/uuid"
	b "streifling.com/jason/cpolis/cmd/backend"
)

const (
	EditMode = iota
	PreviewMode
)

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 {
			return
		}

		type editorHTMLData struct {
			Title       string
			Description string
			Content     string
			HTMLContent template.HTML
			Tags        []*b.Tag
			Mode        int
		}

		var data editorHTMLData
		if session.Values["article"] == nil {
			data = editorHTMLData{}
		} else {
			data = session.Values["article"].(editorHTMLData)
		}
		data.Mode = EditMode

		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")
		template.Must(tmpl, err).ExecuteTemplate(w, "page-content", data)
	}
}

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 {
			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"),
			Description: r.PostFormValue("article-description"),
			Published:   false,
			Rejected:    false,
			AuthorID:    session.Values["id"].(int64),
		}

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

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

		article.Link = fmt.Sprint(c.Domain, c.Port, "/article/serve/", article.ID)
		if err = db.UpdateAttributes(&b.Attribute{Table: "articles", ID: article.ID, AttName: "link", Value: article.Link}); 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
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		tmpl.ExecuteTemplate(w, "page-content", session.Values["role"])
	}
}

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 {
			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")
		description := r.PostFormValue("article-description")
		content := r.PostFormValue("article-content")

		link := fmt.Sprint(c.ArticleDir, "/", id, ".md")
		if err = os.WriteFile(link, []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: "description", Value: description},
			&b.Attribute{Table: "articles", ID: id, AttName: "rejected", Value: false},
		); 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
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		tmpl.ExecuteTemplate(w, "page-content", session.Values["role"])
	}
}

func ShowUnpublishedArticles(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 {
			return
		}

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

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/unpublished-articles.html")
		tmpl = template.Must(tmpl, err)
		tmpl.ExecuteTemplate(w, "page-content", unpublishedArticles)
	}
}

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 {
			return
		}

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

		data.RejectedArticles, err = db.GetCertainArticles(false, 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)
		tmpl.ExecuteTemplate(w, "page-content", data)
	}
}

func ReviewUnpublishedArticle(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 {
			return
		}

		type htmlData struct {
			Title       string
			Description string
			Content     template.HTML
			Tags        []*b.Tag
			ID          int64
		}

		var err error
		data := new(htmlData)

		data.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(data.ID)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

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

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

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

		content, err := b.ConvertToHTML(string(contentBytes))
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.Content = template.HTML(content)

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

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/to-be-published.html")
		tmpl = template.Must(tmpl, err)
		tmpl.ExecuteTemplate(w, "page-content", data)
	}
}

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 {
			return
		}

		type htmlData struct {
			Selected map[int64]bool
			Article  *b.Article
			Content  string
			Tags     []*b.Tag
		}
		data := new(htmlData)

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

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

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

		data.Content = string(contentBytes)

		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
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/rework-article.html")
		tmpl = template.Must(tmpl, err)
		tmpl.ExecuteTemplate(w, "page-content", data)
	}
}

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 {
			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.AddArticleToCurrentIssue(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
		}

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

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		tmpl.ExecuteTemplate(w, "page-content", session.Values["role"])
	}
}

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 {
			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
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		tmpl.ExecuteTemplate(w, "page-content", session.Values["role"])
	}
}

func ShowCurrentArticles(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 {
			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-articles.html")
		template.Must(tmpl, err).ExecuteTemplate(w, "page-content", articles)
	}
}

func UploadArticleImage(c *b.Config, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if _, err := getSession(w, r, c, s); err != nil {
			return
		}

		file, header, err := r.FormFile("article-image")
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
		defer file.Close()

		nameStrings := strings.Split(header.Filename, ".")
		extension := "." + nameStrings[len(nameStrings)-1]
		filename := fmt.Sprint(uuid.New(), extension)
		absFilepath, err := filepath.Abs(fmt.Sprint(c.PicsDir, "/", filename))
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		img, err := os.Create(absFilepath)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		defer img.Close()

		if _, err = io.Copy(img, file); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		url := fmt.Sprint(c.Domain, c.Port, "/image/serve/", filename)
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(url)
	}
}

func ShowPublishedArticles(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 {
			return
		}

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

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/published-articles.html")
		tmpl = template.Must(tmpl, err)
		tmpl.ExecuteTemplate(w, "page-content", publishedArticles)
	}
}

func ReviewArticleForDeletion(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 {
			return
		}

		type htmlData struct {
			Title       string
			Description string
			Content     template.HTML
			Tags        []*b.Tag
			ID          int64
		}

		var err error
		data := new(htmlData)

		data.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(data.ID)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

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

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

		contentBytes, err := os.ReadFile(article.Link)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		content, err := b.ConvertToHTML(string(contentBytes))
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.Content = template.HTML(content)

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

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/to-be-deleted.html")
		tmpl = template.Must(tmpl, err)
		tmpl.ExecuteTemplate(w, "page-content", data)
	}
}

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 {
			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
		}

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

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		tmpl.ExecuteTemplate(w, "page-content", session.Values["role"].(int))
	}
}