// Package backup is de BlueGit-kant van bluegit-backup: de Backupserver-Key,
// de koppeling met één backup server, 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 de opgeslagen koppeling. De key zelf wordt nooit bewaard.
type Conn struct {
	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"`
}

// 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 != "" }

// Manager bewaart de koppeling 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[:])
}

// Load leest de koppeling. Geen bestand is een lege koppeling.
func (m *Manager) Load() (Conn, error) {
	m.mu.Lock()
	defer m.mu.Unlock()
	return m.load()
}

func (m *Manager) load() (Conn, error) {
	var c Conn
	b, err := os.ReadFile(filepath.Join(m.Dir, connFile))
	if errors.Is(err, os.ErrNotExist) {
		return c, nil
	}
	if err != nil {
		return c, err
	}
	err = json.Unmarshal(b, &c)
	return c, err
}

func (m *Manager) save(c Conn) error {
	if m.Dir == "" {
		return errors.New("geen state-map")
	}
	b, err := json.MarshalIndent(c, "", "  ")
	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))
}

// NewKey maakt een nieuwe key en vervangt de oude. Een gekoppelde backup
// server verliest daarmee zijn toegang tot hij de nieuwe key krijgt.
func (m *Manager) NewKey(by string) (string, Conn, error) {
	raw := make([]byte, 32)
	if _, err := rand.Read(raw); err != nil {
		return "", Conn{}, err
	}
	key := KeyPrefix + hex.EncodeToString(raw)
	c := Conn{
		KeyHash: HashKey(key), SignSecret: SigningSecret(key),
		KeyHint: key[:len(KeyPrefix)+6], CreatedAt: time.Now().UTC(), CreatedBy: by,
	}
	m.mu.Lock()
	defer m.mu.Unlock()
	if err := m.save(c); err != nil {
		return "", Conn{}, err
	}
	return key, c, nil
}

// Revoke trekt de key in en vergeet de backup server.
func (m *Manager) Revoke() error {
	m.mu.Lock()
	defer m.mu.Unlock()
	err := os.Remove(filepath.Join(m.Dir, connFile))
	if errors.Is(err, os.ErrNotExist) {
		return nil
	}
	return err
}

// Check zegt of key de uitgegeven key is.
func (m *Manager) Check(key string) (Conn, bool) {
	key = strings.TrimSpace(key)
	if !strings.HasPrefix(key, KeyPrefix) {
		return Conn{}, false
	}
	c, err := m.Load()
	if err != nil || !c.HasKey() {
		return Conn{}, false
	}
	if subtle.ConstantTimeCompare([]byte(HashKey(key)), []byte(c.KeyHash)) != 1 {
		return Conn{}, false
	}
	return c, true
}

// Connect legt het adres van de backup server vast.
func (m *Manager) Connect(serverURL, serverID string) (Conn, error) {
	m.mu.Lock()
	defer m.mu.Unlock()
	c, err := m.load()
	if err != nil {
		return c, err
	}
	if !c.HasKey() {
		return c, errors.New("geen key")
	}
	c.ServerURL = strings.TrimRight(strings.TrimSpace(serverURL), "/")
	c.ServerID = serverID
	c.ConnectedAt = time.Now().UTC()
	c.LastSeen = c.ConnectedAt
	return c, m.save(c)
}

// Seen werkt LastSeen bij, hoogstens één keer per minuut naar schijf.
func (m *Manager) Seen() {
	m.mu.Lock()
	defer m.mu.Unlock()
	c, err := m.load()
	if err != nil || !c.HasKey() || time.Since(c.LastSeen) < time.Minute {
		return
	}
	c.LastSeen = time.Now().UTC()
	_ = m.save(c)
}

// 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)
}
