use std::thread::sleep;
use std::time::{Duration,Instant,SystemTime};
use std::os::unix::net::{UnixStream,UnixListener};

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,
}

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

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

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

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

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 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 mut state = init_state();
        loop {
            cycle += 1;
            sleep(Duration::from_millis(cycle*delay_ms) - start.elapsed());
            if args.verbose {
                println!("{:?} elapsed; updating state...", start.elapsed());
            }
            update_state(&mut state);
        }
    } else {
    }
}