// Package backup is de BlueGit-kant van bluegit-backup: de Backupserver-Keys,
// de koppelingen met een of meer backup servers, het manifest van alle gegevens, het
// ondertekenen van verzoeken en het terugzetten van een backup bij de start.
//
// De koppeling staat in <state>/backup.json en het instance-id in
// <state>/instance_id. Die twee bestanden horen bij deze installatie en gaan
// niet mee in een backup, zodat een rollback de koppeling niet terugdraait.
package backup

import (
	"crypto/rand"
	"crypto/sha256"
	"crypto/subtle"
	"encoding/hex"
	"encoding/json"
	"errors"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"time"
)

// KeyPrefix staat voor elke Backupserver-Key.
const KeyPrefix = "bgbk_"

const (
	connFile     = "backup.json"
	instanceFile = "instance_id"
)

// Conn is één backup server. De key zelf wordt nooit bewaard.
type Conn struct {
	ID          string    `json:"id"`
	Name        string    `json:"name"`
	KeyHash     string    `json:"key_hash"`
	SignSecret  string    `json:"sign_secret"`
	KeyHint     string    `json:"key_hint"`
	CreatedAt   time.Time `json:"created_at"`
	CreatedBy   string    `json:"created_by"`
	ServerURL   string    `json:"server_url,omitempty"`
	ServerID    string    `json:"server_id,omitempty"`
	ConnectedAt time.Time `json:"connected_at,omitempty"`
	LastSeen    time.Time `json:"last_seen,omitempty"`
	// Protocol van de backup server zoals hij het laatst meldde (0: nog
	// onbekend). Zie compat.go.
	PeerProtocol    int    `json:"peer_protocol,omitempty"`
	PeerMinProtocol int    `json:"peer_min_protocol,omitempty"`
	PeerVersion     string `json:"peer_version,omitempty"`
}

// HasKey zegt of er een key is uitgegeven.
func (c Conn) HasKey() bool { return c.KeyHash != "" }

// Connected zegt of een backup server zich met de key heeft gemeld.
func (c Conn) Connected() bool { return c.HasKey() && c.ServerURL != "" }

// MaxServers begrenst het aantal backup servers per BlueGit.
const MaxServers = 16

// file is backup.json. Eén BlueGit kan meerdere backup servers hebben; een
// backup server hoort bij één BlueGit.
type file struct {
	Servers []Conn `json:"servers"`
}

// Manager bewaart de koppelingen in de state-map.
type Manager struct {
	Dir string
	mu  sync.Mutex
}

// HashKey is de opgeslagen vorm van de key.
func HashKey(key string) string {
	s := sha256.Sum256([]byte(key))
	return hex.EncodeToString(s[:])
}

// SigningSecret leidt het HMAC-geheim af uit de key. De backup server doet
// precies hetzelfde, zodat beide kanten verzoeken kunnen ondertekenen.
func SigningSecret(key string) string {
	s := sha256.Sum256([]byte("bluegit-backup-sign:" + key))
	return hex.EncodeToString(s[:])
}

// List geeft alle backup servers, in volgorde van aanmaken.
func (m *Manager) List() ([]Conn, error) {
	m.mu.Lock()
	defer m.mu.Unlock()
	f, err := m.load()
	return f.Servers, err
}

// Get zoekt een backup server op id.
func (m *Manager) Get(id string) (Conn, bool) {
	list, err := m.List()
	if err != nil {
		return Conn{}, false
	}
	for _, c := range list {
		if c.ID == id {
			return c, true
		}
	}
	return Conn{}, false
}

func (m *Manager) load() (file, error) {
	var f file
	b, err := os.ReadFile(filepath.Join(m.Dir, connFile))
	if errors.Is(err, os.ErrNotExist) {
		return f, nil
	}
	if err != nil {
		return f, err
	}
	if err := json.Unmarshal(b, &f); err != nil {
		return f, err
	}
	if f.Servers == nil {
		// Oude vorm met één koppeling.
		var one Conn
		if json.Unmarshal(b, &one) == nil && one.HasKey() {
			if one.ID == "" {
				one.ID = newID()
			}
			if one.Name == "" {
				one.Name = "backup"
			}
			f.Servers = []Conn{one}
			// Meteen bewaren, zodat het id vast is.
			if err := m.save(f); err != nil {
				return f, err
			}
		}
	}
	return f, nil
}

func (m *Manager) save(f file) error {
	if m.Dir == "" {
		return errors.New("geen state-map")
	}
	if f.Servers == nil {
		f.Servers = []Conn{}
	}
	b, err := json.MarshalIndent(f, "", "  ")
	if err != nil {
		return err
	}
	tmp := filepath.Join(m.Dir, connFile+".tmp")
	if err := os.WriteFile(tmp, b, 0o600); err != nil {
		return err
	}
	return os.Rename(tmp, filepath.Join(m.Dir, connFile))
}

func (m *Manager) update(id string, fn func(*Conn) error) (Conn, error) {
	m.mu.Lock()
	defer m.mu.Unlock()
	f, err := m.load()
	if err != nil {
		return Conn{}, err
	}
	for i := range f.Servers {
		if f.Servers[i].ID == id {
			if err := fn(&f.Servers[i]); err != nil {
				return Conn{}, err
			}
			return f.Servers[i], m.save(f)
		}
	}
	return Conn{}, ErrUnknown
}

// ErrUnknown: geen backup server met dat id.
var ErrUnknown = errors.New("onbekende backup server")

func newID() string {
	raw := make([]byte, 6)
	_, _ = rand.Read(raw)
	return hex.EncodeToString(raw)
}

func newKey() (string, error) {
	raw := make([]byte, 32)
	if _, err := rand.Read(raw); err != nil {
		return "", err
	}
	return KeyPrefix + hex.EncodeToString(raw), nil
}

// CleanName maakt van een naam iets korts en toonbaars.
func CleanName(name string) string {
	name = strings.Join(strings.Fields(name), " ")
	if r := []rune(name); len(r) > 60 {
		name = string(r[:60])
	}
	return name
}

// Add maakt een nieuwe backup server met een eigen key. De key wordt
// alleen hier teruggegeven.
func (m *Manager) Add(name, by string) (string, Conn, error) {
	name = CleanName(name)
	if name == "" {
		name = "backup"
	}
	key, err := newKey()
	if err != nil {
		return "", Conn{}, err
	}
	c := Conn{
		ID: newID(), Name: name, KeyHash: HashKey(key), SignSecret: SigningSecret(key),
		KeyHint: key[:len(KeyPrefix)+6], CreatedAt: time.Now().UTC(), CreatedBy: by,
	}
	m.mu.Lock()
	defer m.mu.Unlock()
	f, err := m.load()
	if err != nil {
		return "", Conn{}, err
	}
	if len(f.Servers) >= MaxServers {
		return "", Conn{}, ErrTooMany
	}
	f.Servers = append(f.Servers, c)
	if err := m.save(f); err != nil {
		return "", Conn{}, err
	}
	return key, c, nil
}

// ErrTooMany: MaxServers bereikt.
var ErrTooMany = errors.New("te veel backup servers")

// RotateKey geeft een backup server een nieuwe key. Hij verliest zijn
// toegang tot hij opnieuw koppelt met de nieuwe key.
func (m *Manager) RotateKey(id, by string) (string, Conn, error) {
	key, err := newKey()
	if err != nil {
		return "", Conn{}, err
	}
	c, err := m.update(id, func(c *Conn) error {
		c.KeyHash, c.SignSecret, c.KeyHint = HashKey(key), SigningSecret(key), key[:len(KeyPrefix)+6]
		c.CreatedAt, c.CreatedBy = time.Now().UTC(), by
		c.ServerURL, c.ServerID, c.ConnectedAt = "", "", time.Time{}
		c.PeerProtocol, c.PeerMinProtocol, c.PeerVersion = 0, 0, ""
		return nil
	})
	if err != nil {
		return "", Conn{}, err
	}
	return key, c, nil
}

// Rename geeft een backup server een andere naam.
func (m *Manager) Rename(id, name string) (Conn, error) {
	name = CleanName(name)
	if name == "" {
		return Conn{}, errors.New("naam is leeg")
	}
	return m.update(id, func(c *Conn) error { c.Name = name; return nil })
}

// Remove trekt de key in en vergeet de backup server.
func (m *Manager) Remove(id string) error {
	m.mu.Lock()
	defer m.mu.Unlock()
	f, err := m.load()
	if err != nil {
		return err
	}
	out := f.Servers[:0]
	found := false
	for _, c := range f.Servers {
		if c.ID == id {
			found = true
			continue
		}
		out = append(out, c)
	}
	if !found {
		return ErrUnknown
	}
	f.Servers = out
	return m.save(f)
}

// Check zoekt de backup server bij key.
func (m *Manager) Check(key string) (Conn, bool) {
	key = strings.TrimSpace(key)
	if !strings.HasPrefix(key, KeyPrefix) {
		return Conn{}, false
	}
	list, err := m.List()
	if err != nil {
		return Conn{}, false
	}
	h := HashKey(key)
	for _, c := range list {
		if c.HasKey() && subtle.ConstantTimeCompare([]byte(h), []byte(c.KeyHash)) == 1 {
			return c, true
		}
	}
	return Conn{}, false
}

// Connect legt het adres van een backup server vast.
func (m *Manager) Connect(id, serverURL, serverID string) (Conn, error) {
	return m.update(id, func(c *Conn) error {
		c.ServerURL = strings.TrimRight(strings.TrimSpace(serverURL), "/")
		c.ServerID = serverID
		c.ConnectedAt = time.Now().UTC()
		c.LastSeen = c.ConnectedAt
		return nil
	})
}

// Seen werkt LastSeen bij, hoogstens één keer per minuut naar schijf.
func (m *Manager) Seen(id string) {
	c, ok := m.Get(id)
	if !ok || time.Since(c.LastSeen) < time.Minute {
		return
	}
	_, _ = m.update(id, func(c *Conn) error { c.LastSeen = time.Now().UTC(); return nil })
}

// InstanceID is het vaste id van deze installatie. Het wordt één keer
// gemaakt en gaat niet mee in een backup.
func (m *Manager) InstanceID() (string, error) {
	m.mu.Lock()
	defer m.mu.Unlock()
	p := filepath.Join(m.Dir, instanceFile)
	if b, err := os.ReadFile(p); err == nil {
		if id := strings.TrimSpace(string(b)); id != "" {
			return id, nil
		}
	}
	raw := make([]byte, 16)
	if _, err := rand.Read(raw); err != nil {
		return "", err
	}
	id := hex.EncodeToString(raw)
	if err := os.MkdirAll(m.Dir, 0o750); err != nil {
		return "", err
	}
	return id, os.WriteFile(p, []byte(id+"\n"), 0o600)
}
