minecraft-kajetans-mod/src/main/java/me/km/blockprotections/CommandBlock.java

package me.km.blockprotections;

import com.mojang.authlib.GameProfile;
import java.util.ArrayList;
import java.util.List;
import me.km.KajetansMod;
import me.km.api.GlobalText;
import me.km.api.Module;
import me.km.api.ModuleCommand;
import me.km.api.Utils;
import me.km.permissions.Permissions;
import me.km.scheduler.SnuviScheduler;
import net.minecraft.block.Block;
import net.minecraft.block.BlockDoor;
import net.minecraft.block.state.IBlockState;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;

public class CommandBlock extends ModuleCommand
{
    private final BlockProtectionBank bank;
    private int counter;
    private int index;
    private List<BlockPos> locs;
    private final ArrayList<Block> blocks;
    private boolean checker;
    
    public CommandBlock(Module m) 
    {
        super("block", m);
        super.setDescription("Zeigt alles für die Block-Verwaltung");
        super.setUsage("/block für die Hilfe");
        super.setPermission(Permissions.BLOCK);
        super.addAlias("blocks");
        super.addAlias("pro");
        super.addAlias("protect");
        
        bank = KajetansMod.blocks.getDataBank(BlockProtectionBank.class);
        locs = new ArrayList<>();
        blocks = new ArrayList<>();
    }
    
    @Override
    public boolean execute(ICommandSender cs, String[] arg)   
    {
        if(!(cs instanceof EntityPlayerMP))
        {
            this.getModule().send(cs, GlobalText.onlyPlayer());
            return true;
        }
        Module m = this.getModule();
        EntityPlayerMP p = (EntityPlayerMP) cs;
        World w = p.getEntityWorld();
        if(!KajetansMod.worldManager.getWorldPreferences(w).blockProtection && !KajetansMod.perms.has(cs, Permissions.BLOCK_BYPASS))
        {
            m.send(cs, "Du darfst hier keine Blöcke schützen.");
            return true;
        }
        if(arg.length > 0)
        {
            BlockPos pos = Utils.getPlayerTarget(p);  
            IBlockState state = w.getBlockState(pos);
            Block b = state.getBlock();
            if(!Utils.shouldBeProtected(b) && !KajetansMod.perms.has(cs, Permissions.BLOCK_ALL))
            {
                m.send(cs, "Du kannst diesen Block nicht bearbeiten.");
                m.send(cs, "Du bist auf folgenden Block gerichtet: " + b.toString());
                return true;
            }                  
            if(Utils.getStateValue(state, BlockDoor.HALF) == BlockDoor.EnumDoorHalf.UPPER)
            {
                pos = pos.add(0, -1, 0);
            } 
            switch(arg[0])
            {
                case "protect":  
                {
                    String name = null;
                    if(arg.length >= 2 && KajetansMod.perms.has(cs, Permissions.BLOCK_OTHER))
                    {
                        name = arg[1];
                    }
                    bank.addBlock(pos, w, p, name);
                    if(b != Blocks.CHEST && b != Blocks.TRAPPED_CHEST)
                    {
                        return true;
                    }
                    BlockPos otherChest = Utils.getSameNearbyBlock(w, pos, b);
                    if(otherChest != null)
                    {
                        bank.addBlock(otherChest, w, p, name); 
                    }
                    return true;
                }
                case "remove":
                {
                    if(!bank.doesExist(pos, w))
                    {
                        this.getModule().send(p, "Der Block ist nicht gesichert.");
                        return true;
                    }
                    if(!bank.hasAccess(pos, w, p, false) && !KajetansMod.perms.has(cs, Permissions.BLOCK_BYPASS))
                    {
                        m.send(cs, "Du hast keinen Zugriff auf diesen Block.");
                        return true;
                    }
                    bank.removeBlock(pos, w, p);
                    if(b != Blocks.CHEST && b != Blocks.TRAPPED_CHEST)
                    {
                        return true;
                    }
                    BlockPos otherChest = Utils.getSameNearbyBlock(w, pos, b);
                    if(otherChest != null)
                    {
                        bank.removeBlock(otherChest, w, p); 
                    }
                    return true;
                }
                case "info":
                {
                    bank.printInfo(pos, w, p);
                    return true;
                }
                case "share":
                {
                    if(arg.length >= 2)
                    {
                        if(!bank.doesExist(pos, w))
                        {
                            this.getModule().send(p, "Der Block ist nicht gesichert.");
                            return true;
                        }
                        if(!bank.hasAccess(pos, w, p, false) && !KajetansMod.perms.has(cs, Permissions.BLOCK_BYPASS))
                        {
                            m.send(cs, "Du hast keinen Zugriff auf diesen Block.");
                            return true;
                        }
                        GameProfile player = KajetansMod.playerbank.getDataBank().getOfflinePlayer(arg[1]);
                        if(player == null)
                        {
                            m.send(cs, GlobalText.cantFindPlayer(arg[1]));
                            return true;
                        }
                        bank.addPlayer(pos, w, player, p);
                        if(b != Blocks.CHEST && b != Blocks.TRAPPED_CHEST)
                        {
                            return true;
                        }
                        BlockPos otherChest = Utils.getSameNearbyBlock(w, pos, b);
                        if(otherChest != null)
                        {
                            bank.addPlayer(otherChest, w, player, p); 
                        }
                        return true;
                    }
                }
                case "kick":
                {
                    if(arg.length >= 2)
                    {
                        if(!bank.doesExist(pos, w))
                        {
                            this.getModule().send(p, "Der Block ist nicht gesichert.");
                            return true;
                        }
                        if(!bank.hasAccess(pos, w, p, true) && !KajetansMod.perms.has(cs, Permissions.BLOCK_BYPASS))
                        {
                            m.send(cs, "Du hast keinen Zugriff auf diesen Block.");
                            return true;
                        }
                        GameProfile player = KajetansMod.playerbank.getDataBank().getOfflinePlayer(arg[1]);
                        if(player == null)
                        {
                            m.send(cs, GlobalText.cantFindPlayer(arg[1]));
                            return true;
                        }
                        bank.removePlayer(pos, w, player, p);
                        if(b != Blocks.CHEST && b != Blocks.TRAPPED_CHEST)
                        {
                            return true;
                        }
                        BlockPos otherChest = Utils.getSameNearbyBlock(w, pos, b);
                        if(otherChest != null)
                        {
                            bank.removePlayer(otherChest, w, player, p); 
                        }
                        return true;
                    }
                }
                case "clear":
                {
                    if(KajetansMod.perms.has(cs, Permissions.BLOCK_CLEAR))
                    {
                        checker = false;
                        SnuviScheduler.scheduleAsyncTask(() -> 
                        {
                            this.getModule().send(cs, "Blöcke aus Datenbank abrufen ...");
                            counter = 0;
                            locs = bank.getAllFromWorld(w);
                            checker = true;
                            this.getModule().send(cs, "Fertig ...");
                        });
                        SnuviScheduler.scheduleAsyncTask(() -> 
                        {
                            this.getModule().send(cs, "Schedule: Blöcke aus Welt abrufen ...");
                            if(!checker)
                            {
                                this.getModule().send(cs, "Das Abrufen aller Einträge hat zu lange gedauert.");
                                locs.clear();
                                blocks.clear();
                                return;
                            }
                            for(int i = 0; i < locs.size(); i+=50)
                            {
                                final int end = i + 50;
                                KajetansMod.scheduler.scheduleTask(() -> 
                                {
                                    this.getModule().send(cs, "Blöcke aus Welt abrufen " + (end / 50));
                                    for(int j = end - 50; j < locs.size() && j < end; j++)
                                    {
                                        try
                                        {
                                            blocks.add(w.getBlockState(locs.get(j)).getBlock());
                                        }
                                        catch(NullPointerException ex)
                                        {
                                            blocks.add(null);
                                        }
                                    }
                                    this.getModule().send(cs, "Fertig ...");
                                }, 0);
                            }
                            this.getModule().send(cs, "Fertig ...");
                        }, 200);
                        SnuviScheduler.scheduleAsyncTask(() -> 
                        {
                            this.getModule().send(cs, "Ungültige Entfernen ...");
                            index = 0;
                            blocks.stream().forEach(bl -> 
                            {
                                if(Utils.shouldBeProtected(bl))
                                {
                                    index++;
                                    return;
                                }
                                bank.removeBlock(locs.get(index), w, p);
                                index++;
                                counter++;
                            });
                            this.getModule().send(cs, "Alle ungültigen Protections wurden entfernt. (" + counter + ")");
                            locs.clear();
                            blocks.clear();
                        }, 400);
                        return true;
                    }
                    break;
                }
            }                    
        }
        m.send(cs, "/block ...");
        m.sendHelpListElement(cs, "protect [player]", "Erstellt eine Block-Protection");
        m.sendHelpListElement(cs, "remove", "Löscht eine Block-Protection");
        m.sendHelpListElement(cs, "info", "Gibt Information über den Block");
        m.sendHelpListElement(cs, "share <player>", "Teilt eine Block-Protection mit einem Spieler");
        m.sendHelpListElement(cs, "kick <player>", "Kickt einen Spieler von einer Block-Protection");
        if(KajetansMod.perms.has(cs, Permissions.BLOCK_CLEAR))
        {
            m.sendHelpListElement(cs, "clear", "Entfernt ungültige Block-Protections auf jeden Block");
        }
        return true;        
    }
}