package server

import (
	"context"
	"encoding/json"
	"errors"
	"io"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"
	"sync/atomic"
	"time"

	"gitlab.com/Timfa/bluegit/internal/backup"
	"gitlab.com/Timfa/bluegit/internal/i18n"
)

// Beheer > Backup: een of meer losse backup servers (repo bluegit-backup)
// halen elk met een eigen Backupserver-Key alle gegevens op, krijgen een
// melding bij elke wijziging, en kunnen een archief terugsturen (rollback).
// Vanuit BlueGit is elke backup server ook te bedienen: BlueGit stuurt
// ondertekende verzoeken naar de beheer-API van de backup server. Het
// protocol staat in docs/BACKUP.md.

// maxRestoreBytes begrenst een terug te zetten archief (64 GiB).
const maxRestoreBytes = 64 << 30

var (
	restoreBusy atomic.Bool
	backupFails updateLimiter
)

// BackupView is de stand op Beheer > Backup.
type BackupView struct {
	InstanceID string
	Servers    []backup.Conn
	Max        int
	// Current is de geopende backup server (detailpagina).
	Current *BackupServerView
	NewKey  string
}

// BackupServerView is één backup server met wat hij zelf meldt.
type BackupServerView struct {
	Conn      backup.Conn
	Remote    *backup.RemoteStatus
	Archives  []backup.Archive
	Config    *backup.RemoteConfig
	RemoteErr string
}

// BackupCompatIssue is een backup server die niet bij deze BlueGit past.
// Beheerders zien hem als banner bovenaan elke pagina.
type BackupCompatIssue struct {
	ID, Name string
	// BlueGitTooOld: BlueGit moet geüpdatet worden; anders de backup server.
	BlueGitTooOld bool
	// Protocol en Min van BlueGit en van de backup server.
	Protocol, Min, PeerProtocol, PeerMin int
	PeerVersion                          string
}

// backupCompatIssues leest backup.json (geen netwerk).
func (s *Server) backupCompatIssues() []BackupCompatIssue {
	if s.StateDir == "" {
		return nil
	}
	s.backupInit()
	list, err := s.backupMgr.List()
	if err != nil {
		return nil
	}
	var out []BackupCompatIssue
	for _, c := range list {
		if !c.Incompatible() {
			continue
		}
		min := c.PeerMinProtocol
		if min == 0 {
			min = 1
		}
		out = append(out, BackupCompatIssue{
			ID: c.ID, Name: c.Name, BlueGitTooOld: c.Compat() == backup.CompatBlueGitTooOld,
			Protocol: backup.Protocol(), Min: backup.MinProtocol(), PeerProtocol: c.PeerProtocol, PeerMin: min, PeerVersion: c.PeerVersion,
		})
	}
	return out
}

func (s *Server) backupInit() {
	s.backupOnce.Do(func() {
		s.backupMgr = &backup.Manager{Dir: s.StateDir}
		s.backupHTTP = &http.Client{Timeout: 15 * time.Second}
		s.backupNote = &backup.Notifier{Client: s.backupClient()}
	})
}

func (s *Server) backupClient() *backup.Client {
	return &backup.Client{Manager: s.backupMgr, HTTP: s.backupHTTP}
}

// BackupManager geeft de koppeling (ook voor tests).
func (s *Server) BackupManager() *backup.Manager {
	s.backupInit()
	return s.backupMgr
}

// BackupChanged meldt een wijziging aan de gekoppelde backup server.
func (s *Server) BackupChanged() {
	if s.StateDir == "" {
		return
	}
	s.backupInit()
	s.backupNote.Changed()
}

func (s *Server) backupTree(conn string) backup.Tree {
	return backup.Tree{
		StateDir: s.StateDir, DataDir: s.StoragePath(), Conn: conn,
		Snapshot: func(dst string) error { return s.Store.Snapshot(context.Background(), dst) },
	}
}

func (s *Server) mountBackup(mux *http.ServeMux) {
	mux.HandleFunc("GET /api/v1/backup/info", s.backupKeyed(s.backupInfo))
	mux.HandleFunc("POST /api/v1/backup/connect", s.backupKeyed(s.backupConnect))
	mux.HandleFunc("GET /api/v1/backup/manifest", s.backupKeyed(s.backupCompatible(s.backupManifest)))
	mux.HandleFunc("GET /api/v1/backup/file", s.backupKeyed(s.backupCompatible(s.backupFile)))
	mux.HandleFunc("POST /api/v1/backup/restore", s.backupKeyed(s.backupCompatible(s.backupRestore)))
	mux.HandleFunc("GET /admin/backup", s.adminBackup)
	mux.HandleFunc("POST /admin/backup/servers", s.adminBackupAdd)
	mux.HandleFunc("GET /admin/backup/s/{id}", s.adminBackupServer)
	mux.HandleFunc("POST /admin/backup/s/{id}/key", s.adminBackupKey)
	mux.HandleFunc("POST /admin/backup/s/{id}/rename", s.adminBackupRename)
	mux.HandleFunc("POST /admin/backup/s/{id}/remove", s.adminBackupRemove)
	mux.HandleFunc("POST /admin/backup/s/{id}/act/{name}", s.adminBackupAct)
}

// backupWatch meldt na elk schrijvend verzoek een wijziging. De backup
// server haalt daarna alleen op wat veranderd is; een melding te veel kost
// dus weinig. Tijdens het terugzetten van een backup wordt niet geschreven.
func (s *Server) backupWatch(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch r.Method {
		case http.MethodGet, http.MethodHead, http.MethodOptions:
			next.ServeHTTP(w, r)
			return
		}
		if restoreBusy.Load() {
			http.Error(w, "backup wordt teruggezet; BlueGit herstart zo\n", http.StatusServiceUnavailable)
			return
		}
		next.ServeHTTP(w, r)
		if strings.HasPrefix(r.URL.Path, "/api/v1/backup/") || strings.HasSuffix(r.URL.Path, "/git-upload-pack") {
			return
		}
		s.BackupChanged()
	})
}

func backupErr(w http.ResponseWriter, code int, msg string) {
	writeJSON(w, code, map[string]string{"error": msg})
}

// backupKeyed eist de Backupserver-Key als bearer-token.
func (s *Server) backupKeyed(h func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Cache-Control", "no-store")
		backup.SetOwnHeaders(w.Header())
		if s.StateDir == "" {
			backupErr(w, http.StatusNotFound, "backup niet beschikbaar")
			return
		}
		s.backupInit()
		conn, ok := s.backupMgr.Check(bearer(r))
		if !ok {
			// Alleen mislukte pogingen tellen: hoogstens 5 per minuut per IP.
			if !backupFails.allow(clientIP(r), time.Now()) {
				backupErr(w, http.StatusTooManyRequests, "te veel mislukte pogingen")
				return
			}
			backupErr(w, http.StatusUnauthorized, "ongeldige Backupserver-Key")
			return
		}
		s.backupMgr.Seen(conn.ID)
		// Zonder koppen is het een backup server van vóór de
		// protocolversie: protocol 1.
		peer, _ := backup.PeerFromHeader(r.Header)
		s.backupMgr.SetPeer(conn.ID, peer)
		if c, ok := s.backupMgr.Get(conn.ID); ok {
			conn = c
		}
		h(w, r.WithContext(context.WithValue(r.Context(), backupConnKey{}, conn)))
	}
}

// backupCompatible weigert gegevens uit te wisselen met een backup server
// die niet bij deze BlueGit past (426, met wie er geüpdatet moet worden).
// info en connect blijven werken, zodat beide kanten het kunnen melden.
func (s *Server) backupCompatible(h func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		c := backupConnOf(r)
		if res := c.Compat(); res == backup.CompatBlueGitTooOld || res == backup.CompatBackupTooOld {
			msg := "backup server te oud voor deze BlueGit; update de backup server"
			if res == backup.CompatBlueGitTooOld {
				msg = "BlueGit te oud voor deze backup server; update BlueGit"
			}
			writeJSON(w, http.StatusUpgradeRequired, map[string]any{
				"error": msg, "compat": res, "protocol": backup.Protocol(), "min_protocol": backup.MinProtocol(),
			})
			return
		}
		h(w, r)
	}
}

type backupConnKey struct{}

func backupConnOf(r *http.Request) backup.Conn {
	c, _ := r.Context().Value(backupConnKey{}).(backup.Conn)
	return c
}

func (s *Server) backupInfo(w http.ResponseWriter, r *http.Request) {
	id, err := s.backupMgr.InstanceID()
	if err != nil {
		backupErr(w, 500, err.Error())
		return
	}
	c := backupConnOf(r)
	writeJSON(w, http.StatusOK, map[string]any{
		"instance_id": id, "base_url": s.Cfg.BaseURL, "name": c.Name, "server_url": c.ServerURL, "server_id": c.ServerID,
		"has_storage": s.StoragePath() != "",
		"protocol":    backup.Protocol(), "min_protocol": backup.MinProtocol(), "version": backup.Version(),
		"compat": c.Compat(),
	})
}

func (s *Server) backupConnect(w http.ResponseWriter, r *http.Request) {
	var in struct {
		ServerURL string `json:"server_url"`
		ServerID  string `json:"server_id"`
	}
	if err := json.NewDecoder(io.LimitReader(r.Body, 1<<16)).Decode(&in); err != nil {
		backupErr(w, 400, "ongeldige JSON")
		return
	}
	u, err := url.Parse(strings.TrimSpace(in.ServerURL))
	if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" {
		backupErr(w, 400, "server_url moet een http(s)-adres zijn")
		return
	}
	c, err := s.backupMgr.Connect(backupConnOf(r).ID, u.String(), strings.TrimSpace(in.ServerID))
	if err != nil {
		backupErr(w, 500, err.Error())
		return
	}
	id, _ := s.backupMgr.InstanceID()
	if s.Log != nil {
		s.Log.Info("backup audit", "action", "connect", "id", c.ID, "name", c.Name, "server", c.ServerURL, "server_id", c.ServerID)
	}
	writeJSON(w, http.StatusOK, map[string]any{"instance_id": id, "server_url": c.ServerURL})
}

func (s *Server) backupManifest(w http.ResponseWriter, r *http.Request) {
	id, err := s.backupMgr.InstanceID()
	if err != nil {
		backupErr(w, 500, err.Error())
		return
	}
	m, err := s.backupTree(backupConnOf(r).ID).Build(id)
	if err != nil {
		backupErr(w, 500, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, m)
}

func (s *Server) backupFile(w http.ResponseWriter, r *http.Request) {
	real, err := s.backupTree(backupConnOf(r).ID).Resolve(r.URL.Query().Get("path"))
	if err != nil {
		backupErr(w, http.StatusNotFound, "bestand niet gevonden")
		return
	}
	f, err := os.Open(real)
	if err != nil {
		backupErr(w, http.StatusNotFound, "bestand niet gevonden")
		return
	}
	defer f.Close()
	fi, err := f.Stat()
	if err != nil {
		backupErr(w, 500, err.Error())
		return
	}
	w.Header().Set("Content-Type", "application/octet-stream")
	w.Header().Set("Content-Length", strconv.FormatInt(fi.Size(), 10))
	w.Header().Set("X-Backup-Mtime", strconv.FormatInt(fi.ModTime().UnixMilli(), 10))
	_, _ = io.Copy(w, f)
}

// backupRestore neemt een tar.gz aan, pakt het naast de live gegevens uit
// en herstart BlueGit. Bij de start komt de backup op zijn plek.
func (s *Server) backupRestore(w http.ResponseWriter, r *http.Request) {
	if !s.restoring.TryLock() {
		backupErr(w, http.StatusConflict, "er loopt al een restore")
		return
	}
	defer s.restoring.Unlock()
	restoreBusy.Store(true)
	n, err := s.backupTree("").Stage(http.MaxBytesReader(w, r.Body, maxRestoreBytes))
	if err != nil {
		restoreBusy.Store(false)
		if s.Log != nil {
			s.Log.Warn("backup audit", "action", "restore_failed", "err", err)
		}
		backupErr(w, http.StatusBadRequest, err.Error())
		return
	}
	if s.Log != nil {
		s.Log.Warn("backup audit", "action", "restore_staged", "files", n, "id", backupConnOf(r).ID, "name", backupConnOf(r).Name)
	}
	writeJSON(w, http.StatusAccepted, map[string]any{"files": n, "restarting": s.RequestRestart != nil})
	if f, ok := w.(http.Flusher); ok {
		f.Flush()
	}
	if s.RequestRestart != nil {
		go func() {
			time.Sleep(300 * time.Millisecond)
			s.RequestRestart()
		}()
	}
}

// ---------- Beheer > Backup ----------

func (s *Server) backupList() *BackupView {
	s.backupInit()
	bv := &BackupView{Max: backup.MaxServers}
	bv.Servers, _ = s.backupMgr.List()
	bv.InstanceID, _ = s.backupMgr.InstanceID()
	return bv
}

// backupServerView vraagt status, archieven en instellingen op bij de
// backup server.
func (s *Server) backupServerView(ctx context.Context, conn backup.Conn) *BackupServerView {
	v := &BackupServerView{Conn: conn}
	if !conn.Connected() {
		return v
	}
	ctx, cancel := context.WithTimeout(ctx, 8*time.Second)
	defer cancel()
	// De antwoorden kunnen een nieuw protocol gemeld hebben.
	defer func() {
		if fresh, ok := s.backupMgr.Get(conn.ID); ok {
			v.Conn = fresh
		}
	}()
	c := s.backupClient()
	st, err := c.Status(ctx, conn)
	if err != nil {
		v.RemoteErr = err.Error()
		return v
	}
	v.Remote = &st
	if arch, err := c.Archives(ctx, conn); err == nil {
		v.Archives = arch
	} else {
		v.RemoteErr = err.Error()
	}
	if cfg, err := c.Config(ctx, conn); err == nil {
		v.Config = &cfg
	} else if v.RemoteErr == "" {
		v.RemoteErr = err.Error()
	}
	return v
}

func (s *Server) adminBackup(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok {
		return
	}
	v := s.view(w, r, "title.admin")
	v.Page = "adminbackup"
	v.Backup = s.backupList()
	s.render(w, "adminbackup", v)
}

func (s *Server) backupConnFromPath(w http.ResponseWriter, r *http.Request) (backup.Conn, bool) {
	s.backupInit()
	c, ok := s.backupMgr.Get(r.PathValue("id"))
	if !ok {
		http.NotFound(w, r)
	}
	return c, ok
}

func backupPath(id string) string { return "/admin/backup/s/" + url.PathEscape(id) }

func (s *Server) adminBackupServer(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok {
		return
	}
	conn, ok := s.backupConnFromPath(w, r)
	if !ok {
		return
	}
	v := s.view(w, r, "title.admin")
	v.Page = "adminbackupserver"
	v.Backup = s.backupList()
	v.Backup.Current = s.backupServerView(r.Context(), conn)
	if c, err := r.Cookie("bluegit_backup_key"); err == nil && c.Value != "" {
		v.Backup.NewKey = c.Value
		http.SetCookie(w, &http.Cookie{Name: "bluegit_backup_key", Value: "", Path: backupPath(conn.ID), MaxAge: -1})
	}
	s.render(w, "adminbackup", v)
}

// showKeyOnce zet de nieuwe key in een kort, HttpOnly cookie dat alleen de
// pagina van die backup server leest.
func (s *Server) showKeyOnce(w http.ResponseWriter, id, key string) {
	http.SetCookie(w, &http.Cookie{
		Name: "bluegit_backup_key", Value: key, Path: backupPath(id), MaxAge: 60, HttpOnly: true,
		SameSite: http.SameSiteStrictMode, Secure: strings.HasPrefix(s.Cfg.BaseURL, "https://"),
	})
}

func (s *Server) backupAudit(action, by string, kv ...any) {
	if s.Log != nil {
		s.Log.Info("backup audit", append([]any{"action", action, "by", by}, kv...)...)
	}
}

func (s *Server) adminBackupAdd(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
		return
	}
	s.backupInit()
	by := s.who(r).User.Username
	key, c, err := s.backupMgr.Add(r.FormValue("name"), by)
	if err != nil {
		s.redirect(w, r, "/admin/backup", "", s.backupErrText(r, err))
		return
	}
	s.backupAudit("add", by, "id", c.ID, "name", c.Name)
	s.showKeyOnce(w, c.ID, key)
	s.redirect(w, r, backupPath(c.ID), s.tr(r, "backup.ok.key"), "")
}

func (s *Server) backupErrText(r *http.Request, err error) string {
	switch {
	case errors.Is(err, backup.ErrTooMany):
		return s.tr(r, "backup.err.tooMany", backup.MaxServers)
	case errors.Is(err, backup.ErrUnknown):
		return s.tr(r, "backup.err.unknown")
	}
	return s.trErr(r, unwrapFail(err))
}

func (s *Server) adminBackupKey(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
		return
	}
	conn, ok := s.backupConnFromPath(w, r)
	if !ok {
		return
	}
	by := s.who(r).User.Username
	key, _, err := s.backupMgr.RotateKey(conn.ID, by)
	if err != nil {
		s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err))
		return
	}
	s.backupAudit("new_key", by, "id", conn.ID, "name", conn.Name)
	s.showKeyOnce(w, conn.ID, key)
	s.redirect(w, r, backupPath(conn.ID), s.tr(r, "backup.ok.key"), "")
}

func (s *Server) adminBackupRename(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
		return
	}
	conn, ok := s.backupConnFromPath(w, r)
	if !ok {
		return
	}
	if _, err := s.backupMgr.Rename(conn.ID, r.FormValue("name")); err != nil {
		s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err))
		return
	}
	s.redirect(w, r, backupPath(conn.ID), s.tr(r, "backup.ok.renamed"), "")
}

// removeBackupServer laat de backup server ontkoppelen (als hij bereikbaar
// is) en vergeet hem daarna.
func (s *Server) removeBackupServer(ctx context.Context, by string, conn backup.Conn) error {
	if conn.Connected() {
		ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
		_, _, _ = s.backupClient().Call(ctx, conn, http.MethodPost, "/api/v1/admin/disconnect", map[string]any{})
		cancel()
	}
	if err := s.backupMgr.Remove(conn.ID); err != nil {
		return err
	}
	s.backupTree(conn.ID).RemoveSnapshot()
	s.backupAudit("remove", by, "id", conn.ID, "name", conn.Name)
	return nil
}

func (s *Server) adminBackupRemove(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
		return
	}
	conn, ok := s.backupConnFromPath(w, r)
	if !ok {
		return
	}
	if err := s.removeBackupServer(r.Context(), s.who(r).User.Username, conn); err != nil {
		s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err))
		return
	}
	s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.revoked"), "")
}

// backupAction voert een beheeractie van de backup server uit. BlueGit kent
// de acties niet vooraf: de backup server noemt ze (GET /api/v1/admin/actions),
// zodat alles wat zijn eigen webinterface kan, ook hier kan.
func (s *Server) backupAction(ctx context.Context, by string, conn backup.Conn, name string, in map[string]any) (int, []byte, error) {
	if !conn.Connected() {
		return 0, nil, fail(409, i18n.E("backup.err.none"))
	}
	ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
	defer cancel()
	c := s.backupClient()
	actions, err := c.Actions(ctx, conn)
	if err != nil {
		return 0, nil, fail(502, err)
	}
	var act *backup.RemoteAction
	for i := range actions {
		if actions[i].Name == name && actions[i].Signed {
			act = &actions[i]
		}
	}
	if act == nil {
		return 0, nil, fail(404, i18n.E("backup.err.action"))
	}
	str := func(k string) string {
		v, _ := in[k].(string)
		return strings.TrimSpace(v)
	}
	if name == "rollback" {
		if str("archive") == "" {
			return 0, nil, fail(400, i18n.E("backup.err.archive"))
		}
		if str("confirm") != str("archive") {
			return 0, nil, fail(400, i18n.E("backup.err.confirm"))
		}
	}
	if name == "sync" {
		if _, ok := in["wait"]; !ok {
			in["wait"] = "false"
		}
	}
	p := act.Path
	for _, param := range act.Params {
		v := str(param)
		if v == "" {
			return 0, nil, fail(400, i18n.E("backup.err.archive"))
		}
		p = strings.ReplaceAll(p, "{"+param+"}", url.PathEscape(v))
		delete(in, param)
	}
	var body any
	if act.Method != http.MethodGet {
		body = in
	}
	hc := *s.backupHTTP
	hc.Timeout = 60 * time.Second
	cl := *c
	cl.HTTP = &hc
	code, raw, err := cl.Call(ctx, conn, act.Method, p, body)
	if err != nil {
		return 0, nil, fail(502, err)
	}
	if act.Method != http.MethodGet {
		kv := []any{"id", conn.ID, "name", conn.Name, "remote_action", name, "status", code}
		if a := str("archive"); a != "" {
			kv = append(kv, "archive", a)
		}
		if s.Log != nil && name == "rollback" {
			s.Log.Warn("backup audit", append([]any{"action", "rollback", "by", by}, kv...)...)
		} else {
			s.backupAudit("remote", by, kv...)
		}
	}
	return code, raw, nil
}

func (s *Server) adminBackupAct(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
		return
	}
	conn, ok := s.backupConnFromPath(w, r)
	if !ok {
		return
	}
	back := backupPath(conn.ID)
	name := r.PathValue("name")
	if name == "rollback" && r.FormValue("understood") != "1" {
		s.redirect(w, r, back, "", s.tr(r, "backup.err.understood"))
		return
	}
	in := map[string]any{}
	_ = r.ParseForm()
	for k, v := range r.PostForm {
		if k == "csrf" || k == "understood" || len(v) == 0 {
			continue
		}
		in[k] = v[0]
	}
	code, raw, err := s.backupAction(r.Context(), s.who(r).User.Username, conn, name, in)
	if err != nil {
		s.redirect(w, r, back, "", s.backupErrText(r, err))
		return
	}
	if code >= 300 {
		var e struct {
			Error string `json:"error"`
		}
		_ = json.Unmarshal(raw, &e)
		if e.Error == "" {
			e.Error = http.StatusText(code)
		}
		s.redirect(w, r, back, "", s.tr(r, "backup.err.remote", e.Error))
		return
	}
	msg := s.tr(r, "backup.ok.action")
	if name == "rollback" {
		msg = s.tr(r, "backup.ok.rollback", in["archive"])
	}
	s.redirect(w, r, back, msg, "")
}

// ---------- API voor beheerders ----------

func backupConnJSON(c backup.Conn) map[string]any {
	out := map[string]any{
		"id": c.ID, "name": c.Name, "key_hint": c.KeyHint, "created_at": rfcTime(c.CreatedAt), "created_by": c.CreatedBy,
		"connected": c.Connected(), "server_url": c.ServerURL, "server_id": c.ServerID,
	}
	if c.Connected() {
		out["connected_at"] = rfcTime(c.ConnectedAt)
		out["last_seen"] = rfcTime(c.LastSeen)
	}
	// compat: "" (nog onbekend), ok, bluegit_too_old of backup_too_old.
	out["compat"] = c.Compat()
	out["protocol"] = map[string]any{
		"bluegit": backup.Protocol(), "bluegit_min": backup.MinProtocol(),
		"backup": c.PeerProtocol, "backup_min": c.PeerMinProtocol, "backup_version": c.PeerVersion,
	}
	return out
}

func (s *Server) apiBackupAdmin(w http.ResponseWriter, r *http.Request) bool {
	if !apiUser(r).InstanceAdmin {
		s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
		return false
	}
	s.backupInit()
	return true
}

func (s *Server) apiBackupConn(w http.ResponseWriter, r *http.Request) (backup.Conn, bool) {
	if !s.apiBackupAdmin(w, r) {
		return backup.Conn{}, false
	}
	c, ok := s.backupMgr.Get(r.PathValue("id"))
	if !ok {
		s.writeAPIErr(w, r, fail(404, i18n.E("backup.err.unknown")))
	}
	return c, ok
}

func (s *Server) apiAdminBackup(w http.ResponseWriter, r *http.Request) {
	if !s.apiBackupAdmin(w, r) {
		return
	}
	bv := s.backupList()
	servers := make([]map[string]any, 0, len(bv.Servers))
	for _, c := range bv.Servers {
		servers = append(servers, backupConnJSON(c))
	}
	writeJSON(w, http.StatusOK, map[string]any{"instance_id": bv.InstanceID, "max_servers": bv.Max, "servers": servers})
}

func (s *Server) apiAdminBackupAdd(w http.ResponseWriter, r *http.Request) {
	if !s.apiBackupAdmin(w, r) {
		return
	}
	var in struct {
		Name string `json:"name"`
	}
	_ = readJSON(r, &in)
	by := apiUser(r).Username
	key, c, err := s.backupMgr.Add(in.Name, by)
	if errors.Is(err, backup.ErrTooMany) {
		s.writeAPIErr(w, r, fail(409, err))
		return
	}
	if err != nil {
		s.writeAPIErr(w, r, fail(500, err))
		return
	}
	s.backupAudit("add", by, "id", c.ID, "name", c.Name)
	out := backupConnJSON(c)
	out["key"] = key
	writeJSON(w, http.StatusCreated, out)
}

func (s *Server) apiAdminBackupServer(w http.ResponseWriter, r *http.Request) {
	c, ok := s.apiBackupConn(w, r)
	if !ok {
		return
	}
	v := s.backupServerView(r.Context(), c)
	out := backupConnJSON(v.Conn)
	out["archives"] = v.Archives
	if v.Archives == nil {
		out["archives"] = []backup.Archive{}
	}
	if v.Remote != nil {
		out["remote"] = v.Remote
	}
	if v.Config != nil {
		out["config"] = v.Config
	}
	out["remote_error"] = v.RemoteErr
	writeJSON(w, http.StatusOK, out)
}

func (s *Server) apiAdminBackupRename(w http.ResponseWriter, r *http.Request) {
	c, ok := s.apiBackupConn(w, r)
	if !ok {
		return
	}
	var in struct {
		Name string `json:"name"`
	}
	if err := readJSON(r, &in); err != nil {
		s.writeAPIErr(w, r, fail(400, err))
		return
	}
	c, err := s.backupMgr.Rename(c.ID, in.Name)
	if err != nil {
		s.writeAPIErr(w, r, fail(400, err))
		return
	}
	writeJSON(w, http.StatusOK, backupConnJSON(c))
}

func (s *Server) apiAdminBackupKey(w http.ResponseWriter, r *http.Request) {
	c, ok := s.apiBackupConn(w, r)
	if !ok {
		return
	}
	by := apiUser(r).Username
	key, c, err := s.backupMgr.RotateKey(c.ID, by)
	if err != nil {
		s.writeAPIErr(w, r, fail(500, err))
		return
	}
	s.backupAudit("new_key", by, "id", c.ID, "name", c.Name)
	out := backupConnJSON(c)
	out["key"] = key
	writeJSON(w, http.StatusCreated, out)
}

func (s *Server) apiAdminBackupRemove(w http.ResponseWriter, r *http.Request) {
	c, ok := s.apiBackupConn(w, r)
	if !ok {
		return
	}
	if err := s.removeBackupServer(r.Context(), apiUser(r).Username, c); err != nil {
		s.writeAPIErr(w, r, fail(500, err))
		return
	}
	writeJSON(w, http.StatusNoContent, nil)
}

func (s *Server) apiAdminBackupAction(w http.ResponseWriter, r *http.Request) {
	c, ok := s.apiBackupConn(w, r)
	if !ok {
		return
	}
	in := map[string]any{}
	if r.ContentLength != 0 {
		if err := readJSON(r, &in); err != nil {
			s.writeAPIErr(w, r, fail(400, err))
			return
		}
	}
	code, raw, err := s.backupAction(r.Context(), apiUser(r).Username, c, r.PathValue("name"), in)
	if err != nil {
		s.writeAPIErr(w, r, err)
		return
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(code)
	_, _ = w.Write(raw)
}

func unwrapFail(err error) error {
	var oe interface{ Unwrap() error }
	if errors.As(err, &oe) && oe.Unwrap() != nil {
		return oe.Unwrap()
	}
	return err
}
