package agenttask

import (
	"context"
	"testing"
)

func TestExplicitDependencyCompleteAdvancesOnlyConsumer(t *testing.T) {
	first := testUnit("first", WriteSetOverlap)
	second := testUnit("second", WriteSetOverlap)
	second.ExplicitPredecessors = []DependencyRef{{Ref: "first"}}
	snapshot := testSnapshot("project", "workspace", first, second)
	harness := newHarness(t, map[ProjectID]ProjectWorkflowSnapshot{"project": snapshot}, 2)
	harness.start("project", "workspace", nil)
	if err := harness.manager.Reconcile(context.Background()); err != nil {
		t.Fatalf("Reconcile: %v", err)
	}
	state := harness.store.snapshot()
	if state.Projects["project"].Works["first"].State != WorkStateCompleted ||
		state.Projects["project"].Works["second"].State != WorkStateCompleted {
		t.Fatalf("explicit dependency chain did not complete")
	}
	ordinals := harness.integrator.ordinals()
	if len(ordinals) != 2 || ordinals[0] >= ordinals[1] {
		t.Fatalf("integration ordinals = %v, want predecessor then consumer", ordinals)
	}
}

func TestExplicitDependencyMissingBlocksWithoutInvocation(t *testing.T) {
	work := testUnit("consumer", WriteSetDisjoint)
	work.ExplicitPredecessors = []DependencyRef{{Ref: "not-present"}}
	snapshot := testSnapshot("project", "workspace", work)
	harness := newHarness(t, map[ProjectID]ProjectWorkflowSnapshot{"project": snapshot}, 1)
	harness.start("project", "workspace", nil)
	if err := harness.manager.Reconcile(context.Background()); err != nil {
		t.Fatalf("Reconcile: %v", err)
	}
	record := harness.store.snapshot().Projects["project"].Works["consumer"]
	if record.State != WorkStateBlocked || record.Blocker == nil ||
		record.Blocker.Code != BlockerDependencyMissing {
		t.Fatalf("consumer = %#v", record)
	}
	if harness.invoker.callCount() != 0 {
		t.Fatalf("missing dependency invoked provider")
	}
}

func TestExplicitDependencyAmbiguousAliasBlocks(t *testing.T) {
	left := testUnit("left", WriteSetUnknown)
	left.Aliases = []string{"shared"}
	left.Completed = true
	right := testUnit("right", WriteSetUnknown)
	right.Aliases = []string{"shared"}
	right.Completed = true
	consumer := testUnit("consumer", WriteSetUnknown)
	consumer.ExplicitPredecessors = []DependencyRef{{Ref: "shared"}}
	snapshot := testSnapshot("project", "workspace", left, right, consumer)
	harness := newHarness(t, map[ProjectID]ProjectWorkflowSnapshot{"project": snapshot}, 1)
	harness.start("project", "workspace", nil)
	if err := harness.manager.Reconcile(context.Background()); err != nil {
		t.Fatalf("Reconcile: %v", err)
	}
	record := harness.store.snapshot().Projects["project"].Works["consumer"]
	if record.Blocker == nil || record.Blocker.Code != BlockerDependencyAmbiguous {
		t.Fatalf("consumer blocker = %#v", record.Blocker)
	}
	if harness.invoker.callCount() != 0 {
		t.Fatalf("ambiguous dependency invoked provider")
	}
}