use std::process::Command;
use std::fs::File;
use std::io::prelude::*;

extern crate toml;
extern crate websocket;
extern crate rustc_serialize;
use rustc_serialize::{Decodable};
use rustc_serialize::json::{Json, Decoder};

mod message;
use message::{Message, Push};

fn main() {
    use websocket::{Receiver};
    use websocket::client::request::Url;
    use websocket::Client;

    let mut cfg_file = File::open("config.toml").unwrap();
    let mut s = String::new();
    cfg_file.read_to_string(&mut s);
    let cfg = toml::Parser::new(s.as_ref()).parse().unwrap();
    let token = cfg.get("pushbullet").unwrap().as_table().unwrap().get("token").expect("Could not find 'token' in config.toml").as_str().unwrap();

    let wss_url = format!("wss://stream.pushbullet.com/websocket/{}", token);
    let url = Url::parse(wss_url.as_ref()).unwrap();
    let request = Client::connect(url).unwrap();
    let response = request.send().unwrap();
    response.validate().unwrap();

    let (mut sender, mut receiver) = response.begin().split();

    for message in receiver.incoming_messages() {
        let message = match message {
            Ok(m) => m,
            Err(e) => {
                println!("Error: {:?}", e);
                return;
            }
        };

        match message {
            websocket::Message::Close(_) => {
                return;
            }
            websocket::Message::Text(message) => {
                let json = Json::from_str(message.as_ref()).unwrap();
                let mut decoder = Decoder::new(json);
                let msg = Decodable::decode(&mut decoder).unwrap();
                println!("Got {:?}", msg);
                match msg {
                    Message::Nop => {}
                    Message::Push(Push::Mirror {
                        notification_id,
                        title,
                        body,
                        application_name,
                        ..
                    }) => {
                        let _ = Command::new("notify-send")
                            .arg(title)
                            .arg(body)
                            .arg("-t")
                            .arg("8000")
                            .status().unwrap();
                    }
                    Message::Push(Push::Dismissal { notification_id }) => {
                        
                    }
                }
            }
            _ => {
                println!("Got {:?}", message);
            }
        }
    }
}