use actix_web::dev::ServiceRequest;
pub mod extractor;
pub mod jwt;
pub mod processes;
use crate::auth::processes::check_token;
use crate::auth::processes::extract_header_token;

pub fn process_token(request: &ServiceRequest) -> Result<i32, &'static str> {
    match extract_header_token(request) {
        Ok(token) => check_token(token),
        Err(message) => Err(message),
    }
}

#[cfg(test)]
mod mod_test {

    use actix_web::test::TestRequest;

    use super::process_token;
    use crate::auth::jwt::JwtToken;
    use crate::database::establish_connection;
    use crate::test_helpers::{delete_user, insert_user};

    #[test]
    fn process_token_test() {
        let mut connection = establish_connection();
        let user = insert_user(&mut connection, "secret");

        let token = JwtToken::encode(user.id, user.token_version);
        let request = TestRequest::delete()
            .insert_header(("user-token", token))
            .to_srv_request();

        assert_eq!(Ok(user.id), process_token(&request));

        delete_user(&mut connection, user.id);
    }

    #[actix_web::test]
    async fn process_token_not_existing() {
        let request = TestRequest::default().to_srv_request();

        match process_token(&request) {
            Err(error) => assert_eq!("there is no token", error),
            _ => panic!("Not existing token should not be processes"),
        }
    }

    #[actix_web::test]
    async fn process_wrong_token() {
        let request = TestRequest::default()
            .insert_header(("user-token", "bla"))
            .to_srv_request();

        match process_token(&request) {
            Err(error) => assert_eq!("could not decode token", error),
            _ => panic!("Not existing token should not be processes"),
        }
    }
}