mod config;
mod api;

use launchy::{self, Canvas, CanvasLayout, CanvasLayoutPoller, MsgPollingWrapper, Pad};
use launchy::{Color};
use config::Config;
use serde_json::Value;


pub fn main() {
    let (mut canvas, mut poller) = initpad();
    let mut cfg = config::read("config.json");
    get_zabbix_authtoken(&mut cfg);
    get_zabbix_problems(&mut cfg);
    clear(&mut canvas);
    testinput(&mut canvas, &mut poller);
}

pub fn get_zabbix_authtoken(cfg: &mut Config) {
    let body = api::query_auth_token(&cfg.username, &cfg.password);
    let response = reqwest::blocking::Client::new()
                                .post(&cfg.server)
                                .json(&body)
                                .send()
                                .unwrap();

    let values: Value = response
                                .json()
                                .unwrap();
    cfg.authtoken = values["result"].as_str().unwrap().to_string();
    //cfg.save("config.json");
}

fn get_zabbix_problems(cfg: &mut Config) {
    let body = api::query_problems(&cfg.authtoken, Some(cfg.limit));
    let response = reqwest::blocking::Client::new()
                                .post(&cfg.server)
                                .json(&body)
                                .send()
                                .unwrap();

    let values: Value = response
                                .json()
                                .unwrap();
    for i in values["result"].as_array().unwrap() {
        println!("{}", i);
    };
}

fn initpad() -> (CanvasLayout<'static>, CanvasLayoutPoller) {
    let (mut canvas, poller) = launchy::CanvasLayout::new_polling();
    canvas.add_by_guess_rotated::<launchy::mini::Canvas>(10, 18, launchy::Rotation::UpsideDown).unwrap();
    (canvas, poller)
}

fn testinput(canvas: &mut CanvasLayout, poller: &mut CanvasLayoutPoller) {
    for color in (0u64..).map(|f| Color::red_green_color(f as f32 / 60.0 / 2.5)) {
        for msg in poller.iter_for_millis(17).filter(|msg| msg.is_press()) {
            canvas[msg.pad()] = color;
            println!("{:?}", msg.pad())
        }
        let _res =canvas.flush();
    
        canvas.iter().for_each(|pad| {
            let surrounding_color = pad.neighbors_5().iter()
                    .map(|&p| canvas.get(p).unwrap_or(Color::GREEN))
                    .sum::<Color>() / 5.0 / 1.05;
    
            canvas[pad] = canvas[pad].mix(surrounding_color, 0.4);
        });
    }
}


fn clear(canvas: &mut CanvasLayout) {
    for a in 3..11 {
        for b in 10..18 {
            canvas[Pad { x: a, y: b }] = Color{r: 0f32, g: 0f32, b:1f32};
        }
    }
    let _res =canvas.flush();
}