use async_trait::async_trait;
use json;
use json::object::Object;

#[async_trait]
pub trait Store {
    async fn is_auth(&self, data: &json::JsonValue) -> bool;
}

/// extract_json_value extracts String json value from a key
fn extract_json_value(data: &Object, key: &str) -> String {
    if let Some(u) = data.get(key) {
        match u.as_str() {
            Some(s) => return s.to_string(),
            None => return "".to_string(),
        }
    };
    "".to_string()
}

#[derive(Default)]
pub struct Credentials {
    pub username: String,
    pub password: String,
}

impl Credentials {
    fn new(username: String, password: String) -> Self {
        Credentials { username, password }
    }

    pub fn is_empty(&self) -> bool {
        self.username == "" || self.password == ""
    }
}

impl From<&json::JsonValue> for Credentials {
    fn from(data: &json::JsonValue) -> Self {
        let mut credentials = Credentials::default();
        match data {
            json::JsonValue::Object(ref d) => {
                credentials.username = extract_json_value(&d, "username");
                credentials.password = extract_json_value(&d, "password");
            }
            _ => return credentials,
        }
        credentials
    }
}

#[test]
fn test_credentials() {
    struct Expect {
        data: json::JsonValue,
        is_empty: bool,
    }
    let test_cases: [Expect; 2] = [
        Expect {
            data: json::parse(r#"{"access_token":"AAAAAAAAAAAA.BBBBBBBBBB.CCCCCCCCCC","refresh_token": "DDDDDDDDDDD.EEEEEEEEEEE.FFFFF"}"#).unwrap(),
            is_empty: true
        },
        Expect {
            data: json::parse(r#"{"username":"toto","password": "tata"}"#).unwrap(),
            is_empty: false
        }
    ];

    for t in test_cases {
        let credentials = Credentials::from(&t.data);
        assert_eq!(t.is_empty, credentials.is_empty())
    }
}