use miette::{Context, IntoDiagnostic, Result};

use webrtc::{
    api::{
        interceptor_registry::register_default_interceptors, media_engine::MediaEngine,
        setting_engine::SettingEngine, APIBuilder, API as WebRTC,
    },
    ice::network_type::NetworkType,
    ice_transport::ice_server::RTCIceServer,
    interceptor::registry::Registry as InterceptorRegistry,
    peer_connection::configuration::RTCConfiguration,
};

pub mod channel_info;
pub mod whep;
pub mod whip;

fn setup_ice(setting_engine: &mut SettingEngine) -> Result<()> {
    setting_engine.set_network_types(vec![
        NetworkType::Tcp4,
        NetworkType::Tcp6,
        NetworkType::Udp4,
        NetworkType::Udp6,
    ]);

    // TODO: Set up UDP muxing?
    Ok(())
}

pub fn setup_webrtc() -> Result<WebRTC> {
    let mut media_engine = MediaEngine::default();
    media_engine
        .register_default_codecs()
        .into_diagnostic()
        .wrap_err("Failed to register default media engine codecs.")?;

    let interceptor_registry = InterceptorRegistry::new();
    let interceptor_registry =
        register_default_interceptors(interceptor_registry, &mut media_engine)
            .into_diagnostic()
            .wrap_err("Failed to register default interceptors.")?;

    let mut setting_engine = SettingEngine::default();
    setup_ice(&mut setting_engine)?;

    let api = APIBuilder::new()
        .with_media_engine(media_engine)
        .with_interceptor_registry(interceptor_registry)
        .with_setting_engine(setting_engine)
        .build();

    Ok(api)
}

pub fn create_rtc_config() -> RTCConfiguration {
    RTCConfiguration {
        ice_servers: vec![
            RTCIceServer {
                urls: vec!["stun:stun.cloudflare.com:3478".into()],
                ..Default::default()
            },
            RTCIceServer {
                urls: vec!["stun:stun.l.google.com:19302".into()],
                ..Default::default()
            },
        ],
        ..Default::default()
    }
}