roundabout

use std::{

    fs::{self, File, OpenOptions},

    io,

    os::unix::{fs::OpenOptionsExt, net::UnixStream, process::CommandExt},

    process::{Command, Stdio},

    thread,

    time::Duration,

};

use crate::paths;

pub struct Flock(File);

impl Flock {

    pub fn exclusive(file: File) -> io::Result<Self> {

        use std::os::fd::AsRawFd;

        if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX) } != 0 {

            return Err(io::Error::last_os_error());

        }

        Ok(Self(file))

    }

    pub fn try_exclusive(file: File) -> Option<Self> {

        use std::os::fd::AsRawFd;

        (unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } == 0)

            .then_some(Self(file))

    }

}

impl Drop for Flock {

    fn drop(&mut self) {

        use std::os::fd::AsRawFd;

        unsafe { libc::flock(self.0.as_raw_fd(), libc::LOCK_UN) };

    }

}

pub fn spawn_lock() -> io::Result<Flock> {

    let file = OpenOptions::new()

        .create(true)

        .truncate(false)

        .write(true)

        .mode(0o600)

        .open(paths::spawn_lock())?;

    Flock::exclusive(file)

}

pub fn connect() -> Option<UnixStream> {

    UnixStream::connect(paths::socket()).ok()

}

pub fn connect_or_spawn() -> io::Result<UnixStream> {

    if let Some(s) = connect() {

        return Ok(s);

    }

    let _lock = spawn_lock()?;

    if let Some(s) = connect() {

        return Ok(s);

    }

    let _ = fs::remove_file(paths::socket());

    let log = OpenOptions::new()

        .create(true)

        .append(true)

        .open(paths::state_dir().join("daemon.log"))?;

    let mut cmd = Command::new(std::env::current_exe()?);

    cmd.arg("daemon")

        .stdin(Stdio::null())

        .stdout(Stdio::null())

        .stderr(log);

    unsafe {

        cmd.pre_exec(|| {

            libc::setsid();

            Ok(())

        });

    }

    let mut child = cmd.spawn()?;

    for _ in 0..200 {

        if let Some(s) = connect() {

            let _ = child.wait();

            return Ok(s);

        }

        if let Ok(Some(status)) = child.try_wait()

            && !status.success()

        {

            return Err(io::Error::other(format!(

                "daemon died on startup ({status}), see {}",

                paths::state_dir().join("daemon.log").display()

            )));

        }

        thread::sleep(Duration::from_millis(10));

    }

    Err(io::Error::other("daemon never showed up"))

}