// Package server is de backup server: sync, archieven, de API voor BlueGit
// en de lokale beheer-API.
package server

import (
	"context"
	"crypto/subtle"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log/slog"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"time"

	"git.timfalken.com/timfa/bluegit-backup/internal/archive"
	"git.timfalken.com/timfa/bluegit-backup/internal/config"
	"git.timfalken.com/timfa/bluegit-backup/internal/mirror"
	"git.timfalken.com/timfa/bluegit-backup/internal/protocol"
	"git.timfalken.com/timfa/bluegit-backup/internal/throttle"
)

// Version wordt bij het bouwen gezet (-ldflags -X).
var Version = "dev"

// Server is één backup server voor één BlueGit.
type Server struct {
	Cfg config.Config
	Log *slog.Logger
	// Now is de klok (tests).
	Now func() time.Time
	// HTTP is de client richting BlueGit (tests).
	HTTP *http.Client

	adminToken string
	serverID   string
	limiter    *throttle.Limiter
	mirror     *mirror.Mirror
	archives   *archive.Store

	// work beschermt de kopie: sync, archiveren, rollback en koppelen
	// gebeuren nooit tegelijk.
	work sync.Mutex

	mu          sync.Mutex
	state       State
	lastSync    time.Time
	lastSyncErr string
	lastStats   mirror.Stats
	syncs       int
	notifies    int
	lastArchive time.Time
	archiveErr  string
	rollback    RollbackStatus

	kick chan struct{}
}

// RollbackStatus is de stand van de laatste rollback of restore.
type RollbackStatus struct {
	State   string    `json:"state"` // idle | running | done | failed
	Archive string    `json:"archive,omitempty"`
	Error   string    `json:"error,omitempty"`
	At      time.Time `json:"at,omitempty"`
}

// New zet de mappen klaar en leest de koppeling.
func New(cfg config.Config, log *slog.Logger) (*Server, error) {
	if log == nil {
		log = slog.New(slog.NewTextHandler(io.Discard, nil))
	}
	if err := os.MkdirAll(cfg.DataDir, 0o750); err != nil {
		return nil, err
	}
	s := &Server{Cfg: cfg, Log: log, Now: time.Now, kick: make(chan struct{}, 1)}
	var err error
	if s.adminToken, err = secretFile(cfg.DataDir, "admin.token", "bba_"); err != nil {
		return nil, err
	}
	if s.serverID, err = secretFile(cfg.DataDir, "server_id", ""); err != nil {
		return nil, err
	}
	if s.state, err = loadState(cfg.DataDir); err != nil {
		return nil, err
	}
	s.limiter = throttle.New(cfg.RateLimitKiB << 10)
	s.mirror = &mirror.Mirror{Dir: filepath.Join(cfg.DataDir, "mirror"), Index: filepath.Join(cfg.DataDir, "mirror.index.json")}
	s.archives = &archive.Store{Dir: filepath.Join(cfg.DataDir, "archives")}
	_ = os.RemoveAll(filepath.Join(cfg.DataDir, "tmp"))
	if list, _ := s.archives.List(); len(list) > 0 {
		s.lastArchive = list[0].CreatedAt
	}
	s.rollback.State = "idle"
	return s, nil
}

// SetFree vervangt de vrije-ruimtemeting (tests).
func (s *Server) SetFree(f func(string) (uint64, error)) { s.archives.Free = f }

// AdminToken is het lokale beheertoken.
func (s *Server) AdminToken() string { return s.adminToken }

func (s *Server) now() time.Time { return s.Now() }

func (s *Server) remote(st State) *mirror.Remote {
	return &mirror.Remote{URL: st.BlueGitURL, Key: st.Key, HTTP: s.HTTP, Limiter: s.limiter}
}

func (s *Server) getState() State {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.state
}

// Run start de achtergrondtaken tot ctx klaar is.
func (s *Server) Run(ctx context.Context) {
	go s.syncLoop(ctx)
	go s.archiveLoop(ctx)
}

// Kick vraagt om een sync (na een melding).
func (s *Server) Kick() {
	select {
	case s.kick <- struct{}{}:
	default:
	}
}

func (s *Server) syncLoop(ctx context.Context) {
	full := time.NewTicker(s.Cfg.FullSyncInterval.Duration)
	defer full.Stop()
	s.Kick() // meteen na de start
	for {
		select {
		case <-ctx.Done():
			return
		case <-full.C:
		case <-s.kick:
		}
		s.mu.Lock()
		wait := s.Cfg.MinSyncInterval.Duration - s.now().Sub(s.lastSync)
		s.mu.Unlock()
		if wait > 0 {
			select {
			case <-ctx.Done():
				return
			case <-time.After(wait):
			}
		}
		// Meldingen die in de tussentijd binnenkwamen, zitten in deze sync.
		select {
		case <-s.kick:
		default:
		}
		_, _ = s.SyncNow(ctx)
	}
}

// SyncNow synchroniseert één keer.
func (s *Server) SyncNow(ctx context.Context) (mirror.Stats, error) {
	st := s.getState()
	if !st.Connected() {
		return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
	}
	s.work.Lock()
	defer s.work.Unlock()
	st = s.getState()
	if !st.Connected() {
		return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
	}
	stats, err := s.mirror.Sync(ctx, s.remote(st))
	s.mu.Lock()
	s.lastSync = s.now()
	s.syncs++
	s.lastStats = stats
	if err != nil {
		s.lastSyncErr = err.Error()
	} else {
		s.lastSyncErr = ""
	}
	s.mu.Unlock()
	if err != nil {
		s.Log.Warn("sync mislukt", "err", err)
	} else if stats.Downloaded > 0 || stats.Deleted > 0 {
		s.Log.Info("sync", "files", stats.Files, "downloaded", stats.Downloaded, "bytes", stats.Bytes, "deleted", stats.Deleted)
	}
	return stats, err
}

func (s *Server) archiveLoop(ctx context.Context) {
	t := time.NewTicker(s.tick())
	defer t.Stop()
	for {
		select {
		case <-ctx.Done():
			return
		case <-t.C:
		}
		s.mu.Lock()
		due := s.now().Sub(s.lastArchive) >= s.Cfg.ArchiveInterval.Duration
		synced := !s.lastSync.IsZero() && s.lastSyncErr == ""
		s.mu.Unlock()
		if due && synced {
			if _, err := s.ArchiveNow(); err != nil {
				s.Log.Warn("archief mislukt", "err", err)
			}
		}
		if _, err := s.Prune(); err != nil {
			s.Log.Warn("opruimen mislukt", "err", err)
		}
	}
}

// tick is hoe vaak de archieflus kijkt: een minuut, of korter bij een kort interval.
func (s *Server) tick() time.Duration {
	d := s.Cfg.ArchiveInterval.Duration / 4
	if d > time.Minute {
		d = time.Minute
	}
	if d < 100*time.Millisecond {
		d = 100 * time.Millisecond
	}
	return d
}

// ArchiveNow comprimeert de hele kopie tot een nieuw archief.
func (s *Server) ArchiveNow() (archive.Archive, error) {
	s.work.Lock()
	defer s.work.Unlock()
	if s.mirror.Empty() {
		return archive.Archive{}, errors.New("de kopie is nog leeg")
	}
	now := s.now()
	a, removed, err := s.archives.Create(s.mirror.Dir, now, s.mirror.Size(), s.minFree())
	s.mu.Lock()
	if err != nil {
		s.archiveErr = err.Error()
	} else {
		s.archiveErr = ""
		s.lastArchive = now
	}
	s.mu.Unlock()
	for _, r := range removed {
		s.Log.Info("archief verwijderd: schijf vol", "archive", r)
	}
	if err != nil {
		return a, err
	}
	s.Log.Info("archief gemaakt", "archive", a.Name, "bytes", a.Size)
	if pr, err := s.archives.Prune(now, s.Cfg.RetentionDays, s.minFree()); err == nil {
		for _, r := range pr {
			s.Log.Info("archief verwijderd", "archive", r)
		}
	}
	return a, nil
}

func (s *Server) minFree() uint64 { return uint64(s.Cfg.MinFreeMB) << 20 }

// Prune past de bewaarregels toe.
func (s *Server) Prune() ([]string, error) {
	s.work.Lock()
	defer s.work.Unlock()
	removed, err := s.archives.Prune(s.now(), s.Cfg.RetentionDays, s.minFree())
	for _, r := range removed {
		s.Log.Info("archief verwijderd", "archive", r)
	}
	return removed, err
}

// ---------- HTTP ----------

// Handler is de HTTP-API.
func (s *Server) Handler() http.Handler {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("ok\n")) })
	// Van BlueGit, ondertekend.
	mux.HandleFunc("POST /api/v1/notify", s.signed(s.apiNotify))
	mux.HandleFunc("GET /api/v1/archives", s.signed(s.apiArchives))
	mux.HandleFunc("GET /api/v1/status", s.signed(s.apiStatus))
	mux.HandleFunc("POST /api/v1/rollback", s.signed(s.apiRollback))
	// Lokaal beheer, met admin.token.
	mux.HandleFunc("GET /api/v1/admin/status", s.admin(s.apiStatus))
	mux.HandleFunc("GET /api/v1/admin/archives", s.admin(s.apiArchives))
	mux.HandleFunc("POST /api/v1/admin/connect", s.admin(s.apiConnect))
	mux.HandleFunc("POST /api/v1/admin/sync", s.admin(s.apiSync))
	mux.HandleFunc("POST /api/v1/admin/archive", s.admin(s.apiArchiveNow))
	mux.HandleFunc("POST /api/v1/admin/prune", s.admin(s.apiPrune))
	mux.HandleFunc("POST /api/v1/admin/self-update", s.selfUpdate)
	return mux
}

func writeJSON(w http.ResponseWriter, code int, v any) {
	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("Cache-Control", "no-store")
	w.WriteHeader(code)
	if v != nil {
		_ = json.NewEncoder(w).Encode(v)
	}
}

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

type ctxBody struct{}

// signed controleert de HMAC-handtekening van de gekoppelde BlueGit.
func (s *Server) signed(h http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		st := s.getState()
		if !st.Connected() {
			writeErr(w, http.StatusUnauthorized, "niet gekoppeld")
			return
		}
		body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
		if err != nil {
			writeErr(w, 400, "body")
			return
		}
		if r.Header.Get(protocol.HeaderInstance) != st.InstanceID {
			writeErr(w, http.StatusUnauthorized, "andere BlueGit-instantie")
			return
		}
		if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil {
			writeErr(w, http.StatusUnauthorized, err.Error())
			return
		}
		r = r.WithContext(context.WithValue(r.Context(), ctxBody{}, body))
		h(w, r)
	}
}

func bodyOf(r *http.Request) []byte {
	if b, ok := r.Context().Value(ctxBody{}).([]byte); ok {
		return b
	}
	b, _ := io.ReadAll(io.LimitReader(r.Body, 1<<20))
	return b
}

func (s *Server) admin(h http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		tok := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
		if subtle.ConstantTimeCompare([]byte(tok), []byte(s.adminToken)) != 1 {
			writeErr(w, http.StatusUnauthorized, "admin.token nodig")
			return
		}
		h(w, r)
	}
}

func (s *Server) apiNotify(w http.ResponseWriter, r *http.Request) {
	s.mu.Lock()
	s.notifies++
	s.mu.Unlock()
	s.Kick()
	w.WriteHeader(http.StatusNoContent)
}

func (s *Server) apiArchives(w http.ResponseWriter, r *http.Request) {
	list, err := s.archives.List()
	if err != nil {
		writeErr(w, 500, err.Error())
		return
	}
	writeJSON(w, 200, map[string]any{"archives": list})
}

// Status is wat GET /api/v1/status en de CLI tonen.
type Status struct {
	Version       string         `json:"version"`
	ServerID      string         `json:"server_id"`
	BlueGitURL    string         `json:"bluegit_url,omitempty"`
	InstanceID    string         `json:"instance_id,omitempty"`
	Connected     bool           `json:"connected"`
	LastSync      time.Time      `json:"last_sync,omitempty"`
	SyncError     string         `json:"sync_error,omitempty"`
	LastStats     mirror.Stats   `json:"last_stats"`
	Syncs         int            `json:"syncs"`
	Notifies      int            `json:"notifies"`
	MirrorBytes   int64          `json:"mirror_bytes"`
	Archives      int            `json:"archives"`
	LastArchive   time.Time      `json:"last_archive,omitempty"`
	ArchiveError  string         `json:"archive_error,omitempty"`
	Interval      string         `json:"archive_interval"`
	RetentionDays int            `json:"retention_days"`
	RateLimitKiB  int64          `json:"rate_limit_kib"`
	Rollback      RollbackStatus `json:"rollback"`
}

// Status geeft de huidige stand.
func (s *Server) Status() Status {
	list, _ := s.archives.List()
	s.mu.Lock()
	defer s.mu.Unlock()
	return Status{
		Version: Version, ServerID: s.serverID, BlueGitURL: s.state.BlueGitURL, InstanceID: s.state.InstanceID,
		Connected: s.state.Connected(), LastSync: s.lastSync, SyncError: s.lastSyncErr, LastStats: s.lastStats,
		Syncs: s.syncs, Notifies: s.notifies, MirrorBytes: s.mirror.Size(), Archives: len(list),
		LastArchive: s.lastArchive, ArchiveError: s.archiveErr, Interval: s.Cfg.ArchiveInterval.String(),
		RetentionDays: s.Cfg.RetentionDays, RateLimitKiB: s.Cfg.RateLimitKiB, Rollback: s.rollback,
	}
}

func (s *Server) apiStatus(w http.ResponseWriter, r *http.Request) { writeJSON(w, 200, s.Status()) }

func (s *Server) apiSync(w http.ResponseWriter, r *http.Request) {
	stats, err := s.SyncNow(r.Context())
	if err != nil {
		writeErr(w, 502, err.Error())
		return
	}
	writeJSON(w, 200, stats)
}

func (s *Server) apiArchiveNow(w http.ResponseWriter, r *http.Request) {
	a, err := s.ArchiveNow()
	if err != nil {
		writeErr(w, 409, err.Error())
		return
	}
	writeJSON(w, 201, a)
}

func (s *Server) apiPrune(w http.ResponseWriter, r *http.Request) {
	removed, err := s.Prune()
	if err != nil {
		writeErr(w, 500, err.Error())
		return
	}
	if removed == nil {
		removed = []string{}
	}
	writeJSON(w, 200, map[string]any{"removed": removed})
}

// ---------- koppelen ----------

// ConnectRequest is POST /api/v1/admin/connect.
type ConnectRequest struct {
	URL string `json:"url"`
	Key string `json:"key"`
	// OnConflict is leeg, "wipe" of "restore". Leeg en een andere BlueGit
	// dan de vorige: 409 met de keuzes.
	OnConflict string `json:"on_conflict"`
}

// ConflictError is het 409-antwoord bij een andere BlueGit.
type ConflictError struct {
	Conflict         bool     `json:"conflict"`
	Error            string   `json:"error"`
	PreviousURL      string   `json:"previous_url"`
	PreviousInstance string   `json:"previous_instance"`
	NewInstance      string   `json:"new_instance"`
	Archives         int      `json:"archives"`
	Choices          []string `json:"choices"`
}

func (s *Server) apiConnect(w http.ResponseWriter, r *http.Request) {
	var in ConnectRequest
	if err := json.Unmarshal(bodyOf(r), &in); err != nil {
		writeErr(w, 400, "ongeldige JSON")
		return
	}
	res, conflict, err := s.Connect(r.Context(), in)
	if conflict != nil {
		writeJSON(w, http.StatusConflict, conflict)
		return
	}
	if err != nil {
		var he *mirror.HTTPError
		code := 502
		if errors.As(err, &he) && he.Status == 401 {
			code = 401
		}
		if errors.Is(err, errBadRequest) {
			code = 400
		}
		writeErr(w, code, err.Error())
		return
	}
	writeJSON(w, 200, res)
}

var errBadRequest = errors.New("ongeldig verzoek")

// Connect koppelt deze server aan een BlueGit. Er is er altijd hoogstens één.
func (s *Server) Connect(ctx context.Context, in ConnectRequest) (map[string]any, *ConflictError, error) {
	in.URL = strings.TrimRight(strings.TrimSpace(in.URL), "/")
	in.Key = strings.TrimSpace(in.Key)
	if !strings.HasPrefix(in.URL, "http://") && !strings.HasPrefix(in.URL, "https://") {
		return nil, nil, fmt.Errorf("%w: url moet met http:// of https:// beginnen", errBadRequest)
	}
	if !strings.HasPrefix(in.Key, protocol.KeyPrefix) {
		return nil, nil, fmt.Errorf("%w: de Backupserver-Key begint met %s", errBadRequest, protocol.KeyPrefix)
	}
	switch in.OnConflict {
	case "", "wipe", "restore":
	default:
		return nil, nil, fmt.Errorf("%w: on_conflict moet wipe of restore zijn", errBadRequest)
	}
	if s.Cfg.PublicURL == "" {
		return nil, nil, fmt.Errorf("%w: zet public_url in de configuratie; BlueGit moet deze server kunnen bereiken", errBadRequest)
	}
	s.work.Lock()
	defer s.work.Unlock()
	rem := &mirror.Remote{URL: in.URL, Key: in.Key, HTTP: s.HTTP, Limiter: s.limiter}
	info, err := rem.Info(ctx)
	if err != nil {
		return nil, nil, err
	}
	old := s.getState()
	list, _ := s.archives.List()
	hasData := !s.mirror.Empty() || len(list) > 0
	other := old.InstanceID != "" && old.InstanceID != info.InstanceID && hasData
	mode := ""
	if other {
		if in.OnConflict == "" {
			return nil, &ConflictError{
				Conflict: true, Error: "deze backup server hoort bij een andere BlueGit",
				PreviousURL: old.BlueGitURL, PreviousInstance: old.InstanceID, NewInstance: info.InstanceID,
				Archives: len(list), Choices: []string{"wipe", "restore"},
			}, nil
		}
		mode = in.OnConflict
	}
	if mode == "wipe" {
		if err := s.mirror.Wipe(); err != nil {
			return nil, nil, err
		}
		if err := s.archives.DeleteAll(); err != nil {
			return nil, nil, err
		}
		s.mu.Lock()
		s.lastArchive = time.Time{}
		s.mu.Unlock()
		s.Log.Warn("oude backups verwijderd voor een nieuwe BlueGit", "old", old.InstanceID, "new", info.InstanceID)
	}
	if mode == "restore" && s.mirror.Empty() {
		return nil, nil, fmt.Errorf("%w: de kopie is leeg; er is niets om terug te zetten", errBadRequest)
	}
	if err := rem.Connect(ctx, s.Cfg.PublicURL, s.serverID); err != nil {
		return nil, nil, err
	}
	st := State{BlueGitURL: in.URL, Key: in.Key, InstanceID: info.InstanceID, ConnectedAt: s.now().UTC()}
	if err := saveState(s.Cfg.DataDir, st); err != nil {
		return nil, nil, err
	}
	s.mu.Lock()
	s.state = st
	s.mu.Unlock()
	s.Log.Info("gekoppeld", "bluegit", in.URL, "instance", info.InstanceID, "mode", mode)
	out := map[string]any{"instance_id": info.InstanceID, "bluegit_url": in.URL, "mode": mode}
	if mode == "restore" {
		if err := s.sendMirror(ctx, rem, "restore"); err != nil {
			return nil, nil, fmt.Errorf("terugzetten naar de nieuwe BlueGit mislukt: %w", err)
		}
		out["restored"] = true
	}
	s.Kick()
	return out, nil, nil
}

// sendMirror stuurt de hele kopie als tar.gz naar BlueGit en wacht tot die
// herstart is. Aanroepen met s.work vast.
func (s *Server) sendMirror(ctx context.Context, rem *mirror.Remote, label string) error {
	s.setRollback(RollbackStatus{State: "running", Archive: label, At: s.now().UTC()})
	pr, pw := io.Pipe()
	go func() { pw.CloseWithError(archive.WriteTarGz(pw, s.mirror.Dir)) }()
	if err := rem.Restore(ctx, pr); err != nil {
		pr.CloseWithError(err)
		s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
		return err
	}
	if err := rem.WaitUp(ctx, 3*time.Minute); err != nil {
		s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
		return err
	}
	s.setRollback(RollbackStatus{State: "done", Archive: label, At: s.now().UTC()})
	return nil
}

func (s *Server) setRollback(r RollbackStatus) {
	s.mu.Lock()
	s.rollback = r
	s.mu.Unlock()
}

// ---------- rollback ----------

func (s *Server) apiRollback(w http.ResponseWriter, r *http.Request) {
	var in struct {
		Archive string `json:"archive"`
	}
	if err := json.Unmarshal(bodyOf(r), &in); err != nil || !archive.ValidName(in.Archive) {
		writeErr(w, 400, "ongeldige archiefnaam")
		return
	}
	if _, err := s.archives.Path(in.Archive); err != nil {
		writeErr(w, 404, err.Error())
		return
	}
	s.mu.Lock()
	busy := s.rollback.State == "running"
	if !busy {
		s.rollback = RollbackStatus{State: "running", Archive: in.Archive, At: s.now().UTC()}
	}
	s.mu.Unlock()
	if busy {
		writeErr(w, 409, "er loopt al een rollback")
		return
	}
	s.Log.Warn("rollback gestart", "archive", in.Archive)
	go func() {
		if err := s.Rollback(context.Background(), in.Archive); err != nil {
			s.Log.Error("rollback mislukt", "archive", in.Archive, "err", err)
		}
	}()
	writeJSON(w, http.StatusAccepted, map[string]string{"state": "running", "archive": in.Archive})
}

// Rollback pakt een archief uit, vervangt daarmee de draaiende kopie en
// stuurt die naar BlueGit. Lukt het sturen niet, dan komt de oude kopie
// terug, zodat kopie en BlueGit gelijk blijven.
func (s *Server) Rollback(ctx context.Context, name string) error {
	s.work.Lock()
	defer s.work.Unlock()
	fail := func(err error) error {
		s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
		return err
	}
	st := s.getState()
	if !st.Connected() {
		return fail(errors.New("geen BlueGit gekoppeld"))
	}
	src, err := s.archives.Path(name)
	if err != nil {
		return fail(err)
	}
	fresh := filepath.Join(s.Cfg.DataDir, "mirror.rollback")
	old := filepath.Join(s.Cfg.DataDir, "mirror.old")
	_ = os.RemoveAll(fresh)
	_ = os.RemoveAll(old)
	if err := archive.Extract(src, fresh); err != nil {
		_ = os.RemoveAll(fresh)
		return fail(fmt.Errorf("uitpakken: %w", err))
	}
	oldIndex, _ := os.ReadFile(s.mirror.Index)
	if err := os.Rename(s.mirror.Dir, old); err != nil && !errors.Is(err, os.ErrNotExist) {
		return fail(err)
	}
	if err := os.Rename(fresh, s.mirror.Dir); err != nil {
		_ = os.Rename(old, s.mirror.Dir)
		return fail(err)
	}
	if err := s.mirror.RebuildIndex(); err != nil {
		return fail(err)
	}
	if err := s.sendMirror(ctx, s.remote(st), name); err != nil {
		// Terug naar de kopie van vóór de rollback.
		_ = os.RemoveAll(s.mirror.Dir)
		_ = os.Rename(old, s.mirror.Dir)
		_ = os.WriteFile(s.mirror.Index, oldIndex, 0o600)
		s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
		return err
	}
	_ = os.RemoveAll(old)
	s.Log.Warn("rollback klaar", "archive", name)
	s.Kick()
	return nil
}

// ---------- self-update ----------

// UpdateStarter start de update-unit (tests zetten een stub).
var UpdateStarter = func(ctx context.Context, ref string) error {
	return startUpdateUnit(ctx, ref)
}

var updateHits = struct {
	sync.Mutex
	at []time.Time
}{}

func (s *Server) selfUpdate(w http.ResponseWriter, r *http.Request) {
	tok := os.Getenv("BLUEGIT_BACKUP_UPDATE_TOKEN")
	if tok == "" {
		http.NotFound(w, r)
		return
	}
	updateHits.Lock()
	cut := time.Now().Add(-time.Minute)
	keep := updateHits.at[:0]
	for _, t := range updateHits.at {
		if t.After(cut) {
			keep = append(keep, t)
		}
	}
	updateHits.at = append(keep, time.Now())
	n := len(updateHits.at)
	updateHits.Unlock()
	if n > 5 {
		writeErr(w, http.StatusTooManyRequests, "te veel verzoeken")
		return
	}
	got := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
	if subtle.ConstantTimeCompare([]byte(got), []byte(tok)) != 1 {
		writeErr(w, http.StatusUnauthorized, "unauthorized")
		return
	}
	var in struct {
		Ref string `json:"ref"`
	}
	_ = json.NewDecoder(io.LimitReader(r.Body, 4096)).Decode(&in)
	if !validRef(in.Ref) {
		writeErr(w, 400, "ref moet een volledige sha zijn")
		return
	}
	if err := UpdateStarter(r.Context(), in.Ref); err != nil {
		writeErr(w, 500, err.Error())
		return
	}
	writeJSON(w, http.StatusAccepted, map[string]string{"ref": in.Ref, "state": "started"})
}

func validRef(ref string) bool {
	if len(ref) != 40 {
		return false
	}
	for _, c := range ref {
		if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
			return false
		}
	}
	return true
}
