package backup

import (
	"archive/tar"
	"compress/gzip"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"os"
	"path"
	"path/filepath"
	"sort"
	"strings"
	"sync"
	"time"
)

// Wat er in een backup zit. Logische paden beginnen met state/ of data/.
//
//	state/bluegit.db   consistente kopie (VACUUM INTO), niet het live bestand
//	state/secret.key   nodig om de geheimen in de database te lezen
//	state/ssh/…        SSH-hostkey
//	state/logos/…      project- en groepslogo's
//	state/avatars/…    geüploade avatars
//	data/repos/…       bare repositories
//	data/releases/…    gepubliceerde release-assets (zonder .incoming)
//	data/artifacts/…   CI-artifacts
//
// Niet mee: storage_path, cache.json, backup.json en instance_id (horen bij
// de installatie), data/work (tijdelijke werkmappen), lock-bestanden en
// symlinks.
var (
	stateFiles = []string{"bluegit.db", "secret.key"}
	stateDirs  = []string{"ssh", "logos", "avatars"}
	dataDirs   = []string{"repos", "releases", "artifacts"}
)

// DBPath is het logische pad van de databasekopie.
const DBPath = "state/bluegit.db"

// Entry is één bestand in het manifest.
type Entry struct {
	Path   string `json:"path"`
	Size   int64  `json:"size"`
	MTime  int64  `json:"mtime"` // Unix-milliseconden
	Mode   uint32 `json:"mode"`
	SHA256 string `json:"sha256,omitempty"`
}

// Manifest is de volledige lijst op één moment.
type Manifest struct {
	Instance  string    `json:"instance_id"`
	CreatedAt time.Time `json:"created_at"`
	Files     []Entry   `json:"files"`
}

// Tree kent de twee mappen van een installatie.
type Tree struct {
	StateDir string
	DataDir  string // leeg als er geen datadisk is
	// Snapshot schrijft een consistente kopie van de database naar pad.
	Snapshot func(dst string) error
	// Conn is de koppeling waarvoor de kopie is. Elke backup server krijgt
	// een eigen databasekopie, zodat twee servers die tegelijk een
	// manifest ophalen elkaars kopie niet vervangen.
	Conn string
}

// snapshotMu zorgt dat er maar één databasekopie tegelijk gemaakt wordt.
var snapshotMu sync.Mutex

func (t Tree) snapshotPath() string {
	name := "snapshot.db"
	if t.Conn != "" {
		name = "snapshot-" + safeName(t.Conn) + ".db"
	}
	return filepath.Join(t.StateDir, ".backup", name)
}

// RemoveSnapshot ruimt de databasekopie van een koppeling op.
func (t Tree) RemoveSnapshot() { _ = os.Remove(t.snapshotPath()) }

func safeName(s string) string {
	var b strings.Builder
	for _, r := range s {
		if r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || r == '-' || r == '_' {
			b.WriteRune(r)
		}
	}
	return b.String()
}

// Build maakt een nieuwe databasekopie en loopt alle bestanden af.
func (t Tree) Build(instance string) (Manifest, error) {
	m := Manifest{Instance: instance, CreatedAt: time.Now().UTC(), Files: []Entry{}}
	if t.Snapshot != nil {
		snap := t.snapshotPath()
		if err := os.MkdirAll(filepath.Dir(snap), 0o700); err != nil {
			return m, err
		}
		tmp := snap + ".new"
		snapshotMu.Lock()
		_ = os.Remove(tmp)
		err := t.Snapshot(tmp)
		if err == nil {
			err = os.Rename(tmp, snap)
		} else {
			err = fmt.Errorf("databasekopie: %w", err)
		}
		snapshotMu.Unlock()
		if err != nil {
			return m, err
		}
		e, err := entryOf(DBPath, snap, true)
		if err != nil {
			return m, err
		}
		m.Files = append(m.Files, e)
	}
	for _, f := range stateFiles[1:] {
		p := filepath.Join(t.StateDir, f)
		if e, err := entryOf("state/"+f, p, false); err == nil {
			m.Files = append(m.Files, e)
		}
	}
	for _, d := range stateDirs {
		if err := walk(&m, "state/"+d, filepath.Join(t.StateDir, d)); err != nil {
			return m, err
		}
	}
	if t.DataDir != "" {
		for _, d := range dataDirs {
			if err := walk(&m, "data/"+d, filepath.Join(t.DataDir, d)); err != nil {
				return m, err
			}
		}
	}
	sort.Slice(m.Files, func(i, j int) bool { return m.Files[i].Path < m.Files[j].Path })
	return m, nil
}

func entryOf(logical, real string, hash bool) (Entry, error) {
	fi, err := os.Lstat(real)
	if err != nil {
		return Entry{}, err
	}
	if !fi.Mode().IsRegular() {
		return Entry{}, errors.New("geen gewoon bestand")
	}
	e := Entry{Path: logical, Size: fi.Size(), MTime: fi.ModTime().UnixMilli(), Mode: uint32(fi.Mode().Perm())}
	if hash {
		f, err := os.Open(real)
		if err != nil {
			return e, err
		}
		defer f.Close()
		h := sha256.New()
		if _, err := io.Copy(h, f); err != nil {
			return e, err
		}
		e.SHA256 = hex.EncodeToString(h.Sum(nil))
	}
	return e, nil
}

func skipName(name string) bool {
	return strings.HasSuffix(name, ".lock") || strings.HasPrefix(name, "tmp_") || name == ".incoming"
}

func walk(m *Manifest, logical, root string) error {
	err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
		if err != nil {
			if errors.Is(err, fs.ErrNotExist) {
				return nil
			}
			// Een map die tijdens het lopen verdwijnt (git gc) slaan we over.
			if d != nil && d.IsDir() {
				return fs.SkipDir
			}
			return nil
		}
		if p != root && skipName(d.Name()) {
			if d.IsDir() {
				return fs.SkipDir
			}
			return nil
		}
		if d.IsDir() || d.Type()&fs.ModeSymlink != 0 || !d.Type().IsRegular() {
			return nil
		}
		rel, err := filepath.Rel(root, p)
		if err != nil {
			return nil
		}
		if e, err := entryOf(logical+"/"+filepath.ToSlash(rel), p, false); err == nil {
			m.Files = append(m.Files, e)
		}
		return nil
	})
	if errors.Is(err, fs.ErrNotExist) {
		return nil
	}
	return err
}

// CleanLogical controleert een logisch pad en geeft het genormaliseerd terug.
func CleanLogical(p string) (string, bool) {
	if p == "" || strings.Contains(p, "\\") || strings.ContainsRune(p, 0) || strings.HasPrefix(p, "/") {
		return "", false
	}
	c := path.Clean(p)
	if c != p || c == "." || strings.HasPrefix(c, "../") || strings.Contains(c, "/../") {
		return "", false
	}
	parts := strings.Split(c, "/")
	for _, part := range parts {
		if part == ".." || part == "." || part == "" {
			return "", false
		}
	}
	if len(parts) < 2 {
		return "", false
	}
	switch parts[0] {
	case "state":
		if len(parts) == 2 && contains(stateFiles, parts[1]) {
			return c, true
		}
		if len(parts) >= 3 && contains(stateDirs, parts[1]) {
			return c, true
		}
	case "data":
		if len(parts) >= 3 && contains(dataDirs, parts[1]) && parts[2] != ".incoming" {
			return c, true
		}
	}
	return "", false
}

func contains(list []string, v string) bool {
	for _, x := range list {
		if x == v {
			return true
		}
	}
	return false
}

// Resolve geeft het echte bestand bij een logisch pad. De database komt
// uit de laatste kopie van Build.
func (t Tree) Resolve(logical string) (string, error) {
	c, ok := CleanLogical(logical)
	if !ok {
		return "", errors.New("ongeldig pad")
	}
	var real string
	switch {
	case c == DBPath:
		real = t.snapshotPath()
	case strings.HasPrefix(c, "state/"):
		real = filepath.Join(t.StateDir, filepath.FromSlash(strings.TrimPrefix(c, "state/")))
	default:
		if t.DataDir == "" {
			return "", errors.New("geen datadisk")
		}
		real = filepath.Join(t.DataDir, filepath.FromSlash(strings.TrimPrefix(c, "data/")))
	}
	fi, err := os.Lstat(real)
	if err != nil {
		return "", err
	}
	if !fi.Mode().IsRegular() {
		return "", errors.New("geen gewoon bestand")
	}
	return real, nil
}

// ---------- terugzetten ----------

const restoreDir = ".restore"

type pending struct {
	DataDir string    `json:"data_dir"`
	At      time.Time `json:"at"`
	Files   int       `json:"files"`
}

// Stage pakt een tar.gz met logische paden uit naast de live mappen. Er
// verandert nog niets aan de live gegevens; dat doet ApplyPending bij de
// volgende start. De database en secret.key moeten in het archief zitten.
func (t Tree) Stage(r io.Reader) (int, error) {
	stateStage := filepath.Join(t.StateDir, restoreDir)
	_ = os.RemoveAll(stateStage)
	var dataStage string
	if t.DataDir != "" {
		dataStage = filepath.Join(t.DataDir, restoreDir)
		_ = os.RemoveAll(dataStage)
	}
	fail := func(err error) (int, error) {
		_ = os.RemoveAll(stateStage)
		if dataStage != "" {
			_ = os.RemoveAll(dataStage)
		}
		return 0, err
	}
	gz, err := gzip.NewReader(r)
	if err != nil {
		return fail(fmt.Errorf("geen gzip: %w", err))
	}
	tr := tar.NewReader(gz)
	n := 0
	seenDB, seenKey := false, false
	for {
		h, err := tr.Next()
		if err == io.EOF {
			break
		}
		if err != nil {
			return fail(err)
		}
		if h.Typeflag == tar.TypeDir {
			continue
		}
		if h.Typeflag != tar.TypeReg {
			return fail(fmt.Errorf("%s: alleen gewone bestanden", h.Name))
		}
		c, ok := CleanLogical(strings.TrimPrefix(h.Name, "./"))
		if !ok {
			return fail(fmt.Errorf("ongeldig pad in archief: %q", h.Name))
		}
		var dst string
		if strings.HasPrefix(c, "state/") {
			dst = filepath.Join(stateStage, filepath.FromSlash(c))
		} else {
			if dataStage == "" {
				return fail(errors.New("het archief bevat repositories, maar deze BlueGit heeft nog geen datadisk"))
			}
			dst = filepath.Join(dataStage, filepath.FromSlash(c))
		}
		seenDB = seenDB || c == DBPath
		seenKey = seenKey || c == "state/secret.key"
		if err := os.MkdirAll(filepath.Dir(dst), 0o750); err != nil {
			return fail(err)
		}
		mode := os.FileMode(h.Mode).Perm() & 0o755
		if mode == 0 {
			mode = 0o640
		}
		f, err := os.OpenFile(dst, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode|0o600)
		if err != nil {
			return fail(err)
		}
		if _, err := io.Copy(f, tr); err != nil {
			f.Close()
			return fail(err)
		}
		if err := f.Close(); err != nil {
			return fail(err)
		}
		_ = os.Chtimes(dst, h.ModTime, h.ModTime)
		n++
	}
	if !seenDB || !seenKey {
		return fail(errors.New("het archief mist state/bluegit.db of state/secret.key"))
	}
	b, _ := json.Marshal(pending{DataDir: t.DataDir, At: time.Now().UTC(), Files: n})
	if err := os.WriteFile(filepath.Join(stateStage, "READY"), b, 0o600); err != nil {
		return fail(err)
	}
	return n, nil
}

// HasPending zegt of er een uitgepakte backup klaarstaat.
func HasPending(stateDir string) bool {
	_, err := os.Stat(filepath.Join(stateDir, restoreDir, "READY"))
	return err == nil
}

// ApplyPending zet een klaarstaande backup op zijn plek. Aanroepen bij de
// start, vóór de database open gaat. Geen READY: niets te doen.
func ApplyPending(stateDir string) (bool, error) {
	stage := filepath.Join(stateDir, restoreDir)
	b, err := os.ReadFile(filepath.Join(stage, "READY"))
	if errors.Is(err, os.ErrNotExist) {
		return false, nil
	}
	if err != nil {
		return false, err
	}
	var p pending
	if err := json.Unmarshal(b, &p); err != nil {
		return false, err
	}
	for _, f := range []string{"bluegit.db-wal", "bluegit.db-shm"} {
		_ = os.Remove(filepath.Join(stateDir, f))
	}
	for _, name := range append(append([]string{}, stateFiles...), stateDirs...) {
		if err := swap(filepath.Join(stateDir, name), filepath.Join(stage, "state", name)); err != nil {
			return false, err
		}
	}
	if p.DataDir != "" {
		dstage := filepath.Join(p.DataDir, restoreDir)
		for _, name := range dataDirs {
			if err := swap(filepath.Join(p.DataDir, name), filepath.Join(dstage, "data", name)); err != nil {
				return false, err
			}
		}
		_ = os.RemoveAll(dstage)
	}
	_ = os.RemoveAll(filepath.Join(stateDir, ".backup"))
	return true, os.RemoveAll(stage)
}

// swap vervangt live door staged. Ontbreekt staged, dan verdwijnt live.
func swap(live, staged string) error {
	old := live + ".restore-old"
	_ = os.RemoveAll(old)
	if _, err := os.Lstat(live); err == nil {
		if err := os.Rename(live, old); err != nil {
			return err
		}
	}
	if _, err := os.Lstat(staged); err == nil {
		if err := os.Rename(staged, live); err != nil {
			return err
		}
	}
	return os.RemoveAll(old)
}
