package runner

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

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

// Een aparte runner zonder hartslag: een gewone job wordt afgerond, een
// lopende doNotInterrupt-job blijft staan tot timeout + grace.
func TestReapRemoteRespectsDoNotInterrupt(t *testing.T) {
	s, err := store.Open(filepath.Join(t.TempDir(), "b.db"), make([]byte, 32))
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = s.Close() })
	ctx := context.Background()
	tim, _ := s.UpsertUser(ctx, 1, "tim", "", false)
	repo, _ := s.CreateRepo(ctx, "user", tim.ID, "ci", "", "master", "private")
	tok, _ := s.CreateRunnerRegToken(ctx, "user", tim.ID, tim.ID)
	rn, _, err := s.RegisterRunner(ctx, tok, "remote", "test")
	if err != nil {
		t.Fatal(err)
	}
	pid, _ := s.CreatePipeline(ctx, repo.ID, "a", "refs/heads/master", "push", "tim", "a", []store.NewJob{
		{Name: "safe", Stage: "d", Script: "true", DoNotInterrupt: true},
		{Name: "plain", Stage: "d", Script: "true"},
	})
	jobs, _ := s.JobsByPipeline(ctx, pid)
	for _, j := range jobs {
		_, _ = s.MarkJobRunning(ctx, j.ID)
		_ = s.SetJobRunner(ctx, j.ID, rn.ID, rn.Name)
	}
	old := RemoteOnlineGrace
	RemoteOnlineGrace = -time.Second // runner geldt meteen als stil
	t.Cleanup(func() { RemoteOnlineGrace = old })
	r := &Runner{Store: s, Timeout: time.Hour}
	r.reapRemote(ctx)
	jobs, _ = s.JobsByPipeline(ctx, pid)
	for _, j := range jobs {
		if j.Name == "safe" && j.Status != "running" {
			t.Fatalf("dni-job afgerond: %s", j.Status)
		}
		if j.Name == "plain" && j.Status != "failed" {
			t.Fatalf("gewone job: %s", j.Status)
		}
	}
}

func TestWaitProtected(t *testing.T) {
	r := &Runner{}
	r.protected.Add(1)
	done := make(chan struct{})
	go func() { r.WaitProtected(nil); close(done) }()
	select {
	case <-done:
		t.Fatal("wacht niet")
	case <-time.After(50 * time.Millisecond):
	}
	r.protected.Add(-1)
	select {
	case <-done:
	case <-time.After(3 * time.Second):
		t.Fatal("blijft hangen")
	}
}
