package server

import (
	"context"
	"net/http"
	"strconv"

	"gitlab.com/Timfa/bluegit/internal/access"
	"gitlab.com/Timfa/bluegit/internal/store"
)

// ApprovalView is de goedkeuringsregel zoals de instellingen hem tonen.
type ApprovalView struct {
	MaintainerRequired bool
	RequiredCount      int
	DevelopersApprove  bool
	Locked             bool
	GroupPath          string
	Maintainers        int
	Warn               bool
	WarnText           string
}

// ReviewRow is één reviewer op de merge request.
type ReviewRow struct {
	UserID   int64
	Username string
	Status   string
	Label    string
}

func (s *Server) fillApproval(r *http.Request, v *View, repo store.Repo) {
	pol, groupPath, err := s.Store.EffectiveApproval(r.Context(), repo)
	if err != nil {
		return
	}
	n, _ := s.Store.ProjectMaintainerCount(r.Context(), repo)
	v.Approval = approvalView(pol, groupPath != "", groupPath, n)
	s.paintApprovalWarn(r, v.Approval)
}

func (s *Server) fillGroupApproval(r *http.Request, v *View, g store.Group) {
	pol, err := s.Store.GetApproval(r.Context(), "group", g.ID)
	if err != nil {
		return
	}
	n, _ := s.Store.GroupMaintainerCount(r.Context(), g.ID)
	v.Approval = approvalView(pol, false, "", n)
	s.paintApprovalWarn(r, v.Approval)
}

func approvalView(pol store.ApprovalPolicy, locked bool, groupPath string, maintainers int) *ApprovalView {
	if pol.RequiredCount < 1 {
		pol.RequiredCount = 1
	}
	return &ApprovalView{
		MaintainerRequired: pol.MaintainerRequired,
		RequiredCount:      pol.RequiredCount,
		DevelopersApprove:  pol.DevelopersApprove,
		Locked:             locked,
		GroupPath:          groupPath,
		Maintainers:        maintainers,
		Warn:               pol.MaintainerRequired && pol.RequiredCount > maintainers,
	}
}

func (s *Server) paintApprovalWarn(r *http.Request, a *ApprovalView) {
	if a == nil || !a.Warn {
		return
	}
	a.WarnText = s.tr(r, approvalWarnKey(a.RequiredCount, a.Maintainers), a.RequiredCount, a.Maintainers)
}

func approvalWarnKey(required, maintainers int) string {
	req, who := "many", "many"
	if required == 1 {
		req = "one"
	}
	if maintainers == 1 {
		who = "one"
	}
	return "appr.warn." + req + "." + who
}

func (s *Server) saveRepoApproval(w http.ResponseWriter, r *http.Request) {
	_, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	_, groupPath, err := s.Store.EffectiveApproval(r.Context(), repo)
	if err != nil {
		s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.trErr(r, err))
		return
	}
	if groupPath != "" {
		s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.tr(r, "appr.locked"))
		return
	}
	if err := s.Store.SaveApproval(r.Context(), "repo", repo.ID, approvalFromForm(r)); err != nil {
		s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", s.tr(r, "flash.saved"), "")
}

func (s *Server) saveGroupApproval(w http.ResponseWriter, r *http.Request) {
	g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if err := s.Store.SaveApproval(r.Context(), "group", g.ID, approvalFromForm(r)); err != nil {
		s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", s.tr(r, "flash.saved"), "")
}

func approvalFromForm(r *http.Request) store.ApprovalPolicy {
	n, _ := strconv.Atoi(r.FormValue("required_count"))
	return store.ApprovalPolicy{
		MaintainerRequired: r.FormValue("maintainer_required") == "1",
		RequiredCount:      n,
		DevelopersApprove:  r.FormValue("developers_approve") == "1",
	}
}

func (s *Server) reviewBlocks(r *http.Request, repo store.Repo, mr store.MergeRequest) []string {
	if mr.Status != "open" {
		return nil
	}
	pol, _, err := s.Store.EffectiveApproval(r.Context(), repo)
	if err != nil {
		return nil
	}
	var out []string
	if pol.MaintainerRequired {
		n := s.countApprovals(r.Context(), repo, mr, pol)
		if n < pol.RequiredCount {
			key := "rev.summary.approvals"
			if pol.RequiredCount == 1 {
				key = "rev.summary.approvals.one"
			}
			out = append(out, s.tr(r, key, n, pol.RequiredCount))
		}
	}
	reviews, err := s.Store.ListReviews(r.Context(), mr.ID)
	if err != nil {
		return out
	}
	for _, rev := range reviews {
		switch rev.Status {
		case "changes":
			out = append(out, s.tr(r, "rev.summary.changes", rev.Username))
		case "rejected":
			out = append(out, s.tr(r, "rev.summary.rejected", rev.Username))
		}
	}
	return out
}

func (s *Server) countApprovals(ctx context.Context, repo store.Repo, mr store.MergeRequest, pol store.ApprovalPolicy) int {
	reviews, err := s.Store.ListReviews(ctx, mr.ID)
	if err != nil {
		return 0
	}
	n := 0
	for _, rev := range reviews {
		if rev.Status != "approved" || rev.UserID == mr.AuthorID {
			continue
		}
		role, err := s.Store.EffectiveRole(ctx, rev.UserID, repo.ID)
		if err != nil {
			continue
		}
		if approvalCounts(role, pol) {
			n++
		}
	}
	return n
}

func approvalCounts(role access.Role, pol store.ApprovalPolicy) bool {
	if role.CanManageSettings() {
		return true
	}
	return pol.DevelopersApprove && role.CanWriteCode()
}

func (s *Server) fillReviews(r *http.Request, v *View, repo store.Repo, mr store.MergeRequest, role access.Role) {
	reviews, _ := s.Store.ListReviews(r.Context(), mr.ID)
	for _, rev := range reviews {
		v.Reviews = append(v.Reviews, ReviewRow{
			UserID: rev.UserID, Username: rev.Username, Status: rev.Status,
			Label: s.tr(r, "rev."+rev.Status),
		})
	}
	if v.User == nil || mr.Status != "open" {
		return
	}
	v.CanReview = role.CanWriteCode()
	pol, _, _ := s.Store.EffectiveApproval(r.Context(), repo)
	v.CanApprove = v.CanReview && v.User.ID != mr.AuthorID && approvalCounts(role, pol)
	v.CanDismiss = role.CanManageSettings()
}

func (s *Server) postReview(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	mr, err := s.mrFromRequest(r, repo.ID)
	if err != nil || mr.Status != "open" {
		http.NotFound(w, r)
		return
	}
	back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
	if !role.CanWriteCode() {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	status := r.FormValue("status")
	switch status {
	case "approved", "changes", "rejected":
	default:
		s.redirect(w, r, back, "", s.tr(r, "rev.bad"))
		return
	}
	if status == "approved" {
		if u.ID == mr.AuthorID {
			s.redirect(w, r, back, "", s.tr(r, "rev.own"))
			return
		}
		pol, _, err := s.Store.EffectiveApproval(r.Context(), repo)
		if err != nil || !approvalCounts(role, pol) {
			http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
			return
		}
	}
	if err := s.Store.UpsertReview(r.Context(), repo.ID, mr.ID, u.ID, status); err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.saved"), "")
}

func (s *Server) dismissReview(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	mr, err := s.mrFromRequest(r, repo.ID)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
	if !role.CanManageSettings() {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	userID, _ := strconv.ParseInt(r.FormValue("user_id"), 10, 64)
	if userID == 0 {
		s.redirect(w, r, back, "", s.tr(r, "rev.bad"))
		return
	}
	if err := s.Store.UpsertReview(r.Context(), repo.ID, mr.ID, userID, "dismissed"); err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.saved"), "")
}

func (s *Server) reopenMR(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	mr, err := s.mrFromRequest(r, repo.ID)
	if err != nil || mr.Status != "closed" {
		http.NotFound(w, r)
		return
	}
	if u.ID != mr.AuthorID && !role.CanManageSettings() {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	_ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "open")
	s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.reopened"), "")
}

// noteRequestsChanges zet Request changes als de reactie een suggestie bevat.
func (s *Server) noteRequestsChanges(r *http.Request, repo store.Repo, mr store.MergeRequest, userID int64, suggestion string) {
	if suggestion == "" || mr.Status != "open" {
		return
	}
	_ = s.Store.UpsertReview(r.Context(), repo.ID, mr.ID, userID, "changes")
}
