Event System

/**
 * Base interface for all JDA events.
 */
interface GenericEvent {
    /** Get JDA instance that fired this event */
    JDA getJDA();
    
    /** Get response number for event ordering */
    long getResponseNumber();
}

/**
 * Abstract base class providing empty implementations of all event handler methods.
 * Extend this class and override only the events you want to handle.
 */
abstract class ListenerAdapter {
    // Message Events
    void onMessageReceived(MessageReceivedEvent event);
    void onMessageUpdate(MessageUpdateEvent event);
    void onMessageDelete(MessageDeleteEvent event);
    void onMessageBulkDelete(MessageBulkDeleteEvent event);
    void onMessageReactionAdd(MessageReactionAddEvent event);
    void onMessageReactionRemove(MessageReactionRemoveEvent event);
    void onMessageReactionRemoveAll(MessageReactionRemoveAllEvent event);
    void onMessageReactionRemoveEmoji(MessageReactionRemoveEmojiEvent event);
    
    // Guild Member Events
    void onGuildMemberJoin(GuildMemberJoinEvent event);
    void onGuildMemberRemove(GuildMemberRemoveEvent event);
    void onGuildMemberUpdate(GuildMemberUpdateEvent event);
    void onGuildMemberRoleAdd(GuildMemberRoleAddEvent event);
    void onGuildMemberRoleRemove(GuildMemberRoleRemoveEvent event);
    void onGuildMemberUpdateNickname(GuildMemberUpdateNicknameEvent event);
    void onGuildMemberUpdateAvatar(GuildMemberUpdateAvatarEvent event);
    void onGuildMemberUpdateBoostTime(GuildMemberUpdateBoostTimeEvent event);
    void onGuildMemberUpdateTimeOut(GuildMemberUpdateTimeOutEvent event);
    void onGuildMemberUpdateFlags(GuildMemberUpdateFlagsEvent event);
    
    // Guild Events
    void onGuildReady(GuildReadyEvent event);
    void onGuildJoin(GuildJoinEvent event);
    void onGuildLeave(GuildLeaveEvent event);
    void onGuildAvailable(GuildAvailableEvent event);
    void onGuildUnavailable(GuildUnavailableEvent event);
    void onGuildUpdate(GuildUpdateEvent event);
    void onGuildBan(GuildBanEvent event);
    void onGuildUnban(GuildUnbanEvent event);
    
    // Channel Events
    void onChannelCreate(ChannelCreateEvent event);
    void onChannelDelete(ChannelDeleteEvent event);
    void onChannelUpdateName(ChannelUpdateNameEvent event);
    void onChannelUpdateTopic(ChannelUpdateTopicEvent event);
    void onChannelUpdatePosition(ChannelUpdatePositionEvent event);
    void onChannelUpdateNSFW(ChannelUpdateNSFWEvent event);
    void onChannelUpdateSlowmode(ChannelUpdateSlowmodeEvent event);
    void onChannelUpdateBitrate(ChannelUpdateBitrateEvent event);
    void onChannelUpdateUserLimit(ChannelUpdateUserLimitEvent event);
    
    // Voice Events
    void onGuildVoiceUpdate(GuildVoiceUpdateEvent event);
    void onGuildVoiceJoin(GuildVoiceJoinEvent event);
    void onGuildVoiceMove(GuildVoiceMoveEvent event);
    void onGuildVoiceLeave(GuildVoiceLeaveEvent event);
    void onGuildVoiceMute(GuildVoiceMuteEvent event);
    void onGuildVoiceDeafen(GuildVoiceDeafenEvent event);
    void onGuildVoiceSelfMute(GuildVoiceSelfMuteEvent event);
    void onGuildVoiceSelfDeafen(GuildVoiceSelfDeafenEvent event);
    void onGuildVoiceSuppress(GuildVoiceSuppressEvent event);
    void onGuildVoiceStream(GuildVoiceStreamEvent event);
    void onGuildVoiceVideo(GuildVoiceVideoEvent event);
    void onGuildVoiceRequestToSpeak(GuildVoiceRequestToSpeakEvent event);
    
    // Interaction Events
    void onSlashCommandInteraction(SlashCommandInteractionEvent event);
    void onUserContextInteraction(UserContextInteractionEvent event);
    void onMessageContextInteraction(MessageContextInteractionEvent event);
    void onButtonInteraction(ButtonInteractionEvent event);
    void onSelectMenuInteraction(SelectMenuInteractionEvent event);
    void onStringSelectInteraction(StringSelectInteractionEvent event);
    void onEntitySelectInteraction(EntitySelectInteractionEvent event);
    void onModalInteraction(ModalInteractionEvent event);
    void onCommandAutoCompleteInteraction(CommandAutoCompleteInteractionEvent event);
    
    // Role Events
    void onRoleCreate(RoleCreateEvent event);
    void onRoleDelete(RoleDeleteEvent event);
    void onRoleUpdate(RoleUpdateEvent event);
    
    // Thread Events
    void onThreadRevealed(ThreadRevealedEvent event);
    void onThreadHidden(ThreadHiddenEvent event);
    void onThreadMemberJoin(ThreadMemberJoinEvent event);
    void onThreadMemberLeave(ThreadMemberLeaveEvent event);
    
    // Generic update events
    void onGenericUpdate(GenericUpdateEvent event);
    void onGenericGuildUpdate(GenericGuildUpdateEvent event);
    void onGenericGuildMemberUpdate(GenericGuildMemberUpdateEvent event);
    void onGenericChannelUpdate(GenericChannelUpdateEvent event);
    void onGenericRoleUpdate(GenericRoleUpdateEvent event);
    void onGenericMessageReaction(GenericMessageReactionEvent event);
    void onGenericInteractionCreate(GenericInteractionCreateEvent event);
    
    // Status Events
    void onReady(ReadyEvent event);
    void onDisconnect(DisconnectEvent event);
    void onReconnect(ReconnectEvent event);
    void onResume(ResumedEvent event);
    void onShutdown(ShutdownEvent event);
    void onStatusChange(StatusChangeEvent event);
    void onException(ExceptionEvent event);
    void onGatewayPing(GatewayPingEvent event);
}

import net.dv8tion.jda.api.hooks.ListenerAdapter;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import net.dv8tion.jda.api.events.guild.member.GuildMemberJoinEvent;

public class MyBot extends ListenerAdapter {
    @Override
    public void onMessageReceived(MessageReceivedEvent event) {
        String content = event.getMessage().getContentRaw();
        
        // Ignore bot messages
        if (event.getAuthor().isBot()) return;
        
        // Respond to ping
        if (content.equals("!ping")) {
            event.getChannel().sendMessage("Pong!").queue();
        }
    }
    
    @Override
    public void onGuildMemberJoin(GuildMemberJoinEvent event) {
        // Welcome new members
        String welcome = String.format("Welcome %s to %s!", 
            event.getUser().getName(), 
            event.getGuild().getName());
        
        // Send to system channel if available
        TextChannel systemChannel = event.getGuild().getSystemChannel();
        if (systemChannel != null) {
            systemChannel.sendMessage(welcome).queue();
        }
    }
}

// Register the listener
JDA jda = JDABuilder.createDefault(token)
    .addEventListeners(new MyBot())
    .build();

/**
 * Indicates that a Message was received in a MessageChannel.
 */
class MessageReceivedEvent extends GenericMessageEvent {
    /** Get the received message */
    Message getMessage();
    
    /** Get message author */
    User getAuthor();
    
    /** Get author as member (null if not in guild) */
    Member getMember();
    
    /** Check if message is from webhook */
    boolean isWebhookMessage();
    
    /** Get webhook that sent message (if applicable) */
    WebhookClient getWebhookClient();
}

/**
 * Indicates that a Message was edited in a MessageChannel.
 */
class MessageUpdateEvent extends GenericMessageEvent {
    /** Get updated message */
    Message getMessage();
    
    /** Get message author */
    User getAuthor();
    
    /** Get author as member */
    Member getMember();
}

/**
 * Indicates that a Message was deleted in a MessageChannel.
 */
class MessageDeleteEvent extends GenericMessageEvent {
    // Note: Message content is not available in delete events
    
    /** Get message ID that was deleted */
    long getMessageIdLong();
    String getMessageId();
}

/**
 * Indicates that multiple Messages were deleted at once.
 */
class MessageBulkDeleteEvent extends GenericMessageEvent {
    /** Get list of deleted message IDs */
    List<String> getMessageIds();
    
    /** Get count of deleted messages */
    int getMessageCount();
}

/**
 * Indicates that a reaction was added to a message.
 */
class MessageReactionAddEvent extends GenericMessageReactionEvent {
    /** Get user who added reaction */
    User getUser();
    
    /** Get member who added reaction */
    Member getMember();
    
    /** Get reaction that was added */
    MessageReaction getReaction();
    
    /** Get reaction emoji */
    MessageReaction.ReactionEmoji getReactionEmoji();
    
    /** Retrieve full message */
    RestAction<Message> retrieveMessage();
}

/**
 * Indicates that a reaction was removed from a message.
 */
class MessageReactionRemoveEvent extends GenericMessageReactionEvent {
    /** Get user who removed reaction */
    User getUser();
    
    /** Get member who removed reaction */
    Member getMember();
    
    /** Get reaction that was removed */
    MessageReaction getReaction();
    
    /** Get reaction emoji */
    MessageReaction.ReactionEmoji getReactionEmoji();
}

/**
 * Indicates that a user joined a guild.
 */
class GuildMemberJoinEvent extends GenericGuildMemberEvent {
    /** Get user who joined */
    User getUser();
    
    /** Get guild member object */
    Member getMember();
    
    /** Get guild that was joined */
    Guild getGuild();
}

/**
 * Indicates that a user left a guild.
 */
class GuildMemberRemoveEvent extends GenericGuildEvent {
    /** Get user who left */
    User getUser();
    
    /** Get guild that was left */
    Guild getGuild();
    
    /** Get cached member (if available) */
    Member getMember();
}

/**
 * Indicates that a guild member's roles were modified.
 */
class GuildMemberRoleAddEvent extends GenericGuildMemberEvent {
    /** Get roles that were added */
    List<Role> getRoles();
    
    /** Get member whose roles changed */
    Member getMember();
}

/**
 * Indicates that roles were removed from a guild member.
 */
class GuildMemberRoleRemoveEvent extends GenericGuildMemberEvent {
    /** Get roles that were removed */
    List<Role> getRoles();
    
    /** Get member whose roles changed */
    Member getMember();
}

/**
 * Indicates that a guild member's nickname was changed.
 */
class GuildMemberUpdateNicknameEvent extends GenericGuildMemberUpdateEvent<String> {
    /** Get old nickname */
    String getOldNickname();
    
    /** Get new nickname */
    String getNewNickname();
}

/**
 * Indicates that a guild member was timed out or timeout was removed.
 */
class GuildMemberUpdateTimeOutEvent extends GenericGuildMemberUpdateEvent<OffsetDateTime> {
    /** Get old timeout end time */
    OffsetDateTime getOldTimeOutEnd();
    
    /** Get new timeout end time */
    OffsetDateTime getNewTimeOutEnd();
}

/**
 * Indicates that JDA has finished loading a guild.
 */
class GuildReadyEvent extends GenericGuildEvent {
    /** Get guild that became ready */
    Guild getGuild();
}

/**
 * Indicates that the bot joined a new guild.
 */
class GuildJoinEvent extends GenericGuildEvent {
    /** Get guild that was joined */
    Guild getGuild();
}

/**
 * Indicates that the bot left a guild.
 */
class GuildLeaveEvent extends GenericGuildEvent {
    /** Get guild that was left */
    Guild getGuild();
}

/**
 * Indicates that a guild became available.
 */
class GuildAvailableEvent extends GenericGuildEvent {
    /** Get guild that became available */
    Guild getGuild();
}

/**
 * Indicates that a guild became unavailable.
 */
class GuildUnavailableEvent extends GenericGuildEvent {
    /** Get guild that became unavailable */
    Guild getGuild();
}

/**
 * Indicates that a user was banned from a guild.
 */
class GuildBanEvent extends GenericGuildEvent {
    /** Get user who was banned */
    User getUser();
    
    /** Get guild where ban occurred */
    Guild getGuild();
}

/**
 * Indicates that a user was unbanned from a guild.
 */
class GuildUnbanEvent extends GenericGuildEvent {
    /** Get user who was unbanned */
    User getUser();
    
    /** Get guild where unban occurred */
    Guild getGuild();
}

/**
 * Indicates that a guild voice event occurred.
 */
abstract class GenericGuildVoiceEvent extends GenericGuildEvent {
    /** Get member whose voice state changed */
    Member getMember();
    
    /** Get voice state */
    GuildVoiceState getVoiceState();
}

/**
 * Indicates that a member joined a voice channel.
 */
class GuildVoiceJoinEvent extends GenericGuildVoiceEvent {
    /** Get voice channel that was joined */
    AudioChannel getChannelJoined();
}

/**
 * Indicates that a member left a voice channel.
 */
class GuildVoiceLeaveEvent extends GenericGuildVoiceEvent {
    /** Get voice channel that was left */
    AudioChannel getChannelLeft();
}

/**
 * Indicates that a member moved between voice channels.
 */
class GuildVoiceMoveEvent extends GenericGuildVoiceEvent {
    /** Get voice channel that was left */
    AudioChannel getChannelLeft();
    
    /** Get voice channel that was joined */
    AudioChannel getChannelJoined();
}

/**
 * Indicates that a member was muted/unmuted.
 */
class GuildVoiceMuteEvent extends GenericGuildVoiceEvent {
    /** Check if member is now muted */
    boolean isMuted();
}

/**
 * Indicates that a member was deafened/undeafened.
 */
class GuildVoiceDeafenEvent extends GenericGuildVoiceEvent {
    /** Check if member is now deafened */
    boolean isDeafened();
}

/**
 * Indicates that a member muted/unmuted themselves.
 */
class GuildVoiceSelfMuteEvent extends GenericGuildVoiceEvent {
    /** Check if member is now self-muted */
    boolean isSelfMuted();
}

/**
 * Indicates that a member deafened/undeafened themselves.
 */
class GuildVoiceSelfDeafenEvent extends GenericGuildVoiceEvent {
    /** Check if member is now self-deafened */
    boolean isSelfDeafened();
}

/**
 * Indicates that a channel was created.
 */
class ChannelCreateEvent extends GenericChannelEvent {
    /** Get channel that was created */
    Channel getChannel();
}

/**
 * Indicates that a channel was deleted.
 */
class ChannelDeleteEvent extends GenericChannelEvent {
    /** Get channel that was deleted */
    Channel getChannel();
}

/**
 * Indicates that a text channel's name was updated.
 */
class ChannelUpdateNameEvent extends GenericChannelUpdateEvent<String> {
    /** Get old channel name */
    String getOldName();
    
    /** Get new channel name */
    String getNewName();
}

/**
 * Indicates that a text channel's topic was updated.
 */
class ChannelUpdateTopicEvent extends GenericChannelUpdateEvent<String> {
    /** Get old channel topic */
    String getOldTopic();
    
    /** Get new channel topic */
    String getNewTopic();
}

/**
 * Indicates that a channel's position was updated.
 */
class ChannelUpdatePositionEvent extends GenericChannelUpdateEvent<Integer> {
    /** Get old channel position */
    int getOldPosition();
    
    /** Get new channel position */
    int getNewPosition();
}

/**
 * Indicates that a channel's NSFW status was updated.
 */
class ChannelUpdateNSFWEvent extends GenericChannelUpdateEvent<Boolean> {
    /** Get old NSFW status */
    boolean getOldNSFW();
    
    /** Get new NSFW status */
    boolean getNewNSFW();
}

/**
 * Indicates that JDA has finished loading and is ready to operate.
 */
class ReadyEvent extends GenericEvent {
    /** Get number of guilds available */
    int getGuildAvailableCount();
    
    /** Get number of guilds unavailable */
    int getGuildUnavailableCount();
    
    /** Get total number of guilds */
    int getGuildTotalCount();
}

/**
 * Indicates that JDA has disconnected from Discord.
 */
class DisconnectEvent extends GenericEvent {
    /** Get time when disconnection occurred */
    OffsetDateTime getTimeDisconnected();
    
    /** Get disconnect code */
    CloseCode getCloseCode();
    
    /** Get disconnect reason */
    String getCloseReason();
    
    /** Check if disconnect was by server */
    boolean isClosedByServer();
}

/**
 * Indicates that JDA has reconnected to Discord.
 */
class ReconnectedEvent extends GenericEvent {
    // No additional methods
}

/**
 * Indicates that JDA has resumed a previous session.
 */
class ResumedEvent extends GenericEvent {
    // No additional methods
}

/**
 * Indicates that JDA is shutting down.
 */
class ShutdownEvent extends GenericEvent {
    /** Get time when shutdown occurred */
    OffsetDateTime getTimeShutdown();
    
    /** Get shutdown code */
    int getCode();
}

/**
 * Indicates that JDA's status has changed.
 */
class StatusChangeEvent extends GenericEvent {
    /** Get old status */
    JDA.Status getOldStatus();
    
    /** Get new status */
    JDA.Status getNewStatus();
}

/**
 * Indicates that an exception occurred in JDA.
 */
class ExceptionEvent extends GenericEvent {
    /** Get exception that occurred */
    Throwable getCause();
    
    /** Check if exception is logged */
    boolean isLogged();
}

// Close codes for websocket disconnections
enum CloseCode {
    NORMAL_CLOSURE, GOING_AWAY, PROTOCOL_ERROR, UNSUPPORTED_DATA,
    NO_STATUS_CODE, ABNORMAL_CLOSURE, INVALID_FRAME_PAYLOAD,
    POLICY_VIOLATION, MESSAGE_TOO_BIG, MANDATORY_EXTENSION,
    INTERNAL_SERVER_ERROR, SERVICE_RESTART, TRY_AGAIN_LATER,
    BAD_GATEWAY, TLS_HANDSHAKE_FAILURE, UNKNOWN_ERROR,
    UNKNOWN_OPCODE, DECODE_ERROR, NOT_AUTHENTICATED, 
    AUTHENTICATION_FAILED, ALREADY_AUTHENTICATED,
    INVALID_SEQUENCE, RATE_LIMITED, SESSION_TIMEOUT,
    INVALID_SHARD, SHARDING_REQUIRED, INVALID_API_VERSION,
    INVALID_INTENTS, DISALLOWED_INTENTS
}

// Gateway intents for filtering events
enum GatewayIntent {
    GUILDS, GUILD_MEMBERS, GUILD_MODERATION, GUILD_EMOJIS_AND_STICKERS,
    GUILD_INTEGRATIONS, GUILD_WEBHOOKS, GUILD_INVITES, GUILD_VOICE_STATES,
    GUILD_PRESENCES, GUILD_MESSAGES, GUILD_MESSAGE_REACTIONS, GUILD_MESSAGE_TYPING,
    DIRECT_MESSAGES, DIRECT_MESSAGE_REACTIONS, DIRECT_MESSAGE_TYPING, MESSAGE_CONTENT,
    GUILD_SCHEDULED_EVENTS, AUTO_MODERATION_CONFIGURATION, AUTO_MODERATION_EXECUTION
}