use super::{linux::*, ResultType};
use hbb_common::{allow_err, bail, log, rand::prelude::*, tokio::time};
use pam;
use std::{
    collections::HashMap,
    os::unix::process::CommandExt,
    path::Path,
    process::{Child, Command},
    sync::{
        atomic::{AtomicBool, Ordering},
        mpsc::{sync_channel, SyncSender},
        Arc, Mutex,
    },
    time::{Duration, Instant},
};
use users::{get_user_by_name, os::unix::UserExt, User};

lazy_static::lazy_static! {
    static ref DESKTOP_RUNNING: Arc<AtomicBool> = Arc::new(AtomicBool::new(false));
    static ref DESKTOP_INST: Arc<Mutex<Option<Desktop>>> = Arc::new(Mutex::new(None));
}

pub const VIRTUAL_X11_DESKTOP: &str = "xfce4";
pub const VIRTUAL_X11_DESKTOP_START: &str = "startxfce4";
pub const XFCE4_PANEL: &str = "xfce4-panel";
pub const GNOME_SESSION_BINARY: &str = "gnome-session-binary";
pub const ENV_DESKTOP_PROTOCAL: &str = "RUSTDESK_PROTOCAL";
pub const ENV_DESKTOP_PROTOCAL_WAYLAND: &str = "wayland";
pub const ENV_DESKTOP_PROTOCAL__X11: &str = "x11";
pub const ENV_DESKTOP_PROTOCAL_UNKNOWN: &str = "unknown";

#[derive(Copy, Clone, PartialEq, Debug)]
pub enum Protocal {
    Wayland,
    X11, // Xorg
    Unknown,
}

#[derive(Debug, Clone)]
pub struct DesktopEnv {
    pub protocal: Protocal,
    pub username: String,
    pub uid: String,
    pub display: String,
    pub xauth: String,
}

#[derive(Debug)]
pub struct Desktop {
    env: DesktopEnv,
    child_exit: Arc<AtomicBool>,
    is_child_running: Arc<AtomicBool>,
}

fn check_update_env() {
    let mut inst = DESKTOP_INST.lock().unwrap();
    if let Some(inst) = &mut (*inst) {
        if !inst.is_child_running.load(Ordering::SeqCst) {
            inst.child_exit.store(true, Ordering::SeqCst);
            let old_env = inst.env.clone();
            allow_err!(inst.env.refresh());
            if !inst.env.is_same_env(&old_env) {
                inst.env.update_env();
                log::debug!("desktop env changed, {:?}", &inst.env);
            }
        }
    }
}

pub fn start_xdesktop() {
    std::thread::spawn(|| {
        if wait_xdesktop(20) {
            log::info!("Wait desktop: default");
        } else {
            log::info!("Wait desktop: none");
        }
        *DESKTOP_INST.lock().unwrap() = Some(Desktop::new());

        let interval = time::Duration::from_millis(super::SERVICE_INTERVAL);
        DESKTOP_RUNNING.store(true, Ordering::SeqCst);
        while DESKTOP_RUNNING.load(Ordering::SeqCst) {
            check_update_env();
            std::thread::sleep(interval);
        }
        log::info!("xdesktop update thread exit");
    });
}

pub fn stop_xdesktop() {
    DESKTOP_RUNNING.store(false, Ordering::SeqCst);
}

pub fn get_desktop_env() -> Option<DesktopEnv> {
    match &*DESKTOP_INST.lock().unwrap() {
        Some(inst) => Some(inst.env.clone()),
        None => None,
    }
}

pub fn try_start_x_session(username: &str, password: &str) -> ResultType<DesktopEnv> {
    let mut inst = DESKTOP_INST.lock().unwrap();
    if let Some(inst) = &mut (*inst) {
        let _ = inst.try_start_x_session(username, password)?;
        log::debug!("try_start_x_session, username: {}, {:?}", &username, &inst);
        Ok(inst.env.clone())
    } else {
        bail!(crate::server::LOGIN_MSG_XDESKTOP_NOT_INITED);
    }
}

fn wait_xdesktop(timeout_secs: u64) -> bool {
    let wait_begin = Instant::now();
    while wait_begin.elapsed().as_secs() < timeout_secs {
        let seat0 = get_values_of_seat0(&[0]);
        if !seat0[0].is_empty() {
            return true;
        }

        if let Ok(output) = run_cmds(format!(
            "ps -ef | grep -v 'grep' | grep -E 'gnome-session-binary|{}'",
            XFCE4_PANEL
        )) {
            if !output.is_empty() {
                log::info!("wait xdesktop: find xclient {}", &output);
                return true;
            }
        }

        std::thread::sleep(Duration::from_millis(super::SERVICE_INTERVAL));
    }

    false
}

impl DesktopEnv {
    pub fn new() -> Self {
        let xauth = get_env_var("XAUTHORITY");

        Self {
            protocal: Protocal::Unknown,
            username: "".to_owned(),
            uid: "".to_owned(),
            display: "".to_owned(),
            xauth: if xauth.is_empty() {
                "/tmp/.Xauthority".to_owned()
            } else {
                xauth
            },
        }
    }

    fn update_env(&self) {
        if self.is_ready() {
            std::env::set_var("DISPLAY", &self.display);
            std::env::set_var("XAUTHORITY", &self.xauth);
            std::env::set_var(ENV_DESKTOP_PROTOCAL, &self.protocal.to_string());
        } else {
            std::env::set_var("DISPLAY", "");
            std::env::set_var("XAUTHORITY", "");
            std::env::set_var(ENV_DESKTOP_PROTOCAL, &Protocal::Unknown.to_string());
        }
    }

    pub fn is_same_env(&self, other: &Self) -> bool {
        self.protocal == other.protocal
            && self.uid == other.uid
            && self.display == other.display
            && self.xauth == other.xauth
    }

    #[inline(always)]
    pub fn is_ready(&self) -> bool {
        self.protocal == Protocal::X11
    }

    // The logic mainly fron https://github.com/neutrinolabs/xrdp/blob/34fe9b60ebaea59e8814bbc3ca5383cabaa1b869/sesman/session.c#L334.
    fn get_avail_display() -> ResultType<u32> {
        let display_range = 0..51;
        for i in display_range.clone() {
            if Self::is_x_server_running(i) {
                continue;
            }
            return Ok(i);
        }
        bail!("No avaliable display found in range {:?}", display_range)
    }

    fn is_x_server_running(display: u32) -> bool {
        Path::new(&format!("/tmp/.X11-unix/X{}", display)).exists()
            || Path::new(&format!("/tmp/.X{}-lock", display)).exists()
    }

    fn get_display(&mut self) {
        self.display = get_env_tries("DISPLAY", &self.uid, GNOME_SESSION_BINARY, 10);
        if self.display.is_empty() {
            self.display = get_env_tries("DISPLAY", &self.uid, XFCE4_PANEL, 10);
        }
        if self.display.is_empty() {
            self.display = Self::get_display_by_user(&self.username);
        }
        if self.display.is_empty() {
            self.display = ":0".to_owned();
        }
        self.display = self
            .display
            .replace(&whoami::hostname(), "")
            .replace("localhost", "");
    }

    fn get_xauth(&mut self) {
        self.xauth = get_env_tries("XAUTHORITY", &self.uid, GNOME_SESSION_BINARY, 10);
        if self.xauth.is_empty() {
            get_env_tries("XAUTHORITY", &self.uid, XFCE4_PANEL, 10);
        }

        let gdm = format!("/run/user/{}/gdm/Xauthority", self.uid);
        if self.xauth.is_empty() {
            self.xauth = if std::path::Path::new(&gdm).exists() {
                gdm
            } else {
                let username = &self.username;
                if username == "root" {
                    format!("/{}/.Xauthority", username)
                } else {
                    let tmp = format!("/home/{}/.Xauthority", username);
                    if std::path::Path::new(&tmp).exists() {
                        tmp
                    } else {
                        format!("/var/lib/{}/.Xauthority", username)
                    }
                }
            };
        }
    }

    // fixme: reduce loginctl
    fn get_env_seat0(&mut self) -> ResultType<bool> {
        let output = Command::new("loginctl").output()?;
        for line in String::from_utf8_lossy(&output.stdout).lines() {
            if line.contains("seat0") {
                if let Some(sid) = line.split_whitespace().nth(0) {
                    if Self::is_active(sid)? {
                        if let Some(uid) = line.split_whitespace().nth(1) {
                            self.uid = uid.to_owned();
                        }
                        if let Some(u) = line.split_whitespace().nth(2) {
                            self.username = u.to_owned();
                        }

                        self.protocal = Protocal::Unknown;
                        let type_output = Command::new("loginctl")
                            .args(vec!["show-session", "-p", "Type", sid])
                            .output()?;
                        let type_stdout = String::from_utf8_lossy(&type_output.stdout);

                        if type_stdout.contains("x11") {
                            self.protocal = Protocal::X11;
                            break;
                        } else if type_stdout.contains("wayland") {
                            self.protocal = Protocal::Wayland;
                        }
                    }
                }
            }
        }
        Ok(self.is_ready())
    }

    // some case, there is no seat0 https://github.com/rustdesk/rustdesk/issues/73
    fn get_env_active(&mut self) -> ResultType<bool> {
        let output = Command::new("loginctl").output()?;

        // set active Xorg session
        for line in String::from_utf8_lossy(&output.stdout).lines() {
            if line.contains("sessions listed.") {
                continue;
            }
            if let Some(sid) = line.split_whitespace().nth(0) {
                if Self::is_active(sid)? {
                    if Self::get_display_server_of_session(sid) == ENV_DESKTOP_PROTOCAL__X11 {
                        if let Some(uid) = line.split_whitespace().nth(1) {
                            self.uid = uid.to_owned();
                        }
                        if let Some(u) = line.split_whitespace().nth(2) {
                            self.username = u.to_owned();
                        }

                        self.protocal = Protocal::X11;
                    }
                }
            }
        }
        // // set active xfce4 session
        // for line in String::from_utf8_lossy(&output.stdout).lines() {
        //     if let Some(sid) = line.split_whitespace().nth(0) {
        //         if Self::is_active(sid)? {
        //             let tty_output = Command::new("loginctl")
        //                 .args(vec!["show-session", "-p", "TTY", sid])
        //                 .output()?;
        //             let tty: String = String::from_utf8_lossy(&tty_output.stdout)
        //                 .replace("TTY=", "")
        //                 .trim_end()
        //                 .into();

        //             let xfce_panel_info =
        //                 run_cmds(format!("ps -e | grep \"{}.\\\\+{}\"", tty, XFCE4_PANEL))?;
        //             if xfce_panel_info.trim_end().to_string() != "" {
        //                 if let Some(uid) = line.split_whitespace().nth(1) {
        //                     self.uid = uid.to_owned();
        //                 }
        //                 if let Some(u) = line.split_whitespace().nth(2) {
        //                     self.username = u.to_owned();
        //                 }
        //             }
        //         }
        //     }
        // }
        Ok(self.is_ready())
    }

    // fixme: dup
    fn get_display_server_of_session(session: &str) -> String {
        if let Ok(output) = Command::new("loginctl")
            .args(vec!["show-session", "-p", "Type", session])
            .output()
        // Check session type of the session
        {
            let display_server = String::from_utf8_lossy(&output.stdout)
                .replace("Type=", "")
                .trim_end()
                .into();
            if display_server == "tty" {
                // If the type is tty...
                if let Ok(output) = Command::new("loginctl")
                    .args(vec!["show-session", "-p", "TTY", session])
                    .output()
                // Get the tty number
                {
                    let tty: String = String::from_utf8_lossy(&output.stdout)
                        .replace("TTY=", "")
                        .trim_end()
                        .into();
                    if let Ok(xorg_results) =
                        run_cmds(format!("ps -e | grep \"{}.\\\\+Xorg\"", tty))
                    // And check if Xorg is running on that tty
                    {
                        if xorg_results.trim_end().to_string() != "" {
                            // If it is, manually return "x11", otherwise return tty
                            ENV_DESKTOP_PROTOCAL__X11.to_owned()
                        } else {
                            display_server
                        }
                    } else {
                        // If any of these commands fail just fall back to the display server
                        display_server
                    }
                } else {
                    display_server
                }
            } else {
                // If the session is not a tty, then just return the type as usual
                display_server
            }
        } else {
            "".to_owned()
        }
    }

    // fixme: remove
    fn is_active(sid: &str) -> ResultType<bool> {
        let output = Command::new("loginctl")
            .args(vec!["show-session", "-p", "State", sid])
            .output()?;

        Ok(String::from_utf8_lossy(&output.stdout).contains("active"))
    }

    fn get_display_by_user(user: &str) -> String {
        // log::debug!("w {}", &user);
        if let Ok(output) = std::process::Command::new("w").arg(&user).output() {
            for line in String::from_utf8_lossy(&output.stdout).lines() {
                let mut iter = line.split_whitespace();
                let b = iter.nth(2);
                if let Some(b) = b {
                    if b.starts_with(":") {
                        return b.to_owned();
                    }
                }
            }
        }
        // above not work for gdm user
        //log::debug!("ls -l /tmp/.X11-unix/");
        let mut last = "".to_owned();
        if let Ok(output) = std::process::Command::new("ls")
            .args(vec!["-l", "/tmp/.X11-unix/"])
            .output()
        {
            for line in String::from_utf8_lossy(&output.stdout).lines() {
                let mut iter = line.split_whitespace();
                let user_field = iter.nth(2);
                if let Some(x) = iter.last() {
                    if x.starts_with("X") {
                        last = x.replace("X", ":").to_owned();
                        if user_field == Some(&user) {
                            return last;
                        }
                    }
                }
            }
        }
        last
    }

    fn add_xauth_cookie(
        file: &str,
        display: &str,
        uid: u32,
        gid: u32,
        envs: &HashMap<&str, String>,
    ) -> ResultType<()> {
        let randstr = (0..16)
            .map(|_| format!("{:02x}", random::<u8>()))
            .collect::<String>();
        let output = Command::new("xauth")
            .uid(uid)
            .gid(gid)
            .envs(envs)
            .args(vec!["-q", "-f", file, "add", display, ".", &randstr])
            .output()?;
        // xauth run success, even the following error occurs.
        // Ok(Output { status: ExitStatus(unix_wait_status(0)), stdout: "", stderr: "xauth:  file .Xauthority does not exist\n" })
        let errmsg = String::from_utf8_lossy(&output.stderr).to_string();
        if !errmsg.is_empty() {
            if !errmsg.contains("does not exist") {
                bail!("Failed to launch xauth, {}", errmsg)
            }
        }
        Ok(())
    }

    fn wait_x_server_running(pid: u32, display_num: u32, max_wait_secs: u64) -> ResultType<()> {
        let wait_begin = Instant::now();
        loop {
            if run_cmds(format!("ls /proc/{}", pid))?.is_empty() {
                bail!("X server exit");
            }

            if Self::is_x_server_running(display_num) {
                return Ok(());
            }
            if wait_begin.elapsed().as_secs() > max_wait_secs {
                bail!("Failed to wait xserver after {} seconds", max_wait_secs);
            }
            std::thread::sleep(Duration::from_millis(300));
        }
    }

    fn refresh(&mut self) -> ResultType<bool> {
        *self = Self::new();
        if self.get_env_seat0()? || self.get_env_active()? {
            self.get_display();
            self.get_xauth();
            Ok(true)
        } else {
            Ok(false)
        }
    }
}

impl Drop for Desktop {
    fn drop(&mut self) {
        self.stop_children();
    }
}

impl Desktop {
    fn fatal_exit() {
        std::process::exit(0);
    }

    pub fn new() -> Self {
        Self {
            env: DesktopEnv::new(),
            child_exit: Arc::new(AtomicBool::new(true)),
            is_child_running: Arc::new(AtomicBool::new(false)),
        }
    }

    fn try_start_x_session(&mut self, username: &str, password: &str) -> ResultType<()> {
        match get_user_by_name(username) {
            Some(userinfo) => {
                let mut client = pam::Client::with_password(pam_get_service_name())?;
                client
                    .conversation_mut()
                    .set_credentials(username, password);
                match client.authenticate() {
                    Ok(_) => {
                        if self.env.is_ready() && self.env.username == username {
                            return Ok(());
                        }

                        self.env.username = username.to_string();
                        self.env.uid = userinfo.uid().to_string();
                        self.env.protocal = Protocal::Unknown;
                        match self.start_x_session(&userinfo, password) {
                            Ok(_) => {
                                log::info!("Succeeded to start x11, update env {:?}", &self.env);
                                self.env.update_env();
                                Ok(())
                            }
                            Err(e) => {
                                self.env = DesktopEnv::new();
                                self.env.update_env();
                                bail!("failed to start x session, {}", e);
                            }
                        }
                    }
                    Err(e) => {
                        bail!("failed to check user pass for {}, {}", username, e);
                    }
                }
            }
            None => {
                bail!("failed to get userinfo of {}", username);
            }
        }
    }

    fn start_x_session(&mut self, userinfo: &User, password: &str) -> ResultType<()> {
        self.stop_children();

        let display_num = DesktopEnv::get_avail_display()?;
        // "xServer_ip:display_num.screen_num"
        self.env.display = format!(":{}", display_num);

        let uid = userinfo.uid();
        let gid = userinfo.primary_group_id();
        let envs = HashMap::from([
            ("SHELL", userinfo.shell().to_string_lossy().to_string()),
            ("PATH", "/sbin:/bin:/usr/bin:/usr/local/bin".to_owned()),
            ("USER", self.env.username.clone()),
            ("UID", userinfo.uid().to_string()),
            ("HOME", userinfo.home_dir().to_string_lossy().to_string()),
            (
                "XDG_RUNTIME_DIR",
                format!("/run/user/{}", userinfo.uid().to_string()),
            ),
            // ("DISPLAY", self.display.clone()),
            // ("XAUTHORITY", self.xauth.clone()),
            // (ENV_DESKTOP_PROTOCAL, XProtocal::X11.to_string()),
        ]);
        let env = self.env.clone();
        self.child_exit.store(false, Ordering::SeqCst);
        let is_child_running = self.is_child_running.clone();

        let (tx_res, rx_res) = sync_channel(1);
        let password = password.to_string();
        // start x11
        std::thread::spawn(move || {
            match Self::start_x_session_thread(
                tx_res.clone(),
                is_child_running,
                env,
                uid,
                gid,
                display_num,
                password,
                envs,
            ) {
                Ok(_) => {}
                Err(e) => {
                    log::error!("Failed to start x session thread");
                    allow_err!(tx_res.send(format!("Failed to start x session thread, {}", e)));
                }
            }
        });

        // wait x11
        match rx_res.recv_timeout(Duration::from_millis(10_000)) {
            Ok(res) => {
                if res == "" {
                    self.env.protocal = Protocal::X11;
                    Ok(())
                } else {
                    bail!(res)
                }
            }
            Err(e) => {
                bail!("Failed to recv x11 result {}", e)
            }
        }
    }

    fn start_x_session_thread(
        tx_res: SyncSender<String>,
        is_child_running: Arc<AtomicBool>,
        env: DesktopEnv,
        uid: u32,
        gid: u32,
        display_num: u32,
        password: String,
        envs: HashMap<&str, String>,
    ) -> ResultType<()> {
        let mut client = pam::Client::with_password(pam_get_service_name())?;
        client
            .conversation_mut()
            .set_credentials(&env.username, &password);
        client.authenticate()?;

        client.set_item(pam::PamItemType::TTY, &env.display)?;
        client.open_session()?;

        // fixme: FreeBSD kernel needs to login here.
        // see: https://github.com/neutrinolabs/xrdp/blob/a64573b596b5fb07ca3a51590c5308d621f7214e/sesman/session.c#L556

        let (child_xorg, child_wm) = Self::start_x11(&env, uid, gid, display_num, &envs)?;
        is_child_running.store(true, Ordering::SeqCst);

        log::info!("Start xorg and wm done, notify and wait xtop x11");
        allow_err!(tx_res.send("".to_owned()));

        Self::wait_stop_x11(child_xorg, child_wm);
        log::info!("Wait x11 stop done");
        Ok(())
    }

    fn wait_xorg_exit(child_xorg: &mut Child) -> ResultType<String> {
        if let Ok(_) = child_xorg.kill() {
            for _ in 0..3 {
                match child_xorg.try_wait() {
                    Ok(Some(status)) => return Ok(format!("Xorg exit with {}", status)),
                    Ok(None) => {}
                    Err(e) => {
                        // fatal error
                        log::error!("Failed to wait xorg process, {}", e);
                        bail!("Failed to wait xorg process, {}", e)
                    }
                }
                std::thread::sleep(std::time::Duration::from_millis(1_000));
            }
            log::error!("Failed to wait xorg process, not exit");
            bail!("Failed to wait xorg process, not exit")
        } else {
            Ok("Xorg is already exited".to_owned())
        }
    }

    fn start_x11(
        env: &DesktopEnv,
        uid: u32,
        gid: u32,
        display_num: u32,
        envs: &HashMap<&str, String>,
    ) -> ResultType<(Child, Child)> {
        log::debug!("envs of user {}: {:?}", &env.username, &envs);

        DesktopEnv::add_xauth_cookie(&env.xauth, &env.display, uid, gid, &envs)?;

        // Start Xorg
        let mut child_xorg = Self::start_x_server(&env.xauth, &env.display, uid, gid, &envs)?;

        log::info!("xorg started, wait 10 secs to ensuer x server is running");

        let max_wait_secs = 10;
        // wait x server running
        if let Err(e) =
            DesktopEnv::wait_x_server_running(child_xorg.id(), display_num, max_wait_secs)
        {
            match Self::wait_xorg_exit(&mut child_xorg) {
                Ok(msg) => log::info!("{}", msg),
                Err(e) => {
                    log::error!("{}", e);
                    Self::fatal_exit();
                }
            }
            bail!(e)
        }

        log::info!(
            "xorg is running, start x window manager with DISPLAY: {}, XAUTHORITY: {}",
            &env.display,
            &env.xauth
        );

        std::env::set_var("DISPLAY", &env.display);
        std::env::set_var("XAUTHORITY", &env.xauth);
        // start window manager (startwm.sh)
        let child_wm = match Self::start_x_window_manager(uid, gid, &envs) {
            Ok(c) => c,
            Err(e) => {
                match Self::wait_xorg_exit(&mut child_xorg) {
                    Ok(msg) => log::info!("{}", msg),
                    Err(e) => {
                        log::error!("{}", e);
                        Self::fatal_exit();
                    }
                }
                bail!(e)
            }
        };
        log::info!("x window manager is started");

        Ok((child_xorg, child_wm))
    }

    fn try_wait_x11_child_exit(child_xorg: &mut Child, child_wm: &mut Child) -> bool {
        match child_xorg.try_wait() {
            Ok(Some(status)) => {
                println!(
                    "=============================MYDEBUG Xorg exit with {}",
                    status
                );
                log::info!("Xorg exit with {}", status);
                return true;
            }
            Ok(None) => {}
            Err(e) => log::error!("Failed to wait xorg process, {}", e),
        }

        match child_wm.try_wait() {
            Ok(Some(status)) => {
                println!(
                    "=============================MYDEBUG: wm exit with {}",
                    status
                );
                log::info!("wm exit with {}", status);
                return true;
            }
            Ok(None) => {}
            Err(e) => log::error!("Failed to wait xorg process, {}", e),
        }
        false
    }

    fn wait_x11_children_exit(child_xorg: &mut Child, child_wm: &mut Child) {
        log::debug!("Try kill child process xorg");
        if let Ok(_) = child_xorg.kill() {
            let mut exited = false;
            for _ in 0..2 {
                match child_xorg.try_wait() {
                    Ok(Some(status)) => {
                        println!(
                            "=============================MYDEBUG Xorg exit with {}",
                            status
                        );
                        log::info!("Xorg exit with {}", status);
                        exited = true;
                        break;
                    }
                    Ok(None) => {}
                    Err(e) => {
                        println!(
                            "=============================MYDEBUG Failed to wait xorg process, {}",
                            &e
                        );
                        log::error!("Failed to wait xorg process, {}", e);
                        Self::fatal_exit();
                    }
                }
                std::thread::sleep(std::time::Duration::from_millis(1_000));
            }
            if !exited {
                println!(
                    "=============================MYDEBUG Failed to wait child xorg, after kill()"
                );
                log::error!("Failed to wait child xorg, after kill()");
                // try kill -9?
            }
        }
        log::debug!("Try kill child process wm");
        if let Ok(_) = child_wm.kill() {
            let mut exited = false;
            for _ in 0..2 {
                match child_wm.try_wait() {
                    Ok(Some(status)) => {
                        println!(
                            "=============================MYDEBUG wm exit with {}",
                            status
                        );
                        log::info!("wm exit with {}", status);
                        exited = true;
                    }
                    Ok(None) => {}
                    Err(e) => {
                        println!(
                            "=============================MYDEBUG Failed to wait wm process, {}",
                            &e
                        );
                        log::error!("Failed to wait wm process, {}", e);
                        Self::fatal_exit();
                    }
                }
                std::thread::sleep(std::time::Duration::from_millis(1_000));
            }
            if !exited {
                println!(
                    "=============================MYDEBUG Failed to wait child xorg, after kill()"
                );
                log::error!("Failed to wait child xorg, after kill()");
                // try kill -9?
            }
        }
    }

    fn try_wait_stop_x11(child_xorg: &mut Child, child_wm: &mut Child) -> bool {
        let mut inst = DESKTOP_INST.lock().unwrap();
        let mut exited = true;
        if let Some(inst) = &mut (*inst) {
            if inst.child_exit.load(Ordering::SeqCst) {
                exited = true;
            } else {
                exited = Self::try_wait_x11_child_exit(child_xorg, child_wm);
            }
            if exited {
                println!("=============================MYDEBUG begin to wait x11 children exit");
                Self::wait_x11_children_exit(child_xorg, child_wm);
                inst.is_child_running.store(false, Ordering::SeqCst);
                inst.child_exit.store(true, Ordering::SeqCst);
            }
        }
        exited
    }

    fn wait_stop_x11(mut child_xorg: Child, mut child_wm: Child) {
        loop {
            if Self::try_wait_stop_x11(&mut child_xorg, &mut child_wm) {
                break;
            }
            std::thread::sleep(Duration::from_millis(super::SERVICE_INTERVAL));
        }
    }

    fn get_xorg() -> ResultType<&'static str> {
        // Fedora 26 or later
        let xorg = "/usr/libexec/Xorg";
        if Path::new(xorg).is_file() {
            return Ok(xorg);
        }
        // Debian 9 or later
        let xorg = "/usr/lib/xorg/Xorg";
        if Path::new(xorg).is_file() {
            return Ok(xorg);
        }
        // Ubuntu 16.04 or later
        let xorg = "/usr/lib/xorg/Xorg";
        if Path::new(xorg).is_file() {
            return Ok(xorg);
        }
        // Arch Linux
        let xorg = "/usr/lib/xorg-server/Xorg";
        if Path::new(xorg).is_file() {
            return Ok(xorg);
        }
        // Arch Linux
        let xorg = "/usr/lib/Xorg";
        if Path::new(xorg).is_file() {
            return Ok(xorg);
        }
        // CentOS 7 /usr/bin/Xorg or param=Xorg

        log::warn!("Failed to find xorg, use default Xorg.\n Please add \"allowed_users=anybody\" to \"/etc/X11/Xwrapper.config\".");
        Ok("Xorg")
    }

    fn start_x_server(
        xauth: &str,
        display: &str,
        uid: u32,
        gid: u32,
        envs: &HashMap<&str, String>,
    ) -> ResultType<Child> {
        let xorg = Self::get_xorg()?;
        log::info!("Use xorg: {}", &xorg);
        match Command::new(xorg)
            .envs(envs)
            .uid(uid)
            .gid(gid)
            .args(vec![
                "-noreset",
                "+extension",
                "GLX",
                "+extension",
                "RANDR",
                "+extension",
                "RENDER",
                //"-logfile",
                //"/tmp/RustDesk_xorg.log",
                "-config",
                "rustdesk/xorg.conf",
                "-auth",
                xauth,
                display,
            ])
            .spawn()
        {
            Ok(c) => Ok(c),
            Err(e) => {
                bail!("Failed to start Xorg with display {}, {}", display, e);
            }
        }
    }

    fn start_x_window_manager(
        uid: u32,
        gid: u32,
        envs: &HashMap<&str, String>,
    ) -> ResultType<Child> {
        match Command::new("/etc/rustdesk/startwm.sh")
            .envs(envs)
            .uid(uid)
            .gid(gid)
            .spawn()
        {
            Ok(c) => Ok(c),
            Err(e) => {
                bail!("Failed to start window manager, {}", e);
            }
        }
    }

    fn stop_children(&mut self) {
        self.child_exit.store(true, Ordering::SeqCst);
        for _i in 1..10 {
            if !self.is_child_running.load(Ordering::SeqCst) {
                break;
            }
            std::thread::sleep(Duration::from_millis(super::SERVICE_INTERVAL));
        }
        if self.is_child_running.load(Ordering::SeqCst) {
            log::warn!("xdesktop child is still running!");
        }
    }
}

fn pam_get_service_name() -> &'static str {
    if Path::new("/etc/pam.d/rustdesk").is_file() {
        "rustdesk"
    } else {
        "gdm"
    }
}

impl ToString for Protocal {
    fn to_string(&self) -> String {
        match self {
            Protocal::X11 => ENV_DESKTOP_PROTOCAL__X11.to_owned(),
            Protocal::Wayland => ENV_DESKTOP_PROTOCAL_WAYLAND.to_owned(),
            Protocal::Unknown => ENV_DESKTOP_PROTOCAL_UNKNOWN.to_owned(),
        }
    }
}