extern crate bincode;
extern crate iron;
extern crate cookie;
extern crate rand;
extern crate r2d2;
extern crate r2d2_redis;
extern crate rustc_serialize;
extern crate redis;
#[macro_use]
extern crate log;

use iron::prelude::*;
use iron::middleware::{Handler, AroundMiddleware};
use iron::typemap::Key;
use cookie::Cookie;
use rand::random;
use rustc_serialize::{Encodable, Decodable};
use bincode::SizeLimit;
use bincode::rustc_serialize::{encode, decode};
use redis::{RedisResult, ToRedisArgs, FromRedisValue, RedisError, Value};
use std::sync::Arc;
use std::collections::HashMap;
use std::io::{Error, ErrorKind};
use std::default::Default;
use r2d2::{Pool, PooledConnection};
use r2d2_redis::RedisConnectionManager;

pub trait RequestSessionExt {
    fn get_session<'c, 'd, T: Decodable>(&'c mut self, key: &'d str) -> RedisResult<T>;
    fn remove_session<'c, 'd>(&'c mut self, key: &'d str) -> RedisResult<()>;
    fn set_session<'c, 'd, T: Encodable>(&'c mut self, key: &'d str, value: &T) -> RedisResult<()>;
    fn clear_session<'c, 'd>(&'c mut self) -> RedisResult<()>;
}

pub struct Session {
    cache: Arc<Cache>,
}

impl Session {
    pub fn new(signing_key: &str, expire_seconds: usize, connect_str: &str) -> Self {
        let cache = Cache {
            signing_key: Arc::new(String::from(signing_key).into_bytes()),
            expire_seconds: expire_seconds,
            pool: connect_pool(connect_str),
        };
        Session { cache: Arc::new(cache) }
    }
}
impl AroundMiddleware for Session {
    fn around(self, handler: Box<Handler>) -> Box<Handler> {
        Box::new(SessionHandler {
            cache: self.cache,
            handler: handler,
        }) as Box<Handler>
    }
}

struct Cache {
    expire_seconds: usize,
    signing_key: Arc<Vec<u8>>,
    pool: Pool<RedisConnectionManager>,
}

impl Cache {
    fn get_conn(&self) -> PooledConnection<RedisConnectionManager> {
        let conn = self.pool.get().unwrap();
        conn
    }

    fn refresh(&self, session_id: &str) -> RedisResult<()> {
        let conn = self.get_conn();
        let _: () =
            try!(redis::cmd("EXPIRE").arg(session_id).arg(self.expire_seconds).query(&*conn));
        Ok(())
    }
    fn set<T: Encodable>(&self, session_id: &str, key: &str, value: &T) -> RedisResult<()> {
        let conn = self.get_conn();
        let c = EncodeWrapper(value);
        let _: () = try!(redis::cmd("HSET").arg(session_id).arg(key).arg(c).query(&*conn));
        self.refresh(session_id)
    }

    fn get<T: Decodable>(&self, session_id: &str, key: &str) -> RedisResult<T> {
        let conn = self.get_conn();
        let t: DecodeWrapper<T> = try!(redis::cmd("HGET").arg(session_id).arg(key).query(&*conn));
        match self.refresh(session_id) {
            Ok(_) => Ok(t.0),
            Err(e) => Err(e),
        }
    }

    fn remove(&self, session_id: &str, key: &str) -> RedisResult<()> {
        let conn = self.get_conn();
        let _: () = try!(redis::cmd("HDEL").arg(session_id).arg(key).query(&*conn));
        self.refresh(session_id)
    }

    fn clear(&self, session_id: &str) -> RedisResult<()> {
        let conn = self.get_conn();
        let _: () = try!(redis::cmd("DEL").arg(session_id).query(&*conn));
        Ok(())
    }
}

fn connect_pool(connect_str: &str) -> Pool<RedisConnectionManager> {
    let cache = Default::default();
    info!("Connecting to {}", connect_str);
    let manager = RedisConnectionManager::new(connect_str).unwrap();
    match Pool::new(cache, manager) {
        Ok(pool) => {
            info!("Connected to redis with pool: {:?}", pool);
            return pool;
        }
        Err(err) => {
            panic!("Error occured when connectted to redis:{}. Error info:{}",
                   connect_str,
                   err);
        }
    };
}

impl<'a, 'b> RequestSessionExt for Request<'a, 'b> {
    fn get_session<'c, 'd, T: Decodable>(&'c mut self, key: &'d str) -> RedisResult<T> {
        let cache = self.extensions.get::<CacheKey>().unwrap();
        match self.extensions.get::<SessionKey>() {
            Some(session_id) => cache.get::<T>(session_id, key),
            None => Err(RedisError::from(Error::new(ErrorKind::Other, "no session id"))),
        }
    }
    fn set_session<'c, 'd, T: Encodable>(&'c mut self, key: &'d str, value: &T) -> RedisResult<()> {
        let cache = self.extensions.get::<CacheKey>().unwrap();
        match self.extensions.get::<SessionKey>() {
            Some(session_id) => cache.set(session_id, key, value),
            None => Err(RedisError::from(Error::new(ErrorKind::Other, "no session id"))),
        }
    }

    fn remove_session<'c, 'd>(&'c mut self, key: &'d str) -> RedisResult<()> {
        let cache = self.extensions.get::<CacheKey>().unwrap();
        match self.extensions.get::<SessionKey>() {
            Some(session_id) => cache.remove(session_id, key),
            None => Err(RedisError::from(Error::new(ErrorKind::Other, "no session id"))),
        }
    }

    fn clear_session<'c, 'd>(&'c mut self) -> RedisResult<()> {
        let cache = self.extensions.get::<CacheKey>().unwrap();
        match self.extensions.get::<SessionKey>() {
            Some(session_id) => cache.clear(session_id),
            None => Err(RedisError::from(Error::new(ErrorKind::Other, "no session id"))),
        }
    }
}

struct SessionKey;
impl Key for SessionKey {
    type Value = Arc<String>;
}
struct CacheKey;
impl Key for CacheKey {
    type Value = Arc<Cache>;
}

const COOKIE_SESSION_ID_KEY: &'static str = "RUSESSION";

struct SessionHandler<H: Handler> {
    cache: Arc<Cache>,
    handler: H,
}

impl<H: Handler> Handler for SessionHandler<H> {
    fn handle(&self, req: &mut Request) -> IronResult<Response> {
        let jar = match req.headers.get::<iron::headers::Cookie>() {
            Some(cookies) => cookies.to_cookie_jar(&self.cache.signing_key),
            None => cookie::CookieJar::new(&self.cache.signing_key),
        };

        let map: HashMap<String, cookie::Cookie> = jar.signed()
            .iter()
            .map(|c| (c.name.clone(), c))
            .collect();

        let session_id = match map.get(COOKIE_SESSION_ID_KEY) {
            Some(cookie) => cookie.value.clone(),
            None => rand_string(32),
        };

        req.extensions.insert::<SessionKey>(Arc::new(session_id.clone()));
        req.extensions.insert::<CacheKey>(self.cache.clone());
        match self.handler.handle(req) {
            Ok(mut res) => {
                let cookie = Cookie::new(COOKIE_SESSION_ID_KEY.to_owned(), session_id);
                let cookiejar = cookie::CookieJar::new(&self.cache.signing_key);
                cookiejar.signed().add(cookie);
                res.headers.set(iron::headers::SetCookie(cookiejar.delta()));
                Ok(res)
            }
            Err(e) => Err(e),
        }
    }
}

fn rand_string(length: u32) -> String {
    (0..length)
        .map(|_| {
            (((if random::<bool>() {
                65
            } else {
                97
            }) + random::<u32>() % (26)) as u8) as char
        })
        .collect()
}

struct EncodeWrapper<'a, T: 'a>(&'a T);
impl<'a, T: Encodable + 'a> ToRedisArgs for EncodeWrapper<'a, T> {
    fn to_redis_args(&self) -> Vec<Vec<u8>> {
        vec![encode(&self.0, SizeLimit::Infinite).unwrap()]
    }
}

struct DecodeWrapper<T>(T);
impl<T: Decodable> FromRedisValue for DecodeWrapper<T> {
    fn from_redis_value(v: &Value) -> RedisResult<DecodeWrapper<T>> {
        if let Value::Data(ref items) = *v {
            match decode(&items[..]) {
                Ok(decoded) => {
                    return Ok(DecodeWrapper(decoded));
                }
                Err(err) => {
                    panic!("erro read redis cache:{}", err);
                }
            }
        }
        Err(RedisError::from(Error::new(ErrorKind::Other, "no session found!")))
    }
}