// Package server is de webinterface, de git-HTTP-server en de API.
package server

import (
	"context"
	"crypto/rand"
	"embed"
	"encoding/hex"
	"fmt"
	"gitlab.com/Timfa/bluegit/internal/langpick"
	"gitlab.com/Timfa/bluegit/internal/readcache"
	"gitlab.com/Timfa/bluegit/internal/runnercfg"
	"html/template"
	"io/fs"
	"log/slog"
	"net/http"
	"net/url"
	"strings"
	"sync"
	"time"
	"unicode/utf8"

	"gitlab.com/Timfa/bluegit/internal/access"
	"gitlab.com/Timfa/bluegit/internal/activity"
	"gitlab.com/Timfa/bluegit/internal/auth"
	"gitlab.com/Timfa/bluegit/internal/backup"
	"gitlab.com/Timfa/bluegit/internal/card"
	"gitlab.com/Timfa/bluegit/internal/cispec"
	"gitlab.com/Timfa/bluegit/internal/config"
	"gitlab.com/Timfa/bluegit/internal/gitgraph"
	"gitlab.com/Timfa/bluegit/internal/i18n"
	"gitlab.com/Timfa/bluegit/internal/realip"
	"gitlab.com/Timfa/bluegit/internal/runner"
	"gitlab.com/Timfa/bluegit/internal/store"
)

//go:embed templates/*.html static/*.css static/*.js static/*.svg static/*.ttf static/*.txt
var webFS embed.FS

// Server bedient BlueGit.
type Server struct {
	Cfg     config.Config
	Store   *store.Store
	Auth    auth.Provider
	Mail    auth.Mailer
	Dev     bool
	Git     string
	HookBin string
	Runner  *runner.Runner
	Log     *slog.Logger
	// hookSink vangt de JSON-body af in tests, vóór het HTTP-verzoek.
	hookSink func([]byte)
	// StateDir is de map met database en het bestand storage_path.
	StateDir string
	// AfterStorage krijgt het nieuwe datadisk-pad, voor runner en SSH.
	AfterStorage func(path string)
	// UpdateStarter start bluegit-update.service. Nil gebruikt systemctl.
	UpdateStarter UpdateStarter
	updateHits    updateLimiter
	tmpl          *template.Template
	byLang        map[string]*template.Template

	storageMu  sync.RWMutex
	storage    string
	storageSet bool
	usageMu    sync.Mutex
	usage      dirUsage
	usageDone  chan struct{}
	cards      *card.Cache
	// mergingMR zijn merge requests die opMergeMR nu zelf afrondt.
	// AfterPush mag hun bronbranch niet alvast verwijderen.
	mergingMR sync.Map

	cacheMu sync.RWMutex
	rcache  *readcache.Cache

	graphOnce  sync.Once
	graphCache *gitgraph.Cache

	gitMaint gitMaintState

	// RequestRestart herstart het proces (main: opnieuw exec'en). Nodig na
	// het uitpakken van een backup. Nil: alleen bij de volgende start.
	RequestRestart func()
	backupOnce     sync.Once
	backupMgr      *backup.Manager
	backupNote     *backup.Notifier
	backupHTTP     *http.Client
	restoring      sync.Mutex
}

type principal struct {
	User    store.User
	Session store.Session
	OK      bool
}

type ctxKey struct{}

// Handler is de HTTP-handler met sessies en koppen.
func (s *Server) Handler() http.Handler {
	s.mustTemplates()
	mux := http.NewServeMux()
	mux.HandleFunc("GET /assets/{file}", s.asset)
	mux.HandleFunc("GET /-/info", s.infoPage)
	mux.HandleFunc("GET /help", s.helpIndex)
	mux.HandleFunc("GET /help/{doc}", s.helpPage)
	s.mountRunnerAdmin(mux)
	s.mountAdmin(mux)
	mux.HandleFunc("POST /-/lang", s.switchLang)
	mux.HandleFunc("GET /-/card.png", s.cardPNG)
	mux.HandleFunc("GET /api/v1/oembed", s.oembed)
	s.mountAPI(mux)
	mux.HandleFunc("GET /api/v1/admin/self-update", s.selfUpdateStatus)
	mux.HandleFunc("POST /api/v1/admin/self-update", s.selfUpdate)
	mux.HandleFunc("GET /api/v1/webhooks/openapi.json", s.webhookSpec)
	mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte("ok\n"))
	})
	mux.HandleFunc("GET /login", s.login)
	mux.HandleFunc("GET /auth/callback", s.callback)
	mux.HandleFunc("POST /logout", s.logout)
	mux.HandleFunc("GET /{$}", s.home)
	mux.HandleFunc("GET /new", s.newPage)
	mux.HandleFunc("GET /new/slug", s.slugPreview)
	mux.HandleFunc("POST /new/repo", s.createRepo)
	mux.HandleFunc("POST /new/group", s.createGroup)
	mux.HandleFunc("GET /setup", s.setupPage)
	mux.HandleFunc("POST /setup", s.setupSave)
	mux.HandleFunc("POST /setup/cache", s.setupCacheSave)
	mux.HandleFunc("POST /setup/cache/clear", s.setupCacheClear)
	s.routeRunners(mux)
	mux.HandleFunc("GET /settings", s.account)
	mux.HandleFunc("POST /settings/language", s.saveLanguage)
	mux.HandleFunc("POST /settings/profile", s.saveProfile)
	mux.HandleFunc("POST /settings/tokens", s.createToken)
	mux.HandleFunc("POST /settings/tokens/delete", s.deleteToken)
	mux.HandleFunc("POST /settings/ssh", s.addSSH)
	mux.HandleFunc("POST /settings/ssh/delete", s.deleteSSH)
	mux.HandleFunc("GET /settings/export", s.export)
	mux.HandleFunc("GET /users/{username}", s.profile)
	mux.HandleFunc("GET /users/{username}/avatar", s.userAvatar)
	mux.HandleFunc("GET /users/{username}/{$}", s.trimSlash)
	mux.HandleFunc("GET /{name}", s.userShort)
	mux.HandleFunc("GET /{name}/{$}", s.userShort)
	mux.HandleFunc("GET /groups/{path}/{$}", s.trimSlash)
	mux.HandleFunc("GET /groups/{path}", s.groupPage)
	mux.HandleFunc("GET /groups/{path}/logo", s.groupLogo)
	mux.HandleFunc("POST /groups/{path}/settings", s.saveGroup)
	mux.HandleFunc("POST /groups/{path}/approvals", s.saveGroupApproval)
	mux.HandleFunc("POST /groups/{path}/owner", s.transferGroup)
	mux.HandleFunc("POST /groups/{path}/delete", s.deleteGroup)
	mux.HandleFunc("POST /groups/{path}/logo", s.uploadGroupLogo)
	mux.HandleFunc("POST /groups/{path}/members", s.groupMember)
	mux.HandleFunc("POST /groups/{path}/members/remove", s.groupMemberRemove)
	mux.HandleFunc("POST /groups/{path}/secrets", s.groupSecret)
	mux.HandleFunc("POST /groups/{path}/secrets/reveal", s.groupSecretReveal)
	mux.HandleFunc("POST /groups/{path}/secrets/delete", s.groupSecretDelete)
	mux.HandleFunc("POST /groups/{path}/webhooks", s.groupWebhook)
	mux.HandleFunc("POST /groups/{path}/webhooks/delete", s.groupWebhookDelete)
	mux.HandleFunc("POST /groups/{path}/webhooks/copy", s.groupWebhookCopy)

	mux.HandleFunc("GET /{owner}/{repo}/info/refs", s.gitHTTP)
	mux.HandleFunc("POST /{owner}/{repo}/git-upload-pack", s.gitHTTP)
	mux.HandleFunc("POST /{owner}/{repo}/git-receive-pack", s.gitHTTP)
	mux.HandleFunc("POST /api/v1/repos/{owner}/{repo}/releases", s.createRelease)
	mux.HandleFunc("GET /api/v1/repos/{owner}/{repo}/jobs/{id}/log", s.jobLogAPI)
	mux.HandleFunc("GET /api/v1/repos/{owner}/{repo}/commits/{sha}/diff", s.commitDiffAPI)
	mux.HandleFunc("GET /api/v1/repos/{owner}/{repo}/merge-requests/{number}/diff", s.mrDiffAPI)
	mux.HandleFunc("GET /api/v1/repos/{owner}/{repo}/issues", s.issuesAPI)
	mux.HandleFunc("POST /api/v1/repos/{owner}/{repo}/issues", s.issuesAPI)
	mux.HandleFunc("GET /api/v1/repos/{owner}/{repo}/issues/{number}", s.issueAPI)
	mux.HandleFunc("PUT /api/v1/repos/{owner}/{repo}/issues/{number}", s.issueAPI)
	mux.HandleFunc("DELETE /api/v1/repos/{owner}/{repo}/issues/{number}", s.issueAPI)
	mux.HandleFunc("POST /api/v1/repos/{owner}/{repo}/issues/{number}/notes", s.issueNoteAPI)
	mux.HandleFunc("GET /api/v1/repos/{owner}/{repo}/labels", s.labelsAPI)
	mux.HandleFunc("POST /api/v1/repos/{owner}/{repo}/labels", s.labelsAPI)
	mux.HandleFunc("GET /api/v1/repos/{owner}/{repo}/milestones", s.milestonesAPI)
	mux.HandleFunc("POST /api/v1/repos/{owner}/{repo}/milestones", s.milestonesAPI)
	mux.HandleFunc("GET /api/v1/repos/{owner}/{repo}/webhook-secrets", s.repoWebhookSecrets)
	mux.HandleFunc("POST /api/v1/repos/{owner}/{repo}/webhooks", s.repoWebhookAPI)
	mux.HandleFunc("PUT /api/v1/repos/{owner}/{repo}/webhooks/{id}", s.repoWebhookUpdate)
	mux.HandleFunc("GET /api/v1/repos/{owner}/{repo}/secrets", s.repoSecretsAPI)
	mux.HandleFunc("POST /api/v1/repos/{owner}/{repo}/secrets", s.repoSecretCreateAPI)
	mux.HandleFunc("GET /api/v1/repos/{owner}/{repo}/secrets/{name}", s.repoSecretRevealAPI)
	mux.HandleFunc("PUT /api/v1/repos/{owner}/{repo}/secrets/{name}", s.repoSecretUpdateAPI)
	mux.HandleFunc("POST /api/v1/repos/{owner}/{repo}/secrets/{name}/replace", s.repoSecretReplaceAPI)
	mux.HandleFunc("DELETE /api/v1/repos/{owner}/{repo}/secrets/{name}", s.repoSecretDeleteAPI)
	mux.HandleFunc("GET /api/v1/groups/{path}/webhook-secrets", s.groupWebhookSecrets)
	mux.HandleFunc("POST /api/v1/groups/{path}/hooks", s.groupWebhookAPI)
	mux.HandleFunc("PUT /api/v1/groups/{path}/hooks/{id}", s.groupWebhookUpdate)
	mux.HandleFunc("GET /api/v1/groups/{path}/secrets", s.groupSecretsAPI)
	mux.HandleFunc("POST /api/v1/groups/{path}/secrets", s.groupSecretCreateAPI)
	mux.HandleFunc("GET /api/v1/groups/{path}/secrets/{name}", s.groupSecretRevealAPI)
	mux.HandleFunc("PUT /api/v1/groups/{path}/secrets/{name}", s.groupSecretUpdateAPI)
	mux.HandleFunc("POST /api/v1/groups/{path}/secrets/{name}/replace", s.groupSecretReplaceAPI)
	mux.HandleFunc("DELETE /api/v1/groups/{path}/secrets/{name}", s.groupSecretDeleteAPI)
	mux.HandleFunc("GET /{owner}/{repo}", s.repoHome)
	mux.HandleFunc("GET /{owner}/{repo}/{$}", s.repoRootAlias)
	mux.HandleFunc("GET /{owner}/{repo}/-", s.repoRootAlias)
	mux.HandleFunc("GET /{owner}/{repo}/-/{$}", s.repoRootAlias)
	mux.HandleFunc("GET /{owner}/{repo}/-/tree", s.treeRoot)
	mux.HandleFunc("GET /{owner}/{repo}/-/tree/{path...}", s.tree)
	mux.HandleFunc("GET /{owner}/{repo}/-/blob/{path...}", s.blob)
	mux.HandleFunc("GET /{owner}/{repo}/-/raw/{path...}", s.raw)
	mux.HandleFunc("GET /{owner}/{repo}/-/commits", s.commits)
	mux.HandleFunc("GET /{owner}/{repo}/-/tags", s.tags)
	mux.HandleFunc("POST /{owner}/{repo}/-/tags", s.createTag)
	mux.HandleFunc("POST /{owner}/{repo}/-/tags/delete", s.deleteTag)
	mux.HandleFunc("GET /{owner}/{repo}/-/tags/archive", s.tagArchive)
	mux.HandleFunc("GET /{owner}/{repo}/-/archive/{rev}/{file}", s.commitArchive)
	mux.HandleFunc("GET /{owner}/{repo}/-/commit/{sha}", s.commit)
	mux.HandleFunc("GET /{owner}/{repo}/-/branches/archive", s.branchArchive)
	mux.HandleFunc("GET /{owner}/{repo}/-/branches", s.branches)
	mux.HandleFunc("POST /{owner}/{repo}/-/branches", s.createBranch)
	mux.HandleFunc("POST /{owner}/{repo}/-/branches/delete", s.deleteBranch)
	mux.HandleFunc("POST /{owner}/{repo}/-/branches/rename", s.renameBranch)
	mux.HandleFunc("GET /{owner}/{repo}/-/compare", s.compare)
	mux.HandleFunc("POST /{owner}/{repo}/-/markdown", s.previewMarkdown)
	mux.HandleFunc("POST /{owner}/{repo}/-/tasks", s.toggleTask)
	mux.HandleFunc("GET /{owner}/{repo}/-/merge-requests", s.mergeRequests)
	mux.HandleFunc("GET /{owner}/{repo}/-/merge-requests/new", s.newMR)
	mux.HandleFunc("POST /{owner}/{repo}/-/merge-requests", s.createMR)
	mux.HandleFunc("GET /{owner}/{repo}/-/merge-requests/{number}", s.showMR)
	mux.HandleFunc("POST /{owner}/{repo}/-/merge-requests/{number}", s.updateMR)
	mux.HandleFunc("POST /{owner}/{repo}/-/merge-requests/{number}/merge", s.mergeMR)
	mux.HandleFunc("POST /{owner}/{repo}/-/merge-requests/{number}/close", s.closeMR)
	mux.HandleFunc("POST /{owner}/{repo}/-/merge-requests/{number}/reopen", s.reopenMR)
	mux.HandleFunc("POST /{owner}/{repo}/-/merge-requests/{number}/reviews", s.postReview)
	mux.HandleFunc("POST /{owner}/{repo}/-/merge-requests/{number}/reviews/dismiss", s.dismissReview)
	mux.HandleFunc("POST /{owner}/{repo}/-/merge-requests/{number}/notes", s.createNote)
	mux.HandleFunc("POST /{owner}/{repo}/-/merge-requests/{number}/suggestions", s.applySuggestions)
	mux.HandleFunc("GET /{owner}/{repo}/-/issues", s.issuesPage)
	mux.HandleFunc("GET /{owner}/{repo}/-/issues/new", s.newIssue)
	mux.HandleFunc("POST /{owner}/{repo}/-/issues", s.createIssue)
	mux.HandleFunc("POST /{owner}/{repo}/-/issues/labels", s.createIssueLabel)
	mux.HandleFunc("POST /{owner}/{repo}/-/issues/milestones", s.createIssueMilestone)
	mux.HandleFunc("GET /{owner}/{repo}/-/issues/{number}", s.showIssue)
	mux.HandleFunc("POST /{owner}/{repo}/-/issues/{number}", s.postIssue)
	mux.HandleFunc("GET /{owner}/{repo}/-/pipelines", s.pipelines)
	mux.HandleFunc("POST /{owner}/{repo}/-/pipelines", s.runPipeline)
	mux.HandleFunc("GET /{owner}/{repo}/-/pipelines/{id}", s.pipeline)
	mux.HandleFunc("GET /{owner}/{repo}/-/pipelines/{id}/jobs/{job}", s.showJob)
	mux.HandleFunc("GET /{owner}/{repo}/-/pipelines/{id}/jobs/{job}/log", s.jobLog)
	mux.HandleFunc("POST /{owner}/{repo}/-/pipelines/{id}/jobs/{job}/play", s.playJob)
	mux.HandleFunc("POST /{owner}/{repo}/-/pipelines/{id}/jobs/{job}/cancel", s.cancelJobWeb)
	mux.HandleFunc("POST /{owner}/{repo}/-/pipelines/{id}/cancel", s.cancelPipelineWeb)
	mux.HandleFunc("POST /{owner}/{repo}/-/pipelines/{id}/retry", s.retryPipeline)
	mux.HandleFunc("GET /{owner}/{repo}/-/ci/editor", s.ciEditor)
	mux.HandleFunc("POST /{owner}/{repo}/-/ci/editor", s.saveCIEditor)
	mux.HandleFunc("POST /{owner}/{repo}/-/ci/lint", s.lintCI)
	mux.HandleFunc("GET /{owner}/{repo}/-/releases", s.releases)
	mux.HandleFunc("GET /{owner}/{repo}/-/releases/{$}", s.releasesSlash)
	mux.HandleFunc("GET /{owner}/{repo}/-/releases/{tag}/assets/{name}", s.releaseAsset)
	mux.HandleFunc("POST /{owner}/{repo}/-/releases/{tag}/assets/{name}/delete", s.uiDeleteReleaseAsset)
	mux.HandleFunc("POST /{owner}/{repo}/-/releases/{tag}/delete", s.uiDeleteRelease)
	mux.HandleFunc("GET /{owner}/{repo}/-/logo", s.repoLogo)
	mux.HandleFunc("POST /{owner}/{repo}/-/logo", s.uploadRepoLogo)
	mux.HandleFunc("POST /{owner}/{repo}/-/star", s.toggleStar)
	mux.HandleFunc("POST /{owner}/{repo}/-/fork", s.forkPost)
	mux.HandleFunc("POST /{owner}/{repo}/-/sync-upstream", s.syncUpstreamPost)
	mux.HandleFunc("POST /{owner}/{repo}/-/upstream-merge-requests", s.forkMRPost)
	mux.HandleFunc("GET /{owner}/{repo}/-/forks", s.forksPage)
	mux.HandleFunc("GET /{owner}/{repo}/-/settings", s.settings)
	mux.HandleFunc("POST /{owner}/{repo}/-/settings", s.updateRepo)
	mux.HandleFunc("POST /{owner}/{repo}/-/approvals", s.saveRepoApproval)
	mux.HandleFunc("POST /{owner}/{repo}/-/members", s.repoMember)
	mux.HandleFunc("POST /{owner}/{repo}/-/members/remove", s.repoMemberRemove)
	mux.HandleFunc("POST /{owner}/{repo}/-/protected", s.addProtected)
	mux.HandleFunc("POST /{owner}/{repo}/-/protected/remove", s.removeProtected)
	mux.HandleFunc("POST /{owner}/{repo}/-/protected-tags", s.addProtectedTag)
	mux.HandleFunc("POST /{owner}/{repo}/-/protected-tags/remove", s.removeProtectedTag)
	mux.HandleFunc("POST /{owner}/{repo}/-/secrets", s.repoSecret)
	mux.HandleFunc("POST /{owner}/{repo}/-/secrets/reveal", s.repoSecretReveal)
	mux.HandleFunc("POST /{owner}/{repo}/-/secrets/delete", s.repoSecretDelete)
	mux.HandleFunc("POST /{owner}/{repo}/-/webhooks", s.repoWebhook)
	mux.HandleFunc("POST /{owner}/{repo}/-/webhooks/delete", s.repoWebhookDelete)
	mux.HandleFunc("POST /{owner}/{repo}/-/webhooks/copy", s.repoWebhookCopy)
	mux.HandleFunc("POST /{owner}/{repo}/-/delete", s.deleteRepo)

	s.mountBackup(mux)
	return s.realIP(s.withSession(s.secure(s.backupWatch(s.gate(mux)))))
}

func (s *Server) realIP(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		realip.Apply(r, s.Cfg.ProxySet())
		next.ServeHTTP(w, r)
	})
}

func (s *Server) mustTemplates() {
	if s.byLang != nil {
		return
	}
	s.byLang = map[string]*template.Template{}
	for _, lang := range i18n.All() {
		l := lang
		s.byLang[string(l)] = template.Must(template.New("web").Funcs(template.FuncMap{
			"tip":       func(key string) template.HTML { return runnercfg.Tip(l, key) },
			"admintabs": adminTabs,
			"adminpage": isAdminPage,
			"short": func(v string) string {
				if len(v) > 10 {
					return v[:10]
				}
				return v
			},
			"join": strings.Join,
			"initial": func(s string) string {
				s = strings.TrimSpace(s)
				if s == "" {
					return "?"
				}
				r, _ := utf8.DecodeRuneInString(s)
				return strings.ToUpper(string(r))
			},
			"tileHue": tileHue,
			"splitPath": func(p string) []string {
				if p == "" {
					return nil
				}
				return strings.Split(p, "/")
			},
			"iconOf":        func(name string) string { return fileIcon(name, "blob") },
			"t":             func(key string, args ...any) string { return i18n.T(l, key, args...) },
			"sidecount":     formatSideCount,
			"bgprotocol":    backup.Protocol,
			"bgminprotocol": backup.MinProtocol,
			"date":          func(t time.Time) string { return i18n.FormatDate(l, t) },
			"tn": func(n int, one, many string) string {
				key := many
				if n == 1 {
					key = one
				}
				return i18n.T(l, key, n)
			},
			"roleName":    func(r access.Role) string { return i18n.T(l, "role."+string(r)) },
			"visName":     func(v string) string { return i18n.T(l, "vis."+v) },
			"pushedLabel": func(r store.Repo) string { return pushedLabel(l, r) },
			"presetName": func(id string) string {
				label := i18n.T(l, "set.preset."+id)
				if label == "set.preset."+id {
					return id
				}
				return label
			},
			"printf": fmt.Sprintf,
			"mb":     func(n int64) float64 { return float64(n) / (1 << 20) },
			"dict": func(kv ...any) (map[string]any, error) {
				if len(kv)%2 != 0 {
					return nil, fmt.Errorf("dict")
				}
				m := make(map[string]any, len(kv)/2)
				for i := 0; i < len(kv); i += 2 {
					key, ok := kv[i].(string)
					if !ok {
						return nil, fmt.Errorf("dict")
					}
					m[key] = kv[i+1]
				}
				return m, nil
			},
		}).ParseFS(webFS, "templates/*.html"))
	}
	s.tmpl = s.byLang[string(i18n.EN)]
}

func (s *Server) asset(w http.ResponseWriter, r *http.Request) {
	name := r.PathValue("file")
	if name == "" || strings.Contains(name, "/") || strings.Contains(name, "..") {
		http.NotFound(w, r)
		return
	}
	sub, err := fs.Sub(webFS, "static")
	if err != nil {
		http.Error(w, "assets", http.StatusInternalServerError)
		return
	}
	// CSS/JS moeten na een self-update niet uit een oude cache komen:
	// een achtergebleven stylesheet zet de tekst over de lanes.
	if strings.HasSuffix(name, ".css") || strings.HasSuffix(name, ".js") {
		w.Header().Set("Cache-Control", "no-cache")
	}
	http.ServeFileFS(w, r, sub, name)
}

func (s *Server) secure(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("X-Content-Type-Options", "nosniff")
		w.Header().Set("X-Frame-Options", "DENY")
		w.Header().Set("Referrer-Policy", "strict-origin-when-cross-origin")
		w.Header().Set("Content-Security-Policy", "default-src 'self'; img-src 'self' https: data:; style-src 'self'; form-action 'self'; base-uri 'self'; frame-ancestors 'none'")
		next.ServeHTTP(w, r)
	})
}

func (s *Server) withSession(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		p := principal{}
		if c, err := r.Cookie("bluegit_session"); err == nil && c.Value != "" {
			sess, err := s.Store.Session(r.Context(), c.Value)
			if err == nil && sess.ExpiresAt.After(time.Now()) {
				p.Session = sess
				p.User = sess.User
				p.OK = true
				s.maybeExtend(r.Context(), sess)
			}
		}
		next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), ctxKey{}, p)))
	})
}

func (s *Server) maybeExtend(ctx context.Context, sess store.Session) {
	if time.Until(sess.ExpiresAt) > 6*time.Hour {
		return
	}
	sec, err := s.Auth.Extend(ctx, sess.AccessToken)
	if err != nil || sec <= 0 {
		return
	}
	_ = s.Store.UpdateSessionExpiry(ctx, sess.ID, time.Now().Add(time.Duration(sec)*time.Second))
}

func (s *Server) who(r *http.Request) principal {
	p, _ := r.Context().Value(ctxKey{}).(principal)
	return p
}

func (s *Server) csrfOK(w http.ResponseWriter, r *http.Request) bool {
	if err := r.ParseForm(); err != nil {
		http.Error(w, s.tr(r, "err.badForm"), http.StatusBadRequest)
		return false
	}
	p := s.who(r)
	if !p.OK || r.FormValue("csrf") == "" || r.FormValue("csrf") != p.Session.CSRF {
		http.Error(w, s.tr(r, "err.badCSRF"), http.StatusBadRequest)
		return false
	}
	return true
}

func (s *Server) loginRequired(w http.ResponseWriter, r *http.Request) (store.User, bool) {
	p := s.who(r)
	if !p.OK {
		http.Redirect(w, r, "/login", http.StatusFound)
		return store.User{}, false
	}
	return p.User, true
}

func (s *Server) setSessionCookie(w http.ResponseWriter, id string, exp time.Time) {
	http.SetCookie(w, &http.Cookie{
		Name:     "bluegit_session",
		Value:    id,
		Path:     "/",
		HttpOnly: true,
		SameSite: http.SameSiteLaxMode,
		Secure:   strings.HasPrefix(s.Cfg.BaseURL, "https://"),
		Expires:  exp,
	})
}

func (s *Server) flash(w http.ResponseWriter, notice, problem string) {
	secure := strings.HasPrefix(s.Cfg.BaseURL, "https://")
	if notice != "" {
		http.SetCookie(w, &http.Cookie{Name: "bluegit_notice", Value: url.QueryEscape(notice), Path: "/", MaxAge: 120, HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode})
	}
	if problem != "" {
		http.SetCookie(w, &http.Cookie{Name: "bluegit_error", Value: url.QueryEscape(problem), Path: "/", MaxAge: 120, HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode})
	}
}

func (s *Server) takeFlash(w http.ResponseWriter, r *http.Request) (string, string) {
	notice, problem := flashVal(r, "bluegit_notice"), flashVal(r, "bluegit_error")
	if notice != "" {
		http.SetCookie(w, &http.Cookie{Name: "bluegit_notice", Value: "", Path: "/", MaxAge: -1})
	}
	if problem != "" {
		http.SetCookie(w, &http.Cookie{Name: "bluegit_error", Value: "", Path: "/", MaxAge: -1})
	}
	return notice, problem
}

func cookieVal(r *http.Request, name string) string {
	c, err := r.Cookie(name)
	if err != nil {
		return ""
	}
	return c.Value
}

func flashVal(r *http.Request, name string) string {
	raw := cookieVal(r, name)
	if raw == "" {
		return ""
	}
	v, err := url.QueryUnescape(raw)
	if err != nil {
		return raw
	}
	return v
}

func (s *Server) redirect(w http.ResponseWriter, r *http.Request, path, notice, problem string) {
	s.flash(w, notice, problem)
	http.Redirect(w, r, path, http.StatusSeeOther)
}

func (s *Server) langOf(r *http.Request) i18n.Lang {
	if p := s.who(r); p.OK {
		return i18n.Parse(p.User.Language)
	}
	if c, err := r.Cookie("bluegit_lang"); err == nil {
		return i18n.Parse(c.Value)
	}
	return i18n.EN
}

// switchLang is de taalkiezer in de kopbalk: ingelogd slaat hij de taal op
// het account op, anoniem in een cookie. back is altijd een lokaal pad.
func (s *Server) switchLang(w http.ResponseWriter, r *http.Request) {
	lang := i18n.Parse(r.FormValue("lang"))
	back := langpick.SafeBack(r.FormValue("back"))
	if p := s.who(r); p.OK {
		if !s.csrfOK(w, r) {
			return
		}
		if _, err := s.opSetLanguage(r.Context(), p.User, string(lang)); err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
	} else {
		http.SetCookie(w, &http.Cookie{Name: "bluegit_lang", Value: string(lang), Path: "/", MaxAge: 365 * 86400, HttpOnly: true, SameSite: http.SameSiteLaxMode, Secure: strings.HasPrefix(s.Cfg.BaseURL, "https://")})
	}
	http.Redirect(w, r, back, http.StatusSeeOther)
}

func (s *Server) tr(r *http.Request, key string, args ...any) string {
	return i18n.T(s.langOf(r), key, args...)
}

func (s *Server) trErr(r *http.Request, err error) string {
	return i18n.Text(s.langOf(r), err)
}

func (s *Server) view(w http.ResponseWriter, r *http.Request, title string) View {
	notice, problem := s.takeFlash(w, r)
	lang := s.langOf(r)
	if strings.HasPrefix(title, "title.") {
		title = i18n.T(lang, title)
	}
	name := strings.TrimSpace(s.Cfg.Runner.Name)
	if name == "" {
		name = "Steve"
	}
	v := View{
		Title: title, BaseURL: s.Cfg.BaseURL, RunnerName: name, Notice: notice, Err: problem,
		StorageUnset: s.StoragePath() == "", Lang: string(lang), HTMLLang: htmlLang(lang),
		Cunei: lang == i18n.Cuneiform,
	}
	for _, l := range i18n.All() {
		v.Langs = append(v.Langs, LangChoice{Code: string(l), Label: l.Name()})
	}
	if p := s.who(r); p.OK && !isCrawler(r) {
		u := p.User
		v.User = &u
		v.CSRF = p.Session.CSRF
	}
	back := r.URL.Path
	if r.URL.RawQuery != "" {
		back += "?" + r.URL.RawQuery
	}
	csrfField := ""
	if v.User != nil {
		csrfField = "csrf"
	}
	v.LangPick = langpick.HTML(lang, "/-/lang", back, csrfField, v.CSRF)
	pic := s.cardForPath(r.Context(), r.URL.Path, r.URL.RawQuery, r.URL.Fragment)
	v.Social = &pic.Meta
	return v
}

func htmlLang(l i18n.Lang) string {
	switch l {
	case i18n.NL:
		return "nl"
	case i18n.DE:
		return "de"
	case i18n.FR:
		return "fr"
	default:
		return "en"
	}
}

func (s *Server) render(w http.ResponseWriter, name string, v View) {
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	tmpl := s.byLang[v.Lang]
	if tmpl == nil {
		tmpl = s.tmpl
	}
	if v.User != nil && v.User.InstanceAdmin {
		v.BackupCompat = s.backupCompatIssues()
	}
	if err := tmpl.ExecuteTemplate(w, name, v); err != nil && s.Log != nil {
		s.Log.Error("sjabloon", "name", name, "err", err)
	}
}

func randomState() (string, error) {
	b := make([]byte, 32)
	if _, err := rand.Read(b); err != nil {
		return "", err
	}
	return hex.EncodeToString(b), nil
}

// View is de gegevensset voor elk scherm.
type View struct {
	Backup         *BackupView
	BackupCompat   []BackupCompatIssue
	RunnerList     []RunnerView
	RunnerPref     string
	NewRunnerToken string
	BuiltinFirst   bool
	RunnerOptIn    bool
	GroupRepoCount int
	OptInNames     []string
	Title          string
	BaseURL        string
	RunnerName     string
	User           *store.User
	CSRF           string
	Notice         string
	Err            string
	Repos          []store.Repo
	Groups         []store.Group
	Repo           *store.Repo
	Role           access.Role
	CanWrite       bool
	CanAdmin       bool
	CanMerge       bool
	CanForce       bool
	CanComment     bool
	CanApply       bool
	Commits        []CommitRow
	CommitDays     []CommitDay
	CommitPrev     string
	CommitNext     string
	Commit         *CommitRow
	CommitDiff     *CommitDiff
	Entries        []EntryRow
	TreePath       string
	Blob           string
	BlobPath       string
	Binary         bool
	Branches       []BranchRow
	Branch         *BranchBoard
	MRs            []store.MergeRequest
	Flow           *FlowBoard
	MR             *store.MergeRequest
	Banner         *MRBanner
	MRPipe         *PipeRow
	MergeBlocks    []string
	Approval       *ApprovalView
	Reviews        []ReviewRow
	CanReview      bool
	CanApprove     bool
	CanDismiss     bool
	CanClose       bool
	CanReopen      bool
	IsOwner        bool
	Candidates     []store.Member
	Diff           string
	DiffFiles      []DiffFileView
	Pipes          []store.Pipeline
	PipeRows       []PipeRow
	Pipe           *store.Pipeline
	PipeSource     string
	PipeStatus     string
	PipeLabel      string
	PipeJobs       []JobLink
	PipeStages     []StageView
	PipeFailed     bool
	// PipeWait: waarom deze pipeline wacht (doNotInterrupt in een oudere pipeline).
	PipeWait string
	// PipeCancel: annuleerknop met bevestiging, nil als annuleren niet kan.
	PipeCancel       *CancelView
	Live             bool
	LiveURL          string
	Jobs             []store.Job
	JobPage          *JobPage
	Editor           *CIEditor
	Releases         []store.Release
	Members          []store.Member
	Secrets          []store.SecretMeta
	Inherited        []InheritedSecret
	HookSecrets      []SecretChoice
	Hooks            []HookView
	HookTargets      []HookTarget
	HookEdit         HookDraft
	Patterns         []string
	TagPatterns      []string
	Tags             []TagRow
	Tokens           []store.TokenInfo
	ShowExpiry       bool
	Keys             []store.SSHKey
	CloneHTTP        string
	CloneSSH         string
	Group            *store.Group
	Tab              string
	Rev              string
	NewToken         string
	StorageUnset     bool
	StoragePath      string
	StorageFree      string
	StorageUsed      string
	StorageTotal     string
	StoragePercent   int
	StorageBlueGit   string
	StoragePartial   bool
	Cache            map[string]any
	StorageReserved  string
	HasReserved      bool
	MinFree          string
	Wide             bool
	Info             bool
	Help             bool
	HelpDocs         []HelpDoc
	HelpDoc          *HelpDoc
	RunnerUI         template.HTML
	AdminUsers       []AdminUserRow
	StaleDays        int // Beheer > Pipelines: instance-instelling; repo-instellingen: eigen waarde (-1 = volgen)
	StaleDaysDefault int
	ReleaseOnly      bool
	ShowReleases     bool
	OpenMRCount      int
	OpenIssueCount   int
	ReleaseRepos     []store.Repo
	LangPick         template.HTML
	ShowUpdate       bool
	Update           *UpdateView
	HookDoc          string
	Spec             cispec.Doc
	SpecJSON         template.JS
	APIJSON          template.JS
	Page             string
	Lang             string
	HTMLLang         string
	Cunei            bool
	Langs            []LangChoice
	Query            string
	SortDir          string
	SortBy           string
	MoreRepos        int
	MoreGroups       int
	DashTab          string
	DashPage         int
	DashPages        int
	DashPrev         int
	DashNext         int
	DashRepoN        int
	DashGroupN       int
	Fork             ForkInfo
	Stars            int
	Starred          bool
	ForkTargets      []ForkTarget
	ForkList         []store.Repo
	UpstreamBranches []string
	FlipDir          string
	Cards            []RepoCard
	Head             *CommitRow
	Files            []FileRow
	Tree             []FileRow
	Readme           template.HTML
	MDView           bool
	ReadmeName       string
	LicensePath      string
	NCommits         int
	NBranches        int
	NTags            int
	NReleases        int
	Created          string
	Lines            []CodeLine
	BlobSize         string
	IsSVG            bool
	IsImage          bool // rasterafbeelding met kloppende magic bytes
	FileName         string
	RevProtected     bool
	Graph            *GraphView
	Heat             *activity.Calendar
	Notes            []NoteRow
	Profile          *store.User
	Card             *ProfileCard
	DescHTML         template.HTML
	Timeline         []TimelineItem
	CompareFrom      string
	CompareTo        string
	FormTitle        string
	Labels           []string
	CanEditMR        bool
	Issues           *IssueBoard
	IssueDoc         string
	DescTpls         []string
	TplPick          string
	FormBody         string
	Social           *card.Meta
}

// LangChoice is één taal in de instellingen.
type LangChoice struct {
	Code, Label string
}

// RepoCard is een repository in een groepslijst.
type RepoCard struct {
	Repo    store.Repo
	Stars   int
	Starred bool
	URL     string
	When    string
	Pushed  string
}

// AccountLink is een naam die naar een profiel wijst.
type AccountLink struct {
	Name string
	URL  string
}

// ProfileCard is het blok over een gebruiker, boven de activiteitenkalender.
type ProfileCard struct {
	User                   store.User
	Name, Since, Bio, URL  string
	Heading                string
	Repos, Groups, Contrib int
	Own                    bool
}

// NoteRow is een reactie in de interface.
type NoteRow struct {
	ID                                  int64
	Author, AuthorURL, Body, When, Path string
	Start, End                          int
	HasSuggestion                       bool
	ParentID                            int64
	HTML                                template.HTML
	Replies                             []NoteRow
	At                                  time.Time
}

// DiffFileView is één bestand in de merge-request-diff.
type DiffFileView struct {
	Path  string
	Lines []DiffLineView
}

// DiffLineView is één diffregel, met de reacties die op het nieuwe regelnummer eindigen.
type DiffLineView struct {
	Kind  string
	Text  string
	Old   int
	New   int
	Notes []NoteRow
}

// TagRow is één tag op de tagspagina.
type TagRow struct {
	Name, Message, SHA, Short, Subject, Date, When string
	Annotated, Protected, HasRelease, CanDelete    bool
	ZipURL, TarURL                                 string
}

// FileRow is een rij in de bestandstabel of de boom.
type FileRow struct {
	Name, Path, Icon, Subject, When, SHA string
	Dir                                  bool
	Depth                                int
	Active                               bool
	// Open geldt voor een map die het huidige pad bevat. De browser
	// onthoudt afwijkingen daarvan per repository.
	Open bool
}

// CodeLine is één regel broncode.
type CodeLine struct {
	N    int
	HTML template.HTML
}

// CommitRow is een commit in de interface.
// Author is de gekoppelde gebruiker, of anders de ruwe git-naam.
// RawName en PushedBy zijn gezet als de pusher de fallback is en de git-naam afwijkt.
type CommitRow struct {
	SHA, Short, Author, Who, Date, Subject, Body, When  string
	UserURL, WhoURL, Avatar, Initial, RawName, PushedBy string
	Ident                                               template.HTML
	PipeID                                              int64
	PipeStatus, PipeLabel, PipeDuration                 string
	PipeStages                                          []StageView
	PipeLive, PipeFailed                                bool
}

// CommitDay is één dag op de commitlijst, nieuwste dag eerst.
type CommitDay struct {
	Label string
	Items []CommitRow
}

// EntryRow is een bestand of map.
type EntryRow struct {
	Name, Type, Path string
}

// BranchRow is een branch, met of zonder bescherming.
type BranchRow struct {
	Name, SHA, Short, Subject, When, WhenTitle string
	RepoPath, ZipURL, TarURL                   string
	Protected, Default, CanEdit                bool
	Target                                     string
	Ahead, Behind                              int
	Unix                                       int64
	PipeID                                     int64
	PipeStatus, PipeLabel                      string
	OpenMRs                                    []int64
}

// BranchBoard is de gegroepeerde branches-pagina.
type BranchBoard struct {
	State                 string
	ShowActive, ShowStale bool
	Active, Stale         []BranchRow
}

// TimelineItem is één gebeurtenis of reactie op een merge request.
type TimelineItem struct {
	ID                    int64
	Kind                  string
	Actor, ActorURL, Text string
	When                  string
	Body                  string
	HTML                  template.HTML
	URL                   string
	Replies               []TimelineItem
	At                    time.Time
	Rank                  int
}

// HookView is een webhook plus de laatste pogingen.
type HookView struct {
	ID         int64
	Name       string
	Preset     string
	URL        string
	Method     string
	Filter     string
	Events     string
	Badges     []string
	Deliveries []store.Delivery
}

// HookDraft vult het webhookformulier bij bewerken. ID 0 is een nieuw formulier.
type HookDraft struct {
	ID       int64
	Name     string
	Preset   string
	Filter   string
	URL      string
	Username string
	Avatar   string
	Icon     string
	Alias    string
	Token    string
	Chat     string
	Server   string
	Topic    string
	Home     string
	Room     string
	Method   string
	CType    string
	Headers  string
	Body     string
	OnPush   bool
	OnMR     bool
	OnOK     bool
	OnFail   bool
	OnRel    bool
	OnIssue  bool
	Extra    []HookEventChoice
}

// HookEventChoice is een fijner event als vinkje in het webhookformulier.
type HookEventChoice struct {
	Name string
	Key  string
	On   bool
}

func repoURL(repo store.Repo) string { return "/" + repo.FullPath() }
