// Created by: Claude
// Date: 2026-01-04
// Purpose: Tests pour les protocoles P2P et terminal
// Refs: protocol_events_v_2.md, signaling_v_2.md

use mesh_agent::p2p::protocol::*;

#[test]
fn test_p2p_hello_serialization() {
    let hello = P2PHello {
        t: "P2P_HELLO".to_string(),
        session_id: "session_123".to_string(),
        session_token: "token_abc".to_string(),
        from_device_id: "device_456".to_string(),
    };

    let json = serde_json::to_string(&hello).unwrap();
    let deserialized: P2PHello = serde_json::from_str(&json).unwrap();

    assert_eq!(deserialized.t, "P2P_HELLO");
    assert_eq!(deserialized.session_id, "session_123");
    assert_eq!(deserialized.session_token, "token_abc");
    assert_eq!(deserialized.from_device_id, "device_456");
}

#[test]
fn test_p2p_response_ok() {
    let response = P2PResponse::Ok;

    let json = serde_json::to_string(&response).unwrap();
    assert!(json.contains(r#""t":"P2P_OK""#));

    let deserialized: P2PResponse = serde_json::from_str(&json).unwrap();
    match deserialized {
        P2PResponse::Ok => {}
        _ => panic!("Expected P2P_OK"),
    }
}

#[test]
fn test_p2p_response_deny() {
    let response = P2PResponse::Deny {
        reason: "Invalid token".to_string(),
    };

    let json = serde_json::to_string(&response).unwrap();
    assert!(json.contains(r#""t":"P2P_DENY""#));
    assert!(json.contains("Invalid token"));

    let deserialized: P2PResponse = serde_json::from_str(&json).unwrap();
    match deserialized {
        P2PResponse::Deny { reason } => {
            assert_eq!(reason, "Invalid token");
        }
        _ => panic!("Expected P2P_DENY"),
    }
}

#[test]
fn test_terminal_message_output() {
    let msg = TerminalMessage::Output {
        data: "$ ls -la\n".to_string(),
    };

    let json = serde_json::to_string(&msg).unwrap();
    assert!(json.contains(r#""t":"TERM_OUT""#));

    let deserialized: TerminalMessage = serde_json::from_str(&json).unwrap();
    match deserialized {
        TerminalMessage::Output { data } => {
            assert_eq!(data, "$ ls -la\n");
        }
        _ => panic!("Expected TERM_OUT"),
    }
}

#[test]
fn test_terminal_message_input() {
    let msg = TerminalMessage::Input {
        data: "echo hello\n".to_string(),
    };

    let json = serde_json::to_string(&msg).unwrap();
    assert!(json.contains(r#""t":"TERM_IN""#));

    let deserialized: TerminalMessage = serde_json::from_str(&json).unwrap();
    match deserialized {
        TerminalMessage::Input { data } => {
            assert_eq!(data, "echo hello\n");
        }
        _ => panic!("Expected TERM_IN"),
    }
}

#[test]
fn test_terminal_message_resize() {
    let msg = TerminalMessage::Resize {
        cols: 120,
        rows: 30,
    };

    let json = serde_json::to_string(&msg).unwrap();
    assert!(json.contains(r#""t":"TERM_RESIZE""#));

    let deserialized: TerminalMessage = serde_json::from_str(&json).unwrap();
    match deserialized {
        TerminalMessage::Resize { cols, rows } => {
            assert_eq!(cols, 120);
            assert_eq!(rows, 30);
        }
        _ => panic!("Expected TERM_RESIZE"),
    }
}

#[test]
fn test_all_message_types_have_type_field() {
    // FileMessage
    let file_meta = FileMessage::Meta {
        name: "test.txt".to_string(),
        size: 100,
        hash: "hash".to_string(),
    };
    let json = serde_json::to_string(&file_meta).unwrap();
    assert!(json.contains(r#""t":"FILE_META""#));

    // P2P
    let hello = P2PHello {
        t: "P2P_HELLO".to_string(),
        session_id: "s1".to_string(),
        session_token: "t1".to_string(),
        from_device_id: "d1".to_string(),
    };
    let json = serde_json::to_string(&hello).unwrap();
    assert!(json.contains(r#""t":"P2P_HELLO""#));

    // Terminal
    let term_out = TerminalMessage::Output {
        data: "output".to_string(),
    };
    let json = serde_json::to_string(&term_out).unwrap();
    assert!(json.contains(r#""t":"TERM_OUT""#));
}