package config

import (
	"fmt"
	"io"
	"log/slog"
	"os"
	"path/filepath"
	"strings"
)

// SettingsFile is de web-instellingen onder state_path.
const SettingsFile = "settings.yml"

// ImportMarker wordt gezet na een eenmalige import van config.yml.
const ImportMarker = "config.yml.imported"

// Runtime is de geladen machineconfiguratie plus herkomst.
type Runtime struct {
	Config       Config
	ConfigPath   string
	SettingsPath string
	Imported     bool
}

// LoadRuntime leest config.yml (als die er is) en overlays settings.yml.
//
// Veiligheid bij een self-update:
//   - config.yml wordt nooit herschreven of verwijderd.
//   - Zonder settings.yml start de server precies zoals Load(config.yml).
//   - Een bestaande config.yml wordt één keer naar settings.yml gekopieerd
//     (idempotent via de marker of het bestaan van settings.yml).
//   - Is settings.yml onleesbaar of ongeldig, dan valt de server terug op
//     config.yml en start gewoon.
//   - Omgevingsvariabelen (BLUEGIT_LISTEN, BLUEGIT_AUTH_CLIENT_SECRET, …)
//     winnen altijd, als laatste redmiddel voor beheer.
func LoadRuntime(configPath string, log *slog.Logger) (Runtime, error) {
	if log == nil {
		log = slog.New(slog.NewTextHandler(io.Discard, nil))
	}
	rt := Runtime{ConfigPath: configPath}
	baseline, haveFile, fileErr := loadBaseline(configPath)
	if !haveFile {
		baseline.applyDefaults()
		applyEnv(&baseline)
		_ = fillSecretFromFile(&baseline)
	}

	if imported, err := ImportLegacy(configPath, baseline, log); err != nil {
		log.Error("config.yml-import naar settings.yml mislukt; bestaande config blijft gelden", "err", err)
	} else {
		rt.Imported = imported
	}

	rt.SettingsPath = filepath.Join(baseline.StatePath, SettingsFile)
	result := baseline
	if set, err := LoadSettings(baseline.StatePath); err != nil {
		log.Error("settings.yml onleesbaar; val terug op config.yml", "path", rt.SettingsPath, "err", err)
	} else if set != nil {
		over := baseline
		applyPersisted(&over, set)
		applyEnv(&over)
		if err := fillSecretFromFile(&over); err != nil && over.Auth.ClientSecret == "" {
			log.Warn("client_secret_file niet leesbaar; er is mogelijk een geheim in settings.yml of de omgeving", "err", err)
		}
		if err := over.Validate(); err != nil {
			log.Error("settings.yml ongeldig; val terug op config.yml", "err", err)
		} else {
			result = over
		}
	}

	if err := result.Validate(); err != nil {
		if fileErr != nil {
			return Runtime{}, fileErr
		}
		return Runtime{}, err
	}
	rt.Config = result
	return rt, nil
}

func loadBaseline(configPath string) (Config, bool, error) {
	if strings.TrimSpace(configPath) == "" {
		return Config{}, false, nil
	}
	st, err := os.Stat(configPath)
	if err != nil {
		if os.IsNotExist(err) {
			return Config{}, false, nil
		}
		return Config{}, false, err
	}
	if st.IsDir() {
		return Config{}, false, fmt.Errorf("config: %s is een map", configPath)
	}
	c, err := Load(configPath)
	if err != nil {
		return Config{}, false, err
	}
	return c, true, nil
}

// ImportLegacy kopieert één keer een bestaande config.yml naar settings.yml.
// config.yml zelf blijft ongewijzigd. Idempotent: bestaat settings.yml of
// de marker al, dan gebeurt er niets.
func ImportLegacy(configPath string, src Config, log *slog.Logger) (bool, error) {
	if strings.TrimSpace(src.StatePath) == "" {
		return false, nil
	}
	if err := os.MkdirAll(src.StatePath, 0o750); err != nil {
		return false, err
	}
	setPath := filepath.Join(src.StatePath, SettingsFile)
	markPath := filepath.Join(src.StatePath, ImportMarker)
	if _, err := os.Stat(setPath); err == nil {
		_ = touchMarker(markPath)
		return false, nil
	}
	if _, err := os.Stat(markPath); err == nil {
		return false, nil
	}
	if strings.TrimSpace(configPath) == "" {
		return false, nil
	}
	if _, err := os.Stat(configPath); err != nil {
		return false, nil
	}
	if err := SaveSettings(src.StatePath, persistFrom(src)); err != nil {
		return false, err
	}
	if err := touchMarker(markPath); err != nil {
		return false, err
	}
	if log != nil {
		log.Info("config.yml eenmalig overgenomen in settings.yml; daarna wint de webinterface, config.yml blijft als terugval en is niet meer nodig om te wijzigen",
			"config", configPath, "settings", setPath)
	}
	return true, nil
}

func touchMarker(path string) error {
	f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0o640)
	if err != nil {
		return err
	}
	return f.Close()
}

// atomicWrite schrijft path via een tijdelijk bestand in dezelfde map.
func atomicWrite(path string, data []byte, mode os.FileMode) error {
	dir := filepath.Dir(path)
	if err := os.MkdirAll(dir, 0o750); err != nil {
		return err
	}
	f, err := os.CreateTemp(dir, ".settings-*.tmp")
	if err != nil {
		return err
	}
	tmp := f.Name()
	ok := false
	defer func() {
		if !ok {
			_ = os.Remove(tmp)
		}
	}()
	if _, err := f.Write(data); err != nil {
		_ = f.Close()
		return err
	}
	if err := f.Chmod(mode); err != nil {
		_ = f.Close()
		return err
	}
	if err := f.Sync(); err != nil {
		_ = f.Close()
		return err
	}
	if err := f.Close(); err != nil {
		return err
	}
	if err := os.Rename(tmp, path); err != nil {
		return err
	}
	ok = true
	return nil
}
