// Package images zijn de image-aliassen die Steve voor een job bouwt.
// bluegit/node is geen aparte runner: het is een Dockerfile die bij het
// eerste gebruik lokaal wordt gebouwd en daarna hergebruikt. Een gewone
// naam zoals node:22 blijft een gewoon Docker-image.
package images

import (
	"context"
	"crypto/sha256"
	"embed"
	"encoding/hex"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"sort"
	"strings"
	"sync"
)

//go:embed dockerfiles/*/*
var dockerfiles embed.FS

// builtinOrder is de volgorde op de infopagina.
var builtinOrder = []string{"base", "node", "python", "go", "rust", "java", "dotnet"}

// Preset is één alias. Direct gezet betekent: gebruik dat image zonder bouw.
type Preset struct {
	Name       string
	From       string
	Runtime    string
	Tools      []string
	Dockerfile []byte
	Direct     string
}

// Override komt uit ci.presets in config.yml.
type Override struct {
	Image      string
	Dockerfile string
	From       string
}

var nameRE = regexp.MustCompile(`^[a-z0-9]+(?:[._-][a-z0-9]+)*(?:/[a-z0-9]+(?:[._-][a-z0-9]+)*)+$`)

// Known zegt of name een ingebouwde alias is.
func Known(name string) bool {
	for _, n := range builtinOrder {
		if "bluegit/"+n == name {
			return true
		}
	}
	return false
}

// ValidateOverride keurt één configregel goed.
// hasBuiltin is waar als name al een ingebouwde alias is; from mag die
// Dockerfile dan herschrijven.
func ValidateOverride(name string, o Override, hasBuiltin bool) error {
	if !nameRE.MatchString(name) {
		return fmt.Errorf("ci.presets %q: de naam moet een image-alias zijn, zoals team/tools", name)
	}
	if o.Image != "" && (o.Dockerfile != "" || o.From != "") {
		return fmt.Errorf("ci.presets %s: image sluit dockerfile en from uit", name)
	}
	if o.Image == "" && o.Dockerfile == "" && o.From == "" {
		return fmt.Errorf("ci.presets %s: geef image, dockerfile of from", name)
	}
	if o.From != "" && o.Dockerfile == "" && o.Image == "" && !hasBuiltin {
		return fmt.Errorf("ci.presets %s: from hoort bij een ingebouwde preset of een dockerfile", name)
	}
	if o.Image != "" && !validRef(o.Image) {
		return fmt.Errorf("ci.presets %s: image %q is ongeldig", name, o.Image)
	}
	if o.From != "" && !validRef(o.From) {
		return fmt.Errorf("ci.presets %s: from %q is ongeldig", name, o.From)
	}
	if o.Dockerfile != "" {
		if _, err := os.Stat(o.Dockerfile); err != nil {
			return fmt.Errorf("ci.presets %s: dockerfile %s: %w", name, o.Dockerfile, err)
		}
	}
	return nil
}

func validRef(s string) bool {
	return s != "" && strings.TrimSpace(s) == s && !strings.ContainsAny(s, " \t")
}

// Builtin leest de Dockerfiles die in het binary zitten.
func Builtin() []Preset {
	var out []Preset
	for _, name := range builtinOrder {
		raw, err := dockerfiles.ReadFile("dockerfiles/" + name + "/Dockerfile")
		if err != nil {
			continue
		}
		from, runtime, tools, err := ParseDockerfile(raw)
		if err != nil {
			continue
		}
		out = append(out, Preset{
			Name: "bluegit/" + name, From: from, Runtime: runtime, Tools: tools, Dockerfile: raw,
		})
	}
	return out
}

// Effective is de ingebouwde lijst plus de aliassen uit de configuratie.
// Een bestaande naam wordt vervangen. Nieuwe namen komen er alfabetisch achter.
func Effective(over map[string]Override) ([]Preset, error) {
	base := Builtin()
	index := map[string]int{}
	for i, p := range base {
		index[p.Name] = i
	}
	var extra []string
	for name := range over {
		if _, ok := index[name]; ok {
			continue
		}
		extra = append(extra, name)
	}
	sort.Strings(extra)
	order := make([]string, 0, len(base)+len(extra))
	for _, p := range base {
		order = append(order, p.Name)
	}
	order = append(order, extra...)
	out := make([]Preset, 0, len(order))
	for _, name := range order {
		o, ok := over[name]
		if !ok {
			out = append(out, base[index[name]])
			continue
		}
		cur := Preset{Name: name}
		if i, known := index[name]; known {
			cur = base[i]
		}
		next, err := apply(cur, o)
		if err != nil {
			return nil, err
		}
		out = append(out, next)
	}
	return out, nil
}

func apply(base Preset, o Override) (Preset, error) {
	if err := ValidateOverride(base.Name, o, len(base.Dockerfile) > 0); err != nil {
		return Preset{}, err
	}
	if o.Image != "" {
		return Preset{Name: base.Name, From: o.Image, Runtime: o.Image, Direct: o.Image}, nil
	}
	data := append([]byte(nil), base.Dockerfile...)
	if o.Dockerfile != "" {
		raw, err := os.ReadFile(o.Dockerfile)
		if err != nil {
			return Preset{}, fmt.Errorf("ci.presets %s: %w", base.Name, err)
		}
		data = raw
	}
	if len(data) == 0 {
		return Preset{}, fmt.Errorf("ci.presets %s: geen dockerfile", base.Name)
	}
	if o.From != "" {
		data = rewriteFrom(data, o.From)
	}
	from, runtime, tools, err := ParseDockerfile(data)
	if err != nil {
		return Preset{}, fmt.Errorf("ci.presets %s: %w", base.Name, err)
	}
	return Preset{Name: base.Name, From: from, Runtime: runtime, Tools: tools, Dockerfile: data}, nil
}

// Find zoekt een exacte alias. node:22 is er geen.
func Find(set []Preset, image string) (Preset, bool) {
	image = strings.TrimSpace(image)
	for _, p := range set {
		if p.Name == image {
			return p, true
		}
	}
	return Preset{}, false
}

// ParseDockerfile leest FROM, een regel "# runtime:" en de pakketten uit apk of apt-get.
func ParseDockerfile(data []byte) (from, runtime string, tools []string, err error) {
	sawFrom := false
	for _, line := range strings.Split(string(data), "\n") {
		trim := strings.TrimSpace(line)
		if trim == "" {
			continue
		}
		if strings.HasPrefix(trim, "#") {
			if rest, ok := strings.CutPrefix(trim, "# runtime:"); ok {
				runtime = strings.TrimSpace(rest)
			}
			continue
		}
		if !sawFrom {
			fields := strings.Fields(trim)
			if len(fields) < 2 || !strings.EqualFold(fields[0], "FROM") {
				return "", "", nil, fmt.Errorf("dockerfile moet met FROM beginnen")
			}
			from = fields[1]
			sawFrom = true
			continue
		}
		tools = append(tools, packages(trim)...)
	}
	if from == "" {
		return "", "", nil, fmt.Errorf("dockerfile mist FROM")
	}
	if runtime == "" {
		runtime = from
	}
	return from, runtime, tools, nil
}

func packages(line string) []string {
	var out []string
	if i := strings.Index(line, "apk add"); i >= 0 {
		out = append(out, packageTokens(line[i+len("apk add"):])...)
	}
	if i := strings.Index(line, "apt-get install"); i >= 0 {
		rest := line[i+len("apt-get install"):]
		if j := strings.Index(rest, "&&"); j >= 0 {
			rest = rest[:j]
		}
		out = append(out, packageTokens(rest)...)
	}
	return out
}

func packageTokens(s string) []string {
	var out []string
	for _, f := range strings.Fields(s) {
		if strings.HasPrefix(f, "-") {
			continue
		}
		out = append(out, f)
	}
	return out
}

func rewriteFrom(data []byte, from string) []byte {
	lines := strings.Split(string(data), "\n")
	for i, line := range lines {
		trim := strings.TrimSpace(line)
		if trim == "" || strings.HasPrefix(trim, "#") {
			continue
		}
		if strings.HasPrefix(strings.ToUpper(trim), "FROM ") {
			lines[i] = "FROM " + from
		}
		break
	}
	return []byte(strings.Join(lines, "\n"))
}

var (
	buildMu = sync.Mutex{}
	buildOf = map[string]*sync.Mutex{}
)

func lockRef(ref string) func() {
	buildMu.Lock()
	m := buildOf[ref]
	if m == nil {
		m = &sync.Mutex{}
		buildOf[ref] = m
	}
	buildMu.Unlock()
	m.Lock()
	return m.Unlock
}

// Ensure bouwt de Dockerfile als het resultaat nog niet lokaal staat.
// De tag is de alias plus een hash van de Dockerfile, zodat een wijziging
// een nieuwe bouw is en een gelijke Dockerfile de cache raakt.
func (p Preset) Ensure(ctx context.Context, dockerBin string) (ref string, built bool, err error) {
	if p.Direct != "" {
		return p.Direct, false, nil
	}
	if len(p.Dockerfile) == 0 {
		return "", false, fmt.Errorf("preset %s heeft geen dockerfile", p.Name)
	}
	sum := sha256.Sum256(p.Dockerfile)
	ref = p.Name + ":" + hex.EncodeToString(sum[:6])
	unlock := lockRef(ref)
	defer unlock()
	if ok, _ := imageExists(ctx, dockerBin, ref); ok {
		return ref, false, nil
	}
	dir, err := os.MkdirTemp("", "bluegit-preset-")
	if err != nil {
		return "", false, err
	}
	defer os.RemoveAll(dir)
	if err := os.WriteFile(filepath.Join(dir, "Dockerfile"), p.Dockerfile, 0o644); err != nil {
		return "", false, err
	}
	cmd := exec.CommandContext(ctx, dockerBin, "build", "-t", ref, dir)
	out, err := cmd.CombinedOutput()
	if err != nil {
		msg := strings.TrimSpace(string(out))
		if msg == "" {
			msg = err.Error()
		}
		return "", false, fmt.Errorf("%s", msg)
	}
	return ref, true, nil
}

func imageExists(ctx context.Context, dockerBin, ref string) (bool, error) {
	cmd := exec.CommandContext(ctx, dockerBin, "image", "inspect", "--format", "{{.Id}}", ref)
	if err := cmd.Run(); err != nil {
		return false, err
	}
	return true, nil
}
