package ci

import (
	"strings"
	"testing"
	"time"
)

const sample = `
image: alpine:3.20
stages: [test, build, release]
variables:
  CGO_ENABLED: "0"
jobs:
  test:
    stage: test
    image: golang:1.22
    script:
      - go test ./...
  build:
    stage: build
    needs: [test]
    script:
      - go build -o bluegit ./cmd/bluegit
    artifacts:
      paths: [bluegit]
      expire_in: 14d
  release:
    stage: release
    needs: [build]
    rules:
      - if: $CI_COMMIT_BRANCH == "master"
      - if: $CI_COMMIT_BRANCH =~ /^release\/.*/
    script:
      - echo release
`

func TestParseCommentOnly(t *testing.T) {
	for _, raw := range []string{"", "\n", "# only\n# comments\n"} {
		p, issues := Lint([]byte(raw), nil)
		if len(issues) != 0 || len(p.Jobs) != 0 {
			t.Fatalf("%q issues=%v jobs=%d", raw, issues, len(p.Jobs))
		}
		if _, err := Parse([]byte(raw)); err != nil {
			t.Fatalf("parse %q: %v", raw, err)
		}
	}
	if _, err := Parse([]byte("{}\n")); err == nil {
		t.Fatal("lege mapping hoort een fout te zijn")
	}
	_, issues := Lint([]byte("stages:\n  - test\n"), nil)
	if len(issues) == 0 || issues[0].Key != "ci.err.noJobs" {
		t.Fatalf("stages zonder jobs: %+v", issues)
	}
}

func TestParseSample(t *testing.T) {
	p, err := Parse([]byte(sample))
	if err != nil {
		t.Fatal(err)
	}
	if len(p.Jobs) != 3 {
		t.Fatalf("jobs %d", len(p.Jobs))
	}
	if p.Jobs[1].Image != "alpine:3.20" {
		t.Fatalf("image-default, kreeg %s", p.Jobs[1].Image)
	}
	if !p.Jobs[1].NeedsSet || len(p.Jobs[1].Needs) != 1 || p.Jobs[1].Needs[0] != "test" {
		t.Fatalf("needs %+v", p.Jobs[1].Needs)
	}
	if p.Jobs[1].Artifacts.ExpireIn != 14*24*time.Hour {
		t.Fatalf("expire %s", p.Jobs[1].Artifacts.ExpireIn)
	}
	if p.Variables["CGO_ENABLED"] != "0" {
		t.Fatal("variabele")
	}
	active, err := p.ActiveJobs(map[string]string{"CI_COMMIT_BRANCH": "master"})
	if err != nil || len(active) != 3 {
		t.Fatalf("master: %d %v", len(active), err)
	}
	active, err = p.ActiveJobs(map[string]string{"CI_COMMIT_BRANCH": "release/1"})
	if err != nil || len(active) != 3 {
		t.Fatalf("release branch: %d %v", len(active), err)
	}
	active, err = p.ActiveJobs(map[string]string{"CI_COMMIT_BRANCH": "feature"})
	if err != nil || len(active) != 2 {
		t.Fatalf("feature hoort release over te slaan: %d %v", len(active), err)
	}
}

func TestImplicitStageAndEmptyNeeds(t *testing.T) {
	p, err := Parse([]byte(`
jobs:
  a:
    image: alpine
    script: ["echo a"]
  b:
    image: alpine
    stage: pakket
    needs: []
    script: ["echo b"]
`))
	if err != nil {
		t.Fatal(err)
	}
	if strings.Join(p.Stages, ",") != "test,pakket" {
		t.Fatalf("stages %v", p.Stages)
	}
	if !p.Jobs[1].NeedsSet || len(p.Jobs[1].Needs) != 0 {
		t.Fatal("lege needs horen gezet te zijn")
	}
	status := map[string]string{"a": "queued", "b": "queued"}
	if Gate(p.Jobs, status, p.Jobs[1]) != "ready" {
		t.Fatal("lege needs starten meteen")
	}
	if Gate(p.Jobs, status, p.Jobs[0]) != "ready" {
		t.Fatal("eerste stage start meteen")
	}
	// Een job in een latere stage zonder needs wacht.
	p2, 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(p2.Jobs, map[string]string{"a": "running", "b": "queued"}, p2.Jobs[1]) != "wait" {
		t.Fatal("latere stage wacht")
	}
	if Gate(p2.Jobs, map[string]string{"a": "success", "b": "queued"}, p2.Jobs[1]) != "ready" {
		t.Fatal("latere stage na succes")
	}
	if Gate(p2.Jobs, map[string]string{"a": "skipped", "b": "queued"}, p2.Jobs[1]) != "ready" {
		t.Fatal("overgeslagen telt als klaar")
	}
	if Gate(p2.Jobs, map[string]string{"a": "failed", "b": "queued"}, p2.Jobs[1]) != "skip" {
		t.Fatal("mislukte voorganger slaat de rest over")
	}
}

func TestRejects(t *testing.T) {
	cases := []string{
		"jobs: {}\n",
		"jobs:\n  a:\n    image: alpine\n    script: []\n",
		"stages: [test]\njobs:\n  a:\n    stage: nee\n    image: alpine\n    script: ['x']\n",
		"stages: [test]\njobs:\n  a:\n    stage: test\n    image: alpine\n    needs: [b]\n    script: ['x']\n",
		"stages: [test]\njobs:\n  a:\n    stage: test\n    image: alpine\n    needs: [b]\n    script: ['x']\n  b:\n    stage: test\n    image: alpine\n    needs: [a]\n    script: ['y']\n",
		"jobs:\n  a:\n    image: 'alpine image'\n    script: ['x']\n",
		"jobs:\n  a:\n    image: alpine\n    script: ['x']\n    artifacts:\n      paths: ['../etc/passwd']\n",
		"jobs:\n  a:\n    image: alpine\n    script: ['x']\n    rules:\n      - if: 'niet geldig'\n",
	}
	for _, c := range cases {
		if _, err := Parse([]byte(c)); err == nil {
			t.Fatalf("hoorde afgekeurd:\n%s", c)
		}
	}
}

func TestRuleOperators(t *testing.T) {
	ok, err := evalRule(`$CI_COMMIT_BRANCH != "master"`, map[string]string{"CI_COMMIT_BRANCH": "dev"})
	if err != nil || !ok {
		t.Fatalf("!=")
	}
	ok, err = evalRule(`$CI_COMMIT_BRANCH != "master"`, map[string]string{"CI_COMMIT_BRANCH": "master"})
	if err != nil || ok {
		t.Fatal("!= master")
	}
}
