// CSRF protection
// https://github.com/heartsucker/iron-csrf
extern crate iron;
#[macro_use]
extern crate log;
#[macro_use]
extern crate router;
extern crate env_logger;
extern crate systemhttp;
extern crate iron_sessionstorage;
extern crate staticfile;

use iron_sessionstorage::traits::*;
use iron_sessionstorage::SessionStorage;
use iron_sessionstorage::backends::SignedCookieBackend;
use iron::status;
use iron::modifiers::Header;
use iron::headers::ContentType;
use iron::{Iron, Request, IronResult, Response, Chain};
use router::Router;
use systemhttp::systemd::unit;
use systemhttp::render;
use staticfile::Static;

struct Aaa(String);

impl iron_sessionstorage::Value for Aaa {
    fn get_key() -> &'static str {
        "aaa"
    }
    fn into_raw(self) -> String {
        self.0
    }
    fn from_raw(v: String) -> Option<Self> {
        Some(Aaa(v))
    }
}


fn hello(r: &mut Request) -> IronResult<Response> {
    let mut _value = match try!(r.session().get::<Aaa>()) {
        Some(aaa) => aaa,
        None => Aaa("".to_owned()),
    };

    let name = r.extensions
        .get::<Router>()
        .unwrap()
        .find("name")
        .unwrap_or("World").to_owned();

    let units = unit::get_units().unwrap();

    let sections = ["service", "timer", "socket", "target", "slice", "mount",
                    "path"];
    let units_by_section = sections.iter().map(|&s| {
        (s.to_owned(),
         units.iter().filter(|&u| &u.type_ == s).collect::<Vec<&unit::Unit>>())
    }).collect::<Vec<_>>();

    // let res = Ok(Response::with((status::Ok,
    //                              Header(ContentType::html()),
    //                              render_message(&format!("Hello, {} ({})",
    //                                                      name,
    //                                                      session_value.0),
    //                                             &units))));

    // info!("Updating session value. Current value: {}", session_value.0);
    // session_value.0.push('a');
    // try!(r.session().set(session_value));
    Ok(Response::with((status::Ok,
                       Header(ContentType::html()),
                       render::system_status(&units_by_section))))
}

fn main() {

    env_logger::init().unwrap();
    let secret = b"secret2".to_vec();
    let router = router!(
        root: get "/" => hello,
        name: get "/:name" => hello,
        css: get "/static/main.css" => Static::new(""),
    );
    let mut chain = Chain::new(router);
    chain.link_around(SessionStorage::new(SignedCookieBackend::new(secret)));
    let _server = Iron::new(chain).http(":::8080").unwrap();
    println!("On 8080");
}