package ci

import (
	"strings"
	"testing"
)

func TestGitLabDocument(t *testing.T) {
	raw := []byte(`
stages: [test, deploy]
default:
  image: alpine:3.20
  before_script: ["echo prep"]
variables:
  MODE: {value: "ci"}
.php:
  image: php:8.3
  stage: test
php_tests:
  extends: .php
  script: ["phpunit"]
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
      changes: ["**/*.php"]
    - when: never
frontend_checks:
  stage: test
  script: ["node check"]
  rules:
    - if: $CI_COMMIT_TAG == null
      exists: ["package.json"]
  allow_failure: true
  cache:
    key: modules
    paths: ["node_modules"]
deploy:
  stage: deploy
  when: manual
  resource_group: production
  timeout: 30m
  tags: [deploy]
  only: ["master", "tags"]
  script: ["echo deploy"]
  needs:
    - job: php_tests
      optional: true
`)
	p, err := Parse(raw)
	if err != nil {
		t.Fatal(err)
	}
	if strings.Join(p.Stages, ",") != "test,deploy" {
		t.Fatalf("stages %v", p.Stages)
	}
	if p.Variables["MODE"] != "ci" {
		t.Fatal(p.Variables)
	}
	by := map[string]Job{}
	for _, j := range p.Jobs {
		by[j.Name] = j
	}
	if _, ok := by[".php"]; ok {
		t.Fatal("verborgen job hoort niet te draaien")
	}
	php := by["php_tests"]
	if php.Image != "php:8.3" || php.Stage != "test" || php.Before[0] != "echo prep" {
		t.Fatalf("extends %+v", php)
	}
	front := by["frontend_checks"]
	if !front.AllowFailure || front.Cache.Key != "modules" || front.Cache.Paths[0] != "node_modules" {
		t.Fatalf("frontend %+v", front)
	}
	dep := by["deploy"]
	if dep.When != "manual" || dep.ResourceGroup != "production" || dep.Timeout.Minutes() != 30 {
		t.Fatalf("deploy %+v", dep)
	}
	if len(dep.Needs) != 1 || dep.Optional[0] != "php_tests" {
		t.Fatalf("needs %+v opt %+v", dep.Needs, dep.Optional)
	}

	env := map[string]string{"CI_COMMIT_BRANCH": "master", "CI_DEFAULT_BRANCH": "master", "CI_COMMIT_REF_NAME": "master"}
	active, err := p.Select(Eval{Env: env, Changed: []string{"src/App.php"}, Files: []string{"package.json"}})
	if err != nil {
		t.Fatal(err)
	}
	names := map[string]bool{}
	for _, j := range active {
		names[j.Name] = true
	}
	if !names["php_tests"] || !names["frontend_checks"] || !names["deploy"] {
		t.Fatalf("actief %v", names)
	}
	active, err = p.Select(Eval{Env: map[string]string{"CI_COMMIT_BRANCH": "feature", "CI_DEFAULT_BRANCH": "master", "CI_COMMIT_REF_NAME": "feature"}, Changed: []string{"README"}, Files: []string{}})
	if err != nil {
		t.Fatal(err)
	}
	names = map[string]bool{}
	for _, j := range active {
		names[j.Name] = true
		if j.Name == "deploy" && j.When != "manual" {
			t.Fatal(j.When)
		}
	}
	if names["php_tests"] || names["frontend_checks"] {
		t.Fatalf("feature hoort die jobs over te slaan: %v", names)
	}
	if names["deploy"] {
		t.Fatal("only master/tags")
	}
}

func TestIncludeLocalAndWarnings(t *testing.T) {
	files := map[string]string{
		"ci/base.yml": "jobs:\n  unit:\n    image: alpine\n    script: ['echo unit']\n",
	}
	raw := []byte("include:\n  - local: ci/base.yml\nservices: [db]\njobs:\n  unit:\n    script: ['echo replaced']\n")
	p, err := ParseIn(raw, func(path string) ([]byte, error) { return []byte(files[path]), nil })
	if err != nil {
		t.Fatal(err)
	}
	if len(p.Jobs) != 1 || p.Jobs[0].Script[0] != "echo replaced" || p.Jobs[0].Image != "alpine" {
		t.Fatalf("%+v", p.Jobs)
	}
	if len(p.Warnings) != 1 || p.Warnings[0].Key != "ci.warn.ignored" {
		t.Fatalf("warnings %+v", p.Warnings)
	}
	_, issues := Lint([]byte("include:\n  - project: other\njobs:\n  a:\n    image: alpine\n    script: ['x']\n"), nil)
	found := false
	for _, is := range issues {
		if is.Key == "ci.err.includeRemote" {
			found = true
		}
	}
	if !found {
		t.Fatalf("issues %+v", issues)
	}
}

func TestWhenAndAllowFailure(t *testing.T) {
	p, err := Parse([]byte(`
stages: [een, twee]
jobs:
  a:
    stage: een
    image: alpine
    script: ['echo a']
    allow_failure: true
  b:
    stage: twee
    image: alpine
    script: ['echo b']
  c:
    stage: twee
    image: alpine
    when: always
    script: ['echo c']
  d:
    stage: twee
    image: alpine
    when: on_failure
    script: ['echo d']
`))
	if err != nil {
		t.Fatal(err)
	}
	st := map[string]string{"a": "failed", "b": "queued", "c": "queued", "d": "queued"}
	if Gate(p.Jobs, st, p.Jobs[1]) != "ready" {
		t.Fatal("allow_failure houdt de volgende stage niet tegen")
	}
	if Gate(p.Jobs, st, p.Jobs[2]) != "ready" || Gate(p.Jobs, st, p.Jobs[3]) != "ready" {
		t.Fatal("always en on_failure na een mislukking")
	}
	ok := map[string]string{"a": "success", "b": "queued", "c": "queued", "d": "queued"}
	if Gate(p.Jobs, ok, p.Jobs[3]) != "skip" {
		t.Fatal("on_failure slaat over na succes")
	}
	hard, err := Parse([]byte(`
stages: [een, twee]
jobs:
  a:
    stage: een
    image: alpine
    script: ['echo a']
  b:
    stage: twee
    image: alpine
    script: ['echo b']
`))
	if err != nil {
		t.Fatal(err)
	}
	if Gate(hard.Jobs, map[string]string{"a": "failed", "b": "queued"}, hard.Jobs[1]) != "skip" {
		t.Fatal("harde fout slaat de rest over")
	}
}

func TestMergeRequestPipelineRules(t *testing.T) {
	p, err := Parse([]byte(`
push_job:
  image: alpine:3.20
  script: ["echo push"]
mr_job:
  image: alpine:3.20
  script: ["echo mr"]
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
only_mr:
  image: alpine:3.20
  script: ["echo only"]
  only: ["merge_requests"]
`))
	if err != nil {
		t.Fatal(err)
	}
	pushEnv := Variables(Ref{SHA: "abc", FullRef: "refs/heads/feature", Source: "push", DefaultBranch: "master", ProjectPath: "tim/app"})
	push, err := p.Select(Eval{Env: pushEnv})
	if err != nil {
		t.Fatal(err)
	}
	if len(push) != 1 || push[0].Name != "push_job" {
		t.Fatalf("push: %+v", namesOf(push))
	}
	mr := &MRInfo{ID: 4, IID: 2, Title: "Titel", SourceBranch: "feature", TargetBranch: "master", ProjectPath: "tim/app", ProjectURL: "https://git.example/tim/app", TargetSHA: "def"}
	mrEnv := Variables(Ref{SHA: "abcdef", FullRef: "refs/heads/feature", Source: "merge_request_event", DefaultBranch: "master", ProjectPath: "tim/app", MR: mr})
	if mrEnv["CI_MERGE_REQUEST_IID"] != "2" || mrEnv["CI_MERGE_REQUEST_SOURCE_BRANCH_NAME"] != "feature" || mrEnv["CI_MERGE_REQUEST_TARGET_BRANCH_SHA"] != "def" || mrEnv["CI_MERGE_REQUEST_SOURCE_BRANCH_SHA"] != "abcdef" {
		t.Fatalf("%v", mrEnv)
	}
	got, err := p.Select(Eval{Env: mrEnv})
	if err != nil {
		t.Fatal(err)
	}
	if strings.Join(namesOf(got), ",") != "mr_job,only_mr" {
		t.Fatalf("mr: %v", namesOf(got))
	}
}

func namesOf(jobs []Job) []string {
	out := make([]string, len(jobs))
	for i, j := range jobs {
		out[i] = j.Name
	}
	return out
}

func TestMaskAndVariables(t *testing.T) {
	if got := Mask("token=supersecret value", []string{"supersecret", "ab"}); got != "token=[MASKED] value" {
		t.Fatal(got)
	}
	env := Variables(Ref{SHA: "abcdef1234567890", FullRef: "refs/tags/v1.2.0", Title: "Uitgave", DefaultBranch: "master", Source: "push", ProjectPath: "tim/app", ProjectURL: "https://git.example/tim/app", APIURL: "https://git.example/api/v1", PipelineID: 9})
	if env["CI_COMMIT_TAG"] != "v1.2.0" || env["CI_COMMIT_BRANCH"] != "" || env["CI_COMMIT_SHORT_SHA"] != "abcdef12" {
		t.Fatalf("%v", env)
	}
	if _, ok := env["CI_COMMIT_TIMESTAMP"]; ok {
		t.Fatal("lege committer-tijd hoort geen variabele te zetten")
	}
	stamped := Variables(Ref{SHA: "abcdef1234567890", FullRef: "refs/heads/master", Timestamp: "2026-10-22T22:32:33+00:00"})
	if stamped["CI_COMMIT_TIMESTAMP"] != "2026-10-22T22:32:33+00:00" {
		t.Fatalf("timestamp: %q", stamped["CI_COMMIT_TIMESTAMP"])
	}
	if env["CI_DEFAULT_BRANCH"] != "master" || env["CI_PROJECT_NAME"] != "app" || env["CI_PIPELINE_SOURCE"] != "push" {
		t.Fatalf("%v", env)
	}
	ok, err := evalRule(`$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH`, map[string]string{"CI_COMMIT_BRANCH": "master", "CI_DEFAULT_BRANCH": "master"})
	if err != nil || !ok {
		t.Fatal(err, ok)
	}
	ok, err = evalRule(`$CI_COMMIT_TAG == null`, map[string]string{"CI_COMMIT_TAG": ""})
	if err != nil || !ok {
		t.Fatal("null", err, ok)
	}
}
