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: één losse backup server (repo bluegit-backup) haalt met
// een Backupserver-Key alle gegevens op, krijgt een melding bij elke
// wijziging, en kan een archief terugsturen (rollback). 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 {
	Conn       backup.Conn
	NewKey     string
	Archives   []backup.Archive
	Remote     *backup.RemoteStatus
	RemoteErr  string
	InstanceID string
}

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() backup.Tree {
	return backup.Tree{
		StateDir: s.StateDir, DataDir: s.StoragePath(),
		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.backupManifest))
	mux.HandleFunc("GET /api/v1/backup/file", s.backupKeyed(s.backupFile))
	mux.HandleFunc("POST /api/v1/backup/restore", s.backupKeyed(s.backupRestore))
	mux.HandleFunc("GET /admin/backup", s.adminBackup)
	mux.HandleFunc("POST /admin/backup/key", s.adminBackupKey)
	mux.HandleFunc("POST /admin/backup/revoke", s.adminBackupRevoke)
	mux.HandleFunc("POST /admin/backup/rollback", s.adminBackupRollback)
}

// 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")
		if s.StateDir == "" {
			backupErr(w, http.StatusNotFound, "backup niet beschikbaar")
			return
		}
		s.backupInit()
		if _, ok := s.backupMgr.Check(bearer(r)); !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()
		h(w, r)
	}
}

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, _ := s.backupMgr.Load()
	writeJSON(w, http.StatusOK, map[string]any{
		"instance_id": id, "base_url": s.Cfg.BaseURL, "server_url": c.ServerURL, "server_id": c.ServerID,
		"has_storage": s.StoragePath() != "",
	})
}

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(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", "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().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().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)
	}
	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) backupView(r *http.Request) *BackupView {
	s.backupInit()
	bv := &BackupView{}
	bv.Conn, _ = s.backupMgr.Load()
	bv.InstanceID, _ = s.backupMgr.InstanceID()
	if bv.Conn.Connected() {
		ctx, cancel := context.WithTimeout(r.Context(), 8*time.Second)
		defer cancel()
		arch, err := s.backupClient().Archives(ctx)
		if err != nil {
			bv.RemoteErr = err.Error()
		} else {
			bv.Archives = arch
			if st, err := s.backupClient().Status(ctx); err == nil {
				bv.Remote = &st
			}
		}
	}
	return bv
}

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.backupView(r)
	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: "/admin/backup", MaxAge: -1})
	}
	s.render(w, "adminbackup", v)
}

func (s *Server) adminBackupKey(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
		return
	}
	s.backupInit()
	key, _, err := s.backupMgr.NewKey(s.who(r).User.Username)
	if err != nil {
		s.redirect(w, r, "/admin/backup", "", err.Error())
		return
	}
	if s.Log != nil {
		s.Log.Info("backup audit", "action", "new_key", "by", s.who(r).User.Username)
	}
	// Eenmalig tonen: kort, HttpOnly cookie alleen voor deze pagina.
	http.SetCookie(w, &http.Cookie{
		Name: "bluegit_backup_key", Value: key, Path: "/admin/backup", MaxAge: 60, HttpOnly: true,
		SameSite: http.SameSiteStrictMode, Secure: strings.HasPrefix(s.Cfg.BaseURL, "https://"),
	})
	s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.key"), "")
}

func (s *Server) adminBackupRevoke(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
		return
	}
	s.backupInit()
	if err := s.backupMgr.Revoke(); err != nil {
		s.redirect(w, r, "/admin/backup", "", err.Error())
		return
	}
	if s.Log != nil {
		s.Log.Info("backup audit", "action", "revoke", "by", s.who(r).User.Username)
	}
	s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.revoked"), "")
}

func (s *Server) startRollback(ctx context.Context, by, archive, confirm string) error {
	s.backupInit()
	archive = strings.TrimSpace(archive)
	if archive == "" {
		return fail(400, i18n.E("backup.err.archive"))
	}
	if strings.TrimSpace(confirm) != archive {
		return fail(400, i18n.E("backup.err.confirm"))
	}
	c, _ := s.backupMgr.Load()
	if !c.Connected() {
		return fail(409, i18n.E("backup.err.none"))
	}
	if err := s.backupClient().Rollback(ctx, archive); err != nil {
		return fail(502, err)
	}
	if s.Log != nil {
		s.Log.Warn("backup audit", "action", "rollback", "by", by, "archive", archive)
	}
	return nil
}

func (s *Server) adminBackupRollback(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
		return
	}
	if r.FormValue("understood") != "1" {
		s.redirect(w, r, "/admin/backup", "", s.tr(r, "backup.err.understood"))
		return
	}
	if err := s.startRollback(r.Context(), s.who(r).User.Username, r.FormValue("archive"), r.FormValue("confirm")); err != nil {
		s.redirect(w, r, "/admin/backup", "", s.trErr(r, unwrapFail(err)))
		return
	}
	s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.rollback", r.FormValue("archive")), "")
}

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

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

func (s *Server) apiAdminBackup(w http.ResponseWriter, r *http.Request) {
	if !apiUser(r).InstanceAdmin {
		s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
		return
	}
	bv := s.backupView(r)
	out := map[string]any{
		"instance_id": bv.InstanceID, "has_key": bv.Conn.HasKey(), "key_hint": bv.Conn.KeyHint,
		"connected": bv.Conn.Connected(), "server_url": bv.Conn.ServerURL, "server_id": bv.Conn.ServerID,
		"archives": bv.Archives, "remote_error": bv.RemoteErr,
	}
	if bv.Conn.Connected() {
		out["last_seen"] = rfcTime(bv.Conn.LastSeen)
	}
	if bv.Archives == nil {
		out["archives"] = []backup.Archive{}
	}
	if bv.Remote != nil {
		out["remote"] = bv.Remote
	}
	writeJSON(w, http.StatusOK, out)
}

func (s *Server) apiAdminBackupKey(w http.ResponseWriter, r *http.Request) {
	if !apiUser(r).InstanceAdmin {
		s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
		return
	}
	s.backupInit()
	key, c, err := s.backupMgr.NewKey(apiUser(r).Username)
	if err != nil {
		s.writeAPIErr(w, r, fail(500, err))
		return
	}
	if s.Log != nil {
		s.Log.Info("backup audit", "action", "new_key", "by", apiUser(r).Username)
	}
	writeJSON(w, http.StatusCreated, map[string]any{"key": key, "key_hint": c.KeyHint, "created_at": rfcTime(c.CreatedAt)})
}

func (s *Server) apiAdminBackupRevoke(w http.ResponseWriter, r *http.Request) {
	if !apiUser(r).InstanceAdmin {
		s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
		return
	}
	s.backupInit()
	if err := s.backupMgr.Revoke(); err != nil {
		s.writeAPIErr(w, r, fail(500, err))
		return
	}
	writeJSON(w, http.StatusNoContent, nil)
}

func (s *Server) apiAdminBackupRollback(w http.ResponseWriter, r *http.Request) {
	if !apiUser(r).InstanceAdmin {
		s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
		return
	}
	var in struct {
		Archive string `json:"archive"`
		Confirm string `json:"confirm"`
	}
	if err := readJSON(r, &in); err != nil {
		s.writeAPIErr(w, r, fail(400, i18n.E("backup.err.archive")))
		return
	}
	if err := s.startRollback(r.Context(), apiUser(r).Username, in.Archive, in.Confirm); err != nil {
		s.writeAPIErr(w, r, err)
		return
	}
	writeJSON(w, http.StatusAccepted, map[string]any{"archive": in.Archive, "state": "started"})
}
