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/store"
)

func (s *Server) guard(w http.ResponseWriter, r *http.Request, min access.Role) (store.User, store.Repo, access.Role, bool) {
	owner := r.PathValue("owner")
	name := strings.TrimSuffix(r.PathValue("repo"), ".git")
	repo, err := s.Store.RepoByPath(r.Context(), owner, name)
	if err != nil {
		http.NotFound(w, r)
		return store.User{}, store.Repo{}, "", false
	}
	p := s.who(r)
	var role access.Role
	if p.OK {
		role, err = s.Store.EffectiveRole(r.Context(), p.User.ID, repo.ID)
		if err != nil {
			http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError)
			return store.User{}, store.Repo{}, "", false
		}
	}
	if isCrawler(r) {
		p = principal{}
		role = access.RoleNone
	}
	readable := role.CanRead() || repo.Visibility == "public"
	if !readable {
		if isCrawler(r) {
			s.writeLockedCard(w, r)
		} else if p.OK {
			http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		} else {
			http.NotFound(w, r)
		}
		return store.User{}, store.Repo{}, "", false
	}
	if min != access.RoleReadonly && !role.AtLeast(min) {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return store.User{}, store.Repo{}, "", false
	}
	return p.User, repo, role, true
}

func (s *Server) repoView(w http.ResponseWriter, r *http.Request, repo store.Repo, role access.Role, title string) View {
	v := s.view(w, r, title)
	v.Repo = &repo
	v.Role = role
	v.CanWrite = role.CanWriteCode()
	v.CanAdmin = role.CanManageSettings()
	v.Rev = safeRev(r.URL.Query().Get("rev"), repo.DefaultBranch)
	v.CloneHTTP = strings.TrimRight(s.Cfg.BaseURL, "/") + "/" + repo.FullPath() + ".git"
	v.CloneSSH = s.Cfg.CloneSSH(repo.FullPath())
	return v
}

func (s *Server) repoHome(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, repo.Name)
	v.Wide = true
	s.fillOverview(r, &v, repo)
	v.Heat = s.heatmap(r.Context(), 0, []int64{repo.ID}, s.langOf(r))
	s.render(w, "repo", v)
}

func (s *Server) treeRoot(w http.ResponseWriter, r *http.Request) {
	r.SetPathValue("path", "")
	s.tree(w, r)
}

func (s *Server) tree(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	rel, err := cleanRel(r.PathValue("path"))
	if err != nil {
		http.NotFound(w, r)
		return
	}
	v := s.repoView(w, r, repo, role, rel)
	v.Wide = true
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if _, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, rel); err != nil && rel != "" {
		http.NotFound(w, r)
		return
	}
	s.fillFiles(r, &v, repo, rel, false)
	s.render(w, "files", v)
}

func (s *Server) blob(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	rel, err := cleanRel(r.PathValue("path"))
	if err != nil || rel == "" {
		http.NotFound(w, r)
		return
	}
	v := s.repoView(w, r, repo, role, rel)
	v.Wide = true
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if _, _, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, rel, 1); err != nil {
		http.NotFound(w, r)
		return
	}
	s.fillFiles(r, &v, repo, rel, true)
	s.render(w, "files", v)
}

func (s *Server) commits(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.commits")
	v.Page = "commits"
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	list, _ := gitrepo.Log(r.Context(), s.Git, dir, v.Rev, 50)
	v.Commits = s.presentCommits(r.Context(), repo.ID, list, i18n.Parse(v.Lang))
	s.render(w, "commits", v)
}

func (s *Server) commit(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	sha := r.PathValue("sha")
	if !safeSHA(sha) {
		http.NotFound(w, r)
		return
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	c, err := gitrepo.Show(r.Context(), s.Git, dir, sha)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	v := s.repoView(w, r, repo, role, c.Subject)
	v.Page = "commit"
	v.Wide = true
	lang := i18n.Parse(v.Lang)
	rows := s.presentCommits(r.Context(), repo.ID, []gitrepo.Commit{c}, lang)
	s.attachHeadPipeline(r.Context(), repo, &rows[0], lang)
	v.Commit = &rows[0]
	parents, files, err := gitrepo.CommitPatch(r.Context(), s.Git, dir, c.SHA)
	if err != nil && s.Log != nil {
		s.Log.Warn("commitdiff", "sha", c.SHA, "err", err)
	}
	v.CommitDiff = presentCommitDiff(repo.FullPath(), c.SHA, parents, files)
	s.render(w, "commit", v)
}

func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	s.absorbMergedMRs(r.Context(), repo)
	v := s.repoView(w, r, repo, role, "title.mrs")
	v.Page = "mrs"
	v.MRs, _ = s.Store.ListMergeRequests(r.Context(), repo.ID)
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
	for _, name := range names {
		v.Branches = append(v.Branches, BranchRow{Name: name})
	}
	s.render(w, "mrs", v)
}

func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	source := safeRev(r.FormValue("source"), "")
	target := safeRev(r.FormValue("target"), repo.DefaultBranch)
	desc := desctpl.Expand(r.FormValue("description"), s.mrVars(r, repo, source, target))
	mr, err := s.opCreateMR(r.Context(), u, repo, r.FormValue("title"), desc, source, target, r.FormValue("draft") == "1")
	if err == nil {
		err = s.Store.SetMergeOptions(r.Context(), mr.ID, r.FormValue("remove_source_branch") == "1", r.FormValue("squash") == "1", r.FormValue("squash_commit_message"))
	}
	if !s.uiOK(w, r, repoURL(repo)+"/-/merge-requests", err) {
		return
	}
	num := strconv.FormatInt(mr.Number, 10)
	s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+num, s.tr(r, "flash.mrOpened"), "")
}

func (s *Server) showMR(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	s.absorbMergedMRs(r.Context(), repo)
	n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	v := s.repoView(w, r, repo, role, mr.Title)
	v.Page = "mr"
	v.MR = &mr
	v.Wide = true
	patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
	v.CanComment = role.AtLeast(access.RoleReadonly)
	v.CanMerge = mr.Status == "open" && role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch))
	v.CanApply = mr.Status == "open" && role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch))
	v.MergeBlocks = s.mergeBlocks(r, repo, mr)
	v.CanForce = v.CanMerge && role.CanManageSettings() && len(v.MergeBlocks) > 0
	s.fillMRPipeline(r, &v, repo, mr)
	s.fillReviews(r, &v, repo, mr, role)
	if u.ID != 0 {
		mine := u.ID == mr.AuthorID || role.CanManageSettings()
		v.CanClose = mr.Status == "open" && mine
		v.CanReopen = mr.Status == "closed" && mine
	}
	s.finishMR(r, &v, repo, mr, u)
	s.render(w, "mr", v)
}

func (s *Server) createNote(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
	parent, _ := strconv.ParseInt(r.FormValue("parent"), 10, 64)
	start, _ := strconv.Atoi(r.FormValue("line_start"))
	end, _ := strconv.Atoi(r.FormValue("line_end"))
	if _, err := s.opAddNote(r, u, repo, n, r.FormValue("body"), r.FormValue("path"), start, end, parent); !s.uiOK(w, r, back, err) {
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.note"), "")
}

func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
	out, err := s.opMergeMR(r, u, repo, n, formMergeChoice(r))
	if !s.uiOK(w, r, back, err) {
		return
	}
	notice := s.tr(r, out.Notice)
	if out.Arg != "" {
		notice = s.tr(r, out.Notice, out.Arg)
	}
	s.redirect(w, r, back, notice, "")
}

func formMergeChoice(r *http.Request) mergeChoice {
	remove := r.FormValue("remove_source_branch") == "1"
	squash := r.FormValue("squash") == "1"
	message := r.FormValue("squash_commit_message")
	return mergeChoice{
		FromForm: true,
		Remove:   &remove,
		Squash:   &squash,
		Message:  &message,
		Force:    r.FormValue("force") == "1",
		Confirm:  r.FormValue("confirm_force") == "1",
	}
}

func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
	if !s.uiOK(w, r, back, s.opCloseMR(r.Context(), u, repo, n, false)) {
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.closed"), "")
}

func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {
	n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
	if err != nil {
		return store.MergeRequest{}, err
	}
	return s.Store.MergeRequestByNumber(r.Context(), repoID, n)
}

func (s *Server) pipelines(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	if id := strings.TrimSpace(r.URL.Query().Get("show")); id != "" {
		if n, err := strconv.ParseInt(id, 10, 64); err == nil && n > 0 {
			http.Redirect(w, r, repoURL(repo)+"/-/pipelines/"+id, http.StatusSeeOther)
			return
		}
	}
	v := s.repoView(w, r, repo, role, "title.pipelines")
	v.Wide = true
	v.Page = "pipelines"
	s.fillPipelines(r, &v, repo)
	if wantsJSON(r) {
		s.writePipeList(w, v)
		return
	}
	s.render(w, "pipelines", v)
}

func (s *Server) pipeline(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	v := s.repoView(w, r, repo, role, "title.pipeline")
	v.Wide = true
	v.Page = "pipelines"
	v.Pipe = &p
	jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
	v.Jobs = jobs
	ranks := s.queueRanks(r.Context())
	tr := func(key string, args ...any) string { return s.tr(r, key, args...) }
	v.PipeStatus = displayStatus(p.Status, jobs)
	v.PipeLabel = tr("pipe." + v.PipeStatus)
	v.PipeSource = s.pipelineSourceText(r, repo, p)
	v.PipeJobs = linksFor(jobs, ranks, tr)
	v.PipeStages = stageViews(jobs, ranks, tr)
	v.Live = jobsLive(p.Status, jobs)
	v.LiveURL = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(p.ID, 10)
	if wantsJSON(r) {
		s.writePipeDetail(w, v)
		return
	}
	s.render(w, "pipeline", v)
}

func (s *Server) runPipeline(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if _, err := s.opRunPipeline(r.Context(), u, repo, r.FormValue("ref"), "web"); !s.uiOK(w, r, repoURL(repo)+"/-/pipelines", err) {
		return
	}
	s.redirect(w, r, repoURL(repo)+"/-/pipelines", s.tr(r, "flash.pipeline"), "")
}

func (s *Server) releases(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.releases")
	v.Page = "releases"
	v.Wide = true
	v.Releases, _ = s.Store.ListReleases(r.Context(), repo.ID)
	s.render(w, "releases", v)
}

func (s *Server) createRepo(w http.ResponseWriter, r *http.Request) {
	u, ok := s.loginRequired(w, r)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	repo, err := s.opCreateRepo(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("group"), r.FormValue("visibility"), false)
	if err != nil {
		if statusOf(err) == http.StatusForbidden {
			http.Error(w, s.trErr(r, err), http.StatusForbidden)
			return
		}
		s.failCreate(w, r, s.trErr(r, err))
		return
	}
	s.finishCreate(w, r, repoURL(repo), s.tr(r, "flash.repoCreated"))
}

func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) {
	u, ok := s.loginRequired(w, r)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	g, err := s.opCreateGroup(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("default_role"))
	if err != nil {
		s.failCreate(w, r, s.trErr(r, err))
		return
	}
	s.finishCreate(w, r, "/groups/"+g.Path, s.tr(r, "flash.groupCreated"))
}

func toEntries(base string, in []gitrepo.Entry) []EntryRow {
	var out []EntryRow
	for _, e := range in {
		p := e.Name
		if base != "" {
			p = base + "/" + e.Name
		}
		out = append(out, EntryRow{Name: e.Name, Type: e.Type, Path: p})
	}
	return out
}

func cleanRel(p string) (string, error) {
	p = strings.TrimPrefix(p, "/")
	if p == "" || p == "." {
		return "", nil
	}
	if strings.HasPrefix(p, "/") || strings.Contains(p, "\\") || strings.Contains(p, "..") {
		return "", errBadID
	}
	return p, nil
}

func safeRev(s, fallback string) string {
	if s == "" {
		return fallback
	}
	if strings.HasPrefix(s, "-") || strings.Contains(s, "..") || strings.ContainsAny(s, " \t\n~^:?*[\\") {
		return fallback
	}
	return s
}

func safeSHA(s string) bool {
	if len(s) < 7 || len(s) > 64 {
		return false
	}
	for _, c := range s {
		if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
			return false
		}
	}
	return true
}
