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

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

	"gitlab.com/Timfa/bluegit/internal/backupserver/archive"
	"gitlab.com/Timfa/bluegit/internal/backupserver/config"
	"gitlab.com/Timfa/bluegit/internal/backupserver/mirror"
	"gitlab.com/Timfa/bluegit/internal/backupserver/protocol"
	"gitlab.com/Timfa/bluegit/internal/backupserver/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
	// bluegit is het protocol dat de gekoppelde BlueGit het laatst meldde.
	bluegit      protocol.Peer
	bluegitKnown bool

	kick chan struct{}

	// settings is wat via webinterface, API of BlueGit is ingesteld.
	settings       map[string]string
	restartPending bool
	sessions       map[string]session
	loginFails     map[string][]time.Time
}

// cfg is de huidige configuratie (instellingen kunnen tijdens het draaien
// veranderen).
func (s *Server) cfg() config.Config {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.Cfg
}

// 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
	}
	set, err := config.LoadSettings(cfg.DataDir)
	if err != nil {
		return nil, err
	}
	if err := cfg.Apply(set); err != nil {
		return nil, fmt.Errorf("%s: %w", config.SettingsFile, err)
	}
	s := &Server{Cfg: cfg, Log: log, Now: time.Now, kick: make(chan struct{}, 1), settings: set, sessions: map[string]session{}}
	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, Version: Version, OnPeer: s.setBlueGit}
}

// setBlueGit legt het protocol van BlueGit vast.
func (s *Server) setBlueGit(p protocol.Peer) {
	s.mu.Lock()
	changed := !s.bluegitKnown || s.bluegit != p
	s.bluegit, s.bluegitKnown = p, true
	s.mu.Unlock()
	if changed && p.Compat() != protocol.CompatOK {
		s.Log.Warn("niet compatibel met BlueGit", "compat", p.Compat(), "bluegit_protocol", p.Protocol, "bluegit_min", p.MinProtocol,
			"protocol", protocol.Protocol(), "min", protocol.MinProtocol())
	}
}

// compat is "" (nog onbekend), ok, bluegit_too_old of backup_too_old.
func (s *Server) compat() (string, protocol.Peer) {
	s.mu.Lock()
	defer s.mu.Unlock()
	if !s.bluegitKnown {
		return "", s.bluegit
	}
	return s.bluegit.Compat(), s.bluegit
}

// compatMessage zegt wie er geüpdatet moet worden (leeg als alles past).
func compatMessage(c string, p protocol.Peer) string {
	switch c {
	case protocol.CompatBlueGitTooOld:
		return fmt.Sprintf("BlueGit is verouderd (protocol %d; deze backup server vraagt minstens %d). Update BlueGit; tot dan wordt er niets gesynchroniseerd of teruggezet.", p.Protocol, protocol.MinProtocol())
	case protocol.CompatBackupTooOld:
		return fmt.Sprintf("Deze backup server is verouderd (protocol %d; BlueGit vraagt minstens %d). Update de backup server; tot dan wordt er niets gesynchroniseerd of teruggezet.", protocol.Protocol(), p.MinProtocol)
	}
	return ""
}

// ErrIncompatible: BlueGit en deze backup server passen niet bij elkaar.
var ErrIncompatible = errors.New("niet compatibel")

// checkCompat vraagt info op bij BlueGit en weigert als de protocollen niet
// passen. Aanroepen vóór elke sync, rollback of restore.
func (s *Server) checkCompat(ctx context.Context, rem *mirror.Remote) error {
	info, err := rem.Info(ctx)
	if err != nil {
		return err
	}
	s.setBlueGit(info.Peer())
	if c, p := s.compat(); c != protocol.CompatOK {
		return fmt.Errorf("%w: %s", ErrIncompatible, compatMessage(c, p))
	}
	return nil
}

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) {
	s.Kick() // meteen na de start
	for {
		s.mu.Lock()
		next := s.Cfg.FullSyncInterval.Duration - s.now().Sub(s.lastSync)
		s.mu.Unlock()
		if next < 0 {
			next = 0
		}
		full := time.NewTimer(next)
		select {
		case <-ctx.Done():
			full.Stop()
			return
		case <-full.C:
		case <-s.kick:
			full.Stop()
		}
		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")
	}
	rem := s.remote(st)
	var stats mirror.Stats
	err := s.checkCompat(ctx, rem)
	if err == nil {
		stats, err = s.mirror.Sync(ctx, rem)
	}
	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) {
	for {
		select {
		case <-ctx.Done():
			return
		case <-time.After(s.tick()):
		}
		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
}

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
		}
		// Zonder koppen is het een BlueGit van vóór de protocolversie.
		p, _ := protocol.BlueGitFromHeader(r.Header)
		s.setBlueGit(p)
		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) 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"`
	// Protocol van deze server en van BlueGit; Compat is "" (nog
	// onbekend), ok, bluegit_too_old of backup_too_old.
	Protocol           int    `json:"protocol"`
	MinProtocol        int    `json:"min_protocol"`
	BlueGitProtocol    int    `json:"bluegit_protocol,omitempty"`
	BlueGitMinProtocol int    `json:"bluegit_min_protocol,omitempty"`
	BlueGitVersion     string `json:"bluegit_version,omitempty"`
	Compat             string `json:"compat"`
	CompatMessage      string `json:"compat_message,omitempty"`
}

// Status geeft de huidige stand.
func (s *Server) Status() Status {
	list, _ := s.archives.List()
	compat, peer := s.compat()
	s.mu.Lock()
	defer s.mu.Unlock()
	st := 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,
		Protocol: protocol.Protocol(), MinProtocol: protocol.MinProtocol(), Compat: compat, CompatMessage: compatMessage(compat, peer),
	}
	if s.bluegitKnown {
		st.BlueGitProtocol, st.BlueGitMinProtocol, st.BlueGitVersion = peer.Protocol, peer.MinProtocol, peer.Version
	}
	return st
}

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

// ---------- 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"`
}

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)
	}
	pub := s.cfg().PublicURL
	if pub == "" {
		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, Version: Version, OnPeer: s.setBlueGit}
	info, err := rem.Info(ctx)
	if err != nil {
		return nil, nil, err
	}
	// Ook bij een niet-passende BlueGit koppelen we, zodat BlueGit het zijn
	// beheerders kan laten zien; synchroniseren en terugzetten gebeurt dan niet.
	s.setBlueGit(info.Peer())
	compat := info.Peer().Compat()
	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" && compat != protocol.CompatOK {
		return nil, nil, fmt.Errorf("%w: %s", ErrIncompatible, compatMessage(compat, info.Peer()))
	}
	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, pub, 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, "compat": compat}
	if msg := compatMessage(compat, info.Peer()); msg != "" {
		out["warning"] = msg
	}
	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
	}
	code, out := s.startRollback(in.Archive)
	writeJSON(w, code, out)
}

// 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"))
	}
	if err := s.checkCompat(ctx, s.remote(st)); err != nil {
		return fail(err)
	}
	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
}
