use anyhow::Result;
use cabytcini::*;
use chrono::prelude::*;
use std::{
    sync::{Arc, Mutex},
    thread, time,
};

const UPDATE_FREQUENCY: u64 = 15000;

fn main() -> Result<()> {
    env_logger::init();

    println!(r#"{{ "version": 1 }}\n[[]"#);

    let st: State = State::init();
    let mtst = Arc::new(Mutex::new(st));
    let cfg = config::load()?;

    // 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));
    }

    thread::sleep(time::Duration::from_millis(750));

    loop {
        {
            let data = mtst.lock().unwrap();
            let mut blocks: Vec<Block> = vec![Block {
                full_text: data.front.clone(),
            }];

            if let Some(datni) = &data.weather {
                blocks.push(Block {
                    full_text: format!(
                        "{} {} / {} {}",
                        datni.currently.temperature,
                        datni.currently.summary,
                        datni.daily.data[0].temperature_high,
                        datni.daily.data[0].temperature_low
                    ),
                })
            }

            blocks.push(Block {
                full_text: Local::now().format("%H:%M M%m %-d %a").to_string(),
            });

            println!("{},", serde_json::to_string(&blocks)?);
        }

        let so_often = time::Duration::from_millis(UPDATE_FREQUENCY);
        thread::sleep(so_often);
    }
}