package server

import (
	"net/http"
	"strconv"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/access"
	"gitlab.com/Timfa/bluegit/internal/desctpl"
	"gitlab.com/Timfa/bluegit/internal/gitrepo"
	"gitlab.com/Timfa/bluegit/internal/i18n"
	"gitlab.com/Timfa/bluegit/internal/markdown"
	"gitlab.com/Timfa/bluegit/internal/store"
)

func (s *Server) taskOpt(r *http.Request, csrf string, repo store.Repo, kind, id string, can bool) markdown.Tasks {
	return markdown.Tasks{
		Post: repoURL(repo) + "/-/tasks", CSRF: csrf, Kind: kind, ID: id,
		CanToggle: can && csrf != "", Count: s.tr(r, "tpl.tasks"), Toggle: s.tr(r, "tpl.toggle"),
	}
}

func (s *Server) descriptionTemplates(r *http.Request, repo store.Repo, kind string) []desctpl.Template {
	if s.StoragePath() == "" {
		return nil
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	list, err := desctpl.List(r.Context(), s.Git, dir, repo.DefaultBranch, kind)
	if err != nil {
		return nil
	}
	return list
}

func templateNames(list []desctpl.Template) []string {
	if len(list) == 0 {
		return nil
	}
	out := make([]string, len(list))
	for i, t := range list {
		out[i] = t.Name
	}
	return out
}

// fillTpl zet een sjabloon in een lege beschrijving, of het gekozen sjabloon
// als het formulier ?template= meestuurt. Een lege keuze maakt de tekst leeg.
func (s *Server) fillTpl(r *http.Request, repo store.Repo, kind string, body, picked *string, names *[]string) {
	list := s.descriptionTemplates(r, repo, kind)
	*names = templateNames(list)
	if r.URL.Query().Has("template") {
		name := r.URL.Query().Get("template")
		if name == "" {
			*body = ""
			*picked = ""
			return
		}
		if t, ok := desctpl.Find(list, name); ok {
			*body = t.Body
			*picked = t.Name
		}
		return
	}
	if strings.TrimSpace(*body) == "" {
		if t, ok := desctpl.Default(list); ok {
			*body = t.Body
			*picked = t.Name
		}
	}
}

func (s *Server) mrVars(r *http.Request, repo store.Repo, source, target string) desctpl.Vars {
	v := desctpl.Vars{Source: source, Target: target}
	if s.StoragePath() == "" || source == "" || target == "" {
		return v
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	msgs, err := gitrepo.Messages(r.Context(), s.Git, dir, target+".."+source, 100)
	if err != nil {
		return v
	}
	for _, m := range msgs {
		v.Commits = append(v.Commits, desctpl.Commit{
			Subject: m.Subject, Body: m.Body, Author: m.Author, Email: m.Email, Merge: m.Merge,
		})
	}
	return v
}

func applyToggle(body string, index int, checked bool) (string, error) {
	next, ok := markdown.SetTask(body, index, checked)
	if !ok {
		return "", i18n.E("err.task")
	}
	return next, nil
}

func (s *Server) toggleTask(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if u.ID == 0 {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	index, err := strconv.Atoi(r.FormValue("index"))
	if err != nil || index < 0 {
		http.Error(w, s.tr(r, "err.task"), http.StatusBadRequest)
		return
	}
	id, err := strconv.ParseInt(r.FormValue("id"), 10, 64)
	if err != nil || id < 1 {
		http.Error(w, s.tr(r, "err.task"), http.StatusBadRequest)
		return
	}
	checked := r.FormValue("checked") == "1"
	switch r.FormValue("kind") {
	case "issue":
		s.toggleIssue(w, r, u, repo, role, id, index, checked)
	case "issue-note":
		s.toggleIssueNote(w, r, u, repo, role, id, index, checked)
	case "mr":
		s.toggleMR(w, r, u, repo, role, id, index, checked)
	case "mr-note":
		s.toggleMRNote(w, r, u, repo, id, index, checked)
	default:
		http.Error(w, s.tr(r, "err.task"), http.StatusBadRequest)
	}
}

func (s *Server) toggleIssue(w http.ResponseWriter, r *http.Request, u store.User, repo store.Repo, role access.Role, number int64, index int, checked bool) {
	iss, err := s.Store.IssueByNumber(r.Context(), repo.ID, number)
	if err != nil || !issueVisible(iss, u, role) {
		http.NotFound(w, r)
		return
	}
	back := issuePath(repo, iss.Number)
	if u.ID != iss.AuthorID && !role.CanTriageIssue() {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	next, err := applyToggle(iss.Description, index, checked)
	if err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	if err := s.Store.UpdateIssueText(r.Context(), iss.ID, iss.Title, next); err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	s.issueHook(repo, iss.Number, u.Username, "updated", "")
	s.redirect(w, r, back, "", "")
}

func (s *Server) toggleIssueNote(w http.ResponseWriter, r *http.Request, u store.User, repo store.Repo, role access.Role, id int64, index int, checked bool) {
	note, err := s.Store.IssueNoteByID(r.Context(), repo.ID, id)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	iss, err := s.Store.IssueByID(r.Context(), repo.ID, note.IssueID)
	if err != nil || !issueVisible(iss, u, role) {
		http.NotFound(w, r)
		return
	}
	back := issuePath(repo, iss.Number)
	if u.ID != note.AuthorID {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	next, err := applyToggle(note.Body, index, checked)
	if err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	if err := s.Store.UpdateIssueNoteBody(r.Context(), repo.ID, note.ID, next); err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, back, "", "")
}

func (s *Server) toggleMR(w http.ResponseWriter, r *http.Request, u store.User, repo store.Repo, role access.Role, number int64, index int, checked bool) {
	mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, number)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
	if mr.Status != "open" || (u.ID != mr.AuthorID && !role.CanWriteCode()) {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	next, err := applyToggle(mr.Description, index, checked)
	if err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	if err := s.Store.UpdateMergeRequest(r.Context(), mr.ID, mr.Title, next, mr.Labels); err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, back, "", "")
}

func (s *Server) toggleMRNote(w http.ResponseWriter, r *http.Request, u store.User, repo store.Repo, id int64, index int, checked bool) {
	note, err := s.Store.NoteByID(r.Context(), repo.ID, id)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	mr, err := s.Store.MergeRequest(r.Context(), repo.ID, note.MRID)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
	if u.ID != note.AuthorID {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	next, err := applyToggle(note.Body, index, checked)
	if err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	if err := s.Store.UpdateNoteBody(r.Context(), repo.ID, note.ID, next); err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, back, "", "")
}
