pub fn name_validation_error_to_error_message(db_or_user: &DbOrUser) -> String {

    let argv0 = std::env::args().next().unwrap_or_else(|| match db_or_user {

        DbOrUser::Database(_) => "mysql-dbadm".to_string(),

        DbOrUser::User(_) => "mysql-useradm".to_string(),

    });

    format!(

        db_or_user.capitalized_noun(),

        db_or_user.name(),

}

pub fn authorization_error_message(db_or_user: &DbOrUser) -> String {

    format!(

        db_or_user.lowercased_noun(),

        db_or_user.name(),

}

pub fn handle_create_user_error(error: &CreateUserError, name: &str) {

    let argv0 = std::env::args()

        .next()

        .unwrap_or_else(|| "mysql-useradm".to_string());

    match error {

        CreateUserError::ValidationError(ValidationError::NameValidationError(_)) => {

            eprintln!(

                "{}",

                name_validation_error_to_error_message(&DbOrUser::User(name.into()))

            );

        }

        CreateUserError::ValidationError(ValidationError::AuthorizationError(_)) => {

            eprintln!(

                "{}",

                authorization_error_message(&DbOrUser::User(name.into()))

            );

        }

        CreateUserError::MySqlError(_) | CreateUserError::UserAlreadyExists => {

            eprintln!("{argv0}: Failed to create user '{name}'.");

        }

}

pub fn handle_drop_user_error(error: &DropUserError, name: &str) {

    let argv0 = std::env::args()

        .next()

        .unwrap_or_else(|| "mysql-useradm".to_string());

    match error {

        DropUserError::ValidationError(ValidationError::NameValidationError(_)) => {

            eprintln!(

                "{}",

                name_validation_error_to_error_message(&DbOrUser::User(name.into()))

            );

        }

        DropUserError::ValidationError(ValidationError::AuthorizationError(_)) => {

            eprintln!(

                "{}",

                authorization_error_message(&DbOrUser::User(name.into()))

            );

        }

        DropUserError::MySqlError(_) | DropUserError::UserDoesNotExist => {

            eprintln!("{argv0}: Failed to delete user '{name}'.");

        }

}

pub fn handle_list_users_error(error: &ListUsersError, name: &str) {

    let argv0 = std::env::args()

        .next()

        .unwrap_or_else(|| "mysql-useradm".to_string());

    match error {

        ListUsersError::ValidationError(ValidationError::NameValidationError(_)) => {

            eprintln!(

                "{}",

                name_validation_error_to_error_message(&DbOrUser::User(name.into()))

            );

        }

        ListUsersError::ValidationError(ValidationError::AuthorizationError(_)) => {

            eprintln!(

                "{}",

                authorization_error_message(&DbOrUser::User(name.into()))

            );

        }

        ListUsersError::UserDoesNotExist => {

            eprintln!("{argv0}: User '{name}' does not exist. You must create it first.",);

        }

        ListUsersError::MySqlError(_) => {

            eprintln!("{argv0}: Failed to look up password for user '{name}'");

        }

}

pub fn handle_create_database_error(error: &CreateDatabaseError, name: &str) {

    let argv0 = std::env::args()

        .next()

        .unwrap_or_else(|| "mysql-dbadm".to_string());

    match error {

        CreateDatabaseError::ValidationError(ValidationError::NameValidationError(_)) => {

            eprintln!(

                "{}",

                name_validation_error_to_error_message(&DbOrUser::Database(name.into()))

            );

        }

        CreateDatabaseError::ValidationError(ValidationError::AuthorizationError(_)) => {

            eprintln!(

                "{}",

                authorization_error_message(&DbOrUser::Database(name.into()))

            );

        }

        CreateDatabaseError::MySqlError(_) => {

            eprintln!("{argv0}: Cannot create database '{name}'.");

        }

        CreateDatabaseError::DatabaseAlreadyExists => {

            eprintln!("{argv0}: Database '{name}' already exists.");

        }

}

pub fn handle_drop_database_error(error: &DropDatabaseError, name: &str) {

    let argv0 = std::env::args()

        .next()

        .unwrap_or_else(|| "mysql-dbadm".to_string());

    match error {

        DropDatabaseError::ValidationError(ValidationError::NameValidationError(_)) => {

            eprintln!(

                "{}",

                name_validation_error_to_error_message(&DbOrUser::Database(name.into()))

            );

        }

        DropDatabaseError::ValidationError(ValidationError::AuthorizationError(_)) => {

            eprintln!(

                "{}",

                authorization_error_message(&DbOrUser::Database(name.into()))

            );

        }

        DropDatabaseError::MySqlError(_) => {

            eprintln!("{argv0}: Cannot drop database '{name}'.");

        }

        DropDatabaseError::DatabaseDoesNotExist => {

            eprintln!("{argv0}: Database '{name}' doesn't exist.");

        }

}

pub fn format_show_database_error_message(error: &ListPrivilegesError, name: &str) -> String {

    let argv0 = std::env::args()

        .next()

        .unwrap_or_else(|| "mysql-dbadm".to_string());

    match error {

            name_validation_error_to_error_message(&DbOrUser::Database(name.into()))

            authorization_error_message(&DbOrUser::Database(name.into()))

        ListPrivilegesError::MySqlError(err) => {

            format!("{argv0}: Failed to look up privileges for database '{name}': {err}")

            format!("{argv0}: Database '{name}' doesn't exist.")

}