roundabout

use std::{

    io::{self, BufRead, BufReader, Write},

    os::unix::net::UnixStream,

    path::PathBuf,

};

use serde::{Deserialize, Serialize, de::DeserializeOwned};

use crate::{

    sched::{Need, Reason},

    units::{Bytes, Dur},

};

pub type LeaseId = u64;

#[derive(Clone, Debug, Serialize, Deserialize)]

pub struct Acquire {

    pub need: Need,

    pub cwd: PathBuf,

    pub cmd: Vec<String>,

    pub session: Option<String>,

    pub deadline: Option<Dur>,

    #[serde(default)]

    pub exact: bool,

}

#[derive(Debug, Serialize, Deserialize)]

#[serde(tag = "op", rename_all = "snake_case")]

pub enum Request {

    /// `None` withdraws it

    Expect {

        session: String,

        need: Option<Need>,

    },

    Acquire(Acquire),

    Started {

        pid: i32,

    },

    Usage {

        rss: Bytes,

    },

    Done,

    Status,

    Kill {

        lease: LeaseId,

    },

    Extend {

        lease: LeaseId,

        by: Dur,

    },

    Watch {

        lease: LeaseId,

    },

    Overdue {

        session: String,

    },

}

#[derive(Clone, Debug, Serialize, Deserialize)]

pub struct LeaseInfo {

    pub id: LeaseId,

    pub cmd: Vec<String>,

    pub cwd: PathBuf,

    pub session: Option<String>,

    pub need: Need,

    pub heavy: bool,

    pub running: bool,

    #[serde(default)]

    pub granted: u32,

    /// seconds since queued or started, whichever it's doing

    pub elapsed: u64,

    pub rss: Bytes,

    pub overdue: bool,

    pub waiting: Option<Reason>,

    pub position: usize,

}

#[derive(Clone, Debug, Serialize, Deserialize)]

pub struct IntentInfo {

    pub session: String,

    pub need: Need,

    pub expires_in: u64,

}

#[derive(Debug, Serialize, Deserialize)]

pub struct Status {

    pub leases: Vec<LeaseInfo>,

    pub intents: Vec<IntentInfo>,

    pub ram_free: Bytes,

    pub ram_budget: Bytes,

    pub cores_free: u32,

    pub cores: u32,

}

#[derive(Debug, Serialize, Deserialize)]

#[serde(tag = "ev", rename_all = "snake_case")]

pub enum Event {

    Queued {

        lease: LeaseId,

        position: usize,

        reason: Option<Reason>,

    },

    Granted {

        lease: LeaseId,

        cores: u32,

        /// grows with any bonus cores, since more jobs means more ram

        ram: Bytes,

        heavy: bool,

    },

    Kill,

    Status(Status),

    Overdue {

        leases: Vec<LeaseInfo>,

    },

    Fired {

        overdue: bool,

    },

    Ok,

    Err {

        msg: String,

    },

}

pub fn send<T: Serialize>(stream: &mut UnixStream, msg: &T) -> io::Result<()> {

    let mut line = serde_json::to_vec(msg)?;

    line.push(b'\n');

    stream.write_all(&line)

}

pub struct Reader(BufReader<UnixStream>);

impl Reader {

    pub fn new(stream: &UnixStream) -> io::Result<Self> {

        Ok(Self(BufReader::new(stream.try_clone()?)))

    }

    /// `Ok(None)` on eof

    pub fn recv<T: DeserializeOwned>(&mut self) -> io::Result<Option<T>> {

        let mut line = String::new();

        if self.0.read_line(&mut line)? == 0 {

            return Ok(None);

        }

        serde_json::from_str(&line)

            .map(Some)

            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))

    }

}