package scripts

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

func TestRewritePkgbuild(t *testing.T) {
	root := filepath.Join("..")
	for _, name := range []string{"publish-aur.sh", "aur-ssh-setup.sh", "aur-common.sh", "aur-publish-local.sh"} {
		cmd := exec.Command("bash", "-n", filepath.Join(root, "scripts", name))
		if out, err := cmd.CombinedOutput(); err != nil {
			t.Fatalf("%s: %v %s", name, err, out)
		}
	}
	publish, err := os.ReadFile(filepath.Join(root, "scripts", "publish-aur.sh"))
	if err != nil {
		t.Fatal(err)
	}
	if strings.Contains(string(publish), "CI_JOB_TOKEN") || strings.Contains(string(publish), "JOB-TOKEN") {
		t.Fatal("het archief hoort anoniem opgehaald te worden")
	}
	dir := t.TempDir()
	src, err := os.ReadFile(filepath.Join(root, "packaging", "aur", "PKGBUILD"))
	if err != nil {
		t.Fatal(err)
	}
	dest := filepath.Join(dir, "PKGBUILD")
	if err := os.WriteFile(dest, src, 0o644); err != nil {
		t.Fatal(err)
	}
	version, commit, sum := "20261022183000", "0123456789abcdef0123456789abcdef01234567", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
	cmd := exec.Command("bash", filepath.Join(root, "scripts", "publish-aur.sh"), "--rewrite-only", version, commit, sum, dest)
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("rewrite: %v %s", err, out)
	}
	got, err := os.ReadFile(dest)
	if err != nil {
		t.Fatal(err)
	}
	text := string(got)
	for _, want := range []string{
		"pkgver=" + version,
		"pkgrel=1",
		"_commit=" + commit,
		"sha256sums=('" + sum + "')",
		"https://git.timfalken.com/timfa/bluegit/-/archive/${_commit}/bluegit-${_commit}.tar.gz",
	} {
		if !strings.Contains(text, want) {
			t.Fatalf("mist %q in\n%s", want, text)
		}
	}
	hook, err := os.ReadFile(filepath.Join(root, "packaging", "aur", "bluegit.install"))
	if err != nil {
		t.Fatal(err)
	}
	hookText := string(hook)
	for _, want := range []string{
		"systemd-sysusers bluegit.conf",
		"systemd-tmpfiles --create",
		"systemctl daemon-reload",
		"enable --now bluegit.service",
		"try-restart bluegit.service",
		"disable --now bluegit.service",
		"pre_remove",
		"/etc/bluegit/config.yml",
		"/etc/bluegit/client_secret",
		"BLUEGIT_AUTH_CLIENT_SECRET",
		"/run/systemd/system",
		"User=bluegit",
	} {
		if !strings.Contains(hookText, want) {
			t.Fatalf("hook mist %q", want)
		}
	}
	if strings.Contains(hookText, "rm ") {
		t.Fatal("hook hoort geen bestanden te verwijderen")
	}
	installBody, ok := shellFunc(hookText, "post_install")
	if !ok || !strings.Contains(installBody, "enable --now bluegit.service") || !strings.Contains(installBody, "systemd-tmpfiles --create") {
		t.Fatal("post_install start de service niet of maakt de homedir niet")
	}
	upgradeBody, ok := shellFunc(hookText, "post_upgrade")
	if !ok || strings.Contains(upgradeBody, "post_install") || !strings.Contains(upgradeBody, "try-restart bluegit.service") {
		t.Fatalf("post_upgrade hoort alleen te herstarten:\n%s", upgradeBody)
	}
	removeBody, ok := shellFunc(hookText, "pre_remove")
	if !ok || !strings.Contains(removeBody, "disable --now bluegit.service") {
		t.Fatal("pre_remove zet de service niet uit")
	}
	local, err := os.ReadFile(filepath.Join(root, "scripts", "aur-publish-local.sh"))
	if err != nil {
		t.Fatal(err)
	}
	for _, bad := range []string{"CI_COMMIT_SHA", "CI_JOB_TOKEN", "JOB-TOKEN", "AUR_SSH_PRIVATE_KEY", "AUR_GIT_AUTHOR", "GIT_SSH_COMMAND", "aur-ssh-setup"} {
		if strings.Contains(string(local), bad) {
			t.Fatalf("lokaal script noemt %s", bad)
		}
	}
}

func shellFunc(script, name string) (string, bool) {
	marker := name + "() {"
	i := strings.Index(script, marker)
	if i < 0 {
		return "", false
	}
	rest := script[i+len(marker):]
	depth := 1
	for j, r := range rest {
		switch r {
		case '{':
			depth++
		case '}':
			depth--
			if depth == 0 {
				return rest[:j], true
			}
		}
	}
	return "", false
}

func scriptEnv(extra ...string) []string {
	skip := []string{
		"GIT_AUTHOR_", "GIT_COMMITTER_", "GIT_DIR=", "GIT_WORK_TREE=",
		"GIT_CONFIG_COUNT=", "GIT_CONFIG_KEY_", "GIT_CONFIG_VALUE_",
		"GIT_CONFIG_GLOBAL=", "GIT_CONFIG_SYSTEM=",
	}
	out := make([]string, 0, len(os.Environ())+len(extra))
	for _, e := range os.Environ() {
		drop := false
		for _, p := range skip {
			if strings.HasPrefix(e, p) {
				drop = true
				break
			}
		}
		if !drop {
			out = append(out, e)
		}
	}
	return append(out, extra...)
}

func runCmd(t *testing.T, dir string, env []string, name string, args ...string) string {
	t.Helper()
	cmd := exec.Command(name, args...)
	if dir != "" {
		cmd.Dir = dir
	}
	cmd.Env = env
	out, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("%s %v: %v\n%s", name, args, err, out)
	}
	return string(out)
}

func initPublishedMaster(t *testing.T, env []string) string {
	t.Helper()
	root := t.TempDir()
	repo := filepath.Join(root, "repo")
	bare := filepath.Join(root, "origin.git")
	if err := os.MkdirAll(repo, 0o755); err != nil {
		t.Fatal(err)
	}
	runCmd(t, repo, env, "git", "init", "-b", "master")
	runCmd(t, repo, env, "git", "config", "user.name", "Test")
	runCmd(t, repo, env, "git", "config", "user.email", "test@example.com")
	if err := os.WriteFile(filepath.Join(repo, "README"), []byte("x\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	runCmd(t, repo, env, "git", "add", "README")
	runCmd(t, repo, env, "git", "commit", "-m", "init")
	runCmd(t, root, env, "git", "init", "--bare", "-b", "master", bare)
	runCmd(t, repo, env, "git", "remote", "add", "origin", bare)
	runCmd(t, repo, env, "git", "push", "-u", "origin", "master")
	return repo
}

func TestAurCommitPublished(t *testing.T) {
	dir := t.TempDir()
	pkg := filepath.Join(dir, "PKGBUILD")
	sha := "0123456789abcdef0123456789abcdef01234567"
	if err := os.WriteFile(pkg, []byte("pkgver=1\npkgrel=1\n_commit="+sha+"\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	common := filepath.Join("..", "scripts", "aur-common.sh")
	ask := func(commit, file string) string {
		t.Helper()
		cmd := exec.Command("bash", "-c", `source "$1"; if aur_commit_published "$2" "$3"; then echo yes; else echo no; fi`, "bash", common, file, commit)
		out, err := cmd.CombinedOutput()
		if err != nil {
			t.Fatalf("aur_commit_published: %v %s", err, out)
		}
		return strings.TrimSpace(string(out))
	}
	if ask(sha, pkg) != "yes" {
		t.Fatal("bekende sha hoort al gepubliceerd te zijn")
	}
	if ask("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", pkg) != "no" {
		t.Fatal("andere sha hoort nog niet gepubliceerd te zijn")
	}
	if ask(sha, filepath.Join(dir, "missing")) != "no" {
		t.Fatal("ontbrekende PKGBUILD is niet gepubliceerd")
	}
}

func TestCopyPackagingAur(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	for _, name := range []string{"PKGBUILD", "bluegit.install", ".SRCINFO"} {
		if err := os.WriteFile(filepath.Join(src, name), []byte(name+"\n"), 0o644); err != nil {
			t.Fatal(err)
		}
	}
	script := filepath.Join("..", "scripts", "aur-publish-local.sh")
	cmd := exec.Command("bash", "-c", `source "$1"; copy_packaging_aur "$2" "$3"`, "bash", script, src, dest)
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("kopie: %v %s", err, out)
	}
	for _, name := range []string{"PKGBUILD", "bluegit.install", ".SRCINFO"} {
		got, err := os.ReadFile(filepath.Join(dest, name))
		if err != nil {
			t.Fatalf("mist %s: %v", name, err)
		}
		if string(got) != name+"\n" {
			t.Fatalf("%s = %q", name, got)
		}
	}
}

func TestLocalAurCheckOnly(t *testing.T) {
	env := scriptEnv(
		"GIT_AUTHOR_NAME=Test",
		"GIT_AUTHOR_EMAIL=test@example.com",
		"GIT_COMMITTER_NAME=Test",
		"GIT_COMMITTER_EMAIL=test@example.com",
	)
	script := filepath.Join("..", "scripts", "aur-publish-local.sh")
	check := func(t *testing.T, repo string) (string, error) {
		t.Helper()
		cache := filepath.Join(t.TempDir(), "cache")
		cmd := exec.Command("bash", script, "--check-only", repo)
		cmd.Env = append(append([]string{}, env...), "BLUEGIT_AUR_CACHE="+cache)
		out, err := cmd.CombinedOutput()
		if _, statErr := os.Stat(cache); !os.IsNotExist(statErr) {
			t.Fatal("check-only raakte de AUR-werkmap")
		}
		return string(out), err
	}

	t.Run("gelijk", func(t *testing.T) {
		repo := initPublishedMaster(t, env)
		sha := strings.TrimSpace(runCmd(t, repo, env, "git", "rev-parse", "origin/master"))
		out, err := check(t, repo)
		if err != nil {
			t.Fatalf("check-only: %v\n%s", err, out)
		}
		if !strings.Contains(out, "Publiceren: "+sha) {
			t.Fatalf("sha van origin/master ontbreekt:\n%s", out)
		}
	})
	t.Run("niet schoon", func(t *testing.T) {
		repo := initPublishedMaster(t, env)
		if err := os.WriteFile(filepath.Join(repo, "dirty"), []byte("z\n"), 0o644); err != nil {
			t.Fatal(err)
		}
		out, err := check(t, repo)
		if err == nil || !strings.Contains(out, "niet schoon") {
			t.Fatalf("vuile checkout hoorde te falen:\n%s", out)
		}
	})
	t.Run("niet master", func(t *testing.T) {
		repo := initPublishedMaster(t, env)
		runCmd(t, repo, env, "git", "checkout", "-b", "other")
		out, err := check(t, repo)
		if err == nil || !strings.Contains(out, "niet op master") {
			t.Fatalf("andere branch hoorde te falen:\n%s", out)
		}
	})
	t.Run("wijkt af", func(t *testing.T) {
		repo := initPublishedMaster(t, env)
		if err := os.WriteFile(filepath.Join(repo, "README"), []byte("y\n"), 0o644); err != nil {
			t.Fatal(err)
		}
		runCmd(t, repo, env, "git", "add", "README")
		runCmd(t, repo, env, "git", "commit", "-m", "lokaal")
		out, err := check(t, repo)
		if err == nil || !strings.Contains(out, "wijkt af van origin/master") {
			t.Fatalf("lokale commit hoorde te falen:\n%s", out)
		}
	})
}

func TestInstallHookService(t *testing.T) {
	skipWithoutUserNS(t)
	work := t.TempDir()
	hook, err := filepath.Abs(filepath.Join("..", "packaging", "aur", "bluegit.install"))
	if err != nil {
		t.Fatal(err)
	}
	script := filepath.Join(work, "hooktest.sh")
	if err := os.WriteFile(script, []byte(installHookTest), 0o755); err != nil {
		t.Fatal(err)
	}
	cmd := exec.Command("unshare", "-U", "-r", "-m", "bash", script, hook, work)
	out, err := cmd.CombinedOutput()
	if err != nil || !strings.Contains(string(out), "hook-ok") {
		t.Fatalf("install-hook: %v\n%s", err, out)
	}
}

const installHookTest = `#!/usr/bin/env bash
set -euo pipefail
hook="$1"
work="$2"
bin="$work/bin"
log="$work/log"
mode="$work/mode"
etc="$work/etc"
mkdir -p "$bin" "$etc/bluegit"

cat > "$bin/systemctl" <<'EOF'
#!/bin/sh
printf '%s\n' "$*" >> "$BLUEGIT_TEST_LOG"
mode=$(cat "$BLUEGIT_TEST_MODE" 2>/dev/null || true)
case "$mode" in
  bus)
    echo "System has not been booted with systemd." >&2
    exit 1
    ;;
  other)
    echo "Failed to enable unit: Unit bluegit.service not found." >&2
    exit 1
    ;;
esac
exit 0
EOF
printf '#!/bin/sh\nexit 0\n' > "$bin/systemd-sysusers"
printf '#!/bin/sh\nexit 0\n' > "$bin/systemd-tmpfiles"
chmod +x "$bin/systemctl" "$bin/systemd-sysusers" "$bin/systemd-tmpfiles"

export BLUEGIT_TEST_LOG="$log"
export BLUEGIT_TEST_MODE="$mode"
export PATH="$bin:/usr/bin:/bin"

mount --bind "$etc" /etc
mount -t tmpfs tmpfs /run
# shellcheck disable=SC1090
source "$hook"

reset() {
  : > "$log"
  unset _BLUEGIT_SYSTEMD_CHECKED _BLUEGIT_SYSTEMD_OK
  rm -rf /etc/bluegit /run/systemd
  mkdir -p /etc/bluegit
}

echo ok > "$mode"

echo "case geen-systemd" >&2
reset
out=$(post_install)
post_upgrade
pre_remove
post_remove
printf '%s\n' "$out" | grep -q 'systemd draait niet'
printf '%s\n' "$out" | grep -q 'clientgeheim'
if [[ -s "$log" ]]; then
  echo "systemctl liep zonder systemd: $(cat "$log")" >&2
  exit 1
fi

echo "case zonder-geheim" >&2
reset
mkdir -p /run/systemd/system
printf 'client_secret: ""\n' > /etc/bluegit/config.yml
out=$(post_install)
printf '%s\n' "$out" | grep -q 'niet gestart'
printf '%s\n' "$out" | grep -q '/usr/share/bluegit/storage.conf.example'
if printf '%s\n' "$out" | grep -q 'systemd draait niet'; then
  echo "onterecht chroot" >&2
  exit 1
fi
grep -qx 'daemon-reload' "$log"
if grep -q 'enable' "$log"; then
  echo "enable zonder geheim" >&2
  exit 1
fi

echo "case client_secret" >&2
reset
mkdir -p /run/systemd/system
printf 'base_url: https://git.example\n' > /etc/bluegit/config.yml
printf 'geheim\n' > /etc/bluegit/client_secret
out=$(post_install)
if printf '%s\n' "$out" | grep -q 'niet gestart'; then
  echo "onverwachte melding: $out" >&2
  exit 1
fi
grep -qx 'daemon-reload' "$log"
grep -qx 'enable --now bluegit.service' "$log"

echo "case secret.env" >&2
reset
mkdir -p /run/systemd/system
printf 'x: y\n' > /etc/bluegit/config.yml
printf '  \n' > /etc/bluegit/client_secret
printf '%s\n' "BLUEGIT_AUTH_CLIENT_SECRET='geheim'" > /etc/bluegit/secret.env
post_install >/dev/null
grep -qx 'enable --now bluegit.service' "$log"

echo "case lege-quotes" >&2
reset
mkdir -p /run/systemd/system
printf 'x: y\n' > /etc/bluegit/config.yml
printf '%s\n' '# BLUEGIT_AUTH_CLIENT_SECRET=nope' 'BLUEGIT_AUTH_CLIENT_SECRET=""' > /etc/bluegit/secret.env
post_install >/dev/null
if grep -q enable "$log"; then
  echo "lege quotes telden als geheim" >&2
  exit 1
fi

echo "case zonder-config" >&2
reset
mkdir -p /run/systemd/system
printf 'geheim\n' > /etc/bluegit/client_secret
post_install >/dev/null
if grep -q enable "$log"; then
  echo "enable zonder config" >&2
  exit 1
fi

echo "case upgrade" >&2
reset
mkdir -p /run/systemd/system
post_upgrade >/dev/null
grep -qx 'daemon-reload' "$log"
grep -qx 'try-restart bluegit.service' "$log"
if grep -q enable "$log"; then
  echo "upgrade zette de service aan" >&2
  exit 1
fi

echo "case verwijderen" >&2
reset
mkdir -p /run/systemd/system
pre_remove >/dev/null
grep -qx 'disable --now bluegit.service' "$log"
: > "$log"
post_remove >/dev/null
grep -qx 'daemon-reload' "$log"

echo "case bus" >&2
reset
mkdir -p /run/systemd/system
echo bus > "$mode"
printf 'x: y\n' > /etc/bluegit/config.yml
printf 'geheim\n' > /etc/bluegit/client_secret
post_install >/dev/null
echo ok > "$mode"

echo "case echte-fout" >&2
reset
mkdir -p /run/systemd/system
echo other > "$mode"
if post_install >/dev/null; then
  echo "echte systemctl-fout werd genegeerd" >&2
  exit 1
fi

echo hook-ok
`

func TestPkgverUsesCommitterTime(t *testing.T) {
	root, err := filepath.Abs(filepath.Join(".."))
	if err != nil {
		t.Fatal(err)
	}
	script := filepath.Join(root, "scripts", "publish-aur.sh")
	common, err := os.ReadFile(filepath.Join(root, "scripts", "aur-common.sh"))
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(string(common), `safe.directory="$dir"`) || !strings.Contains(string(common), `safe.directory=*`) {
		t.Fatal("aur-common geeft safe.directory niet mee")
	}
	out, err := gitInRepo(root, "rev-parse", "HEAD").Output()
	if err != nil {
		t.Fatal(err)
	}
	sha := strings.TrimSpace(string(out))
	if got := printPkgver(t, script, sha, "2026-10-22T22:32:33Z"); got != "20261022223233" {
		t.Fatalf("Z: %s", got)
	}
	if got := printPkgver(t, script, sha, "2026-10-22T23:32:33+01:00"); got != "20261022223233" {
		t.Fatalf("offset: %s", got)
	}
	if got := printPkgver(t, script, sha, "2026-10-22T00:30:00+02:00"); got != "20261021223000" {
		t.Fatalf("rollover: %s", got)
	}

	got := printPkgver(t, script, sha, "")
	updater := gitInRepo(root, "show", "-s", "--date=format-local:%Y%m%d%H%M%S", "--format=%cd", sha)
	updater.Env = append(os.Environ(), "TZ=UTC")
	up, err := updater.Output()
	if err != nil {
		t.Fatal(err)
	}
	if got != strings.TrimSpace(string(up)) {
		t.Fatalf("pkgver %s wijkt af van de updater %s", got, strings.TrimSpace(string(up)))
	}
	now, err := exec.Command("date", "-u", "+%Y%m%d%H%M%S").Output()
	if err != nil {
		t.Fatal(err)
	}
	if got == strings.TrimSpace(string(now)) && got != strings.TrimSpace(string(up)) {
		t.Fatal("pkgver volgt de klok van de job")
	}
}

// gitInRepo zet safe.directory op de commandoregel. De testgebruiker is
// op Steve niet de eigenaar van de checkout; een kale git -C sterft dan
// met exit 128.
func gitInRepo(dir string, args ...string) *exec.Cmd {
	all := append([]string{"-c", "safe.directory=" + dir, "-c", "safe.directory=*", "-C", dir}, args...)
	return exec.Command("git", all...)
}

func printPkgver(t *testing.T, script, sha, stamp string) string {
	t.Helper()
	env := make([]string, 0, len(os.Environ()))
	for _, e := range os.Environ() {
		if strings.HasPrefix(e, "CI_COMMIT_TIMESTAMP=") || strings.HasPrefix(e, "CI_COMMIT_SHA=") {
			continue
		}
		// De runner zet later zelf safe.directory. De test haalt die weg,
		// anders slaagt --print-pkgver ook zonder -c in het script.
		drop := false
		for _, p := range []string{"GIT_CONFIG_COUNT=", "GIT_CONFIG_KEY_", "GIT_CONFIG_VALUE_", "GIT_CONFIG_GLOBAL=", "GIT_CONFIG_SYSTEM="} {
			if strings.HasPrefix(e, p) {
				drop = true
				break
			}
		}
		if drop {
			continue
		}
		env = append(env, e)
	}
	env = append(env, "CI_COMMIT_SHA="+sha, "GIT_CONFIG_GLOBAL=/dev/null", "GIT_CONFIG_SYSTEM=/dev/null")
	if stamp != "" {
		env = append(env, "CI_COMMIT_TIMESTAMP="+stamp)
	}
	cmd := exec.Command("bash", script, "--print-pkgver")
	cmd.Env = env
	out, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("print-pkgver: %v %s", err, out)
	}
	return strings.TrimSpace(string(out))
}

// skipWithoutUserNS slaat de test over als unshare ontbreekt of als de
// kernel user namespaces weigert. In een container is de binary er vaak
// wel, maar geeft unshare(CLONE_NEWUSER|CLONE_NEWNS) EPERM.
func skipWithoutUserNS(t *testing.T) {
	t.Helper()
	if _, err := exec.LookPath("unshare"); err != nil {
		t.Skip("unshare ontbreekt")
	}
	out, err := exec.Command("unshare", "-U", "-r", "-m", "true").CombinedOutput()
	if err != nil {
		t.Skipf("user namespaces niet beschikbaar: %v: %s", err, out)
	}
}
