package update

import (
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
)

func root(t *testing.T) string {
	t.Helper()
	return filepath.Join("..", "..")
}

func TestPackagingFiles(t *testing.T) {
	base := root(t)
	unit, err := os.ReadFile(filepath.Join(base, "packaging", "bluegit-update.service"))
	if err != nil {
		t.Fatal(err)
	}
	text := string(unit)
	for _, want := range []string{
		"Type=oneshot",
		"User=root",
		"ExecStart=/usr/lib/bluegit/update",
		"EnvironmentFile=-/etc/bluegit/env",
		"TimeoutStartSec=3h",
	} {
		if !strings.Contains(text, want) {
			t.Fatalf("unit mist %q", want)
		}
	}
	if strings.Contains(text, "User=bluegit") {
		t.Fatal("de update-unit hoort niet als bluegit te draaien")
	}
	rules, err := os.ReadFile(filepath.Join(base, "packaging", "bluegit-update.rules"))
	if err != nil {
		t.Fatal(err)
	}
	ruleText := string(rules)
	for _, want := range []string{
		`subject.user != "bluegit"`,
		`action.lookup("verb") == "start"`,
		`action.lookup("unit") == "bluegit-update.service"`,
		"polkit.Result.YES",
		"org.freedesktop.systemd1.manage-units",
	} {
		if !strings.Contains(ruleText, want) {
			t.Fatalf("polkit mist %q", want)
		}
	}
	for _, banned := range []string{"stop", "restart", "isolate"} {
		if strings.Contains(ruleText, banned) {
			t.Fatalf("polkit noemt %s", banned)
		}
	}
	service, err := os.ReadFile(filepath.Join(base, "packaging", "bluegit.service"))
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(string(service), "EnvironmentFile=-/etc/bluegit/env") {
		t.Fatal("bluegit.service leest /etc/bluegit/env niet")
	}
	sysusers, err := os.ReadFile(filepath.Join(base, "packaging", "sysusers.conf"))
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(string(sysusers), "u bluegit-build ") {
		t.Fatal("sysusers mist bluegit-build")
	}
	tmpfiles, err := os.ReadFile(filepath.Join(base, "packaging", "tmpfiles.conf"))
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(string(tmpfiles), "d /var/lib/bluegit-build 0750 bluegit-build bluegit-build -") {
		t.Fatal("tmpfiles maakt /var/lib/bluegit-build niet")
	}
	hook, err := os.ReadFile(filepath.Join(base, "packaging", "aur", "bluegit.install"))
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(string(hook), "bluegit-build") || !strings.Contains(string(hook), "systemd-sysusers bluegit.conf") {
		t.Fatal("install-hook maakt de bouwgebruiker niet")
	}
	if !strings.Contains(string(hook), "systemd-tmpfiles --create bluegit.conf") {
		t.Fatal("install-hook maakt de homedir van bluegit-build niet")
	}
	if !strings.Contains(string(hook), "try-restart bluegit.service") {
		t.Fatal("upgrade hoort de service te herstarten")
	}
	pkg, err := os.ReadFile(filepath.Join(base, "packaging", "aur", "PKGBUILD"))
	if err != nil {
		t.Fatal(err)
	}
	pkgText := string(pkg)
	for _, want := range []string{
		"packaging/bluegit-update.sh",
		"/usr/lib/bluegit/update",
		"bluegit-update.service",
		"49-bluegit-update.rules",
	} {
		if !strings.Contains(pkgText, want) {
			t.Fatalf("PKGBUILD installeert %s niet", want)
		}
	}
}

func TestUpdateScriptBehavior(t *testing.T) {
	if _, err := exec.LookPath("bash"); err != nil {
		t.Skip("bash ontbreekt")
	}
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git ontbreekt")
	}
	base := root(t)
	script := filepath.Join(base, "packaging", "bluegit-update.sh")
	if out, err := exec.Command("bash", "-n", script).CombinedOutput(); err != nil {
		t.Fatalf("syntax: %v %s", err, out)
	}
	body, err := os.ReadFile(script)
	if err != nil {
		t.Fatal(err)
	}
	text := string(body)
	for _, want := range []string{
		"makepkg --noconfirm --nosign",
		"pacman -U --noconfirm",
		"runuser -u",
		"safe.directory",
		"update.log",
		"TZ=UTC git_repo",
		"--date=format-local:%Y%m%d%H%M%S",
		"flock -n",
		"wait_until_idle",
	} {
		if !strings.Contains(text, want) {
			t.Fatalf("script mist %q", want)
		}
	}
	if strings.Contains(text, "gitlab.com") {
		t.Fatal("de updater hoort de lokale bare repo te gebruiken")
	}

	repo := t.TempDir()
	git := func(args ...string) {
		t.Helper()
		cmd := exec.Command("git", args...)
		cmd.Dir = repo
		cmd.Env = append(os.Environ(),
			"GIT_AUTHOR_DATE=2026-01-02T03:04:05Z",
			"GIT_COMMITTER_DATE=2026-01-02T03:04:05Z",
		)
		if out, err := cmd.CombinedOutput(); err != nil {
			t.Fatalf("git %s: %v %s", args, err, out)
		}
	}
	git("init", "-b", "master")
	git("config", "user.email", "tim@users.git.timfalken.com")
	git("config", "user.name", "tim")
	if err := os.WriteFile(filepath.Join(repo, "README"), []byte("x\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	git("add", "README")
	git("commit", "-m", "een")
	shaOut, err := exec.Command("git", "-C", repo, "rev-parse", "HEAD").Output()
	if err != nil {
		t.Fatal(err)
	}
	sha := strings.TrimSpace(string(shaOut))

	bin := t.TempDir()
	count := filepath.Join(bin, "count")
	if err := os.WriteFile(count, []byte("2\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	curl := filepath.Join(bin, "curl")
	curlBody := "#!/bin/bash\nn=$(tr -d '[:space:]' < " + shellQuote(count) + ")\nprintf '{\"running\":%s}\\n' \"$n\"\nif [[ \"$n\" != 0 ]]; then echo $((n-1)) > " + shellQuote(count) + "; fi\n"
	if err := os.WriteFile(curl, []byte(curlBody), 0o755); err != nil {
		t.Fatal(err)
	}
	probe := "source " + shellQuote(script) + "\n" +
		"valid_ref '' && valid_ref 'master' && valid_ref " + shellQuote(sha) + " || exit 1\n" +
		"valid_ref '../x' && exit 1\n" +
		"valid_ref 'master;rm' && exit 1\n" +
		"ver=$(pkgver_of " + shellQuote(repo) + " " + shellQuote(sha) + ")\n" +
		"[[ \"$ver\" == 20260102030405 ]] || { echo \"pkgver $ver\"; exit 1; }\n" +
		"export PATH=" + shellQuote(bin) + ":$PATH\n" +
		"export BLUEGIT_UPDATE_TOKEN=test BLUEGIT_UPDATE_URL=http://127.0.0.1:9 BLUEGIT_UPDATE_POLL=0 BLUEGIT_UPDATE_TIMEOUT=5\n" +
		"wait_until_idle\n"
	cmd := exec.Command("bash", "-c", probe)
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("gedrag: %v %s", err, out)
	}
}

func TestMakepkgRunsBesidePkgbuild(t *testing.T) {
	if _, err := exec.LookPath("bash"); err != nil {
		t.Skip("bash ontbreekt")
	}
	script := filepath.Join(root(t), "packaging", "bluegit-update.sh")
	abs, err := filepath.Abs(script)
	if err != nil {
		t.Fatal(err)
	}
	script = abs
	work := t.TempDir()
	if err := os.WriteFile(filepath.Join(work, "PKGBUILD"), []byte("pkgname=bluegit\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	bin := t.TempDir()
	record := filepath.Join(t.TempDir(), "pwd")
	runuser := "#!/bin/bash\nset -euo pipefail\nwhile [[ $# -gt 0 && \"$1\" != \"--\" ]]; do shift; done\n[[ $# -gt 0 ]] || exit 1\nshift\nexec \"$@\"\n"
	makepkg := "#!/bin/bash\nset -euo pipefail\n{\nprintf '%s\\n' \"$(pwd)\"\nprintf '%s\\n' \"$GOCACHE\"\nprintf '%s\\n' \"$GOPATH\"\n} > " + shellQuote(record) + "\n[[ -f PKGBUILD ]]\n"
	if err := os.WriteFile(filepath.Join(bin, "runuser"), []byte(runuser), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(bin, "makepkg"), []byte(makepkg), 0o755); err != nil {
		t.Fatal(err)
	}
	probe := "source " + shellQuote(script) + "\nbuild_package " + shellQuote(work) + "\n"
	cmd := exec.Command("bash", "-c", probe)
	cmd.Dir = t.TempDir()
	cmd.Env = append(os.Environ(), "PATH="+bin+string(os.PathListSeparator)+os.Getenv("PATH"))
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("makepkg: %v %s", err, out)
	}
	raw, err := os.ReadFile(record)
	if err != nil {
		t.Fatal(err)
	}
	lines := strings.Split(strings.TrimRight(string(raw), "\n"), "\n")
	if len(lines) != 3 || lines[0] != work || lines[1] != filepath.Join(work, "gocache") || lines[2] != filepath.Join(work, "gopath") {
		t.Fatalf("makepkg zag %q, verwacht cwd %s en cache daaronder", lines, work)
	}
}

func shellQuote(s string) string {
	return "'" + strings.ReplaceAll(s, "'", "'\\''") + "'"
}
