use warp_util::standardized_path::StandardizedPath;

use super::super::protocol::RequestId;
use super::super::server_model::ConnectionId;
use super::{DiffModelKey, RemoteDiffStateManager};
use crate::code_review::diff_state::{BackendOrigin, DiffMode, LocalDiffStateModel};

/// Uses `try_new` instead of `try_from_local` so that Unix-style paths
/// like `/repo` are recognised as absolute on all platforms (including Windows).
fn test_key(repo: &str, mode: DiffMode) -> DiffModelKey {
    DiffModelKey {
        repo_path: StandardizedPath::try_new(repo).unwrap(),
        mode,
    }
}

fn new_conn() -> ConnectionId {
    uuid::Uuid::new_v4()
}

// ── Subscription tracking ───────────────────────────────────────────

#[test]
fn subscribe_registers_connection() {
    let mut model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);
    let conn = new_conn();

    model.subscribe_connection(key.clone(), conn);

    assert_eq!(model.subscribed_connections(&key), vec![conn]);
}

#[test]
fn subscribe_multiple_connections_to_same_key() {
    let mut model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);
    let conn_a = new_conn();
    let conn_b = new_conn();

    model.subscribe_connection(key.clone(), conn_a);
    model.subscribe_connection(key.clone(), conn_b);

    let subs = model.subscribed_connections(&key);
    assert_eq!(subs.len(), 2);
    assert!(subs.contains(&conn_a));
    assert!(subs.contains(&conn_b));
}

#[test]
fn subscribe_same_connection_to_different_keys() {
    let mut model = RemoteDiffStateManager::new();
    let key_head = test_key("/repo", DiffMode::Head);
    let key_main = test_key("/repo", DiffMode::MainBranch);
    let conn = new_conn();

    model.subscribe_connection(key_head.clone(), conn);
    model.subscribe_connection(key_main.clone(), conn);

    assert_eq!(model.subscribed_connections(&key_head), vec![conn]);
    assert_eq!(model.subscribed_connections(&key_main), vec![conn]);
}

#[test]
fn subscribed_connections_returns_empty_for_unknown_key() {
    let model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);

    assert!(model.subscribed_connections(&key).is_empty());
}

// ── Unsubscribe ─────────────────────────────────────────────────────

#[test]
fn unsubscribe_last_connection_removes_model() {
    let mut model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);
    let conn = new_conn();

    // Simulate model insertion + subscription (what handle_get_diff_state does).
    warpui::App::test((), |mut app| async move {
        let handle =
            app.add_model(|ctx| LocalDiffStateModel::new(None, BackendOrigin::ClientLocal, ctx));
        model.insert_model(key.clone(), handle);
        model.subscribe_connection(key.clone(), conn);

        model.unsubscribe_connection(&key, conn);

        assert!(model.get_model(&key).is_none());
        assert!(model.subscribed_connections(&key).is_empty());
    });
}

#[test]
fn unsubscribe_one_of_two_keeps_model() {
    let mut model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);
    let conn_a = new_conn();
    let conn_b = new_conn();

    warpui::App::test((), |mut app| async move {
        let handle =
            app.add_model(|ctx| LocalDiffStateModel::new(None, BackendOrigin::ClientLocal, ctx));
        model.insert_model(key.clone(), handle);
        model.subscribe_connection(key.clone(), conn_a);
        model.subscribe_connection(key.clone(), conn_b);

        model.unsubscribe_connection(&key, conn_a);

        assert!(model.get_model(&key).is_some());
        assert_eq!(model.subscribed_connections(&key), vec![conn_b]);
    });
}

#[test]
fn unsubscribe_clears_pending_responses_for_that_connection() {
    let mut model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);
    let conn_a = new_conn();
    let conn_b = new_conn();

    warpui::App::test((), |mut app| async move {
        let handle =
            app.add_model(|ctx| LocalDiffStateModel::new(None, BackendOrigin::ClientLocal, ctx));
        model.insert_model(key.clone(), handle);
        model.subscribe_connection(key.clone(), conn_a);
        model.subscribe_connection(key.clone(), conn_b);
        model.add_pending_response(key.clone(), RequestId::new(), conn_a);
        model.add_pending_response(key.clone(), RequestId::new(), conn_b);

        model.unsubscribe_connection(&key, conn_a);

        // Only conn_b's pending response should remain.
        let pending = model.drain_pending_responses(&key);
        assert_eq!(pending.len(), 1);
        assert_eq!(pending[0].conn_id, conn_b);
    });
}

// ── remove_connection ───────────────────────────────────────────────

#[test]
fn remove_connection_unsubscribes_from_all_keys() {
    let mut model = RemoteDiffStateManager::new();
    let key_head = test_key("/repo", DiffMode::Head);
    let key_main = test_key("/repo", DiffMode::MainBranch);
    let conn = new_conn();

    warpui::App::test((), |mut app| async move {
        let h1 =
            app.add_model(|ctx| LocalDiffStateModel::new(None, BackendOrigin::ClientLocal, ctx));
        let h2 =
            app.add_model(|ctx| LocalDiffStateModel::new(None, BackendOrigin::ClientLocal, ctx));
        model.insert_model(key_head.clone(), h1);
        model.insert_model(key_main.clone(), h2);
        model.subscribe_connection(key_head.clone(), conn);
        model.subscribe_connection(key_main.clone(), conn);

        model.remove_connection(conn);

        // Both models dropped because conn was the sole subscriber.
        assert!(model.get_model(&key_head).is_none());
        assert!(model.get_model(&key_main).is_none());
    });
}

#[test]
fn remove_connection_keeps_models_with_other_subscribers() {
    let mut model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);
    let conn_a = new_conn();
    let conn_b = new_conn();

    warpui::App::test((), |mut app| async move {
        let handle =
            app.add_model(|ctx| LocalDiffStateModel::new(None, BackendOrigin::ClientLocal, ctx));
        model.insert_model(key.clone(), handle);
        model.subscribe_connection(key.clone(), conn_a);
        model.subscribe_connection(key.clone(), conn_b);

        model.remove_connection(conn_a);

        assert!(model.get_model(&key).is_some());
        assert_eq!(model.subscribed_connections(&key), vec![conn_b]);
    });
}

#[test]
fn remove_connection_clears_pending_responses() {
    let mut model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);
    let conn = new_conn();

    warpui::App::test((), |mut app| async move {
        let handle =
            app.add_model(|ctx| LocalDiffStateModel::new(None, BackendOrigin::ClientLocal, ctx));
        model.insert_model(key.clone(), handle);
        model.subscribe_connection(key.clone(), conn);
        model.add_pending_response(key.clone(), RequestId::new(), conn);

        model.remove_connection(conn);

        // Model removed, so pending responses should be gone too.
        assert!(!model.has_pending_responses(&key));
    });
}

// ── Pending response tracking ───────────────────────────────────────

#[test]
fn has_pending_responses_false_when_empty() {
    let model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);

    assert!(!model.has_pending_responses(&key));
}

#[test]
fn add_and_drain_pending_responses() {
    let mut model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);
    let conn = new_conn();
    let rid = RequestId::new();

    model.add_pending_response(key.clone(), rid, conn);

    assert!(model.has_pending_responses(&key));

    let drained = model.drain_pending_responses(&key);
    assert_eq!(drained.len(), 1);
    assert_eq!(drained[0].conn_id, conn);

    // After drain, no pending responses remain.
    assert!(!model.has_pending_responses(&key));
}

#[test]
fn drain_pending_responses_returns_empty_for_unknown_key() {
    let mut model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);

    assert!(model.drain_pending_responses(&key).is_empty());
}

#[test]
fn multiple_pending_responses_for_same_key() {
    let mut model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);
    let conn_a = new_conn();
    let conn_b = new_conn();

    model.add_pending_response(key.clone(), RequestId::new(), conn_a);
    model.add_pending_response(key.clone(), RequestId::new(), conn_b);

    let drained = model.drain_pending_responses(&key);
    assert_eq!(drained.len(), 2);
    assert_eq!(drained[0].conn_id, conn_a);
    assert_eq!(drained[1].conn_id, conn_b);
}

// ── Model CRUD ──────────────────────────────────────────────────────

#[test]
fn get_model_returns_none_when_empty() {
    let model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);

    assert!(model.get_model(&key).is_none());
}

#[test]
fn insert_and_get_model() {
    let mut model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);

    warpui::App::test((), |mut app| async move {
        let handle =
            app.add_model(|ctx| LocalDiffStateModel::new(None, BackendOrigin::ClientLocal, ctx));
        model.insert_model(key.clone(), handle);

        assert!(model.get_model(&key).is_some());
    });
}

#[test]
fn remove_model_clears_pending_and_subscriptions() {
    let mut model = RemoteDiffStateManager::new();
    let key = test_key("/repo", DiffMode::Head);
    let conn = new_conn();

    warpui::App::test((), |mut app| async move {
        let handle =
            app.add_model(|ctx| LocalDiffStateModel::new(None, BackendOrigin::ClientLocal, ctx));
        model.insert_model(key.clone(), handle);
        model.subscribe_connection(key.clone(), conn);
        model.add_pending_response(key.clone(), RequestId::new(), conn);

        model.remove_model(&key);

        assert!(model.get_model(&key).is_none());
        assert!(!model.has_pending_responses(&key));
        assert!(model.subscribed_connections(&key).is_empty());
    });
}

// ── Key equality ────────────────────────────────────────────────────

#[test]
fn different_modes_are_different_keys() {
    let mut model = RemoteDiffStateManager::new();
    let key_head = test_key("/repo", DiffMode::Head);
    let key_main = test_key("/repo", DiffMode::MainBranch);
    let conn = new_conn();

    model.subscribe_connection(key_head.clone(), conn);

    assert_eq!(model.subscribed_connections(&key_head).len(), 1);
    assert!(model.subscribed_connections(&key_main).is_empty());
}

#[test]
fn different_repos_are_different_keys() {
    let mut model = RemoteDiffStateManager::new();
    let key_a = test_key("/repo-a", DiffMode::Head);
    let key_b = test_key("/repo-b", DiffMode::Head);
    let conn = new_conn();

    model.subscribe_connection(key_a.clone(), conn);

    assert_eq!(model.subscribed_connections(&key_a).len(), 1);
    assert!(model.subscribed_connections(&key_b).is_empty());
}