use crate::api_data::current_user_id::CurrentUserID;
use crate::api_data::login_success::LoginSuccess;
use crate::api_data::res_check_email_exists::ResCheckEmailExists;
use crate::controllers::routes::RequestResult;
use crate::data::error::ResultBoxError;
use crate::data::http_request_handler::HttpRequestHandler;
use crate::data::user::User;
use crate::helpers::{account_helper, user_helper};

/// Account controller
///
/// @author Pierre Hubert

impl HttpRequestHandler {
    /// Get information about a user based on its email address specified in the request
    pub fn post_user_info_from_email(&mut self, field: &str) -> ResultBoxError<User> {
        let email = self.post_email(field)?;

        self.ok_or_not_found(
            user_helper::find_user_by_email(&email),
            format!("Requested user in '{}' not found!", email).as_str(),
        )
    }
}

/// Sign in user
pub fn login_user(request: &mut HttpRequestHandler) -> RequestResult {
    let email = request.post_email("userMail")?;
    let password = request.post_string_opt("userPassword", 3, true)?;

    // TODO : limit request

    // Authenticate user
    let token = account_helper::login_user(
        &email, &password, request.api_client());

    match token {
        Ok(t) => {
            request.set_response(LoginSuccess::new(&t))
        }
        Err(e) => {
            // TODO : limit request
            println!("Error on login: {}", e);
            request.forbidden("Invalid email address / password!".to_string())
        }
    }
}

/// Sign out user
pub fn logout_user(request: &mut HttpRequestHandler) -> RequestResult {
    account_helper::destroy_login_tokens(
        &request.user_id()?,
        request.api_client(),
    )?;

    request.success("User disconnected.")
}

/// Disconnect a user from all his devices
pub fn disconnect_all_devices(r: &mut HttpRequestHandler) -> RequestResult {
    account_helper::destroy_all_user_tokens(r.user_id_ref()?)?;

    r.success("Successfully disconnected!")
}

/// Get current user ID
pub fn user_id(request: &mut HttpRequestHandler) -> RequestResult {
    request.set_response(CurrentUserID::new(&request.user_id()?))
}

/// Check out whether an email address exists or not
pub fn exists_mail(r: &mut HttpRequestHandler) -> RequestResult {
    let email = r.post_email("email")?;

    r.set_response(ResCheckEmailExists::new(account_helper::exists_mail(&email)?))
}

/// Check out whether a given user has set security questions or not
pub fn has_security_questions(r: &mut HttpRequestHandler) -> RequestResult {
    let user = r.post_user_info_from_email("email")?;

    // TODO : continue implementation
    println!("{:#?}", user);
    r.success("implement me")
}