package taskassignment

import (
	"bytes"
	"testing"

	runnerv1 "gitea.dev/actionslib/runner/v1"
	"google.golang.org/protobuf/types/known/structpb"
)

func task(t *testing.T, labels string) *runnerv1.Task {
	t.Helper()
	context, err := structpb.NewStruct(map[string]any{"repository": "owner/repo"})
	if err != nil {
		t.Fatal(err)
	}
	return &runnerv1.Task{
		Id:              42,
		Context:         context,
		WorkflowPayload: []byte("jobs:\n  publish:\n    runs-on: " + labels + "\n    steps: []\n"),
	}
}

func TestNewSelectsPlacementFromRunsOn(t *testing.T) {
	for _, test := range []struct {
		labels    string
		placement Placement
	}{
		{"[self-hosted, pod]", KubernetesContainer},
		{"[self-hosted, container]", KubernetesContainer},
		{"[self-hosted, container, kubernetes]", KubernetesContainer},
		{"[self-hosted, vm]", OpenSandboxVM},
		{"[self-hosted, vm-dev]", OpenSandboxVM},
		{"[self-hosted, vm, opensandbox]", OpenSandboxVM},
	} {
		assignment, err := New(task(t, test.labels), "ddupan.top")
		if err != nil {
			t.Fatal(err)
		}
		if assignment.Placement != test.placement || assignment.ID != "gitea-task-42" {
			t.Fatalf("assignment = %#v", assignment)
		}
	}
}

func TestNewRejectsInvalidPlacement(t *testing.T) {
	for _, labels := range []string{
		"[self-hosted]",
		"[self-hosted, pod, vm]",
		"[self-hosted, pod, container]",
		"[self-hosted, pod, kubernetes]",
		"[self-hosted, container, opensandbox]",
		"[self-hosted, vm, kubernetes]",
		"[self-hosted, container, kubernetes, opensandbox]",
		"[pod]",
	} {
		if _, err := New(task(t, labels), "ddupan.top"); err == nil {
			t.Fatalf("expected labels %s to fail", labels)
		}
	}
}

func TestAssignmentWireRoundTripAndValidation(t *testing.T) {
	want, err := New(task(t, "[self-hosted, pod]"), "ddupan.top")
	if err != nil {
		t.Fatal(err)
	}
	data, err := Marshal(want)
	if err != nil {
		t.Fatal(err)
	}
	got, err := Unmarshal(data, "ddupan.top")
	if err != nil {
		t.Fatal(err)
	}
	if got.ID != want.ID || got.Placement != want.Placement || got.Identity != want.Identity || !bytes.Equal(got.Task.WorkflowPayload, want.Task.WorkflowPayload) {
		t.Fatalf("round trip = %#v, want %#v", got, want)
	}

	tampered := bytes.Replace(data, []byte(`"driver":"kubernetes"`), []byte(`"driver":"opensandbox"`), 1)
	if _, err := Unmarshal(tampered, "ddupan.top"); err == nil {
		t.Fatal("expected tampered placement to fail")
	}
}

func TestFromMetadataRecoversMinimalAssignment(t *testing.T) {
	assignment, err := FromMetadata(map[string]string{
		"ci.ddupan.top/assignment-id":  "gitea-task-42",
		"ci.ddupan.top/task-id":        "42",
		"ci.ddupan.top/workload-class": "vm",
		"ci.ddupan.top/driver":         "opensandbox",
	}, map[string]string{
		"ci.ddupan.top/repository": "owner/repo",
		"ci.ddupan.top/job-key":    "publish",
		"ci.ddupan.top/spiffe-id":  "spiffe://ddupan.top/ci/owner/repo/publish",
	}, "ddupan.top")
	if err != nil || assignment.Task.GetId() != 42 || assignment.Placement != OpenSandboxVM {
		t.Fatalf("assignment=%#v err=%v", assignment, err)
	}
}