package orchestrator_test

import (
	"testing"

	"vetting/internal/model"
	"vetting/internal/orchestrator"
)

func TestNextForOverride(t *testing.T) {
	tests := []struct {
		name        string
		from        model.RunState
		failedStage string
		want        model.RunState
		wantErr     bool
	}{
		{"storage override", model.StateFailedHolding, "Storage", model.StateStorage, false},
		{"smart override", model.StateFailedHolding, "SMART", model.StateSMART, false},
		{"inventory override", model.StateFailedHolding, "Inventory", model.StateInventoryCheck, false},
		{"unknown stage", model.StateFailedHolding, "NotAStage", "", true},
		{"not holding", model.StateStorage, "Storage", "", true},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			got, err := orchestrator.NextForOverride(tc.from, tc.failedStage)
			if tc.wantErr {
				if err == nil {
					t.Fatalf("expected error, got %q", got)
				}
				return
			}
			if err != nil {
				t.Fatalf("unexpected error: %v", err)
			}
			if got != tc.want {
				t.Fatalf("got %q, want %q", got, tc.want)
			}
		})
	}
}

func TestNextStageWalk(t *testing.T) {
	// Walking StageCompleted from each stage should land on the next
	// one in the canonical order, and from Reporting onto Completed.
	chain := []model.RunState{
		model.StateInventoryCheck,
		model.StateSpecValidate,
		model.StateSMART,
		model.StateCPUStress,
		model.StateStorage,
		model.StateNetwork,
		model.StateGPU,
		model.StatePSU,
		model.StateReporting,
		model.StateCompleted,
	}
	for i := 0; i < len(chain)-1; i++ {
		got, err := orchestrator.Next(chain[i], orchestrator.TriggerStageCompleted)
		if err != nil {
			t.Fatalf("Next(%q): %v", chain[i], err)
		}
		if got != chain[i+1] {
			t.Fatalf("Next(%q) = %q, want %q", chain[i], got, chain[i+1])
		}
	}
}