package server

import (
	"context"
	"encoding/json"
	"errors"
	"net/http"
	"sort"
	"strconv"
	"strings"

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

func (s *Server) settings(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.settings")
	v.Page = "settings"
	v.Wide = true
	v.Tab = settingsTab(r.URL.Query().Get("tab"))
	if role.CanManageSettings() {
		v.Members, _ = s.Store.ListMembers(r.Context(), "repo", repo.ID)
		if repo.OwnerKind == "user" {
			owner, err := s.Store.UserByID(r.Context(), repo.OwnerID)
			if err == nil {
				v.Members = append([]store.Member{{UserID: owner.ID, Username: owner.Username, Role: access.RoleMaintainer}}, v.Members...)
			}
		}
		v.Secrets, _ = s.Store.ListSecrets(r.Context(), "repo", repo.ID)
		v.Inherited = s.inheritedSecrets(r.Context(), repo)
		v.HookSecrets = s.repoSecretChoices(r, repo)
		v.Patterns, _ = s.Store.ProtectedPatterns(r.Context(), repo.ID)
		v.TagPatterns, _ = s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
		v.Hooks = s.hookViews(r, "repo", repo.ID)
		v.HookTargets = s.hookTargets(r)
		s.fillHookEdit(r, &v, "repo", repo.ID)
		s.fillApproval(r, &v, repo)
		v.StaleDays, _ = s.Store.RepoStaleManualDays(r.Context(), repo.ID)
		v.StaleDaysDefault, _ = s.Store.StaleManualDays(r.Context())
	}
	s.render(w, "settings", v)
}

func (s *Server) hookViews(r *http.Request, kind string, id int64) []HookView {
	hooks, err := s.Store.ListWebhooks(r.Context(), kind, id)
	if err != nil {
		return nil
	}
	lang := s.langOf(r)
	var out []HookView
	for _, h := range hooks {
		d, _ := s.Store.RecentDeliveries(r.Context(), h.ID)
		out = append(out, HookView{
			ID: h.ID, Name: h.Name, Preset: h.Preset, URL: h.URLTemplate, Method: h.Method,
			Filter: h.BranchFilter, Events: strings.Join(h.Events, ", "),
			Badges: eventBadges(lang, h.Events), Deliveries: d,
		})
	}
	return out
}

func eventBadges(lang i18n.Lang, events []string) []string {
	var out []string
	for _, e := range events {
		key := ""
		switch e {
		case webhook.EventPush:
			key = "set.ev.push"
		case webhook.EventMergeRequest:
			key = "set.ev.mr"
		case webhook.EventPipelineSuccess:
			key = "set.ev.ok"
		case webhook.EventPipelineFailure:
			key = "set.ev.fail"
		case webhook.EventRelease:
			key = "set.ev.release"
		}
		if key == "" {
			out = append(out, e)
			continue
		}
		out = append(out, i18n.T(lang, key))
	}
	return out
}

func (s *Server) fillHookEdit(r *http.Request, v *View, kind string, id int64) {
	if kind == "repo" && v.Tab != "webhooks" {
		return
	}
	if kind == "group" && v.Tab != "settings" {
		return
	}
	raw := strings.TrimSpace(r.URL.Query().Get("hook"))
	if raw == "" {
		return
	}
	hid, err := strconv.ParseInt(raw, 10, 64)
	if err != nil || hid <= 0 {
		return
	}
	h, err := s.Store.Webhook(r.Context(), kind, id, hid)
	if err != nil {
		return
	}
	v.HookEdit = draftFrom(h)
	if v.HookEdit.Token != "" {
		v.HookSecrets = keepToken(v.HookSecrets, v.HookEdit.Token)
	}
}

func keepToken(in []SecretChoice, name string) []SecretChoice {
	for _, c := range in {
		if c.Name == name {
			return in
		}
	}
	return append(in, SecretChoice{Name: name, Label: name})
}

func draftFrom(h store.Webhook) HookDraft {
	d := HookDraft{
		ID: h.ID, Name: h.Name, Preset: h.Preset, Filter: h.BranchFilter, Method: h.Method,
	}
	var in webhook.Input
	if h.Fields != "" && json.Unmarshal([]byte(h.Fields), &in) == nil {
		d.URL, d.Username, d.Avatar, d.Icon, d.Alias = in.URL, in.Username, in.Avatar, in.Icon, in.Alias
		d.Token, d.Chat, d.Server, d.Topic = in.Token, in.Chat, in.Server, in.Topic
		d.Home, d.Room, d.CType, d.Headers, d.Body = in.Homeserver, in.Room, in.ContentType, in.Headers, in.Body
		if in.Method != "" {
			d.Method = in.Method
		}
	} else {
		d.URL = h.URLTemplate
		d.Body = h.BodyTemplate
		d.Headers = headerLines(h.Headers)
		d.CType = h.Headers["Content-Type"]
	}
	for _, e := range h.Events {
		switch e {
		case webhook.EventPush:
			d.OnPush = true
		case webhook.EventMergeRequest:
			d.OnMR = true
		case webhook.EventPipelineSuccess:
			d.OnOK = true
		case webhook.EventPipelineFailure:
			d.OnFail = true
		case webhook.EventRelease:
			d.OnRel = true
		case webhook.EventIssue:
			d.OnIssue = true
		}
	}
	d.Extra = hookEventChoices(h.Events)
	if d.Preset == "" {
		d.Preset = webhook.PresetCustom
	}
	if d.Method == "" {
		d.Method = "POST"
	}
	return d
}

func headerLines(h map[string]string) string {
	if len(h) == 0 {
		return ""
	}
	keys := make([]string, 0, len(h))
	for k := range h {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	var b strings.Builder
	for i, k := range keys {
		if i > 0 {
			b.WriteByte('\n')
		}
		b.WriteString(k)
		b.WriteString(": ")
		b.WriteString(h[k])
	}
	return b.String()
}

func (s *Server) updateRepo(w http.ResponseWriter, r *http.Request) {
	_, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if err := s.opUpdateRepo(r.Context(), s.who(r).User, repo, r.FormValue("description"), r.FormValue("visibility")); err != nil {
		s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err))
		return
	}
	if rv := r.FormValue("release_visibility"); rv != "" {
		if err := s.opSetReleaseVisibility(r.Context(), s.who(r).User, repo, rv); err != nil {
			s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err))
			return
		}
	}
	if err := s.opSetRepoCIPaused(r.Context(), s.who(r).User, repo, r.FormValue("ci_paused") == "1"); err != nil {
		s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err))
		return
	}
	if sd := strings.TrimSpace(r.FormValue("stale_manual_days")); sd != "" || r.Form.Has("stale_manual_days") {
		n := -1
		if sd != "" {
			v, err := strconv.Atoi(sd)
			if err != nil {
				s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.tr(r, "stale.err.days"))
				return
			}
			n = v
		}
		if err := s.Store.SetRepoStaleManualDays(r.Context(), repo.ID, n); err != nil {
			s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.tr(r, "stale.err.days"))
			return
		}
	}
	s.redirect(w, r, repoURL(repo)+"/-/settings", s.tr(r, "flash.saved"), "")
}

func (s *Server) repoMember(w http.ResponseWriter, r *http.Request) {
	s.memberPost(w, r, "repo")
}

func (s *Server) repoMemberRemove(w http.ResponseWriter, r *http.Request) {
	s.memberRemove(w, r, "repo")
}

func (s *Server) groupMember(w http.ResponseWriter, r *http.Request) {
	s.memberPost(w, r, "group")
}

func (s *Server) groupMemberRemove(w http.ResponseWriter, r *http.Request) {
	s.memberRemove(w, r, "group")
}

func (s *Server) memberPost(w http.ResponseWriter, r *http.Request, kind string) {
	scopeID, back, ok := s.adminScope(w, r, kind)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if err := s.opSetMember(r.Context(), s.who(r).User, kind, scopeID, r.FormValue("username"), r.FormValue("role")); err != nil {
		s.redirect(w, r, back, "", s.commitProblem(r, err))
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.memberSaved"), "")
}

func (s *Server) memberRemove(w http.ResponseWriter, r *http.Request, kind string) {
	scopeID, back, ok := s.adminScope(w, r, kind)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if err := s.opRemoveMember(r.Context(), s.who(r).User, kind, scopeID, r.FormValue("username")); err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.memberRemoved"), "")
}

func (s *Server) adminScope(w http.ResponseWriter, r *http.Request, kind string) (int64, string, bool) {
	if kind == "group" {
		g, role, ok := s.guardGroup(w, r, access.RoleMaintainer)
		if !ok {
			return 0, "", false
		}
		_ = role
		return g.ID, "/groups/" + g.Path + "?tab=members", true
	}
	_, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
	if !ok {
		return 0, "", false
	}
	return repo.ID, repoURL(repo) + "/-/settings?tab=members", true
}

func (s *Server) addProtected(w http.ResponseWriter, r *http.Request) {
	_, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if err := s.opProtect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), false); err != nil {
		s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", s.tr(r, "flash.branchOn"), "")
}

func (s *Server) removeProtected(w http.ResponseWriter, r *http.Request) {
	_, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	_ = s.opUnprotect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), false)
	s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", s.tr(r, "flash.patternOff"), "")
}

func (s *Server) repoSecret(w http.ResponseWriter, r *http.Request) {
	s.secretPost(w, r, "repo")
}
func (s *Server) repoSecretDelete(w http.ResponseWriter, r *http.Request) {
	s.secretDelete(w, r, "repo")
}
func (s *Server) groupSecret(w http.ResponseWriter, r *http.Request) {
	s.secretPost(w, r, "group")
}
func (s *Server) groupSecretDelete(w http.ResponseWriter, r *http.Request) {
	s.secretDelete(w, r, "group")
}

// secretScope laat alleen een maintainer secrets bekijken of bewerken, ook protected.
func (s *Server) secretScope(w http.ResponseWriter, r *http.Request, kind string) (int64, string, bool) {
	if kind == "group" {
		g, role, ok := s.guardGroup(w, r, access.RoleReadonly)
		if !ok {
			return 0, "", false
		}
		if !role.CanManageSecrets() {
			http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden)
			return 0, "", false
		}
		return g.ID, "/groups/" + g.Path + "?tab=settings#secrets", true
	}
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return 0, "", false
	}
	if !role.CanManageSecrets() {
		http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden)
		return 0, "", false
	}
	return repo.ID, repoURL(repo) + "/-/settings?tab=secrets", true
}

func (s *Server) secretPost(w http.ResponseWriter, r *http.Request, kind string) {
	scopeID, back, ok := s.secretScope(w, r, kind)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	name := strings.TrimSpace(r.FormValue("name"))
	value := r.FormValue("value")
	protected := r.FormValue("protected") == "1"
	flash := "flash.secretSaved"
	var err error
	switch r.FormValue("mode") {
	case "update":
		err = s.Store.UpdateSecret(r.Context(), kind, scopeID, name, value, protected)
	case "replace":
		err = s.Store.ReplaceSecret(r.Context(), kind, scopeID, name, value, protected)
		flash = "flash.secretReplaced"
	default:
		err = s.Store.CreateSecret(r.Context(), kind, scopeID, name, value, protected, r.FormValue("invisible") == "1")
	}
	if err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	_ = s.Store.SetSecretExpand(r.Context(), kind, scopeID, name, r.FormValue("expand") == "1")
	s.redirect(w, r, back, s.tr(r, flash), "")
}

func (s *Server) repoSecretReveal(w http.ResponseWriter, r *http.Request) {
	s.secretReveal(w, r, "repo")
}

func (s *Server) groupSecretReveal(w http.ResponseWriter, r *http.Request) {
	s.secretReveal(w, r, "group")
}

func (s *Server) secretReveal(w http.ResponseWriter, r *http.Request, kind string) {
	scopeID, _, ok := s.secretScope(w, r, kind)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	value, err := s.Store.RevealSecret(r.Context(), kind, scopeID, strings.TrimSpace(r.FormValue("name")))
	w.Header().Set("Content-Type", "application/json")
	if err != nil {
		s.writeSecretJSONErr(w, r, err)
		return
	}
	_ = json.NewEncoder(w).Encode(map[string]string{"value": value})
}

func (s *Server) writeSecretJSONErr(w http.ResponseWriter, r *http.Request, err error) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(secretStatus(err))
	_ = json.NewEncoder(w).Encode(map[string]string{"error": s.trErr(r, err)})
}

func secretStatus(err error) int {
	if store.Missing(err) {
		return http.StatusNotFound
	}
	var ie i18n.Error
	if errors.As(err, &ie) {
		switch ie.Key {
		case "err.secretHidden":
			return http.StatusForbidden
		case "err.secretExists", "err.secretVisible":
			return http.StatusConflict
		}
	}
	return http.StatusBadRequest
}

func (s *Server) secretDelete(w http.ResponseWriter, r *http.Request, kind string) {
	scopeID, back, ok := s.secretScope(w, r, kind)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	_ = s.Store.DeleteSecret(r.Context(), kind, scopeID, r.FormValue("name"))
	s.redirect(w, r, back, s.tr(r, "flash.secretRemoved"), "")
}

func (s *Server) repoWebhook(w http.ResponseWriter, r *http.Request) { s.webhookPost(w, r, "repo") }
func (s *Server) repoWebhookDelete(w http.ResponseWriter, r *http.Request) {
	s.webhookDelete(w, r, "repo")
}
func (s *Server) groupWebhook(w http.ResponseWriter, r *http.Request) {
	s.webhookPost(w, r, "group")
}
func (s *Server) groupWebhookDelete(w http.ResponseWriter, r *http.Request) {
	s.webhookDelete(w, r, "group")
}

func (s *Server) webhookPost(w http.ResponseWriter, r *http.Request, kind string) {
	scopeID, back, ok := s.adminScope(w, r, kind)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks")
	if kind == "group" {
		back += "#webhooks"
	}
	var events []string
	for _, e := range webhook.AllEvents() {
		if r.FormValue("event_"+e) == "1" {
			events = append(events, e)
		}
	}
	id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
	_, err := s.saveWebhookRecord(r.Context(), kind, scopeID, id, strings.TrimSpace(r.FormValue("name")), r.FormValue("preset"), r.FormValue("branch_filter"), events, webhook.Input{
		URL: r.FormValue("url"), Username: r.FormValue("username"), Avatar: r.FormValue("avatar"),
		Icon: r.FormValue("icon"), Alias: r.FormValue("alias"), Token: r.FormValue("token"),
		Chat: r.FormValue("chat"), Server: r.FormValue("server"), Topic: r.FormValue("topic"),
		Homeserver: r.FormValue("homeserver"), Room: r.FormValue("room"),
		Method: r.FormValue("method"), ContentType: r.FormValue("content_type"),
		Headers: r.FormValue("headers"), Body: r.FormValue("body"),
	})
	if err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.webhookSaved"), "")
}

func (s *Server) createWebhookRecord(ctx context.Context, kind string, scopeID int64, name, preset, filter string, events []string, in webhook.Input) (int64, error) {
	return s.saveWebhookRecord(ctx, kind, scopeID, 0, name, preset, filter, events, in)
}

func (s *Server) saveWebhookRecord(ctx context.Context, kind string, scopeID, id int64, name, preset, filter string, events []string, in webhook.Input) (int64, error) {
	if !webhook.KnownPreset(preset) {
		return 0, i18n.E("err.preset")
	}
	filter = strings.TrimSpace(filter)
	if _, err := webhook.MatchBranch(filter, "main"); err != nil {
		return 0, err
	}
	if len(events) == 0 {
		return 0, i18n.E("err.pickEvent")
	}
	spec, err := webhook.Prepare(preset, in)
	if err != nil {
		return 0, err
	}
	raw, err := json.Marshal(in)
	if err != nil {
		return 0, err
	}
	rec := store.Webhook{
		ID: id, ScopeKind: kind, ScopeID: scopeID, Name: name,
		Preset: preset, URLTemplate: spec.URL, Headers: spec.Headers,
		BodyTemplate: spec.Body, Events: events, BranchFilter: filter, Method: spec.Method,
		Fields: string(raw),
	}
	if id > 0 {
		if err := s.Store.UpdateWebhook(ctx, rec); err != nil {
			return 0, err
		}
		return id, nil
	}
	return s.Store.CreateWebhook(ctx, rec)
}

func (s *Server) webhookDelete(w http.ResponseWriter, r *http.Request, kind string) {
	scopeID, back, ok := s.adminScope(w, r, kind)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks")
	id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
	_ = s.opDeleteWebhook(r.Context(), s.who(r).User, kind, scopeID, id)
	s.redirect(w, r, back, s.tr(r, "flash.webhookRemoved"), "")
}

func (s *Server) deleteRepo(w http.ResponseWriter, r *http.Request) {
	_, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	u := s.who(r).User
	if err := s.opDeleteRepo(r.Context(), u, repo, r.FormValue("confirm"), false); err != nil {
		s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err))
		return
	}
	s.redirect(w, r, "/", s.tr(r, "flash.repoDeleted"), "")
}

func (s *Server) deleteGroup(w http.ResponseWriter, r *http.Request) {
	g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if err := s.opDeleteGroup(r.Context(), s.who(r).User, g, r.FormValue("confirm")); err != nil {
		s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.commitProblem(r, err))
		return
	}
	s.redirect(w, r, "/", s.tr(r, "flash.groupDeleted"), "")
}

func (s *Server) guardGroup(w http.ResponseWriter, r *http.Request, min access.Role) (store.Group, access.Role, bool) {
	g, err := s.Store.GroupByPath(r.Context(), r.PathValue("path"))
	if err != nil {
		http.NotFound(w, r)
		return store.Group{}, "", false
	}
	p := s.who(r)
	var role access.Role
	if p.OK {
		role, err = s.Store.GroupRole(r.Context(), g.ID, p.User.ID)
		if err != nil {
			http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError)
			return store.Group{}, "", false
		}
	}
	if isCrawler(r) {
		p = principal{}
		role = access.RoleNone
	}
	if min == access.RoleReadonly {
		if role.CanRead() || g.Visibility == "public" {
			return g, role, true
		}
		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.Group{}, "", false
	}
	if !p.OK {
		http.Redirect(w, r, "/login", http.StatusFound)
		return store.Group{}, "", false
	}
	if !role.AtLeast(min) {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return store.Group{}, "", false
	}
	return g, role, true
}

func (s *Server) groupPage(w http.ResponseWriter, r *http.Request) {
	g, role, ok := s.guardGroup(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	v := s.view(w, r, g.Name)
	v.Wide = true
	v.Group = &g
	v.Role = role
	v.CanAdmin = role.CanManageSettings()
	tab := r.URL.Query().Get("tab")
	switch tab {
	case "members":
		if !role.CanRead() {
			tab = ""
		}
	case "settings":
		if !role.CanManageSettings() {
			tab = ""
		}
	default:
		tab = ""
	}
	v.Tab = tab
	all, _ := s.Store.ReposByGroup(r.Context(), g.ID) // laatste push eerst
	uid := int64(0)
	if v.User != nil {
		uid = v.User.ID
	}
	var repos []store.Repo
	for _, repo := range all {
		if repo.Visibility == "public" {
			repos = append(repos, repo)
			continue
		}
		if uid == 0 {
			continue
		}
		er, err := s.Store.EffectiveRole(r.Context(), uid, repo.ID)
		if err == nil && er.CanRead() {
			repos = append(repos, repo)
		}
	}
	q := strings.TrimSpace(r.URL.Query().Get("q"))
	dir := r.URL.Query().Get("dir")
	if dir != "desc" {
		dir = "asc"
	}
	by := r.URL.Query().Get("sort")
	if by != "name" {
		by = "pushed"
	}
	v.Query, v.SortDir, v.SortBy = q, dir, by
	if dir == "desc" {
		v.FlipDir = "asc"
	} else {
		v.FlipDir = "desc"
	}
	if lq := strings.ToLower(q); lq != "" {
		var filtered []store.Repo
		for _, repo := range repos {
			if strings.Contains(strings.ToLower(repo.Name), lq) {
				filtered = append(filtered, repo)
			}
		}
		repos = filtered
	}
	if by == "pushed" {
		store.SortReposByPush(repos)
	} else {
		sort.Slice(repos, func(i, j int) bool {
			a, b := strings.ToLower(repos[i].Name), strings.ToLower(repos[j].Name)
			if dir == "desc" {
				return a > b
			}
			return a < b
		})
	}
	lang := s.langOf(r)
	v.Cards = s.repoCards(r.Context(), uid, repos, lang)
	v.Repos = repos
	v.GroupRepoCount = len(all)
	v.Heat = s.heatmap(r.Context(), 0, s.visibleIDs(r.Context(), uid, repos), lang)
	if tab == "members" && role.CanRead() {
		v.Members, _ = s.Store.ListMembers(r.Context(), "group", g.ID)
	}
	if tab == "settings" && role.CanManageSettings() {
		v.Members, _ = s.Store.ListMembers(r.Context(), "group", g.ID)
		v.Secrets, _ = s.Store.ListSecrets(r.Context(), "group", g.ID)
		v.HookSecrets = s.groupSecretChoices(r, g)
		v.Hooks = s.hookViews(r, "group", g.ID)
		v.HookTargets = s.hookTargets(r)
		s.fillHookEdit(r, &v, "group", g.ID)
		s.fillGroupApproval(r, &v, g)
		s.fillGroupRunners(w, r, &v, g)
		if v.User != nil && v.User.ID == g.OwnerID {
			v.IsOwner = true
			v.Candidates = groupCandidates(v.Members, g.OwnerID)
		}
	}
	s.render(w, "group", v)
}

func settingsTab(tab string) string {
	switch tab {
	case "leden", "members":
		return "members"
	case "geheimen", "secrets":
		return "secrets"
	case "branches":
		return "branches"
	case "tags":
		return "tags"
	case "webhooks":
		return "webhooks"
	case "approvals":
		return "approvals"
	default:
		return "general"
	}
}

func scopeTab(kind, repoTab string) string {
	if kind == "group" {
		if repoTab == "members" {
			return "?tab=members"
		}
		return "?tab=settings"
	}
	return "?tab=" + repoTab
}

// hookEventChoices zet de fijnere events klaar voor het formulier.
func hookEventChoices(selected []string) []HookEventChoice {
	on := map[string]bool{}
	for _, e := range selected {
		on[e] = true
	}
	var out []HookEventChoice
	for _, e := range webhook.SpecificEvents() {
		out = append(out, HookEventChoice{Name: e, Key: "set.ev." + e, On: on[e]})
	}
	return out
}

// pushedLabel is de korte tekst bij de laatste push van een repo.
func pushedLabel(lang i18n.Lang, repo store.Repo) string {
	if repo.PushedAt.IsZero() {
		return i18n.T(lang, "repo.neverPushed")
	}
	return i18n.T(lang, "repo.pushedAt", i18n.FormatDate(lang, repo.PushedAt))
}
