use crate::GeoffreyDatabaseModel;
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::convert::TryFrom;

#[derive(Serialize, Deserialize, Debug, Clone, PartialOrd, PartialEq, Copy)]
pub enum Permissions {
    ModelGet = 0,
    ModelPost,
    Command,
    ModCommand,
    Admin,
}

impl TryFrom<&str> for Permissions {
    type Error = String;
    fn try_from(s: &str) -> Result<Self, Self::Error> {
        Ok(match s {
            "ModelGet" => Self::ModelGet,
            "ModelPost" => Self::ModelPost,
            "Command" => Self::Command,
            "ModCommand" => Self::ModCommand,
            "Admin" => Self::Admin,
            _ => return Err(format!("Unable to parse '{}' as a permission", s)),
        })
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Token {
    pub id: Option<u64>,
    permission: u64,
    pub created: DateTime<Utc>,
    pub modified: DateTime<Utc>,
    pub secret: String,
}

impl Token {
    pub fn set_permission(&mut self, permission: Permissions) {
        self.permission |= 1u64 << permission as u32;
    }

    pub fn clear_permission(&mut self, permission: Permissions) {
        self.permission &= !(1u64 << permission as u32);
    }

    pub fn check_permission(&self, permission: Permissions) -> bool {
        (self.permission >> permission as u32) & 0x1u64 == 0x1u64
    }

    pub fn clear_all_permission(&mut self) {
        self.permission = 0x0u64;
    }
}

impl Default for Token {
    fn default() -> Self {
        Self {
            id: None,
            permission: 0,
            created: Utc::now(),
            modified: Utc::now(),
            secret: String::new(),
        }
    }
}

impl GeoffreyDatabaseModel for Token {
    fn id(&self) -> Option<u64> {
        self.id
    }

    fn set_id(&mut self, id: u64) {
        self.id = Some(id);
    }

    fn tree() -> String {
        "token".to_string()
    }
}

impl PartialEq for Token {
    fn eq(&self, other: &Self) -> bool {
        self.permission == other.permission
    }
}

#[cfg(test)]
mod tests {
    use crate::models::token::{Permissions, Token};

    #[test]
    fn test_token() {
        let mut token = Token::default();

        token.set_permission(Permissions::ModelGet);
        assert_eq!(token.permission, 0x1u64);

        token.set_permission(Permissions::ModelPost);
        assert_eq!(token.permission, 0x3u64);
    }
}