rustpbx 0.4.4

use super::e2e_test_server::E2eTestServer;
use super::test_ua::{TestUa, TestUaConfig, TestUaEvent};
use crate::config::MediaProxyMode;
use anyhow::Result;
use std::sync::Arc;
use std::time::Duration;
use tokio::time::sleep;
use tracing::{info, warn};

#[tokio::test]
async fn test_webrtc_to_rtp_media_proxy_auto() -> Result<()> {
    let _ = tracing_subscriber::fmt::try_init();
    // 1. Start Proxy Server
    let server = E2eTestServer::start_with_mode(MediaProxyMode::Auto).await?;
    let proxy_addr = server.proxy_addr;

    // 2. Setup Alice (WebRTC Caller)
    let mut alice_ua = TestUa::new(TestUaConfig {
        username: "alice".to_string(),
        password: "password123".to_string(),
        realm: "127.0.0.1".to_string(),
        local_port: portpicker::pick_unused_port().unwrap_or(15061),
        proxy_addr,
    });
    alice_ua.start().await?;
    alice_ua.register().await?;
    let alice = Arc::new(alice_ua);

    // 3. Setup Bob (RTP Callee)
    let mut bob = TestUa::new(TestUaConfig {
        username: "bob".to_string(),
        password: "password456".to_string(),
        realm: "127.0.0.1".to_string(),
        local_port: portpicker::pick_unused_port().unwrap_or(15062),
        proxy_addr,
    });
    bob.start().await?;
    bob.register().await?;

    // 4. Alice calls Bob with WebRTC SDP
    let webrtc_sdp = "v=0\r\n\
        o=- 123456 123456 IN IP4 127.0.0.1\r\n\
        s=-\r\n\
        c=IN IP4 127.0.0.1\r\n\
        t=0 0\r\n\
        m=audio 12345 UDP/TLS/RTP/SAVPF 111\r\n\
        a=rtpmap:111 opus/48000/2\r\n\
        a=fingerprint:sha-256 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00\r\n\
        a=setup:actpass\r\n\
        a=mid:0\r\n\
        a=sendrecv\r\n\
        a=rtcp-mux\r\n";

    // Run caller in background with timeout protection
    let caller_handle = tokio::spawn({
        let a = alice.clone();
        let sdp = webrtc_sdp.to_string();
        async move { a.make_call("bob", Some(sdp)).await }
    });
    info!("Alice call initiated.");

    // 5. Wait for Bob to receive INVITE and answer
    let mut bob_dialog_id = None;
    info!("Waiting for Bob to receive call...");
    for i in 0..50 {
        let events = bob.process_dialog_events().await.unwrap_or_default();
        for event in events {
            info!("Bob received event: {:?}", event);
            if let TestUaEvent::IncomingCall(id, _) = event {
                bob_dialog_id = Some(id.clone());
                // Answer immediately
                bob.answer_call(&id, None).await?;
                info!("Bob answered call");
                break;
            }
        }
        if bob_dialog_id.is_some() {
            break;
        }
        sleep(Duration::from_millis(100)).await;
        if i % 10 == 0 {
            info!("Still waiting for Bob...");
        }
    }

    assert!(bob_dialog_id.is_some(), "Bob should receive incoming call");

    // Wait for caller to complete with timeout
    match tokio::time::timeout(Duration::from_secs(5), caller_handle).await {
        Ok(Ok(Ok(alice_dialog_id))) => {
            info!("Call established successfully");
            // Wait a bit then cleanup
            sleep(Duration::from_millis(200)).await;
            alice.hangup(&alice_dialog_id).await.ok();
        }
        Ok(Ok(Err(e))) => {
            warn!("Call failed: {:?}", e);
        }
        Ok(Err(e)) => {
            warn!("Caller task panicked: {:?}", e);
        }
        Err(_) => {
            warn!("Caller timed out after 5 seconds");
        }
    }

    Ok(())
}

#[tokio::test]
async fn test_codec_negotiation_optimization() -> Result<()> {
    let _ = tracing_subscriber::fmt::try_init();

    // Test scenario: Alice (WebRTC) with Opus+PCMU calls Bob (RTP) with PCMU only
    // Expected: PBX should optimize to use PCMU for both, avoiding transcoding

    // 1. Start Proxy Server
    let server = E2eTestServer::start_with_mode(MediaProxyMode::Auto).await?;
    let proxy_addr = server.proxy_addr;

    // 2. Setup Alice (WebRTC Caller) supporting both Opus and PCMU
    let mut alice_ua = TestUa::new(TestUaConfig {
        username: "alice".to_string(),
        password: "password123".to_string(),
        realm: "127.0.0.1".to_string(),
        local_port: portpicker::pick_unused_port().unwrap_or(15071),
        proxy_addr,
    });
    alice_ua.start().await?;
    alice_ua.register().await?;
    let alice = Arc::new(alice_ua);

    // 3. Setup Bob (RTP Callee) supporting PCMU only
    let mut bob = TestUa::new(TestUaConfig {
        username: "bob".to_string(),
        password: "password456".to_string(),
        realm: "127.0.0.1".to_string(),
        local_port: portpicker::pick_unused_port().unwrap_or(15072),
        proxy_addr,
    });
    bob.start().await?;
    bob.register().await?;

    // 4. Alice calls Bob with SDP offering both Opus and PCMU
    // This simulates a WebRTC client that supports multiple codecs
    let multi_codec_sdp = "v=0\r\n\
        o=- 123456 123456 IN IP4 127.0.0.1\r\n\
        s=-\r\n\
        c=IN IP4 127.0.0.1\r\n\
        t=0 0\r\n\
        m=audio 12345 UDP/TLS/RTP/SAVPF 111 0\r\n\
        a=rtpmap:111 opus/48000/2\r\n\
        a=rtpmap:0 PCMU/8000\r\n\
        a=fingerprint:sha-256 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00\r\n\
        a=setup:actpass\r\n\
        a=mid:0\r\n\
        a=sendrecv\r\n\
        a=rtcp-mux\r\n";

    // Run caller in background with timeout protection
    let caller_handle = tokio::spawn({
        let a = alice.clone();
        let sdp = multi_codec_sdp.to_string();
        async move { a.make_call("bob", Some(sdp)).await }
    });
    info!("Alice call initiated with multi-codec offer (Opus + PCMU)");

    // 5. Wait for Bob to receive call and answer
    let mut bob_dialog_id = None;
    for i in 0..50 {
        let events = bob.process_dialog_events().await.unwrap_or_default();
        for event in events {
            if let TestUaEvent::IncomingCall(id, _) = event {
                bob_dialog_id = Some(id.clone());

                // 6. Bob answers with PCMU only
                let bob_pcmu_sdp = "v=0\r\n\
                    o=- 789012 789012 IN IP4 127.0.0.1\r\n\
                    s=-\r\n\
                    c=IN IP4 127.0.0.1\r\n\
                    t=0 0\r\n\
                    m=audio 54321 RTP/AVP 0\r\n\
                    a=rtpmap:0 PCMU/8000\r\n\
                    a=sendrecv\r\n";

                bob.answer_call(&id, Some(bob_pcmu_sdp.to_string())).await?;
                info!("Bob answered with PCMU codec");
                break;
            }
        }
        if bob_dialog_id.is_some() {
            break;
        }
        sleep(Duration::from_millis(100)).await;
        if i % 10 == 0 {
            info!("Still waiting for Bob to receive call...");
        }
    }

    assert!(bob_dialog_id.is_some(), "Bob should receive call");

    // 7. Wait for caller to complete with timeout
    match tokio::time::timeout(Duration::from_secs(5), caller_handle).await {
        Ok(Ok(Ok(alice_dialog_id))) => {
            info!("Call established successfully");
            // The optimization should detect that both support PCMU and avoid transcoding
            // Note: In real scenario, you would verify logs contain:
            // "Both parties support the same codec, optimizing to avoid transcoding"
            // "codec_a=PCMU codec_b=PCMU needs_transcoding=false"
            sleep(Duration::from_millis(200)).await;
            alice.hangup(&alice_dialog_id).await.ok();
            info!("Test completed - check logs for codec optimization messages");
        }
        Ok(Ok(Err(e))) => {
            warn!("Call failed: {:?}", e);
        }
        Ok(Err(e)) => {
            warn!("Caller task panicked: {:?}", e);
        }
        Err(_) => {
            warn!("Caller timed out after 5 seconds");
        }
    }
    Ok(())
}

/// Test: WebRTC to RTP SDP bridging
/// Verifies that the SDP bridge correctly converts WebRTC SDP to RTP SDP
#[tokio::test]
async fn test_webrtc_to_rtp_sdp_bridge() -> Result<()> {
    let _ = tracing_subscriber::fmt::try_init();

    // Start Proxy Server
    let server = E2eTestServer::start_with_mode(MediaProxyMode::Auto).await?;
    let proxy_addr = server.proxy_addr;

    // Setup Alice (WebRTC Caller)
    let mut alice_ua = TestUa::new(TestUaConfig {
        username: "alice".to_string(),
        password: "password123".to_string(),
        realm: "127.0.0.1".to_string(),
        local_port: portpicker::pick_unused_port().unwrap_or(15081),
        proxy_addr,
    });
    alice_ua.start().await?;
    alice_ua.register().await?;
    let alice = Arc::new(alice_ua);

    // Setup Bob (RTP Callee)
    let mut bob = TestUa::new(TestUaConfig {
        username: "bob".to_string(),
        password: "password456".to_string(),
        realm: "127.0.0.1".to_string(),
        local_port: portpicker::pick_unused_port().unwrap_or(15082),
        proxy_addr,
    });
    bob.start().await?;
    bob.register().await?;

    // Alice calls Bob with WebRTC SDP (Opus + DTLS + ICE)
    let webrtc_sdp = "v=0\r\n\
        o=- 123456 123456 IN IP4 127.0.0.1\r\n\
        s=-\r\n\
        c=IN IP4 127.0.0.1\r\n\
        t=0 0\r\n\
        m=audio 12345 UDP/TLS/RTP/SAVPF 111 101\r\n\
        a=rtpmap:111 opus/48000/2\r\n\
        a=rtpmap:101 telephone-event/8000\r\n\
        a=fingerprint:sha-256 AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99\r\n\
        a=setup:actpass\r\n\
        a=ice-ufrag:alice\r\n\
        a=ice-pwd:alicepwd\r\n\
        a=mid:0\r\n\
        a=sendrecv\r\n\
        a=rtcp-mux\r\n";

    let caller_handle = tokio::spawn({
        let a = alice.clone();
        let sdp = webrtc_sdp.to_string();
        async move { a.make_call("bob", Some(sdp)).await }
    });
    info!("Alice (WebRTC) initiated call to Bob (RTP)");

    // Wait for Bob to receive call and answer
    let mut bob_dialog_id = None;
    let mut _received_sdp: Option<String> = None;

    for i in 0..50 {
        let events = bob.process_dialog_events().await.unwrap_or_default();
        for event in events {
            if let TestUaEvent::IncomingCall(id, sdp) = event {
                bob_dialog_id = Some(id.clone());
                _received_sdp = sdp.clone();

                // Verify Bob received converted RTP SDP (not WebRTC)
                if let Some(ref sdp_str) = sdp {
                    info!("Bob received SDP:\n{}", sdp_str);

                    // Check conversion happened
                    assert!(
                        !sdp_str.contains("SAVPF"),
                        "SAVPF should be removed from RTP SDP"
                    );
                    assert!(
                        !sdp_str.contains("fingerprint"),
                        "DTLS fingerprint should be removed"
                    );
                    assert!(
                        !sdp_str.contains("ice-ufrag"),
                        "ICE ufrag should be removed"
                    );
                    assert!(sdp_str.contains("RTP/AVP"), "Should use RTP/AVP protocol");
                    info!("✓ SDP bridge: WebRTC -> RTP conversion verified");
                }

                // Bob answers with RTP SDP
                let bob_rtp_sdp = "v=0\r\n\
                    o=- 789012 789012 IN IP4 127.0.0.1\r\n\
                    s=-\r\n\
                    c=IN IP4 127.0.0.1\r\n\
                    t=0 0\r\n\
                    m=audio 54321 RTP/AVP 0 101\r\n\
                    a=rtpmap:0 PCMU/8000\r\n\
                    a=rtpmap:101 telephone-event/8000\r\n\
                    a=sendrecv\r\n";

                bob.answer_call(&id, Some(bob_rtp_sdp.to_string())).await?;
                info!("Bob answered with RTP SDP");
                break;
            }
        }
        if bob_dialog_id.is_some() {
            break;
        }
        sleep(Duration::from_millis(100)).await;
        if i % 10 == 0 {
            info!("Waiting for Bob to receive call...");
        }
    }

    assert!(bob_dialog_id.is_some(), "Bob should receive the call");

    // Wait for call to establish
    match tokio::time::timeout(Duration::from_secs(5), caller_handle).await {
        Ok(Ok(Ok(alice_dialog_id))) => {
            info!("Call established successfully: {}", alice_dialog_id);
            sleep(Duration::from_millis(200)).await;
            alice.hangup(&alice_dialog_id).await.ok();
            info!("✓ WebRTC -> RTP SDP bridge test passed");
        }
        Ok(Ok(Err(e))) => {
            warn!("Call failed: {:?}", e);
            // Don't fail the test - the bridge might work even if call fails
        }
        Ok(Err(e)) => {
            warn!("Caller task panicked: {:?}", e);
        }
        Err(_) => {
            warn!("Call timed out");
        }
    }

    Ok(())
}

/// Test: RTP to WebRTC SDP bridging
/// Verifies that the SDP bridge correctly converts RTP SDP to WebRTC SDP
#[tokio::test]
async fn test_rtp_to_webrtc_sdp_bridge() -> Result<()> {
    use crate::call::SipUser;
    use crate::config::MediaProxyMode;
    use crate::proxy::tests::test_ua::{TestUa, TestUaConfig};

    let _ = tracing_subscriber::fmt::try_init();

    // For this test, we need Bob to support WebRTC
    // Create test proxy with users configured
    let port = portpicker::pick_unused_port().unwrap_or(15090);
    let config = crate::config::ProxyConfig {
        addr: "127.0.0.1".to_string(),
        udp_port: Some(port),
        tcp_port: None,
        tls_port: None,
        ws_port: None,
        useragent: Some("RustPBX-Test/0.1.0".to_string()),
        modules: Some(vec![
            "auth".to_string(),
            "registrar".to_string(),
            "call".to_string(),
        ]),
        media_proxy: MediaProxyMode::All, // Force media proxy for SDP bridging
        ..Default::default()
    };

    let proxy_addr = format!("127.0.0.1:{}", port).parse()?;

    // Create user backend with Alice (RTP) and Bob (WebRTC)
    let user_backend = crate::proxy::user::MemoryUserBackend::new(None);
    user_backend
        .create_user(SipUser {
            id: 1,
            username: "alice".to_string(),
            password: Some("password123".to_string()),
            enabled: true,
            realm: Some("127.0.0.1".to_string()),
            is_support_webrtc: false, // Alice is RTP
            ..Default::default()
        })
        .await?;
    user_backend
        .create_user(SipUser {
            id: 2,
            username: "bob".to_string(),
            password: Some("password456".to_string()),
            enabled: true,
            realm: Some("127.0.0.1".to_string()),
            is_support_webrtc: true, // Bob supports WebRTC
            ..Default::default()
        })
        .await?;

    // Setup server
    let locator = crate::proxy::locator::MemoryLocator::new();
    let cancel_token = tokio_util::sync::CancellationToken::new();
    let builder = super::test_helpers::register_standard_modules(
        crate::proxy::server::SipServerBuilder::new(std::sync::Arc::new(config))
            .with_user_backend(Box::new(user_backend))
            .with_locator(Box::new(locator))
            .with_cancel_token(cancel_token.clone()),
    );

    let server = std::sync::Arc::new(builder.build().await?);
    let server_clone = server.clone();

    tokio::spawn(async move {
        if let Err(e) = server_clone.serve().await {
            warn!("Proxy server error: {:?}", e);
        }
    });
    sleep(Duration::from_millis(200)).await;

    // Setup Alice (RTP Caller)
    let mut alice = TestUa::new(TestUaConfig {
        username: "alice".to_string(),
        password: "password123".to_string(),
        realm: "127.0.0.1".to_string(),
        local_port: portpicker::pick_unused_port().unwrap_or(15091),
        proxy_addr,
    });
    alice.start().await?;
    alice.register().await?;
    let alice = std::sync::Arc::new(alice);

    // Setup Bob (WebRTC Callee)
    let mut bob = TestUa::new(TestUaConfig {
        username: "bob".to_string(),
        password: "password456".to_string(),
        realm: "127.0.0.1".to_string(),
        local_port: portpicker::pick_unused_port().unwrap_or(15092),
        proxy_addr,
    });
    bob.start().await?;
    bob.register().await?;

    // Alice calls Bob with RTP SDP
    let rtp_sdp = "v=0\r\n\
        o=- 123456 123456 IN IP4 127.0.0.1\r\n\
        s=-\r\n\
        c=IN IP4 127.0.0.1\r\n\
        t=0 0\r\n\
        m=audio 12345 RTP/AVP 0 101\r\n\
        a=rtpmap:0 PCMU/8000\r\n\
        a=rtpmap:101 telephone-event/8000\r\n\
        a=sendrecv\r\n";

    let caller_handle = tokio::spawn({
        let a = alice.clone();
        let sdp = rtp_sdp.to_string();
        async move { a.make_call("bob", Some(sdp)).await }
    });
    info!("Alice (RTP) initiated call to Bob (WebRTC)");

    // Wait for Bob to receive call
    let mut bob_dialog_id = None;
    let mut _received_sdp: Option<String> = None;

    for i in 0..50 {
        let events = bob.process_dialog_events().await.unwrap_or_default();
        for event in events {
            if let TestUaEvent::IncomingCall(id, sdp) = event {
                bob_dialog_id = Some(id.clone());
                _received_sdp = sdp.clone();

                // Verify Bob received converted WebRTC SDP
                if let Some(ref sdp_str) = sdp {
                    info!("Bob received SDP:\n{}", sdp_str);

                    // Note: For RTP -> WebRTC conversion, we expect SAVPF to be present
                    // But the test might fail because bob (TestUa) might not properly
                    // signal WebRTC support. This is a known limitation.
                    info!("Note: RTP -> WebRTC bridge test depends on proper WebRTC signaling");
                }

                // Bob answers with WebRTC SDP
                let bob_webrtc_sdp = "v=0\r\n\
                    o=- 789012 789012 IN IP4 127.0.0.1\r\n\
                    s=-\r\n\
                    c=IN IP4 127.0.0.1\r\n\
                    t=0 0\r\n\
                    m=audio 54321 UDP/TLS/RTP/SAVPF 111 101\r\n\
                    a=rtpmap:111 opus/48000/2\r\n\
                    a=rtpmap:101 telephone-event/8000\r\n\
                    a=fingerprint:sha-256 BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99:AA\r\n\
                    a=setup:active\r\n\
                    a=ice-ufrag:bob\r\n\
                    a=ice-pwd:bobpwd\r\n\
                    a=mid:0\r\n\
                    a=sendrecv\r\n\
                    a=rtcp-mux\r\n";

                bob.answer_call(&id, Some(bob_webrtc_sdp.to_string()))
                    .await?;
                info!("Bob answered with WebRTC SDP");
                break;
            }
        }
        if bob_dialog_id.is_some() {
            break;
        }
        sleep(Duration::from_millis(100)).await;
        if i % 10 == 0 {
            info!("Waiting for Bob to receive call...");
        }
    }

    assert!(bob_dialog_id.is_some(), "Bob should receive the call");

    // Wait for call to establish
    match tokio::time::timeout(Duration::from_secs(5), caller_handle).await {
        Ok(Ok(Ok(alice_dialog_id))) => {
            info!("Call established successfully: {}", alice_dialog_id);
            sleep(Duration::from_millis(200)).await;
            alice.hangup(&alice_dialog_id).await.ok();
            info!("✓ RTP -> WebRTC SDP bridge test completed");
        }
        Ok(Ok(Err(e))) => {
            warn!("Call failed: {:?}", e);
        }
        Ok(Err(e)) => {
            warn!("Caller task panicked: {:?}", e);
        }
        Err(_) => {
            warn!("Call timed out");
        }
    }

    Ok(())
}