AntiRedstoneClockRemastered.java

package net.onelitefeather.antiredstoneclockremastered;

import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Stage;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.onelitefeather.antiredstoneclockremastered.injection.MetricsModule;
import net.onelitefeather.antiredstoneclockremastered.injection.CommandFrameworkModule;
import net.onelitefeather.antiredstoneclockremastered.injection.CommandModule;
import net.onelitefeather.antiredstoneclockremastered.injection.ExternalSupportModule;
import net.onelitefeather.antiredstoneclockremastered.injection.ListenerModule;
import net.onelitefeather.antiredstoneclockremastered.injection.PlatformModule;
import net.onelitefeather.antiredstoneclockremastered.injection.ServiceModule;
import net.onelitefeather.antiredstoneclockremastered.injection.TranslationModule;
import net.onelitefeather.antiredstoneclockremastered.service.UpdateService;
import net.onelitefeather.antiredstoneclockremastered.utils.CheckTPS;
import org.bukkit.plugin.java.JavaPlugin;

import java.util.Arrays;

public class AntiRedstoneClockRemastered extends JavaPlugin {
    
    // Injector for dependency injection
    private Injector injector;

    public static final Component PREFIX = MiniMessage.miniMessage().deserialize("<gradient:red:white>[AntiRedstoneClock]</gradient>");

    @Override
    public void onLoad() {
        saveDefaultConfig();
        reloadConfig();
        saveConfig();
        injector = Guice.createInjector(Stage.PRODUCTION, Arrays.asList(
                new PlatformModule(this),
                new TranslationModule(),
                new ServiceModule(),
                new ExternalSupportModule(),
                new CommandModule(),
                new ListenerModule()
                )
        );
    }

    @Override
    public void onEnable() {
        injector.getInstance(TranslationModule.class);
        injector.getInstance(CheckTPS.class).startCheck();
        donationInformation();
        injector.getInstance(UpdateService.class).schedule();
        injector.getInstance(UpdateService.class).run();
        injector.getInstance(UpdateService.class).notifyConsole(getComponentLogger());
        injector.getInstance(CommandFrameworkModule.class).enable();
        injector.getInstance(MetricsModule.class).registerCharts();
        this.injector.getInstance(ListenerModule.class).registerEvents(injector, this);
    }
    @Override
    public void onDisable() {
        injector.getInstance(UpdateService.class).shutdown();
    }

    private void donationInformation() {
        getComponentLogger().info(Component.translatable("antiredstoneclockremastered.notify.donation.console"));
    }

}

PlayerListener.java

package net.onelitefeather.antiredstoneclockremastered.listener;

import jakarta.inject.Inject;
import net.kyori.adventure.text.Component;
import net.onelitefeather.antiredstoneclockremastered.AntiRedstoneClockRemastered;
import net.onelitefeather.antiredstoneclockremastered.service.api.RedstoneClockService;
import net.onelitefeather.antiredstoneclockremastered.service.UpdateService;
import net.onelitefeather.antiredstoneclockremastered.utils.Constants;
import org.bukkit.block.BlockFace;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.player.PlayerJoinEvent;

public final class PlayerListener implements Listener {

    private final RedstoneClockService redstoneClockService;
    private final UpdateService updateService;

    @Inject
    public PlayerListener(RedstoneClockService redstoneClockService, UpdateService updateService) {
        this.redstoneClockService = redstoneClockService;
        this.updateService = updateService;
    }

    @EventHandler
    private void onPlayerJoinEvent(PlayerJoinEvent playerJoinEvent) {
        var player = playerJoinEvent.getPlayer();
        if (player.isOp() || (player.hasPermission(Constants.PERMISSION_NOTIFY) && !player.hasPermission(Constants.DISABLE_DONATION_NOTIFY))) {
            player.sendMessage(Component.translatable("antiredstoneclockremastered.notify.donation.player").arguments(AntiRedstoneClockRemastered.PREFIX));
        }
        if (player.isOp() || player.hasPermission(Constants.PERMISSION_NOTIFY_UPDATE)) {
            this.updateService.notifyPlayer(player);
        }
    }

    @EventHandler(priority = EventPriority.HIGHEST)
    private void onBlockBreak(BlockBreakEvent blockBreakEvent) {
        var block = blockBreakEvent.getBlock();
        recheck:
        if (Constants.REDSTONE_ITEMS.contains(block.getType())) {
            this.redstoneClockService.removeClockByLocation(block.getLocation());
        } else {
            block = block.getRelative(BlockFace.UP);
            break recheck;
        }
    }

    @EventHandler(priority = EventPriority.HIGHEST)
    private void onSignBlockBreak(BlockBreakEvent blockBreakEvent) {
        var block = blockBreakEvent.getBlock();
        var hasKey = block.hasMetadata(Constants.META_KEY_ARCR_SIGN);
        if (hasKey) {
            blockBreakEvent.setDropItems(false);
        }
    }
}

PlayerListenerTest.java

package net.onelitefeather.antiredstoneclockremastered.listener;

import be.seeseemelk.mockbukkit.MockBukkit;
import be.seeseemelk.mockbukkit.ServerMock;
import net.kyori.adventure.text.Component;
import net.onelitefeather.antiredstoneclockremastered.AntiRedstoneClockRemastered;
import org.bukkit.event.player.PlayerJoinEvent;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;


class PlayerListenerTest {

    private ServerMock server;
    private AntiRedstoneClockRemastered plugin;

    public static class AntiRedstoneClockRemasteredPlugin extends AntiRedstoneClockRemastered
    {
        @Override
        public void onEnable() {

        }

        @Override
        public void onDisable() {

        }
    }

    @BeforeEach
    void setUp() {
        server = MockBukkit.mock();
        plugin = MockBukkit.load(AntiRedstoneClockRemasteredPlugin.class);
    }

    @AfterEach
    void tearDown()
    {
        MockBukkit.unmock();
    }

    @Test
    void testOnPlayerJoinEvent() {
        var playerListener = new PlayerListener(null, null);
        server.getPluginManager().registerEvents(playerListener, plugin);
        var player = server.addPlayer();
        server.getPluginManager().callEvent(new PlayerJoinEvent(player, Component.text("Welcome")));

        // Assertions can be added here to verify expected behavior
    }
}