Updated Mimic

package me.blindedbythesun.nya.modules;

import me.blindedbythesun.nya.Addon;
import meteordevelopment.meteorclient.events.packets.PacketEvent;
import meteordevelopment.meteorclient.settings.BoolSetting;
import meteordevelopment.meteorclient.settings.Setting;
import meteordevelopment.meteorclient.settings.SettingGroup;
import meteordevelopment.meteorclient.settings.StringListSetting;
import meteordevelopment.meteorclient.settings.StringSetting;
import meteordevelopment.meteorclient.systems.modules.Module;
import meteordevelopment.orbit.EventHandler;
import meteordevelopment.meteorclient.systems.modules.Modules;
import net.minecraft.network.packet.s2c.play.GameMessageS2CPacket;

import java.util.List;
import java.util.Random;
import me.blindedbythesun.nya.modules.notifications.NotificationType;

public class Mimic extends Module {

    private final SettingGroup sgGeneral = this.settings.getDefaultGroup();

    private final Setting<List<String>> targets = sgGeneral.add(new StringListSetting.Builder()
        .name("target-usernames")
        .description("The list of players whose messages you want to mimic")
        .defaultValue(List.of("popbob"))
        .build()
    );

    private final Setting<Boolean> greenText = sgGeneral.add(new BoolSetting.Builder()
        .name("green-text")
        .description("Enables green text for mimicked messages by adding a > prefix")
        .defaultValue(false)
        .build()
    );

    private final Setting<Boolean> antiTrolling = sgGeneral.add(new BoolSetting.Builder()
        .name("anti-troll")
        .description("Protect yourself from being trolled by replacing your name with the targets")
        .defaultValue(true)
        .build()
    );

    private final Setting<Boolean> antiKickProtection = sgGeneral.add(new BoolSetting.Builder()
        .name("anti-kick")
        .description("Appends random letters and numbers to mimicked messages to prevent spam detection")
        .defaultValue(false)
        .build()
    );

    private final Setting<Boolean> mimicPrivateMessages = sgGeneral.add(new BoolSetting.Builder()
        .name("mimic-private-messages")
        .description("Mimics private messages received and sends them back to the sender")
        .defaultValue(true)
        .build()
    );

    private final Setting<Boolean> privateMessageEnabled = sgGeneral.add(new BoolSetting.Builder()
        .name("send-private-message")
        .description("Enable sending a private message after mimicking")
        .defaultValue(false)
        .build()
    );

    private final Setting<String> privateMessageContent = sgGeneral.add(new StringSetting.Builder()
        .name("private-message-text")
        .description("The private message to send to the mimicked player")
        .defaultValue("nya")
        .visible(privateMessageEnabled::get)
        .build()
    );

    public Mimic() {
        super(Addon.CATEGORY, "mimic", "Repeats messages of a specified player for maximum fun");
        Modules.get().add(this);
    }

    @Override
    public void onActivate() {
        List<String> targetList = targets.get();
        if (targetList.isEmpty()) {
            Addon.notifications.addNotification("Invalid Config", "Target usernames list is empty, please add players", 4000, NotificationType.ERROR);
            return;
        }

        targetList.forEach(target -> {
            if (!isTargetOnline(target)) {
                String message = String.format("Your mimic target, %s, is not online", target);
                Addon.notifications.addNotification("Target Offline", message, 4000, NotificationType.WARNING);
            }
        });
    }

    @EventHandler
    public void onPacket(PacketEvent.Receive event) {
        if (!(event.packet instanceof GameMessageS2CPacket packet)) return;

        String formattedMessage = packet.content().getString().trim();
        if (formattedMessage.isEmpty()) return;

        String senderName = extractSenderName(formattedMessage);
        String messageContent = extractMessageContent(formattedMessage);

        if (formattedMessage.contains(" whispers: ")) {
            String sender = extractPrivateMessageSender(formattedMessage);
            String content = extractPrivateMessageContent(formattedMessage);

            if (sender == null || sender.isEmpty() || content == null || content.isEmpty()) return;

            if (!targets.get().contains(sender)) return;

            if (!isTargetOnline(sender)) {
                String message = String.format("Your mimic target, %s, is not online", sender);
                Addon.notifications.addNotification("Target Offline", message, 4000, NotificationType.WARNING);
                return;
            }

            if (antiTrolling.get()) {
                content = content.replaceAll("(?i)" + mc.player.getName().getString(), sender);
            }

            mc.player.networkHandler.sendCommand("w " + sender + " " + content);
            return;
        }

        if (senderName.isEmpty() || !targets.get().contains(senderName)) return;

        if (!isTargetOnline(senderName)) {
            String message = String.format("Your mimic target, %s, is not online", senderName);
            Addon.notifications.addNotification("Target Offline", message, 4000, NotificationType.WARNING);
            return;
        }

        if (antiTrolling.get()) {
            messageContent = messageContent.replaceAll("(?i)" + mc.player.getName().getString(), senderName);
        }

        if (antiKickProtection.get() && !messageContent.isEmpty()) {
            messageContent += generateRandomSuffix();
        }

        if (!messageContent.isEmpty()) {
            mc.player.networkHandler.sendChatMessage(greenText.get() ? "> " + sanitizeMessage(messageContent) : sanitizeMessage(messageContent));

            if (privateMessageEnabled.get() && !privateMessageContent.get().trim().isEmpty()) {
                mc.player.networkHandler.sendCommand("w " + senderName + " " + privateMessageContent.get().trim());
            }
        }
    }

    private boolean isTargetOnline(String target) {
        return mc.player.networkHandler.getPlayerList().stream()
            .anyMatch(player -> player.getProfile().getName().equalsIgnoreCase(target));
    }

    private String sanitizeMessage(String message) {
        if (message.startsWith("/") || message.startsWith("*") || message.startsWith(",")) {
            message = " " + message;
        }
        return message;
    }

    private String extractSenderName(String message) {
        if (message.startsWith("<") && message.contains(">")) {
            int endIndex = message.indexOf(">");
            return message.substring(1, endIndex);
        }
        return "";
    }

    private String extractMessageContent(String message) {
        if (message.startsWith("<") && message.contains(">")) {
            int startIndex = message.indexOf(">");
            return message.substring(startIndex + 2).trim();
        }
        return "";
    }

    private String extractPrivateMessageSender(String message) {
        if (message.contains(" whispers: ")) {
            int endIndex = message.indexOf(" whispers:");
            if (endIndex > 0) {
                return message.substring(0, endIndex).trim();
            }
        }
        return "";
    }

    private String extractPrivateMessageContent(String message) {
        if (message.contains(" whispers: ")) {
            int startIndex = message.indexOf(" whispers:") + " whispers:".length();
            if (startIndex < message.length()) {
                return message.substring(startIndex).trim();
            }
        }
        return "";
    }

    private String generateRandomSuffix() {
        Random random = new Random();
        int length = random.nextInt(4) + 3;
        String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        StringBuilder suffix = new StringBuilder(" [");

        for (int i = 0; i < length; i++) {
            suffix.append(characters.charAt(random.nextInt(characters.length())));
        }
        suffix.append("]");

        return suffix.toString();
    }
}