//! Integration test for the orchestrator wiring in the composition root
//! (ARCHITECTURE §14.3).
//!
//! These tests prove that [`AppState`] actually *starts and stops* per-project
//! orchestrator watchers — the gap that previously left the whole §14.3 feature
//! dormant (the `OrchestratorService`/watcher existed but were never constructed
//! at runtime). The per-file request→dispatch→response behaviour is covered by
//! the infrastructure watcher tests; here we assert the lifecycle the open/close
//! commands rely on: registration is idempotent, projects are isolated, and
//! stopping unregisters.

use std::path::PathBuf;

use app_tauri_lib::state::AppState;
use domain::ports::IdGenerator;
use domain::project::{Project, ProjectPath};
use domain::remote::RemoteRef;
use domain::ProjectId;
use infrastructure::UuidGenerator;

/// A unique, absolute temp path (never written to at build time — the stores are
/// lazy — so it need not exist).
fn temp_path(tag: &str) -> PathBuf {
    let ids = UuidGenerator::new();
    std::env::temp_dir().join(format!("idea-orch-test-{tag}-{}", ids.new_uuid()))
}

/// Builds a domain [`Project`] rooted at a fresh temp path.
fn make_project() -> Project {
    let ids = UuidGenerator::new();
    let root = temp_path("root");
    Project::new(
        ProjectId::from_uuid(ids.new_uuid()),
        "demo",
        ProjectPath::new(root.to_string_lossy().into_owned()).unwrap(),
        RemoteRef::local(),
        1_700_000_000_000,
    )
    .unwrap()
}

fn watcher_count(state: &AppState) -> usize {
    state.orchestrator_watchers.lock().unwrap().len()
}

fn has_watcher(state: &AppState, id: &ProjectId) -> bool {
    state.orchestrator_watchers.lock().unwrap().contains_key(id)
}

fn mcp_count(state: &AppState) -> usize {
    state.mcp_servers.lock().unwrap().len()
}

fn has_mcp(state: &AppState, id: &ProjectId) -> bool {
    state.mcp_servers.lock().unwrap().contains_key(id)
}

#[tokio::test]
async fn ensure_watch_registers_a_watcher_and_is_idempotent() {
    let state = AppState::build(temp_path("appdata"));
    let project = make_project();

    assert_eq!(watcher_count(&state), 0, "no watcher before open");

    state.ensure_orchestrator_watch(&project);
    assert!(has_watcher(&state, &project.id));
    assert_eq!(watcher_count(&state), 1);

    // Opening the same project again must not spawn a second watcher.
    state.ensure_orchestrator_watch(&project);
    assert_eq!(watcher_count(&state), 1, "ensure is idempotent per project");
}

#[tokio::test]
async fn stop_watch_unregisters_the_watcher() {
    let state = AppState::build(temp_path("appdata"));
    let project = make_project();

    state.ensure_orchestrator_watch(&project);
    assert!(has_watcher(&state, &project.id));

    state.stop_orchestrator_watch(&project.id);
    assert!(
        !has_watcher(&state, &project.id),
        "watcher removed on close"
    );
    assert_eq!(watcher_count(&state), 0);

    // Stopping an unknown project is a no-op (does not panic).
    state.stop_orchestrator_watch(&project.id);
}

#[tokio::test]
async fn watchers_are_isolated_per_project() {
    let state = AppState::build(temp_path("appdata"));
    let a = make_project();
    let b = make_project();

    state.ensure_orchestrator_watch(&a);
    state.ensure_orchestrator_watch(&b);

    assert_eq!(watcher_count(&state), 2);
    assert!(has_watcher(&state, &a.id));
    assert!(has_watcher(&state, &b.id));

    // Closing one leaves the other running.
    state.stop_orchestrator_watch(&a.id);
    assert!(!has_watcher(&state, &a.id));
    assert!(has_watcher(&state, &b.id));
    assert_eq!(watcher_count(&state), 1);
}

// --- M3: IdeA MCP server lifecycle (twin of the watcher, Décision 4) ---
//
// The MCP server registry (`mcp_servers`) is the twin of `orchestrator_watchers`:
// `ensure_orchestrator_watch` starts both side by side on open/create, and
// `stop_orchestrator_watch` tears both down on close. These tests mirror the
// watcher lifecycle tests above against the MCP registry. The per-project
// supervision task parks on a stop signal (no blocking serve loop), so open/close
// must return promptly — the `#[tokio::test]` harness itself proves no figing
// (the test completes).

#[tokio::test]
async fn ensure_watch_starts_an_mcp_server_per_project() {
    let state = AppState::build(temp_path("appdata"));
    let project = make_project();

    assert_eq!(mcp_count(&state), 0, "no MCP server before open");

    state.ensure_orchestrator_watch(&project);
    assert!(
        has_mcp(&state, &project.id),
        "MCP server registered alongside the watcher"
    );
    assert_eq!(mcp_count(&state), 1);
}

#[tokio::test]
async fn ensure_mcp_server_is_idempotent_per_project() {
    let state = AppState::build(temp_path("appdata"));
    let project = make_project();

    state.ensure_orchestrator_watch(&project);
    assert_eq!(mcp_count(&state), 1);

    // Opening the same project again must not spawn a second MCP server.
    state.ensure_orchestrator_watch(&project);
    assert_eq!(
        mcp_count(&state),
        1,
        "MCP server start is idempotent per project"
    );
    assert!(has_mcp(&state, &project.id));
}

#[tokio::test]
async fn stop_watch_unregisters_the_mcp_server() {
    let state = AppState::build(temp_path("appdata"));
    let project = make_project();

    state.ensure_orchestrator_watch(&project);
    assert!(has_mcp(&state, &project.id));

    state.stop_orchestrator_watch(&project.id);
    assert!(
        !has_mcp(&state, &project.id),
        "MCP server removed on close"
    );
    assert_eq!(mcp_count(&state), 0);

    // Stopping an unknown project is a no-op (does not panic) for the MCP twin too.
    state.stop_orchestrator_watch(&project.id);
}

#[tokio::test]
async fn watcher_and_mcp_server_coexist_and_close_together() {
    let state = AppState::build(temp_path("appdata"));
    let project = make_project();

    // Open: both entry doors onto the same OrchestratorService are live.
    state.ensure_orchestrator_watch(&project);
    assert!(has_watcher(&state, &project.id), "watcher live on open");
    assert!(has_mcp(&state, &project.id), "MCP server live on open");
    assert_eq!(watcher_count(&state), 1);
    assert_eq!(mcp_count(&state), 1);

    // Close: the symmetric teardown removes both.
    state.stop_orchestrator_watch(&project.id);
    assert!(!has_watcher(&state, &project.id), "watcher gone on close");
    assert!(!has_mcp(&state, &project.id), "MCP server gone on close");
    assert_eq!(watcher_count(&state), 0);
    assert_eq!(mcp_count(&state), 0);
}

#[tokio::test]
async fn mcp_servers_are_isolated_per_project() {
    let state = AppState::build(temp_path("appdata"));
    let a = make_project();
    let b = make_project();

    state.ensure_orchestrator_watch(&a);
    state.ensure_orchestrator_watch(&b);

    assert_eq!(mcp_count(&state), 2, "one MCP server per open project");
    assert!(has_mcp(&state, &a.id));
    assert!(has_mcp(&state, &b.id));

    // Closing one leaves the other's MCP server running.
    state.stop_orchestrator_watch(&a.id);
    assert!(!has_mcp(&state, &a.id));
    assert!(has_mcp(&state, &b.id));
    assert_eq!(mcp_count(&state), 1);
}