package store

import (
	"context"
	"testing"
)

func TestPipelineBlocksMerge(t *testing.T) {
	if PipelineBlocksMerge(nil) != "waiting" {
		t.Fatal("leeg")
	}
	if PipelineBlocksMerge([]Job{{Status: "success"}, {Status: "failed", AllowFailure: true}, {Status: "skipped"}}) != "" {
		t.Fatal("allow_failure mag mislukt zijn")
	}
	if PipelineBlocksMerge([]Job{{Status: "success"}, {Status: "queued", AllowFailure: true}}) != "running" {
		t.Fatal("open allow_failure houdt tegen")
	}
	if PipelineBlocksMerge([]Job{{Status: "manual"}}) != "running" {
		t.Fatal("manual is nog niet klaar")
	}
	if PipelineBlocksMerge([]Job{{Status: "failed"}}) != "failed" {
		t.Fatal("harde fout")
	}
	if PipelineBlocksMerge([]Job{{Status: "canceled"}}) != "failed" {
		t.Fatal("geannuleerd houdt de merge tegen")
	}
}

func TestRefreshWaitsForQueuedJobs(t *testing.T) {
	s := openTest(t)
	ctx := context.Background()
	tim, err := s.UpsertUser(ctx, 1, "tim", "", false)
	if err != nil {
		t.Fatal(err)
	}
	repo, err := s.CreateRepo(ctx, "user", tim.ID, "ci", "", "master", "private")
	if err != nil {
		t.Fatal(err)
	}
	id, err := s.CreatePipeline(ctx, repo.ID, "abc", "refs/heads/master", "push", "tim", "fail", []NewJob{
		{Name: "hard", Stage: "test", Script: "exit 1"},
		{Name: "later", Stage: "deploy", Script: "exit 0"},
	})
	if err != nil {
		t.Fatal(err)
	}
	jobs, err := s.JobsByPipeline(ctx, id)
	if err != nil {
		t.Fatal(err)
	}
	for _, j := range jobs {
		if j.Name == "hard" {
			if err := s.FinishJob(ctx, j.ID, "failed", ""); err != nil {
				t.Fatal(err)
			}
		}
	}
	status, err := s.RefreshPipelineStatus(ctx, id)
	if err != nil || status != "running" {
		t.Fatalf("wachtrij hoort de pipeline open te houden: %s %v", status, err)
	}
	for _, j := range jobs {
		if j.Name == "later" {
			if err := s.SkipJob(ctx, j.ID, "skipped"); err != nil {
				t.Fatal(err)
			}
		}
	}
	status, err = s.RefreshPipelineStatus(ctx, id)
	if err != nil || status != "failed" {
		t.Fatalf("na het overslaan: %s %v", status, err)
	}
}

func TestCancelInterruptibleAndRequeue(t *testing.T) {
	s := openTest(t)
	ctx := context.Background()
	tim, err := s.UpsertUser(ctx, 1, "tim", "", false)
	if err != nil {
		t.Fatal(err)
	}
	repo, err := s.CreateRepo(ctx, "user", tim.ID, "ci", "", "master", "private")
	if err != nil {
		t.Fatal(err)
	}
	first, err := s.CreatePipeline(ctx, repo.ID, "abc", "refs/heads/master", "push", "tim", "eerste", []NewJob{
		{Name: "stop", Stage: "test", Script: "echo", Interruptible: true},
		{Name: "keep", Stage: "test", Script: "echo"},
	})
	if err != nil {
		t.Fatal(err)
	}
	second, err := s.CreatePipeline(ctx, repo.ID, "def", "refs/heads/master", "push", "tim", "tweede", []NewJob{
		{Name: "next", Stage: "test", Script: "echo", Interruptible: true},
	})
	if err != nil {
		t.Fatal(err)
	}
	running, pipes, err := s.CancelInterruptible(ctx, repo.ID, "refs/heads/master", second)
	if err != nil {
		t.Fatal(err)
	}
	if len(running) != 0 || len(pipes) != 1 || pipes[0] != first {
		t.Fatalf("running %v pipes %v", running, pipes)
	}
	jobs, err := s.JobsByPipeline(ctx, first)
	if err != nil {
		t.Fatal(err)
	}
	for _, j := range jobs {
		if j.Name == "stop" && j.Status != "canceled" {
			t.Fatalf("stop: %s", j.Status)
		}
		if j.Name == "keep" && j.Status != "queued" {
			t.Fatalf("keep: %s", j.Status)
		}
	}
	if err := s.FinishJob(ctx, jobs[0].ID, "failed", "nope\n"); err != nil {
		t.Fatal(err)
	}
	if err := s.RequeueJob(ctx, jobs[0].ID, 1, "retry\n"); err != nil {
		t.Fatal(err)
	}
	again, err := s.JobsByPipeline(ctx, first)
	if err != nil {
		t.Fatal(err)
	}
	if again[0].Status != "queued" || again[0].Attempt != 1 {
		t.Fatalf("%s attempt %d", again[0].Status, again[0].Attempt)
	}
	status, err := s.RefreshPipelineStatus(ctx, first)
	if err != nil || status != "running" {
		t.Fatalf("na retry: %s %v", status, err)
	}
	for _, j := range again {
		if j.Name == "keep" {
			if err := s.SkipJob(ctx, j.ID, "skip"); err != nil {
				t.Fatal(err)
			}
		}
		if j.Name == "stop" {
			if err := s.FinishJob(ctx, j.ID, "canceled", ""); err != nil {
				t.Fatal(err)
			}
		}
	}
	status, err = s.RefreshPipelineStatus(ctx, first)
	if err != nil || status != "canceled" {
		t.Fatalf("pipeline: %s %v", status, err)
	}
}
