use hyper::header;
use rustc_serialize::json::Json;

use super::{Token, Lifetime};
use client::response::{FromResponse, ParseError, JsonHelper};

/// The bearer token type.
///
/// See [RFC 6750](http://tools.ietf.org/html/rfc6750).
#[derive(Debug, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable)]
pub struct Bearer<L: Lifetime> {
    access_token: String,
    scope: Option<String>,
    lifetime: L,
}

impl<L: Lifetime> Token<L> for Bearer<L> {
    fn access_token(&self) -> &str { &self.access_token }
    fn scope(&self) -> Option<&str> { self.scope.as_ref().map(|s| &s[..]) }
    fn lifetime(&self) -> &L { &self.lifetime }
}

impl<'a, L: Lifetime> Into<header::Authorization<header::Bearer>> for &'a Bearer<L> {
    fn into(self) -> header::Authorization<header::Bearer> {
        header::Authorization(header::Bearer { token: self.access_token.clone() })
    }
}

impl<L: Lifetime> Bearer<L> {
    fn from_response_and_lifetime(json: &Json, lifetime: L) -> Result<Self, ParseError> {
        let obj = try!(JsonHelper(json).as_object());

        let token_type = try!(obj.get_string("token_type"));
        if token_type != "Bearer" && token_type != "bearer" {
            return Err(ParseError::ExpectedFieldValue("token_type", "Bearer"));
        }

        let access_token = try!(obj.get_string("access_token"));
        let scope = obj.get_string_option("scope");

        Ok(Bearer {
            access_token: access_token.into(),
            scope: scope.map(Into::into),
            lifetime: lifetime,
        })
    }
}

impl<L: Lifetime> FromResponse for Bearer<L> {
    fn from_response(json: &Json) -> Result<Self, ParseError> {
        let lifetime = try!(FromResponse::from_response(json));
        Bearer::from_response_and_lifetime(json, lifetime)
    }

    fn from_response_inherit(json: &Json, prev: &Self) -> Result<Self, ParseError> {
        let lifetime = try!(FromResponse::from_response_inherit(json, &prev.lifetime));
        Bearer::from_response_and_lifetime(json, lifetime)
    }
}

#[cfg(feature = "serde")]
mod serde {
    use std::marker::PhantomData;

    use serde::{Serialize, Serializer, Deserialize, Deserializer};
    use serde::{ser, de};

    use token::Lifetime;
    use super::Bearer;

    impl<L: Lifetime + Serialize> Serialize for Bearer<L> {
        fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
            serializer.serialize_struct("Bearer", SerVisitor(self, 0))
        }
    }

    struct SerVisitor<'a, L: Lifetime + Serialize + 'a>(&'a Bearer<L>, u8);
    impl<'a, L: Lifetime + Serialize + 'a> ser::MapVisitor for SerVisitor<'a, L> {
        fn visit<S: Serializer>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error> {
            self.1 += 1;
            match self.1 {
                1 => serializer.serialize_struct_elt("access_token", &self.0.access_token).map(Some),
                2 => serializer.serialize_struct_elt("scope", &self.0.scope).map(Some),
                3 => serializer.serialize_struct_elt("lifetime", &self.0.lifetime).map(Some),
                _ => Ok(None),
            }
        }

        fn len(&self) -> Option<usize> { Some(3) }
    }

    impl<L: Lifetime + Deserialize> Deserialize for Bearer<L> {
        fn deserialize<D: Deserializer>(deserializer: &mut D) -> Result<Self, D::Error> {
            static FIELDS: &'static [&'static str] = &["access_token", "scope", "lifetime"];
            deserializer.deserialize_struct("Bearer", FIELDS, DeVisitor(PhantomData))
        }
    }

    struct DeVisitor<L: Lifetime + Deserialize>(PhantomData<L>);
    impl<L: Lifetime + Deserialize> de::Visitor for DeVisitor<L> {
        type Value = Bearer<L>;

        fn visit_map<V: de::MapVisitor>(&mut self, mut visitor: V) -> Result<Bearer<L>, V::Error> {
            let mut access_token = None;
            let mut scope = None;
            let mut lifetime = None;

            loop {
                match try!(visitor.visit_key()) {
                    Some(Field::AccessToken) => access_token = Some(try!(visitor.visit_value())),
                    Some(Field::Scope) => scope = Some(try!(visitor.visit_value())),
                    Some(Field::Lifetime) => lifetime = Some(try!(visitor.visit_value())),
                    None => break,
                }
            }

            let access_token = match access_token {
                Some(s) => s,
                None => return visitor.missing_field("access_token"),
            };
            let lifetime = match lifetime {
                Some(l) => l,
                None => return visitor.missing_field("lifetime"),
            };

            try!(visitor.end());

            Ok(Bearer {
                access_token: access_token,
                scope: scope,
                lifetime: lifetime,
            })
        }
    }

    enum Field {
        AccessToken,
        Scope,
        Lifetime,
    }

    impl Deserialize for Field {
        fn deserialize<D: Deserializer>(deserializer: &mut D) -> Result<Self, D::Error> {
            deserializer.deserialize(FieldVisitor)
        }
    }

    struct FieldVisitor;
    impl de::Visitor for FieldVisitor {
        type Value = Field;

        fn visit_str<E: de::Error>(&mut self, value: &str) -> Result<Field, E> {
            match value {
                "access_token" => Ok(Field::AccessToken),
                "scope" => Ok(Field::Scope),
                "lifetime" => Ok(Field::Lifetime),
                _ => Err(de::Error::custom("expected access_token, scope or lifetime")),
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use chrono::{UTC, Duration};
    use rustc_serialize::json::Json;

    use client::response::{FromResponse, ParseError};
    use token::{Static, Refresh};
    use super::Bearer;

    #[test]
    fn from_response_with_invalid_token_type() {
        let json = Json::from_str(r#"{"token_type":"MAC","access_token":"aaaaaaaa"}"#).unwrap();
        assert_eq!(
            ParseError::ExpectedFieldValue("token_type", "Bearer"),
            Bearer::<Static>::from_response(&json).unwrap_err()
        );
    }

    #[test]
    fn from_response_capital_b() {
        let json = Json::from_str(r#"{"token_type":"Bearer","access_token":"aaaaaaaa"}"#).unwrap();
        assert_eq!(
            Bearer {
                access_token: String::from("aaaaaaaa"),
                scope: None,
                lifetime: Static,
            },
            Bearer::<Static>::from_response(&json).unwrap()
        );
    }

    #[test]
    fn from_response_little_b() {
        let json = Json::from_str(r#"{"token_type":"bearer","access_token":"aaaaaaaa"}"#).unwrap();
        assert_eq!(
            Bearer {
                access_token: String::from("aaaaaaaa"),
                scope: None,
                lifetime: Static,
            },
            Bearer::<Static>::from_response(&json).unwrap()
        );
    }

    #[test]
    fn from_response_with_scope() {
        let json = Json::from_str(
            r#"{"token_type":"Bearer","access_token":"aaaaaaaa","scope":"foo"}"#
        ).unwrap();
        assert_eq!(
            Bearer {
                access_token: String::from("aaaaaaaa"),
                scope: Some(String::from("foo")),
                lifetime: Static,
            },
            Bearer::<Static>::from_response(&json).unwrap()
        );
    }

    #[test]
    fn from_response_refresh() {
        let json = Json::from_str(r#"
            {
                "token_type":"Bearer",
                "access_token":"aaaaaaaa",
                "expires_in":3600,
                "refresh_token":"bbbbbbbb"
            }
        "#).unwrap();
        let bearer = Bearer::<Refresh>::from_response(&json).unwrap();
        assert_eq!("aaaaaaaa", bearer.access_token);
        assert_eq!(None, bearer.scope);
        let refresh = bearer.lifetime;
        assert_eq!("bbbbbbbb", refresh.refresh_token());
        assert!(refresh.expires() > &UTC::now());
        assert!(refresh.expires() <= &(UTC::now() + Duration::seconds(3600)));
    }

    #[test]
    fn from_response_inherit_refresh() {
        let json = Json::from_str(r#"
            {
                "token_type":"Bearer",
                "access_token":"aaaaaaaa",
                "expires_in":3600,
                "refresh_token":"bbbbbbbb"
            }
        "#).unwrap();
        let prev = Bearer::<Refresh>::from_response(&json).unwrap();

        let json = Json::from_str(r#"
            {
                "token_type":"Bearer",
                "access_token":"cccccccc",
                "expires_in":3600
            }
        "#).unwrap();
        let bearer = Bearer::<Refresh>::from_response_inherit(&json, &prev).unwrap();
        assert_eq!("cccccccc", bearer.access_token);
        assert_eq!(None, bearer.scope);
        let refresh = bearer.lifetime;
        assert_eq!("bbbbbbbb", refresh.refresh_token());
        assert!(refresh.expires() > &UTC::now());
        assert!(refresh.expires() <= &(UTC::now() + Duration::seconds(3600)));
    }

    #[cfg(feature = "serde")]
    #[test]
    fn serialize_deserialize() {
        use serde_json;

        let original = Bearer {
            access_token: String::from("foo"),
            scope: Some(String::from("bar")),
            lifetime: Static,
        };
        let serialized = serde_json::to_value(&original);
        let deserialized = serde_json::from_value(serialized).unwrap();
        assert_eq!(original, deserialized);
    }
}