use anyhow::Result;
use log::*;
use std::{
    io::{prelude::*, BufReader},
    net::Shutdown,
    os::unix::net::{UnixListener, UnixStream},
    sync::{Arc, Mutex},
    thread, time,
};

use cabytcini::*;

pub 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.trim().to_string();
    info!("new message: {}", data.msg);
    stream.shutdown(Shutdown::Both).expect("socket to close");
}

const UPDATE_FREQUENCY: u64 = 15000;

fn update_every_so_often(st: MTState) {
    loop {
        let so_often = time::Duration::from_millis(UPDATE_FREQUENCY);
        thread::sleep(so_often);

        {
            let data = st.lock().unwrap();
            data.xsetroot();
        }
    }
}

fn main() -> Result<()> {
    let st: State = State::init();
    st.xsetroot();
    let mtst = Arc::new(Mutex::new(st));
    env_logger::init();
    let cfg = config::load()?;

    // start update thread
    {
        let mtst = mtst.clone();
        thread::spawn(move || update_every_so_often(mtst));
    }

    // start front thread
    {
        let mtst = mtst.clone();
        let cfg = cfg.clone();
        thread::spawn(move || front::update(mtst, cfg));
    }

    // start weather thread
    {
        let mtst = mtst.clone();
        let cfg = cfg.clone();
        thread::spawn(move || weather::update(mtst, cfg));
    }

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

    Ok(())
}