use actix::{Actor, Context, Handler, Message, MessageResult};

use crate::data::entity_manager::EntityManager;
use crate::data::user::{User, UserID};

#[derive(Debug)]
pub enum LoginResult {
    AccountNotFound,
    InvalidPassword,
    AccountDisabled,
    Success(User),
}

#[derive(Message)]
#[rtype(LoginResult)]
pub struct LoginRequest {
    pub login: String,
    pub password: String,
}

#[derive(Message)]
#[rtype(GetUserResult)]
pub struct GetUserRequest(pub UserID);

#[derive(Debug)]
pub struct GetUserResult(pub Option<User>);

#[derive(Message)]
#[rtype(FindUserByUsernameResult)]
pub struct FindUserByUsername(pub String);

#[derive(Debug)]
pub struct FindUserByUsernameResult(pub Option<User>);

#[derive(Message)]
#[rtype(GetAllUsersResult)]
pub struct GetAllUsersRequest;

#[derive(Debug)]
pub struct GetAllUsersResult(pub Vec<User>);

#[derive(Message)]
#[rtype(ChangePasswordResult)]
pub struct ChangePasswordRequest {
    pub user_id: UserID,
    pub new_password: String,
    pub temporary: bool,
}

#[derive(Debug)]
pub struct ChangePasswordResult(pub bool);

#[derive(Debug)]
pub struct UpdateUserResult(pub bool);

#[derive(Message)]
#[rtype(UpdateUserResult)]
pub struct UpdateUserRequest(pub User);

#[derive(Debug)]
pub struct DeleteUserResult(pub bool);

#[derive(Message)]
#[rtype(DeleteUserResult)]
pub struct DeleteUserRequest(pub UserID);

pub struct UsersActor {
    manager: EntityManager<User>,
}

impl UsersActor {
    pub fn new(manager: EntityManager<User>) -> Self {
        Self { manager }
    }
}

impl Actor for UsersActor {
    type Context = Context<Self>;
}

impl Handler<LoginRequest> for UsersActor {
    type Result = MessageResult<LoginRequest>;

    fn handle(&mut self, msg: LoginRequest, _ctx: &mut Self::Context) -> Self::Result {
        match self.manager.find_by_username_or_email(&msg.login) {
            None => MessageResult(LoginResult::AccountNotFound),
            Some(user) => {
                if !user.verify_password(&msg.password) {
                    return MessageResult(LoginResult::InvalidPassword);
                }

                if !user.enabled {
                    return MessageResult(LoginResult::AccountDisabled);
                }

                MessageResult(LoginResult::Success(user))
            }
        }
    }
}

impl Handler<ChangePasswordRequest> for UsersActor {
    type Result = MessageResult<ChangePasswordRequest>;

    fn handle(&mut self, msg: ChangePasswordRequest, _ctx: &mut Self::Context) -> Self::Result {
        MessageResult(ChangePasswordResult(self.manager.change_user_password(
            &msg.user_id,
            &msg.new_password,
            msg.temporary,
        )))
    }
}

impl Handler<GetUserRequest> for UsersActor {
    type Result = MessageResult<GetUserRequest>;

    fn handle(&mut self, msg: GetUserRequest, _ctx: &mut Self::Context) -> Self::Result {
        MessageResult(GetUserResult(self.manager.find_by_user_id(&msg.0)))
    }
}

impl Handler<FindUserByUsername> for UsersActor {
    type Result = MessageResult<FindUserByUsername>;

    fn handle(&mut self, msg: FindUserByUsername, _ctx: &mut Self::Context) -> Self::Result {
        MessageResult(FindUserByUsernameResult(
            self.manager.find_by_username_or_email(&msg.0),
        ))
    }
}

impl Handler<GetAllUsersRequest> for UsersActor {
    type Result = MessageResult<GetAllUsersRequest>;

    fn handle(&mut self, _msg: GetAllUsersRequest, _ctx: &mut Self::Context) -> Self::Result {
        MessageResult(GetAllUsersResult(self.manager.cloned()))
    }
}

impl Handler<UpdateUserRequest> for UsersActor {
    type Result = MessageResult<UpdateUserRequest>;

    fn handle(&mut self, msg: UpdateUserRequest, _ctx: &mut Self::Context) -> Self::Result {
        MessageResult(UpdateUserResult(match self.manager.update_or_push(msg.0) {
            Ok(_) => true,
            Err(e) => {
                log::error!("Failed to update user information! {:?}", e);
                false
            }
        }))
    }
}

impl Handler<DeleteUserRequest> for UsersActor {
    type Result = MessageResult<DeleteUserRequest>;

    fn handle(&mut self, msg: DeleteUserRequest, _ctx: &mut Self::Context) -> Self::Result {
        let user = match self.manager.find_by_user_id(&msg.0) {
            None => {
                log::warn!(
                    "Could not delete account {:?} because it was not found!",
                    msg.0
                );
                return MessageResult(DeleteUserResult(false));
            }
            Some(s) => s,
        };

        MessageResult(DeleteUserResult(match self.manager.remove(&user) {
            Ok(_) => true,
            Err(e) => {
                log::error!("Failed to update delete account! {:?}", e);
                false
            }
        }))
    }
}