use crate::app::{Command, SharedState};
use color_eyre::eyre::Error;
use futures_channel::mpsc::UnboundedReceiver;
use mumble_web2_common::{ProxyOverrides, ServerStatus};
use std::time::Duration;

/// Desktop platform implementation using Tokio and native audio.
pub struct DesktopPlatform;

impl super::PlatformInterface for DesktopPlatform {
    type AudioSystem = super::native_audio::NativeAudioSystem;
    type ConfigSystem = super::native_config::NativeConfigSystem;

    async fn sleep(duration: Duration) {
        tokio::time::sleep(duration).await;
    }

    async fn load_proxy_overrides() -> color_eyre::Result<ProxyOverrides> {
        Ok(ProxyOverrides {
            proxy_url: None,
            cert_hash: None,
            any_server: true,
        })
    }

    async fn network_connect(
        address: String,
        username: String,
        event_rx: &mut UnboundedReceiver<Command>,
        overrides: &ProxyOverrides,
        state: SharedState,
    ) -> Result<(), Error> {
        super::connect::network_connect(address, username, event_rx, overrides, state).await
    }

    async fn get_status(client: &reqwest::Client) -> color_eyre::Result<ServerStatus> {
        super::connect::get_status(client).await
    }

    fn init_logging() {
        use tracing::level_filters::LevelFilter;
        use tracing_subscriber::filter::EnvFilter;

        let env_filter = EnvFilter::builder()
            .with_default_directive(LevelFilter::INFO.into())
            .from_env_lossy();

        tracing_subscriber::fmt()
            .with_target(true)
            .with_level(true)
            .with_env_filter(env_filter)
            .init();
    }

    fn request_permissions() {
        // No-op on desktop
    }
}