mod xsetroot;

use chrono::prelude::*;
use std::fmt;
use std::io::prelude::*;
use std::io::BufReader;
use std::sync::{Arc, Mutex};
use std::thread;
use std::os::unix::net::{UnixStream, UnixListener};
use xsetroot::XSetRoot;

type MTState = Arc<Mutex<State>>;

fn handle_client(stream: UnixStream, st: MTState) {
    let mut rdr = BufReader::new(&stream);
    let mut msg = String::new();
    let _ = rdr.read_line(&mut msg);
    let _ = write!(&stream, "OK");

    let mut data = st.lock().unwrap();
    data.msg = msg;
    data.show();
}

fn main() -> std::io::Result::<()> {
    let mut st: State = State::init();
    st.msg = "coi rodo .ui.".to_string();
    st.show();
    let mtst = Arc::new(Mutex::new(st));

    let listener = UnixListener::bind("/home/cadey/tmp/cabytcini.sock")?;
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                thread::spawn(|| handle_client(stream, mtst.clone()));
            },
            Err(err) => {
                break;
            },
        }
    }

    Ok(())
}

struct State {
    msg: String,
}

impl fmt::Display for State {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.msg)
    }
}

impl State {
    fn init() -> State {
        State {
            msg: "".to_string(),
        }
    }

    fn show(&self) {
        let now = Local::now();
        let xsr = XSetRoot::init();
        xsr.render(format!("{} | {}", self, now.format("%H:%M M%m %-d %a")));
    }
}