package agenttask

import (
	"context"
	"sync"
	"testing"
)

type fakeWorkflowEvidence struct {
	mu           sync.Mutex
	observeFunc  func(WorkflowEvidenceRequest, int) (ArtifactEvidence, error)
	repairErr    error
	observeCalls []WorkflowEvidenceRequest
	repairCalls  []WorkflowEvidenceRepairRequest
}

func newFakeWorkflowEvidence() *fakeWorkflowEvidence {
	return &fakeWorkflowEvidence{}
}

func (f *fakeWorkflowEvidence) Observe(
	_ context.Context,
	request WorkflowEvidenceRequest,
) (ArtifactEvidence, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	call := len(f.observeCalls)
	f.observeCalls = append(f.observeCalls, request)
	if f.observeFunc != nil {
		return f.observeFunc(request, call)
	}
	return ArtifactEvidence{
		Active: true, Identity: artifactIdentity(request.Project, request.Work, request.Submission),
		Completeness: ArtifactComplete,
	}, nil
}

func (f *fakeWorkflowEvidence) Repair(
	_ context.Context,
	request WorkflowEvidenceRepairRequest,
) error {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.repairCalls = append(f.repairCalls, request)
	return f.repairErr
}

func (f *fakeWorkflowEvidence) counts() (int, int) {
	f.mu.Lock()
	defer f.mu.Unlock()
	return len(f.observeCalls), len(f.repairCalls)
}

func TestMatchWorkflowEvidence(t *testing.T) {
	expected := ArtifactIdentity{
		ProjectID: "project", WorkspaceID: "workspace", WorkUnitID: "work",
		AttemptID: "attempt", ArtifactID: "artifact",
	}
	for _, test := range []struct {
		name     string
		observed ArtifactEvidence
		want     WorkflowEvidenceStatus
	}{
		{
			name:     "complete active pair",
			observed: ArtifactEvidence{Active: true, Identity: expected, Completeness: ArtifactComplete},
			want:     WorkflowEvidenceMatched,
		},
		{
			name:     "placeholder active pair",
			observed: ArtifactEvidence{Active: true, Identity: expected, Completeness: ArtifactPlaceholder},
			want:     WorkflowEvidencePlaceholder,
		},
		{
			name: "wrong attempt identity",
			observed: ArtifactEvidence{Active: true, Identity: ArtifactIdentity{
				ProjectID: "project", WorkspaceID: "workspace", WorkUnitID: "work",
				AttemptID: "other-attempt", ArtifactID: "artifact",
			}, Completeness: ArtifactComplete},
			want: WorkflowEvidenceIdentityMismatch,
		},
		{
			name:     "inactive pair",
			observed: ArtifactEvidence{Active: false, Identity: expected, Completeness: ArtifactComplete},
			want:     WorkflowEvidenceNotActive,
		},
		{
			name:     "unknown completeness is invalid",
			observed: ArtifactEvidence{Active: true, Identity: expected, Completeness: "unknown"},
			want:     WorkflowEvidenceInvalid,
		},
	} {
		t.Run(test.name, func(t *testing.T) {
			if got := MatchWorkflowEvidence(expected, test.observed).Status; got != test.want {
				t.Fatalf("match status = %q, want %q", got, test.want)
			}
		})
	}
}