package server

import (
	"net/http"
	"sort"
	"strings"

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

func (s *Server) branches(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	v := s.repoView(w, r, repo, role, "title.branches")
	v.Page = "branches"
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	tips, _ := gitrepo.BranchTips(r.Context(), s.Git, dir)
	patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
	for _, tip := range tips {
		row := BranchRow{
			Name: tip.Name, SHA: tip.SHA, Short: shortSHA(tip.SHA),
			Subject: tip.Subject, When: tip.Date,
			Protected: access.BranchProtected(patterns, tip.Name),
			Default:   tip.Name == repo.DefaultBranch,
		}
		if !row.Default && repo.DefaultBranch != "" {
			ahead, behind, err := gitrepo.AheadBehind(r.Context(), s.Git, dir, repo.DefaultBranch, tip.Name)
			if err == nil {
				row.Ahead, row.Behind = ahead, behind
			}
		}
		if p, err := s.Store.LatestPipelineByCommit(r.Context(), repo.ID, tip.SHA); err == nil {
			jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
			row.PipeID = p.ID
			row.PipeStatus = displayStatus(p.Status, jobs)
			row.PipeLabel = s.tr(r, "pipe."+row.PipeStatus)
		}
		if mrs, err := s.Store.OpenMergeRequestsBySource(r.Context(), repo.ID, tip.Name); err == nil && len(mrs) > 0 {
			row.MRNumber = mrs[0].Number
		}
		v.Branches = append(v.Branches, row)
	}
	sort.Slice(v.Branches, func(i, j int) bool {
		if v.Branches[i].Default != v.Branches[j].Default {
			return v.Branches[i].Default
		}
		return v.Branches[i].Name < v.Branches[j].Name
	})
	tags, _ := gitrepo.Tags(r.Context(), s.Git, dir)
	for _, name := range tags {
		v.Tags = append(v.Tags, TagRow{Name: name})
	}
	s.render(w, "branches", v)
}

func (s *Server) createBranch(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	back := repoURL(repo) + "/-/branches"
	if !role.CanWriteCode() {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	name := strings.TrimSpace(r.FormValue("name"))
	if err := names.ValidBranch(name); err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	from := safeRev(r.FormValue("from"), repo.DefaultBranch)
	if from == "" {
		s.redirect(w, r, back, "", s.tr(r, "err.branches"))
		return
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if gitOne(r.Context(), s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+name) != "" {
		s.redirect(w, r, back, "", s.tr(r, "err.branchName", name))
		return
	}
	if err := s.postReceive(r.Context(), repo, u, dir, func() error {
		return gitrepo.CreateBranch(r.Context(), s.Git, dir, name, from)
	}); err != nil {
		s.redirect(w, r, back, "", s.commitProblem(r, err))
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.branchCreated"), "")
}

func (s *Server) deleteBranch(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	back := repoURL(repo) + "/-/branches"
	if !role.CanWriteCode() {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	name := strings.TrimSpace(r.FormValue("name"))
	if r.FormValue("confirm") != name || name == "" {
		s.redirect(w, r, back, "", s.tr(r, "err.branchConfirm"))
		return
	}
	if locked, text := s.branchLocked(r, repo, name); locked {
		s.redirect(w, r, back, "", text)
		return
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if err := s.postReceive(r.Context(), repo, u, dir, func() error {
		return gitrepo.DeleteBranch(r.Context(), s.Git, dir, name)
	}); err != nil {
		s.redirect(w, r, back, "", s.commitProblem(r, err))
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.branchDeleted"), "")
}

func (s *Server) renameBranch(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	back := repoURL(repo) + "/-/branches"
	if !role.CanWriteCode() {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	name := strings.TrimSpace(r.FormValue("name"))
	newName := strings.TrimSpace(r.FormValue("new_name"))
	if r.FormValue("confirm") != name || name == "" {
		s.redirect(w, r, back, "", s.tr(r, "err.branchConfirm"))
		return
	}
	if err := names.ValidBranch(newName); err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	if locked, text := s.branchLocked(r, repo, name); locked {
		s.redirect(w, r, back, "", text)
		return
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if gitOne(r.Context(), s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+newName) != "" {
		s.redirect(w, r, back, "", s.tr(r, "err.branchName", newName))
		return
	}
	if err := s.postReceive(r.Context(), repo, u, dir, func() error {
		if err := gitrepo.RenameBranch(r.Context(), s.Git, dir, name, newName); err != nil {
			return err
		}
		return s.Store.RenameOpenMRBranches(r.Context(), repo.ID, name, newName)
	}); err != nil {
		s.redirect(w, r, back, "", s.commitProblem(r, err))
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.branchRenamed"), "")
}

// branchLocked weigert de standaardbranch en elke beschermde branch, ook voor een beheerder.
func (s *Server) branchLocked(r *http.Request, repo store.Repo, name string) (bool, string) {
	if name == repo.DefaultBranch {
		return true, s.tr(r, "err.branchLocked", name)
	}
	patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
	if access.BranchProtected(patterns, name) {
		return true, s.tr(r, "err.branchLocked", name)
	}
	return false, ""
}
