/// udp server
///
/// eg. discovery
///
use hbb_common::{base_proto::PeerInfo, config::SERVER_UDP_PORT, ResultType};
use socket_cs::udp::{Server, UdpHandlers};

/// Simple copy from ../connections.rs#send_logon_response
/// Should be merged into one function.
fn get_peer_info() -> PeerInfo {
    let username = crate::platform::get_active_username();
    #[allow(unused_mut)]
    let mut sas_enabled = false;
    #[cfg(windows)]
    if crate::platform::is_root() {
        sas_enabled = true;
    }
    PeerInfo {
        hostname: whoami::hostname(),
        username,
        platform: whoami::platform().to_string(),
        version: crate::VERSION.to_owned(),
        sas_enabled,
        ..Default::default()
    }
}

pub mod discovery {
    use super::get_peer_info;
    use crate::ipc;
    use hbb_common::{
        config::{Config, PeerConfig, PeerInfoSerde, SERVER_UDP_PORT},
        discovery_proto::{Discovery as DiscoveryProto, DiscoveryBack as DiscoveryBackProto},
        log, protobuf, tokio, ResultType,
    };
    use socket_cs::{discovery::*, udp::UdpHandlers};

    async fn get_discovery_back_info() -> DiscoveryBackProto {
        let peer = get_peer_info();
        DiscoveryBackProto {
            id: ipc::get_id_async().await,
            peer: protobuf::MessageField::from_option(Some(peer)),
            ..Default::default()
        }
    }

    fn process_discovery_back(info: DiscoveryBackProto) {
        let mut config = PeerConfig::load(info.id.as_str());

        let peer = info.peer.as_ref().unwrap();
        let serde = PeerInfoSerde {
            username: peer.username.clone(),
            hostname: peer.hostname.clone(),
            platform: peer.platform.clone(),
        };
        config.info = serde;
        config.store(info.id.as_str());

        #[tokio::main(flavor = "current_thread")]
        async fn notify_index_window() -> ResultType<()> {
            let ms_timeout = 300;
            let mut c = ipc::connect(ms_timeout, "_index").await?;
            c.send(&ipc::Data::SessionsUpdated).await?;
            Ok(())
        }
        std::thread::spawn(move || {
            if let Err(e) = notify_index_window() {
                log::error!("Failed to notify index window, {}", e);
            }
        });
    }

    pub fn launch_lan_discover() {
        std::thread::spawn(move || {
            if let Err(e) = lan_discover() {
                log::error!("Failed to lauch lan discover, {}", e);
            }
        });
    }

    #[tokio::main(flavor = "current_thread")]
    pub async fn lan_discover() -> ResultType<()> {
        let peer = get_peer_info();
        let client = DiscoveryClient::create(DiscoveryProto {
            id: ipc::get_id_async().await,
            peer: protobuf::MessageField::from_option(Some(peer)),
            port: SERVER_UDP_PORT as i32,
            ..Default::default()
        })
        .await?;

        client.lan_discover(SERVER_UDP_PORT).await
    }

    pub(super) async fn handle_discovery(handlers: UdpHandlers) -> UdpHandlers {
        let info = get_discovery_back_info().await;
        handlers
            .handle(
                CMD_DISCOVERY.as_bytes().to_vec(),
                Box::new(HandlerDiscovery::new(
                    // Some(|| Config::get_option("enable-be-discovered") == "Y".to_owned()),
                    Some(|| true),
                    info,
                )),
            )
            .handle(
                CMD_DISCOVERY_BACK.as_bytes().to_vec(),
                Box::new(HandlerDiscoveryBack::new(process_discovery_back)),
            )
    }
}

pub(super) async fn start_udp_server() -> ResultType<Server> {
    let handlers = discovery::handle_discovery(UdpHandlers::new()).await;

    let mut server = Server::create(SERVER_UDP_PORT)?;
    server.start(handlers).await?;
    Ok(server)
}