use defguard_wireguard_rs::{
    host::Peer, key::Key, InterfaceConfiguration, WGApi, WireguardInterfaceApi,
};
//use log::{debug, error, info, warn};
use std::{
    collections::{BTreeSet, HashMap},
    net::ToSocketAddrs,
    sync::Arc,
};
use tokio::{net::TcpListener, sync::RwLock};

use crate::daemon::*;
use crate::daemon_config::*;

pub async fn add_network(
    name: String,
    privkey: String,
    address: String,
    port: u16,
    peers: &HashMap<Key, PeerConfig>,
) -> Result<(WGApi, BTreeSet<(String, String)>), DaemonError> {
    let mut hostname_pairs = BTreeSet::new();

    let wg = WGApi::new(name.clone(), false)?;
    let defguard_peers = peers
        .iter()
        .map(|(peer_key, p)| Peer {
            public_key: peer_key.clone(),
            preshared_key: p.psk.clone(),
            protocol_version: None,
            endpoint: p
                .endpoint
                .clone()
                .map(|e| match e {
                    Endpoint::Ip(ep) => Some(ep),
                    Endpoint::Domain(s, p) => (s, p)
                        .to_socket_addrs()
                        .ok()
                        .map(|mut it| it.next())
                        .flatten(),
                })
                .flatten(),
            last_handshake: None,
            tx_bytes: 0,
            rx_bytes: 0,
            persistent_keepalive_interval: None,
            allowed_ips: p.ips.iter().map(|(ip_mask, _)| ip_mask.clone()).collect(),
        })
        .collect();
    wg.create_interface()?;
    wg.configure_interface(&InterfaceConfiguration {
        name: name.clone(),
        prvkey: privkey,
        address: address,
        port: port as u32,
        peers: defguard_peers,
    })?;

    peers
        .values()
        .map(|peer| {
            if peer.use_hostnames {
                peer.ips
                    .iter()
                    .map(|(mask, may_dom)| {
                        if let Some(dom) = may_dom {
                            hostname_pairs.insert((format!("{}", mask.ip), dom.clone()));
                        }
                    })
                    .count();
            }
        })
        .count();

    Ok((wg, hostname_pairs))
}

pub async fn run_network(
    state: Arc<RwLock<State>>,
    sock: TcpListener,
    nw_name: String,
) -> Result<(), DaemonError> {
    Ok(())
}