// Package config leest de configuratie van de backup server.
package config

import (
	"fmt"
	"os"
	"strings"
	"time"

	"gopkg.in/yaml.v3"
)

// Config is /etc/bluegit-backup/config.yml.
type Config struct {
	// Listen is waar de backup server luistert (plain HTTP; TLS doet een
	// proxy ervoor als dat nodig is).
	Listen string `yaml:"listen"`
	// PublicURL is het adres waarop BlueGit deze server bereikt, voor
	// meldingen, de archieflijst en rollback.
	PublicURL string `yaml:"public_url"`
	// DataDir bevat de draaiende kopie, de archieven en de koppeling.
	DataDir string `yaml:"data_dir"`
	// ArchiveInterval: zo vaak wordt de hele kopie gecomprimeerd en
	// opgeslagen. Standaard 24h (dagelijks).
	ArchiveInterval Duration `yaml:"archive_interval"`
	// RetentionDays: archieven ouder dan dit worden verwijderd. 0 = nooit
	// op leeftijd. Het nieuwste archief blijft altijd staan.
	RetentionDays int `yaml:"retention_days"`
	// MinFreeMB: zakt de vrije ruimte op DataDir hieronder, dan gaat het
	// oudste archief weg (het nieuwste blijft altijd staan).
	MinFreeMB int64 `yaml:"min_free_mb"`
	// RateLimitKiB begrenst het downloaden van BlueGit, in KiB/s.
	// Standaard 1024. 0 = geen limiet.
	RateLimitKiB int64 `yaml:"rate_limit_kib"`
	// FullSyncInterval: ook zonder melding wordt zo vaak gesynchroniseerd.
	FullSyncInterval Duration `yaml:"full_sync_interval"`
	// MinSyncInterval: na een melding wacht de server minstens zo lang
	// sinds de vorige sync, zodat een drukke BlueGit niet elke seconde een
	// databasekopie hoeft te maken.
	MinSyncInterval Duration `yaml:"min_sync_interval"`
}

// Duration leest "24h", "30m" enzovoort.
type Duration struct{ time.Duration }

// UnmarshalYAML leest een Go-duur of een aantal seconden.
func (d *Duration) UnmarshalYAML(n *yaml.Node) error {
	s := strings.TrimSpace(n.Value)
	if s == "" {
		return nil
	}
	if strings.HasSuffix(s, "d") {
		var days int
		if _, err := fmt.Sscanf(s, "%dd", &days); err == nil {
			d.Duration = time.Duration(days) * 24 * time.Hour
			return nil
		}
	}
	v, err := time.ParseDuration(s)
	if err != nil {
		return fmt.Errorf("ongeldige duur %q", s)
	}
	d.Duration = v
	return nil
}

// MarshalYAML schrijft de duur terug als tekst.
func (d Duration) MarshalYAML() (any, error) { return d.String(), nil }

// Defaults vult lege velden.
func (c *Config) Defaults() {
	if c.Listen == "" {
		c.Listen = "0.0.0.0:8080"
	}
	if c.DataDir == "" {
		c.DataDir = "/var/lib/bluegit-backup"
	}
	if c.ArchiveInterval.Duration == 0 {
		c.ArchiveInterval.Duration = 24 * time.Hour
	}
	if c.RetentionDays == 0 {
		c.RetentionDays = 30
	}
	if c.RetentionDays < 0 {
		c.RetentionDays = 0
	}
	if c.MinFreeMB == 0 {
		c.MinFreeMB = 1024
	}
	if c.RateLimitKiB == 0 {
		c.RateLimitKiB = 1024
	}
	if c.RateLimitKiB < 0 {
		c.RateLimitKiB = 0
	}
	if c.FullSyncInterval.Duration == 0 {
		c.FullSyncInterval.Duration = time.Hour
	}
	if c.MinSyncInterval.Duration == 0 {
		c.MinSyncInterval.Duration = 10 * time.Second
	}
}

// Validate controleert de combinatie.
func (c Config) Validate() error {
	if c.ArchiveInterval.Duration < time.Second {
		return fmt.Errorf("archive_interval moet minstens 1s zijn")
	}
	if c.FullSyncInterval.Duration < time.Second || c.MinSyncInterval.Duration < 0 {
		return fmt.Errorf("full_sync_interval moet minstens 1s zijn")
	}
	if c.PublicURL != "" && !strings.HasPrefix(c.PublicURL, "http://") && !strings.HasPrefix(c.PublicURL, "https://") {
		return fmt.Errorf("public_url moet met http:// of https:// beginnen")
	}
	return nil
}

// Load leest path. Een ontbrekend bestand geeft de standaardwaarden.
func Load(path string) (Config, error) {
	var c Config
	b, err := os.ReadFile(path)
	if err != nil && !os.IsNotExist(err) {
		return c, err
	}
	if err == nil {
		if err := yaml.Unmarshal(b, &c); err != nil {
			return c, fmt.Errorf("%s: %w", path, err)
		}
	}
	c.Defaults()
	return c, c.Validate()
}

// Example is een voorbeeldconfiguratie.
func Example() string {
	return `# bluegit-backup. Kopieer naar /etc/bluegit-backup/config.yml.
listen: 0.0.0.0:8080
# Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).
public_url: http://backup.lan:8080
data_dir: /var/lib/bluegit-backup
# Zo vaak wordt de hele kopie gecomprimeerd opgeslagen. Standaard dagelijks.
archive_interval: 24h
# Archieven ouder dan dit gaan weg (0 = nooit op leeftijd). Het nieuwste blijft.
retention_days: 30
# Minder vrije ruimte dan dit: het oudste archief gaat weg.
min_free_mb: 1024
# Downloadsnelheid van BlueGit in KiB/s, zodat BlueGit er geen last van heeft.
rate_limit_kib: 1024
# Ook zonder melding zo vaak alles nalopen.
full_sync_interval: 1h
# Minimale tijd tussen twee syncs na meldingen.
min_sync_interval: 10s
`
}
