package main

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

	"gopkg.in/yaml.v3"

	"gitlab.com/Timfa/bluegit/internal/apppaths"
)

const (
	connectionFile = "connection.yml"
	connectionMark = "config.yml.imported"
	defaultWorkDir = "/var/lib/bluegit-runner"
	defaultWindows = "BlueGit-runner"
)

// machineSettings is het deel van de runnerconfig dat in de webinterface hoort.
type machineSettings struct {
	URL         string `yaml:"url,omitempty"`
	Token       string `yaml:"token,omitempty"`
	Name        string `yaml:"name,omitempty"`
	Docker      string `yaml:"docker,omitempty"`
	Git         string `yaml:"git,omitempty"`
	Network     string `yaml:"network,omitempty"`
	Concurrency int    `yaml:"concurrency,omitempty"`
	UIListen    string `yaml:"ui_listen,omitempty"`
	Language    string `yaml:"language,omitempty"`
}

func defaultWorkDirPath() string {
	return apppaths.DataDir(defaultWorkDir, defaultWindows)
}

func resolveWorkDir(flagDir, cfgPath string, file Config) string {
	if d := strings.TrimSpace(flagDir); d != "" {
		return d
	}
	if d := strings.TrimSpace(os.Getenv("BLUEGIT_RUNNER_WORK_DIR")); d != "" {
		return d
	}
	if d := strings.TrimSpace(file.WorkDir); d != "" {
		return d
	}
	return defaultWorkDirPath()
}

func loadFileConfig(path string) (Config, error) {
	var c Config
	b, err := os.ReadFile(path)
	if err != nil {
		if os.IsNotExist(err) {
			return c, nil
		}
		return c, err
	}
	if err := yaml.Unmarshal(b, &c); err != nil {
		return c, err
	}
	return c, nil
}

func loadConnection(workDir string) (machineSettings, error) {
	var m machineSettings
	b, err := os.ReadFile(filepath.Join(workDir, connectionFile))
	if err != nil {
		if os.IsNotExist(err) {
			return m, nil
		}
		return m, err
	}
	err = yaml.Unmarshal(b, &m)
	return m, err
}

func saveConnection(workDir string, m machineSettings) error {
	if err := os.MkdirAll(workDir, 0o750); err != nil {
		return err
	}
	b, err := yaml.Marshal(m)
	if err != nil {
		return err
	}
	path := filepath.Join(workDir, connectionFile)
	tmp := path + ".tmp"
	if err := os.WriteFile(tmp, b, 0o600); err != nil {
		return err
	}
	return os.Rename(tmp, path)
}

func applyMachine(c *Config, m machineSettings) {
	if m.URL != "" {
		c.URL = strings.TrimRight(m.URL, "/")
	}
	if m.Token != "" {
		c.Token = m.Token
	}
	if m.Name != "" {
		c.Name = m.Name
	}
	if m.Docker != "" {
		c.Docker = m.Docker
	}
	if m.Git != "" {
		c.Git = m.Git
	}
	if m.Network != "" {
		c.Network = m.Network
	}
	if m.Concurrency > 0 {
		c.Concurrency = m.Concurrency
	}
	if m.UIListen != "" {
		c.UIListen = m.UIListen
	}
	if m.Language != "" {
		c.Language = m.Language
	}
}

func machineFrom(c Config) machineSettings {
	return machineSettings{
		URL: c.URL, Token: c.Token, Name: c.Name, Docker: c.Docker, Git: c.Git,
		Network: c.Network, Concurrency: c.Concurrency, UIListen: c.UIListen, Language: c.Language,
	}
}

func importRunnerLegacy(workDir, cfgPath string, file Config, log *slog.Logger) {
	if workDir == "" {
		return
	}
	_ = os.MkdirAll(workDir, 0o750)
	set := filepath.Join(workDir, connectionFile)
	mark := filepath.Join(workDir, connectionMark)
	if _, err := os.Stat(set); err == nil {
		_ = os.WriteFile(mark, nil, 0o640)
		return
	}
	if _, err := os.Stat(mark); err == nil {
		return
	}
	if cfgPath == "" {
		return
	}
	if _, err := os.Stat(cfgPath); err != nil {
		return
	}
	if err := saveConnection(workDir, machineFrom(file)); err != nil {
		if log != nil {
			log.Error("config.yml-import naar connection.yml mislukt; bestaande config blijft gelden", "err", err)
		}
		return
	}
	_ = os.WriteFile(mark, nil, 0o640)
	if log != nil {
		log.Info("config.yml eenmalig overgenomen in connection.yml; daarna wint de webinterface", "config", cfgPath, "settings", set)
	}
}

// loadRuntime leest optioneel config.yml, importeert eenmaal, en overlays
// connection.yml. url en token mogen leeg zijn (registratie via de UI).
func loadRuntime(cfgPath, workDirFlag string, log *slog.Logger) (Config, error) {
	if log == nil {
		log = slog.New(slog.NewTextHandler(io.Discard, nil))
	}
	file, err := loadFileConfig(cfgPath)
	if err != nil {
		return Config{}, fmt.Errorf("config: %w", err)
	}
	work := resolveWorkDir(workDirFlag, cfgPath, file)
	importRunnerLegacy(work, cfgPath, file, log)
	c := file
	c.WorkDir = work
	if m, err := loadConnection(work); err != nil {
		log.Error("connection.yml onleesbaar; val terug op config.yml", "err", err)
	} else {
		applyMachine(&c, m)
	}
	c.WorkDir = work
	c.defaults()
	return c, nil
}

func registered(c Config) bool {
	return strings.TrimSpace(c.URL) != "" && strings.TrimSpace(c.Token) != ""
}
