package sdlc

import "testing"

func makeTestFeature(phase FeaturePhase) *Feature {
	f := &Feature{
		Slug:  "auth",
		Title: "Auth",
		Phase: phase,
		Artifacts: map[ArtifactType]*Artifact{
			ArtifactSpec:      NewArtifact(ArtifactSpec),
			ArtifactDesign:    NewArtifact(ArtifactDesign),
			ArtifactTasks:     NewArtifact(ArtifactTasks),
			ArtifactQAPlan:    NewArtifact(ArtifactQAPlan),
			ArtifactReview:    NewArtifact(ArtifactReview),
			ArtifactAudit:     NewArtifact(ArtifactAudit),
			ArtifactQAResults: NewArtifact(ArtifactQAResults),
		},
	}
	return f
}

func TestClassifyDraftNeedsSpec(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseDraft)

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionCreateSpec {
		t.Errorf("Action = %q, want CREATE_SPEC", cl.Action)
	}
	if cl.RuleMatched != "needs-spec" {
		t.Errorf("RuleMatched = %q, want needs-spec", cl.RuleMatched)
	}
}

func TestClassifyDraftSpecDraftNeedsApproval(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseDraft)
	f.GetArtifact(ArtifactSpec).MarkDraft()

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionAwaitApproval {
		t.Errorf("Action = %q, want AWAIT_APPROVAL", cl.Action)
	}
	if cl.RuleMatched != "spec-needs-approval" {
		t.Errorf("RuleMatched = %q, want spec-needs-approval", cl.RuleMatched)
	}
}

func TestClassifyDraftSpecApprovedTransition(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseDraft)
	f.GetArtifact(ArtifactSpec).Approve("user")

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionTransition {
		t.Errorf("Action = %q, want TRANSITION", cl.Action)
	}
	if cl.TransitionTo != PhaseSpecified {
		t.Errorf("TransitionTo = %q, want specified", cl.TransitionTo)
	}
}

func TestClassifySpecifiedNeedsDesign(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseSpecified)

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionCreateDesign {
		t.Errorf("Action = %q, want CREATE_DESIGN", cl.Action)
	}
}

func TestClassifySpecifiedNeedsTasks(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseSpecified)
	f.GetArtifact(ArtifactDesign).Approve("user")

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionCreateTasks {
		t.Errorf("Action = %q, want CREATE_TASKS", cl.Action)
	}
}

func TestClassifySpecifiedNeedsQAPlan(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseSpecified)
	f.GetArtifact(ArtifactDesign).Approve("user")
	f.GetArtifact(ArtifactTasks).Approve("user")

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionCreateQAPlan {
		t.Errorf("Action = %q, want CREATE_QA_PLAN", cl.Action)
	}
}

func TestClassifySpecifiedPlanningComplete(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseSpecified)
	f.GetArtifact(ArtifactDesign).Approve("user")
	f.GetArtifact(ArtifactTasks).Approve("user")
	f.GetArtifact(ArtifactQAPlan).Approve("user")

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionTransition {
		t.Errorf("Action = %q, want TRANSITION", cl.Action)
	}
	if cl.TransitionTo != PhasePlanned {
		t.Errorf("TransitionTo = %q, want planned", cl.TransitionTo)
	}
}

func TestClassifyPlannedTransitionsToReady(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhasePlanned)

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionTransition {
		t.Errorf("Action = %q, want TRANSITION", cl.Action)
	}
	if cl.TransitionTo != PhaseReady {
		t.Errorf("TransitionTo = %q, want ready", cl.TransitionTo)
	}
}

func TestClassifyImplementationNextTask(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseImplementation)
	f.Tasks = AddTask(nil, "Task 1")
	f.Tasks = AddTask(f.Tasks, "Task 2")

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionImplementTask {
		t.Errorf("Action = %q, want IMPLEMENT_TASK", cl.Action)
	}
	if cl.TaskID != "task-001" {
		t.Errorf("TaskID = %q, want task-001", cl.TaskID)
	}
}

func TestClassifyImplementationComplete(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseImplementation)
	f.Tasks = AddTask(nil, "Task 1")
	f.Tasks, _ = StartTask(f.Tasks, "task-001")
	f.Tasks, _ = CompleteTask(f.Tasks, "task-001")

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionTransition {
		t.Errorf("Action = %q, want TRANSITION", cl.Action)
	}
	if cl.TransitionTo != PhaseReview {
		t.Errorf("TransitionTo = %q, want review", cl.TransitionTo)
	}
}

func TestClassifyReviewNeeded(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseReview)

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionReviewCode {
		t.Errorf("Action = %q, want REVIEW_CODE", cl.Action)
	}
}

func TestClassifyReviewNeedsFix(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseReview)
	f.GetArtifact(ArtifactReview).MarkNeedsFix()

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionFixReviewIssues {
		t.Errorf("Action = %q, want FIX_REVIEW_ISSUES", cl.Action)
	}
}

func TestClassifyReviewPassed(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseReview)
	f.GetArtifact(ArtifactReview).MarkPassed()

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionTransition {
		t.Errorf("Action = %q, want TRANSITION", cl.Action)
	}
	if cl.TransitionTo != PhaseAudit {
		t.Errorf("TransitionTo = %q, want audit", cl.TransitionTo)
	}
}

func TestClassifyAuditNeeded(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseAudit)

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionAuditCode {
		t.Errorf("Action = %q, want AUDIT_CODE", cl.Action)
	}
}

func TestClassifyAuditPassed(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseAudit)
	f.GetArtifact(ArtifactAudit).MarkPassed()

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionTransition {
		t.Errorf("Action = %q, want TRANSITION", cl.Action)
	}
	if cl.TransitionTo != PhaseQA {
		t.Errorf("TransitionTo = %q, want qa", cl.TransitionTo)
	}
}

func TestClassifyQANeeded(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseQA)

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionRunQA {
		t.Errorf("Action = %q, want RUN_QA", cl.Action)
	}
}

func TestClassifyQAPassed(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseQA)
	f.GetArtifact(ArtifactQAResults).MarkPassed()

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionTransition {
		t.Errorf("Action = %q, want TRANSITION", cl.Action)
	}
	if cl.TransitionTo != PhaseMerge {
		t.Errorf("TransitionTo = %q, want merge", cl.TransitionTo)
	}
}

func TestClassifyMerge(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseMerge)

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionMergeFeature {
		t.Errorf("Action = %q, want MERGE_FEATURE", cl.Action)
	}
}

func TestClassifyArchive(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseReleased)

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionArchive {
		t.Errorf("Action = %q, want ARCHIVE", cl.Action)
	}
}

func TestClassifyBlocked(t *testing.T) {
	c := NewClassifier()
	f := makeTestFeature(PhaseDraft)
	f.AddBlocker("depends on payments")

	cl := c.Classify(&EvalContext{
		State:   DefaultState("test"),
		Feature: f,
		Config:  DefaultConfig("test"),
	})

	if cl.Action != ActionBlocked {
		t.Errorf("Action = %q, want BLOCKED", cl.Action)
	}
}

// TestFullLifecycleClassification walks through the entire feature lifecycle.
func TestFullLifecycleClassification(t *testing.T) {
	c := NewClassifier()
	cfg := DefaultConfig("test")
	state := DefaultState("test")
	f := makeTestFeature(PhaseDraft)

	// Phase: Draft
	// Step 1: needs spec
	cl := c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.Action != ActionCreateSpec {
		t.Fatalf("step1: Action = %q, want CREATE_SPEC", cl.Action)
	}

	// Step 2: spec created -> needs approval
	f.GetArtifact(ArtifactSpec).MarkDraft()
	cl = c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.Action != ActionAwaitApproval {
		t.Fatalf("step2: Action = %q, want AWAIT_APPROVAL", cl.Action)
	}

	// Step 3: spec approved -> transition to specified
	f.GetArtifact(ArtifactSpec).Approve("user")
	cl = c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.Action != ActionTransition || cl.TransitionTo != PhaseSpecified {
		t.Fatalf("step3: Action = %q/%q", cl.Action, cl.TransitionTo)
	}

	// Phase: Specified
	f.Transition(PhaseSpecified)

	// Step 4: needs design
	cl = c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.Action != ActionCreateDesign {
		t.Fatalf("step4: Action = %q, want CREATE_DESIGN", cl.Action)
	}

	// Step 5: design approved -> needs tasks
	f.GetArtifact(ArtifactDesign).Approve("user")
	cl = c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.Action != ActionCreateTasks {
		t.Fatalf("step5: Action = %q, want CREATE_TASKS", cl.Action)
	}

	// Step 6: tasks approved -> needs qa plan
	f.GetArtifact(ArtifactTasks).Approve("user")
	cl = c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.Action != ActionCreateQAPlan {
		t.Fatalf("step6: Action = %q, want CREATE_QA_PLAN", cl.Action)
	}

	// Step 7: qa plan approved -> transition to planned
	f.GetArtifact(ArtifactQAPlan).Approve("user")
	cl = c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.Action != ActionTransition || cl.TransitionTo != PhasePlanned {
		t.Fatalf("step7: Action = %q/%q", cl.Action, cl.TransitionTo)
	}

	// Phase: Planned -> Ready -> Implementation
	f.Transition(PhasePlanned)
	f.Transition(PhaseReady)
	f.Transition(PhaseImplementation)

	// Add tasks
	f.Tasks = AddTask(nil, "Create user model")
	f.Tasks = AddTask(f.Tasks, "Add validation")

	// Step 8: implement next task
	cl = c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.Action != ActionImplementTask {
		t.Fatalf("step8: Action = %q, want IMPLEMENT_TASK", cl.Action)
	}

	// Complete all tasks
	f.Tasks, _ = StartTask(f.Tasks, "task-001")
	f.Tasks, _ = CompleteTask(f.Tasks, "task-001")
	f.Tasks, _ = StartTask(f.Tasks, "task-002")
	f.Tasks, _ = CompleteTask(f.Tasks, "task-002")

	// Step 9: implementation complete -> transition to review
	cl = c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.Action != ActionTransition || cl.TransitionTo != PhaseReview {
		t.Fatalf("step9: Action = %q/%q", cl.Action, cl.TransitionTo)
	}

	// Phase: Review
	f.Transition(PhaseReview)
	f.GetArtifact(ArtifactReview).MarkPassed()
	cl = c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.TransitionTo != PhaseAudit {
		t.Fatalf("review->audit: TransitionTo = %q", cl.TransitionTo)
	}

	// Phase: Audit
	f.Transition(PhaseAudit)
	f.GetArtifact(ArtifactAudit).MarkPassed()
	cl = c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.TransitionTo != PhaseQA {
		t.Fatalf("audit->qa: TransitionTo = %q", cl.TransitionTo)
	}

	// Phase: QA
	f.Transition(PhaseQA)
	f.GetArtifact(ArtifactQAResults).MarkPassed()
	cl = c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.TransitionTo != PhaseMerge {
		t.Fatalf("qa->merge: TransitionTo = %q", cl.TransitionTo)
	}

	// Phase: Merge
	f.Transition(PhaseMerge)
	cl = c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.Action != ActionMergeFeature {
		t.Fatalf("merge: Action = %q, want MERGE_FEATURE", cl.Action)
	}

	// Phase: Released
	f.Transition(PhaseReleased)
	cl = c.Classify(&EvalContext{State: state, Feature: f, Config: cfg})
	if cl.Action != ActionArchive {
		t.Fatalf("released: Action = %q, want ARCHIVE", cl.Action)
	}
}