package config

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

	"gopkg.in/yaml.v3"
)

// Startup zijn de opstartkeuzes: gegevensmap en eventueel een oude config.yml.
type Startup struct {
	// ConfigPath is het pad naar een oude config.yml (leeg: standaard zoeken).
	ConfigPath string
	// DataDir is --data-dir (leeg: omgeving of bestand of standaard).
	DataDir string
	// DataDirEnv is BLUEGIT_BACKUP_DATA_DIR.
	DataDirEnv string
}

// Resolve bepaalt de gegevensmap en het pad van een eventuele oude config.yml.
func (s Startup) Resolve() (dataDir, cfgPath string, err error) {
	cfgPath = strings.TrimSpace(s.ConfigPath)
	if cfgPath == "" {
		cfgPath = DefaultConfigPath()
	}
	if d := strings.TrimSpace(s.DataDir); d != "" {
		return d, cfgPath, nil
	}
	if d := strings.TrimSpace(s.DataDirEnv); d != "" {
		return d, cfgPath, nil
	}
	if st, err := os.Stat(cfgPath); err == nil && !st.IsDir() {
		c, err := loadFile(cfgPath)
		if err != nil {
			return "", cfgPath, err
		}
		if strings.TrimSpace(c.DataDir) != "" {
			return c.DataDir, cfgPath, nil
		}
	}
	return DefaultDataDir(), cfgPath, nil
}

// LoadRuntime leest settings.yml, neemt eventueel één keer een oude
// config.yml over, en vult standaardwaarden in.
func LoadRuntime(st Startup, log *slog.Logger) (Config, error) {
	dataDir, cfgPath, err := st.Resolve()
	if err != nil {
		return Config{}, err
	}
	if err := os.MkdirAll(dataDir, 0o750); err != nil {
		return Config{}, err
	}
	if log == nil {
		log = slog.New(slog.NewTextHandler(io.Discard, nil))
	}
	if err := ImportLegacy(dataDir, cfgPath, log); err != nil {
		return Config{}, err
	}
	c := Config{DataDir: dataDir}
	c.Defaults()
	c.DataDir = dataDir
	set, err := LoadSettings(dataDir)
	if err != nil {
		return c, err
	}
	for k := range set {
		if f, ok := FieldByKey(k); !ok || f.Readonly {
			delete(set, k)
		}
	}
	if len(set) > 0 {
		if err := c.Apply(set); err != nil {
			return c, fmt.Errorf("%s: %w", SettingsFile, err)
		}
	}
	c.DataDir = dataDir
	return c, c.Validate()
}

// ImportLegacy neemt een bestaande config.yml één keer over in settings.yml.
// Bestaande sleutels in settings.yml winnen. Ontbreekt het bestand, dan gebeurt
// er niets. Na afloop staat config.yml.imported in data_dir.
func ImportLegacy(dataDir, cfgPath string, log *slog.Logger) error {
	marker := filepath.Join(dataDir, LegacyImportMarker)
	if _, err := os.Stat(marker); err == nil {
		return nil
	}
	src := firstExistingFile(cfgPath, filepath.Join(dataDir, LegacyConfigCopy))
	if src == "" {
		return nil
	}
	loaded, err := Load(src)
	if err != nil {
		return fmt.Errorf("oude config %s: %w", src, err)
	}
	set, err := LoadSettings(dataDir)
	if err != nil {
		return err
	}
	added := 0
	for _, f := range Fields {
		if f.Readonly {
			continue
		}
		if _, ok := set[f.Key]; ok {
			continue
		}
		if v := loaded.Get(f.Key); v != "" {
			set[f.Key] = v
			added++
		}
	}
	if err := SaveSettings(dataDir, set); err != nil {
		return err
	}
	body := fmt.Sprintf("imported_from: %s\nimported_at: %s\n", src, time.Now().UTC().Format(time.RFC3339))
	if err := os.WriteFile(marker, []byte(body), 0o600); err != nil {
		return err
	}
	if log != nil {
		log.Info("oude config.yml overgenomen in settings.yml; config.yml is niet meer nodig",
			"from", src, "settings", filepath.Join(dataDir, SettingsFile), "keys", added)
	}
	return nil
}

func firstExistingFile(paths ...string) string {
	for _, p := range paths {
		p = strings.TrimSpace(p)
		if p == "" {
			continue
		}
		st, err := os.Stat(p)
		if err == nil && !st.IsDir() {
			return p
		}
	}
	return ""
}

func loadFile(path string) (Config, error) {
	var c Config
	b, err := os.ReadFile(path)
	if err != nil {
		return c, err
	}
	if err := yaml.Unmarshal(b, &c); err != nil {
		return c, fmt.Errorf("%s: %w", path, err)
	}
	return c, nil
}
