package interview

import (
	"context"
	"testing"

	"tutor/internal/learnermemory"
	"tutor/internal/workflows"
)

func TestDiagnosticSessionAnswerFlow(t *testing.T) {
	memory := learnermemory.NewService(learnermemory.NewMemoryStore())
	service := NewService(NewMemoryStore(), workflows.NewStubRunner(), memory)

	session, err := service.CreateSession(context.Background(), CreateSessionInput{
		UserID:     "user-1",
		TargetRole: "junior backend developer",
		Stack:      []string{"go", "postgres"},
	})
	if err != nil {
		t.Fatalf("CreateSession error: %v", err)
	}
	if session.Track != BackendDeveloperTrack {
		t.Fatalf("Track = %q", session.Track)
	}
	if session.Status != SessionInProgress {
		t.Fatalf("Status = %q, want %q", session.Status, SessionInProgress)
	}
	if len(session.Questions) == 0 {
		t.Fatal("expected diagnostic questions")
	}

	answer, err := service.SubmitAnswer(context.Background(), SubmitAnswerInput{
		SessionID:  session.ID,
		QuestionID: session.Questions[0].ID,
		AnswerText: "Idempotent methods can be retried safely because repeated calls have the same intended effect.",
	})
	if err != nil {
		t.Fatalf("SubmitAnswer error: %v", err)
	}
	if answer.Grade.AnswerID != answer.ID {
		t.Fatalf("grade answer id = %q, want %q", answer.Grade.AnswerID, answer.ID)
	}
	if len(answer.Grade.Concepts) == 0 {
		t.Fatal("expected graded concepts")
	}
	if len(answer.Grade.Evidence) == 0 {
		t.Fatal("expected grading evidence")
	}

	loaded, err := service.GetSession(session.ID)
	if err != nil {
		t.Fatalf("GetSession error: %v", err)
	}
	if len(loaded.Answers) != 1 {
		t.Fatalf("answers = %d, want 1", len(loaded.Answers))
	}

	snapshot, err := memory.Snapshot(session.UserID)
	if err != nil {
		t.Fatalf("memory snapshot error: %v", err)
	}
	if len(snapshot.Mastery) == 0 {
		t.Fatal("expected memory mastery updates")
	}
	if len(snapshot.Mastery[0].Evidence) == 0 {
		t.Fatal("expected memory evidence")
	}
}

func TestDiagnosticSessionCompletesAfterAllQuestionsAnswered(t *testing.T) {
	memory := learnermemory.NewService(learnermemory.NewMemoryStore())
	service := NewService(NewMemoryStore(), workflows.NewStubRunner(), memory)

	session, err := service.CreateSession(context.Background(), CreateSessionInput{
		UserID:     "user-1",
		TargetRole: "junior backend developer",
		Stack:      []string{"go"},
	})
	if err != nil {
		t.Fatalf("CreateSession error: %v", err)
	}

	for _, question := range session.Questions {
		if _, err := service.SubmitAnswer(context.Background(), SubmitAnswerInput{
			SessionID:  session.ID,
			QuestionID: question.ID,
			AnswerText: "This answer gives a concrete backend tradeoff with an operational example for the interview.",
		}); err != nil {
			t.Fatalf("SubmitAnswer(%s) error: %v", question.ID, err)
		}
	}

	loaded, err := service.GetSession(session.ID)
	if err != nil {
		t.Fatalf("GetSession error: %v", err)
	}
	if loaded.Status != SessionComplete {
		t.Fatalf("Status = %q, want %q", loaded.Status, SessionComplete)
	}
}