package runner

import (
	"context"
	"path/filepath"
	"testing"

	"gitlab.com/Timfa/bluegit/internal/store"
)

func TestSettleSkipsLaterStageButNotAllowFailure(t *testing.T) {
	key := make([]byte, 32)
	st, err := store.Open(filepath.Join(t.TempDir(), "bluegit.db"), key)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	ctx := context.Background()
	tim, err := st.UpsertUser(ctx, 1, "tim", "", false)
	if err != nil {
		t.Fatal(err)
	}
	repo, err := st.CreateRepo(ctx, "user", tim.ID, "ci", "", "master", "private")
	if err != nil {
		t.Fatal(err)
	}
	id, err := st.CreatePipeline(ctx, repo.ID, "abc", "refs/heads/master", "push", "tim", "fail", []store.NewJob{
		{Name: "hard", Stage: "test", Script: "exit 1"},
		{Name: "soft", Stage: "test", Script: "exit 1", AllowFailure: true},
		{Name: "later", Stage: "deploy", Script: "exit 0"},
		{Name: "anyway", Stage: "deploy", Script: "exit 0", When: "always"},
	})
	if err != nil {
		t.Fatal(err)
	}
	jobs, _ := st.JobsByPipeline(ctx, id)
	for _, j := range jobs {
		if j.Name == "hard" || j.Name == "soft" {
			if err := st.FinishJob(ctx, j.ID, "failed", ""); err != nil {
				t.Fatal(err)
			}
		}
	}
	rn := &Runner{Store: st, Storage: t.TempDir()}
	rn.settle(ctx, id)
	got := map[string]string{}
	jobs, _ = st.JobsByPipeline(ctx, id)
	for _, j := range jobs {
		got[j.Name] = j.Status
	}
	if got["later"] != "skipped" || got["anyway"] != "queued" || got["soft"] != "failed" {
		t.Fatalf("status: %v", got)
	}
	status, err := st.RefreshPipelineStatus(ctx, id)
	if err != nil || status != "running" {
		t.Fatalf("always-job houdt de pipeline open: %s %v", status, err)
	}
}

// Zoals pipeline #26: test faalt, build wordt overgeslagen, en release
// met needs: [build] moet meekomen. publish_aur met needs: [] blijft staan.
func TestSettleSkipsNeedsChainButNotEmptyNeeds(t *testing.T) {
	key := make([]byte, 32)
	st, err := store.Open(filepath.Join(t.TempDir(), "bluegit.db"), key)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	ctx := context.Background()
	tim, err := st.UpsertUser(ctx, 1, "tim", "", false)
	if err != nil {
		t.Fatal(err)
	}
	repo, err := st.CreateRepo(ctx, "user", tim.ID, "ci", "", "master", "private")
	if err != nil {
		t.Fatal(err)
	}
	id, err := st.CreatePipeline(ctx, repo.ID, "725e6947", "refs/heads/master", "push", "tim", "fail", []store.NewJob{
		{Name: "test", Stage: "test", Script: "exit 1"},
		{Name: "build", Stage: "build", Script: "go build", Needs: []string{"test"}, NeedsSet: true},
		{Name: "release", Stage: "release", Script: "curl", Needs: []string{"build"}, NeedsSet: true},
		{Name: "deploy", Stage: "deploy", Script: "scp", Needs: []string{"build", "release"}, NeedsSet: true},
		{Name: "publish_aur", Stage: "deploy", Script: "aur", Needs: []string{}, NeedsSet: true, AllowFailure: true},
		{Name: "anyway", Stage: "deploy", Script: "echo", Needs: []string{"build"}, NeedsSet: true, When: "always"},
	})
	if err != nil {
		t.Fatal(err)
	}
	jobs, _ := st.JobsByPipeline(ctx, id)
	for _, j := range jobs {
		if j.Name == "test" {
			if err := st.FinishJob(ctx, j.ID, "failed", ""); err != nil {
				t.Fatal(err)
			}
		}
	}
	rn := &Runner{Store: st, Storage: t.TempDir()}
	rn.settle(ctx, id)
	got := map[string]string{}
	jobs, _ = st.JobsByPipeline(ctx, id)
	for _, j := range jobs {
		got[j.Name] = j.Status
	}
	want := map[string]string{
		"test": "failed", "build": "skipped", "release": "skipped", "deploy": "skipped",
		"publish_aur": "queued", "anyway": "queued",
	}
	for name, status := range want {
		if got[name] != status {
			t.Errorf("%s: got %s, want %s (alles: %v)", name, got[name], status, got)
		}
	}
}

func TestSettleSkippedStageDoesNotBlockWithoutNeeds(t *testing.T) {
	key := make([]byte, 32)
	st, err := store.Open(filepath.Join(t.TempDir(), "bluegit.db"), key)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	ctx := context.Background()
	tim, err := st.UpsertUser(ctx, 1, "tim", "", false)
	if err != nil {
		t.Fatal(err)
	}
	repo, err := st.CreateRepo(ctx, "user", tim.ID, "ci", "", "master", "private")
	if err != nil {
		t.Fatal(err)
	}
	id, err := st.CreatePipeline(ctx, repo.ID, "abc", "refs/heads/master", "push", "tim", "skip", []store.NewJob{
		{Name: "a", Stage: "een", Script: "echo a"},
		{Name: "b", Stage: "twee", Script: "echo b"},
		{Name: "c", Stage: "twee", Script: "echo c", Needs: []string{"a"}, NeedsSet: true},
	})
	if err != nil {
		t.Fatal(err)
	}
	jobs, _ := st.JobsByPipeline(ctx, id)
	for _, j := range jobs {
		if j.Name == "a" {
			if err := st.SkipJob(ctx, j.ID, "skipped"); err != nil {
				t.Fatal(err)
			}
		}
	}
	rn := &Runner{Store: st, Storage: t.TempDir()}
	rn.settle(ctx, id)
	got := map[string]string{}
	jobs, _ = st.JobsByPipeline(ctx, id)
	for _, j := range jobs {
		got[j.Name] = j.Status
	}
	if got["a"] != "skipped" || got["b"] != "queued" || got["c"] != "skipped" {
		t.Fatalf("status: %v", got)
	}
}
