//go:build !slurp_full
// +build !slurp_full

package temporal

import (
	"context"
	"fmt"
	"testing"
)

func TestTemporalGraphStubBasicLifecycle(t *testing.T) {
	storage := newMockStorage()
	graph := NewTemporalGraph(storage)
	ctx := context.Background()

	address := createTestAddress("stub/basic")
	contextNode := createTestContext("stub/basic", []string{"go"})

	node, err := graph.CreateInitialContext(ctx, address, contextNode, "tester")
	if err != nil {
		t.Fatalf("expected initial context creation to succeed, got error: %v", err)
	}

	if node == nil {
		t.Fatal("expected non-nil temporal node for initial context")
	}

	decision := createTestDecision("stub-dec-001", "tester", "initial evolution", ImpactLocal)
	evolved, err := graph.EvolveContext(ctx, address, createTestContext("stub/basic", []string{"go", "feature"}), ReasonCodeChange, decision)
	if err != nil {
		t.Fatalf("expected context evolution to succeed, got error: %v", err)
	}

	if evolved.Version != node.Version+1 {
		t.Fatalf("expected version to increment, got %d after %d", evolved.Version, node.Version)
	}

	latest, err := graph.GetLatestVersion(ctx, address)
	if err != nil {
		t.Fatalf("expected latest version retrieval to succeed, got error: %v", err)
	}

	if latest.Version != evolved.Version {
		t.Fatalf("expected latest version %d, got %d", evolved.Version, latest.Version)
	}
}

func TestTemporalInfluenceAnalyzerStub(t *testing.T) {
	storage := newMockStorage()
	graph := NewTemporalGraph(storage).(*temporalGraphImpl)
	analyzer := NewInfluenceAnalyzer(graph)
	ctx := context.Background()

	addrA := createTestAddress("stub/serviceA")
	addrB := createTestAddress("stub/serviceB")

	if _, err := graph.CreateInitialContext(ctx, addrA, createTestContext("stub/serviceA", []string{"go"}), "tester"); err != nil {
		t.Fatalf("failed to create context A: %v", err)
	}
	if _, err := graph.CreateInitialContext(ctx, addrB, createTestContext("stub/serviceB", []string{"go"}), "tester"); err != nil {
		t.Fatalf("failed to create context B: %v", err)
	}

	if err := graph.AddInfluenceRelationship(ctx, addrA, addrB); err != nil {
		t.Fatalf("expected influence relationship to succeed, got error: %v", err)
	}

	analysis, err := analyzer.AnalyzeInfluenceNetwork(ctx)
	if err != nil {
		t.Fatalf("expected influence analysis to succeed, got error: %v", err)
	}

	if analysis.TotalNodes == 0 {
		t.Fatal("expected influence analysis to report at least one node")
	}
}

func TestTemporalDecisionNavigatorStub(t *testing.T) {
	storage := newMockStorage()
	graph := NewTemporalGraph(storage).(*temporalGraphImpl)
	navigator := NewDecisionNavigator(graph)
	ctx := context.Background()

	address := createTestAddress("stub/navigator")
	if _, err := graph.CreateInitialContext(ctx, address, createTestContext("stub/navigator", []string{"go"}), "tester"); err != nil {
		t.Fatalf("failed to create initial context: %v", err)
	}

	for i := 2; i <= 3; i++ {
		id := fmt.Sprintf("stub-hop-%03d", i)
		decision := createTestDecision(id, "tester", "hop", ImpactLocal)
		if _, err := graph.EvolveContext(ctx, address, createTestContext("stub/navigator", []string{"go", "v"}), ReasonCodeChange, decision); err != nil {
			t.Fatalf("failed to evolve context to version %d: %v", i, err)
		}
	}

	timeline, err := navigator.GetDecisionTimeline(ctx, address, false, 0)
	if err != nil {
		t.Fatalf("expected timeline retrieval to succeed, got error: %v", err)
	}

	if timeline == nil || timeline.TotalDecisions == 0 {
		t.Fatal("expected non-empty decision timeline")
	}
}