package ci

import "testing"

func TestRuleExpr(t *testing.T) {
	env := map[string]string{
		"CI_COMMIT_BRANCH":   "master",
		"CI_DEFAULT_BRANCH":  "master",
		"CI_COMMIT_TAG":      "",
		"CI_PIPELINE_SOURCE": "push",
		"PATTERN":            `^release/.*`,
		"MSG":                "Hello.World",
	}
	cases := []struct {
		expr string
		ok   bool
	}{
		{`$CI_COMMIT_BRANCH == "master"`, true},
		{`$CI_COMMIT_BRANCH == "feature"`, false},
		{`$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH && $CI_PIPELINE_SOURCE == "push"`, true},
		{`$CI_COMMIT_BRANCH == "nope" || $CI_PIPELINE_SOURCE == "push"`, true},
		{`($CI_COMMIT_BRANCH == "nope" || $CI_COMMIT_BRANCH == "master") && $CI_COMMIT_TAG == null`, true},
		{`$CI_COMMIT_TAG == null`, true},
		{`$CI_COMMIT_BRANCH != null`, true},
		{`$CI_COMMIT_BRANCH =~ /^master$/`, true},
		{`$CI_COMMIT_BRANCH =~ /feature/`, false},
		{`$CI_COMMIT_BRANCH !~ /feature/`, true},
		{`$CI_COMMIT_BRANCH =~ /^MASTER$/i`, true},
		{`$MSG =~ /Hello\.World/`, true},
		{`$MSG =~ /Hello.World/`, true},
		{`$CI_COMMIT_BRANCH =~ $PATTERN`, false},
		{`$CI_COMMIT_BRANCH =~ /^release\/.*/ || $CI_COMMIT_BRANCH == "master"`, true},
		{`"$CI_COMMIT_BRANCH" == "master"`, true},
		{`${CI_COMMIT_BRANCH} == 'master'`, true},
	}
	for _, tc := range cases {
		ok, err := evalRule(tc.expr, env)
		if err != nil {
			t.Fatalf("%s: %v", tc.expr, err)
		}
		if ok != tc.ok {
			t.Fatalf("%s: got %v", tc.expr, ok)
		}
	}
	if err := checkRule(`$FOO =~ $PATTERN`); err != nil {
		t.Fatal(err)
	}
	if _, err := evalRule(`$CI_COMMIT_BRANCH ==`, env); err == nil {
		t.Fatal("kapotte expressie")
	}
	if _, err := evalRule(`$MSG =~ /(/`, env); err == nil {
		t.Fatal("kapotte regex")
	}
	if _, err := evalRule(`($CI_COMMIT_BRANCH == "master"`, env); err == nil {
		t.Fatal("haakje")
	}
}

func TestWorkflowParallelServices(t *testing.T) {
	raw := []byte(`
workflow:
  rules:
    - if: $CI_COMMIT_BRANCH == "master" && $CI_PIPELINE_SOURCE == "push"
    - when: never
default:
  interruptible: true
  retry: 2
build:
  image: alpine:3.20
  script: ["echo $CI_NODE_INDEX"]
  parallel: 2
  environment:
    name: review
    url: https://example.test/$CI_COMMIT_REF_SLUG
pack:
  image: alpine:3.20
  script: ["echo pack"]
  needs: [build]
  retry:
    max: 5
    when: [runner_system_failure, stuck_or_timeout_failure]
  services:
    - name: postgres:16
      alias: db
      variables:
        POSTGRES_PASSWORD: secret
    - redis:7
  interruptible: false
matrix:
  image: alpine:3.20
  script: ["echo matrix"]
  parallel:
    matrix:
      - PROVIDER: [aws, gcp]
        STACK: app
      - PROVIDER: aws
        STACK: [backup]
`)
	p, err := Parse(raw)
	if err != nil {
		t.Fatal(err)
	}
	if len(p.Workflow) != 2 {
		t.Fatalf("workflow %d", len(p.Workflow))
	}
	ok, err := p.Allow(Eval{Env: map[string]string{"CI_COMMIT_BRANCH": "feature", "CI_PIPELINE_SOURCE": "push"}})
	if err != nil || ok {
		t.Fatalf("feature hoort geen pipeline: %v %v", ok, err)
	}
	ok, err = p.Allow(Eval{Env: map[string]string{"CI_COMMIT_BRANCH": "master", "CI_PIPELINE_SOURCE": "push"}})
	if err != nil || !ok {
		t.Fatalf("master hoort wel: %v %v", ok, err)
	}
	jobs, err := p.Select(Eval{Env: map[string]string{"CI_COMMIT_BRANCH": "master", "CI_PIPELINE_SOURCE": "push"}})
	if err != nil {
		t.Fatal(err)
	}
	byName := map[string]Job{}
	for _, j := range jobs {
		byName[j.Name] = j
	}
	if _, ok := byName["build 1/2"]; !ok || byName["build 1/2"].Variables["CI_NODE_TOTAL"] != "2" {
		t.Fatalf("parallel: %v", namesOf(jobs))
	}
	if !byName["build 1/2"].Interruptible || byName["build 1/2"].Retry.Max != 2 {
		t.Fatalf("default: %+v", byName["build 1/2"])
	}
	if byName["build 1/2"].Environment.Name != "review" || byName["build 1/2"].Environment.URL == "" {
		t.Fatalf("environment: %+v", byName["build 1/2"].Environment)
	}
	pack := byName["pack"]
	if pack.Interruptible || pack.Retry.Max != 2 || len(pack.Retry.When) != 2 {
		t.Fatalf("retry geklemd: %+v", pack.Retry)
	}
	if len(pack.Needs) != 2 || pack.Needs[0] != "build 1/2" || pack.Needs[1] != "build 2/2" {
		t.Fatalf("needs: %v", pack.Needs)
	}
	if len(pack.Services) != 2 || pack.Services[0].Alias != "db" || pack.Services[1].Alias != "redis" {
		t.Fatalf("services: %+v", pack.Services)
	}
	if _, ok := byName["matrix: [aws, app]"]; !ok {
		t.Fatalf("matrix: %v", namesOf(jobs))
	}
	if byName["matrix: [gcp, app]"].Variables["PROVIDER"] != "gcp" || byName["matrix: [aws, backup]"].Variables["STACK"] != "backup" {
		t.Fatalf("matrix vars")
	}
	if got := Expand("https://example.test/$CI_COMMIT_REF_SLUG", map[string]string{"CI_COMMIT_REF_SLUG": "master"}); got != "https://example.test/master" {
		t.Fatal(got)
	}
}

func TestGateCanceled(t *testing.T) {
	jobs := []Job{{Name: "a", Stage: "test"}, {Name: "b", Stage: "deploy"}}
	status := map[string]string{"a": "canceled", "b": "queued"}
	if got := Gate(jobs, status, jobs[1]); got != "skip" {
		t.Fatalf("canceled houdt de volgende tegen: %s", got)
	}
	jobs[0].AllowFailure = true
	if got := Gate(jobs, status, jobs[1]); got != "ready" {
		t.Fatalf("allow_failure canceled: %s", got)
	}
}
