use std::error;
use std::io::{Read,Write};
use std::os::unix::net::{UnixStream,UnixListener};
use std::str;
use std::sync::{Arc,Mutex};
use std::thread::{sleep,spawn};
use std::time::{Duration,Instant,SystemTime};

use clap::Parser;
use serde::{Serialize,Deserialize};

#[derive(Parser)]
struct Cli {
    #[arg(short='d', long)]
    daemon: bool,
    #[arg(short='v', long)]
    verbose: bool,
    #[arg(short='D', long, default_value="10")]
    delay: u64,
    #[arg(short='s', long, default_value="varanus.sock")]
    socket: String,
}

#[derive(Serialize, Deserialize)]
struct Battery {
}

#[derive(Serialize, Deserialize)]
struct Power {
}

#[derive(Serialize, Deserialize)]
struct Process {
    power: Power,
}

#[derive(Serialize, Deserialize)]
struct State {
    asof: SystemTime,
}

type Result<T> = std::result::Result<T, Box<dyn error::Error>>;

fn init_state() -> State {
    let asof = SystemTime::now();
    return State {
        asof: asof,
    }
}

fn update_state(state: &mut State) {
    let asof = SystemTime::now();
    state.asof = asof;
}

fn get_state(sockfile: String) -> Result<State> {
    let mut socket = UnixStream::connect(sockfile)?;
    let mut buf = vec![];
    socket.read_to_end(&mut buf)?;
    Ok(serde_json::from_str::<State>(str::from_utf8(&buf)?)?)
}

fn main() {
    let args = Cli::parse();
    if args.daemon {
        let start = Instant::now();
        let delay_ms: u64 = args.delay * 1000;
        let mut cycle: u64 = 0;
        let state_mutex = Arc::new(Mutex::new(init_state()));
        let listen_thread = {
            let state_mutex = Arc::clone(&state_mutex);
            spawn(move || {
                let listener = UnixListener::bind(args.socket).unwrap();
                loop {
                    match listener.accept() {
                        Ok((mut socket,accept)) => {
                            let json = {
                                let state = state_mutex.lock().unwrap();
                                serde_json::to_string(&*state).unwrap()
                            };
                            socket.write_all(json.as_bytes()).unwrap();
                        },
                        Err(e) => println!("error: {:?}", e)
                    }
                }
            });
        };
        loop {
            cycle += 1;
            sleep(Duration::from_millis(cycle*delay_ms) - start.elapsed());
            if args.verbose {
                println!("{:?} elapsed; updating state...", start.elapsed());
            }
            {
                let mut state = state_mutex.lock().unwrap();
                update_state(&mut state);
            }
        }
    } else {
        let state = get_state(args.socket).unwrap();
    }
}