// Package runnercfg is de beheerbare configuratie van een runner: de
// aparte bluegit-runner en de ingebouwde BlueGit-runner (Steve) delen
// dezelfde instellingen, hardware-aanbevelingen, image-presets, pauze
// (drain) en het overzicht van actieve jobs. De webinterface van beide
// gebruikt het HTML-fragment uit ui.go.
package runnercfg

import (
	"encoding/json"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"regexp"
	"sort"
	"strings"
	"sync"

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

// Pull-policy's voor gewone images (presets worden altijd lokaal gebouwd).
const (
	PullIfNotPresent = "if-not-present"
	PullAlways       = "always"
	PullNever        = "never"
)

// Preset is een eigen image-template: óf een vast image, óf een Dockerfile
// (met optioneel een ander basis-image). Naam zoals team/tools.
type Preset struct {
	Name       string `json:"name"`
	Image      string `json:"image,omitempty"`
	Dockerfile string `json:"dockerfile,omitempty"`
	From       string `json:"from,omitempty"`
	Note       string `json:"note,omitempty"`
}

// Settings zijn de instellingen die een beheerder in de UI ziet.
type Settings struct {
	Name          string   `json:"name"`
	Concurrency   int      `json:"concurrency"`
	MaxImages     int      `json:"max_images"`
	CPUs          float64  `json:"cpus"`       // per job; 0 = geen limiet
	MemoryMB      int      `json:"memory_mb"`  // per job; 0 = geen limiet
	PidsLimit     int      `json:"pids_limit"` // per job; 0 = geen limiet
	MaxDiskGB     int      `json:"max_disk_gb"`
	PullPolicy    string   `json:"pull_policy"`
	CleanupWork   bool     `json:"cleanup_work"`
	PruneDangling bool     `json:"prune_dangling"`
	PruneCacheGB  int      `json:"prune_cache_gb"`
	JobTimeoutMin int      `json:"job_timeout_min"` // 0 = wat de job/server zegt
	Labels        []string `json:"labels"`
	Presets       []Preset `json:"presets"`
	Paused        bool     `json:"paused"`
}

// Defaults zijn veilige standaardwaarden, ook zonder hardwaredetectie.
func Defaults() Settings {
	return Settings{
		Concurrency: 1, MaxImages: 20, MemoryMB: 0, CPUs: 0, PidsLimit: 0,
		MaxDiskGB: 0, PullPolicy: PullIfNotPresent, CleanupWork: true,
		PruneDangling: true, PruneCacheGB: 10,
	}
}

var labelRE = regexp.MustCompile(`^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,62}$`)
var nameRE = regexp.MustCompile(`^[\pL\pN][\pL\pN ._-]{0,62}$`)

// Validate geeft een vertaalbare fout (sleutel uit de catalogus rui.err.*).
func (s *Settings) Validate() error {
	s.Name = strings.TrimSpace(s.Name)
	if s.Name != "" && !nameRE.MatchString(s.Name) {
		return Err("rui.err.name")
	}
	if s.Concurrency < 1 || s.Concurrency > 64 {
		return Err("rui.err.concurrency")
	}
	if s.MaxImages < 1 || s.MaxImages > 1000 {
		return Err("rui.err.images")
	}
	if s.CPUs < 0 || s.CPUs > 512 || s.MemoryMB < 0 || s.PidsLimit < 0 || s.MaxDiskGB < 0 || s.PruneCacheGB < 0 || s.JobTimeoutMin < 0 {
		return Err("rui.err.limits")
	}
	if s.MemoryMB > 0 && s.MemoryMB < 64 {
		return Err("rui.err.memory")
	}
	switch s.PullPolicy {
	case "":
		s.PullPolicy = PullIfNotPresent
	case PullIfNotPresent, PullAlways, PullNever:
	default:
		return Err("rui.err.pull")
	}
	var labels []string
	seen := map[string]bool{}
	for _, l := range s.Labels {
		l = strings.TrimSpace(l)
		if l == "" || seen[l] {
			continue
		}
		if !labelRE.MatchString(l) {
			return Err("rui.err.label", l)
		}
		seen[l] = true
		labels = append(labels, l)
	}
	s.Labels = labels
	names := map[string]bool{}
	for i := range s.Presets {
		p := &s.Presets[i]
		if err := p.Validate(); err != nil {
			return err
		}
		if names[p.Name] {
			return Err("rui.err.presetDup", p.Name)
		}
		names[p.Name] = true
	}
	return nil
}

// Validate keurt één eigen preset goed (dezelfde regels als ci.presets).
func (p *Preset) Validate() error {
	p.Name = strings.TrimSpace(strings.ToLower(p.Name))
	p.Image, p.From = strings.TrimSpace(p.Image), strings.TrimSpace(p.From)
	p.Dockerfile = strings.TrimSpace(strings.ReplaceAll(p.Dockerfile, "\r\n", "\n"))
	if p.Image == "" && p.Dockerfile == "" && p.From == "" {
		return Err("rui.err.presetEmpty", p.Name)
	}
	if p.Image != "" && (p.Dockerfile != "" || p.From != "") {
		return Err("rui.err.presetBoth", p.Name)
	}
	if p.From != "" && p.Dockerfile == "" && !images.Known(p.Name) {
		return Err("rui.err.presetFrom", p.Name)
	}
	if p.Dockerfile != "" && !strings.Contains(strings.ToUpper(p.Dockerfile), "FROM ") {
		return Err("rui.err.presetDockerfile", p.Name)
	}
	o := images.Override{Image: p.Image, From: p.From}
	if p.Dockerfile != "" {
		o.Dockerfile = os.DevNull // bestaat; de echte tekst wordt later weggeschreven
	}
	if err := images.ValidateOverride(p.Name, o, images.Known(p.Name)); err != nil {
		return Err("rui.err.preset", p.Name, err.Error())
	}
	return nil
}

// RunArgs zijn de extra `docker run`-argumenten voor de limieten per job.
func (s Settings) RunArgs() []string {
	var out []string
	if s.CPUs > 0 {
		out = append(out, "--cpus", trimFloat(s.CPUs))
	}
	if s.MemoryMB > 0 {
		out = append(out, "--memory", fmt.Sprintf("%dm", s.MemoryMB))
	}
	if s.PidsLimit > 0 {
		out = append(out, "--pids-limit", fmt.Sprint(s.PidsLimit))
	}
	return out
}

func trimFloat(f float64) string {
	return strings.TrimRight(strings.TrimRight(fmt.Sprintf("%.2f", f), "0"), ".")
}

// Overrides schrijft de Dockerfiles van eigen presets naar dir en geeft
// de aliassen zoals images.Effective ze wil. base zijn de presets uit de
// configuratie (ci.presets); eigen presets uit de UI gaan voor.
func (s Settings) Overrides(dir string, base map[string]images.Override) (map[string]images.Override, error) {
	out := map[string]images.Override{}
	for k, v := range base {
		out[k] = v
	}
	for _, p := range s.Presets {
		o := images.Override{Image: p.Image, From: p.From}
		if p.Dockerfile != "" {
			pd := filepath.Join(dir, "presets", strings.ReplaceAll(p.Name, "/", "__"))
			if err := os.MkdirAll(pd, 0o755); err != nil {
				return nil, err
			}
			f := filepath.Join(pd, "Dockerfile")
			if err := os.WriteFile(f, []byte(p.Dockerfile+"\n"), 0o644); err != nil {
				return nil, err
			}
			o.Dockerfile = f
		}
		out[p.Name] = o
	}
	return out, nil
}

// File bewaart Settings als JSON (schrijfbaar door de service, anders dan /etc).
type File struct {
	Path string
	mu   sync.Mutex
}

// Load leest de instellingen; een ontbrekend bestand geeft def.
func (f *File) Load(def Settings) (Settings, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	b, err := os.ReadFile(f.Path)
	if errors.Is(err, os.ErrNotExist) {
		return def, nil
	}
	if err != nil {
		return def, err
	}
	s := def
	if err := json.Unmarshal(b, &s); err != nil {
		return def, fmt.Errorf("%s: %w", f.Path, err)
	}
	return s, nil
}

// Save schrijft atomair.
func (f *File) Save(s Settings) error {
	f.mu.Lock()
	defer f.mu.Unlock()
	sort.SliceStable(s.Presets, func(i, j int) bool { return s.Presets[i].Name < s.Presets[j].Name })
	b, err := json.MarshalIndent(s, "", "  ")
	if err != nil {
		return err
	}
	if err := os.MkdirAll(filepath.Dir(f.Path), 0o755); err != nil {
		return err
	}
	tmp := f.Path + ".tmp"
	if err := os.WriteFile(tmp, b, 0o600); err != nil {
		return err
	}
	return os.Rename(tmp, f.Path)
}

// Error is een vertaalbare fout; Key staat in de i18n-catalogus.
type Error struct {
	Key  string
	Args []any
}

func (e Error) Error() string { return e.Key }

// Err maakt een Error.
func Err(key string, args ...any) error { return Error{Key: key, Args: args} }
