package me.km.datatools;

import me.km.api.GlobalText;
import me.km.api.Module;
import me.km.api.ModuleCommand;
import me.km.api.Utils;
import me.km.chatmanager.ChatManager;
import me.km.nms.NmsUtilities;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import me.km.permissions.Permissions;
import me.km.utils.ItemStackUtils;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLiving;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.item.ItemStack;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.text.TextComponentString;

public class CommandDataTools extends ModuleCommand
{
    private final ArrayList<String> first;
    
    public CommandDataTools(Module m) 
    {
        super("datatools", m);
        super.setDescription("Spezielle Commands um Daten zu verändern");
        super.setUsage("/datatools für die Hilfe");
        super.setPermission(Permissions.DATATOOLS);  
        super.addAlias("dt");
        
        first = new ArrayList<>(Arrays.asList(new String[]
                {"print-nbt", "flag", "attribute", "hide-entity", "show-entity", "name-entity", "name-item", "lore-item", "silent-entity"})); 
    }

    @Override
    public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos targetPos) 
    {
        List<String> names = new ArrayList<>();
        switch (args.length) 
        {
            case 1:
                first.stream().filter(e -> e.toLowerCase().startsWith(args[0].toLowerCase())).forEach(e ->
                {
                    names.add(e);
                }); 
                break;
            case 2:
                if(args[0].equals("flag"))
                {
                    Arrays.stream(ItemStackUtils.ItemFlag.values()).filter(e -> e.toString().toLowerCase().startsWith(args[1].toLowerCase())).forEach(e ->
                    {
                        names.add(e.toString());
                    });
                }
                else if(args[0].equals("attribute"))
                {
                    Arrays.stream(ItemStackUtils.Attribute.values()).filter(e -> e.toString().toLowerCase().startsWith(args[1].toLowerCase())).forEach(e ->
                    {
                        names.add(e.toString());
                    });
                }   
                break;
            case 3:
                if(args[0].equals("attribute"))
                {
                    Arrays.stream(EntityEquipmentSlot.values()).filter(e -> e.toString().toLowerCase().startsWith(args[2].toLowerCase())).forEach(e ->
                    {
                        names.add(e.toString());
                    });
                }   
                break;
            case 5:
                if(args[0].equals("attribute"))
                {
                    Arrays.stream(ItemStackUtils.Operation.values()).filter(e -> e.toString().toLowerCase().startsWith(args[4].toLowerCase())).forEach(e ->
                    {
                        names.add(e.toString());
                    });
                }   
                break;    
        }
        return names;  
    }

    @Override
    public boolean execute(ICommandSender cs, String[] arg) 
    {
        if(!(cs instanceof EntityPlayerMP))
        {
            this.getModule().send(cs, GlobalText.onlyPlayer());
            return true;
        }
        EntityPlayerMP p = (EntityPlayerMP) cs;
        Module m = this.getModule();
        if(arg.length >= 1)
        {         
            switch (arg[0]) 
            {
                case "print-nbt":
                {
                    Entity ent = Utils.getTargetedEntity(p, 3, Entity.class);
                    if(ent == null)
                    {
                        m.send(cs, "Du musst auf ein Objekt gerichtet sein.");
                        return true;
                    }       
                    this.getModule().send(cs, GlobalText.Spacer());
                    this.getModule().send(cs, "NBT-Daten " + ent.getName());
                    String nbt = NmsUtilities.getNbtString(ent);
                    cs.sendMessage(new TextComponentString(NmsUtilities.highlightNbtSyntax(nbt)));   
                    NmsUtilities.sendCopyableText(p, nbt);
                    return true;
                }
                case "test":
                {
                    EntityLiving ent = Utils.getTargetedEntity(p, 3, EntityLiving.class);
                    if(ent == null)
                    {
                        m.send(cs, "Du musst auf ein Objekt gerichtet sein.");
                        return true;
                    }       
                    NmsUtilities.canDestroyBlocks((EntityLiving) ent);
                    return true;
                }
                case "flag":
                {
                    if(arg.length < 2)
                    {
                        break;
                    }
                    ItemStack stack = p.getHeldItemMainhand();
                    if(stack == ItemStack.EMPTY)
                    {
                        m.send(cs, "Du musst ein Item in der Hand halten.");
                        return true;
                    }
                    try
                    {
                        ItemStackUtils.ItemFlag flag = ItemStackUtils.ItemFlag.valueOf(arg[1].toUpperCase());
                        ItemStackUtils.addItemFlag(stack, flag);
                        m.send(cs, "Die Flag wurde hinzugefügt.");
                    }
                    catch(IllegalArgumentException ex)
                    {
                        m.send(cs, "Die gegebene Flag existiert nicht.");
                    }                           
                    return true;
                }
                case "attribute":
                {
                    ItemStack stack = p.getHeldItemMainhand();
                    if(stack == ItemStack.EMPTY)
                    {
                        m.send(cs, "Du musst ein Item in der Hand halten.");
                        return true;
                    }                            
                    if(arg.length < 5)
                    {
                        break;
                    }
                    try
                    {
                        ItemStackUtils.addAttribute(stack, ItemStackUtils.Attribute.valueOf(arg[1]), 
                                EntityEquipmentSlot.valueOf(arg[2]), Double.parseDouble(arg[3]), ItemStackUtils.Operation.valueOf(arg[4]));
                        m.send(cs, "Das Attribut wurde hinzugefügt.");
                    } 
                    catch(NumberFormatException ex)
                    {
                        m.send(cs, "Die angegebene Zahl ist ungültig.");
                    }
                    catch(IllegalArgumentException ex)
                    {
                        m.send(cs, "Ein angegebener Enum existiert nicht.");
                    }
                    return true;
                }
                case "hide-entity":
                {
                    Entity ent = Utils.getTargetedEntity(p, 3, Entity.class);
                    if(ent == null)
                    {
                        m.send(cs, "Du musst auf ein Objekt gerichtet sein.");
                        return true;
                    }                        
                    ent.setInvisible(true);
                    m.send(cs, "Das Objekt sollte nun unsichtbar sein.");
                    return true;    
                }
                case "show-entity":
                    Collection<Entity> ents = Utils.getNearbyEntities(p.getEntityWorld(), p.getPositionVector(), 3, Entity.class);
                    if(ents.isEmpty())
                    {
                        m.send(cs, "Du musst mindestens ein Objekt in deiner Nähe haben.");
                        return true;
                    } 
                    ents.stream().forEach(ent -> ent.setInvisible(false));
                    m.send(cs, "Alle Objekte in deiner Nähe sollten wieder sichtbar sein.");
                    return true;  
                case "silent-entity":
                {
                    Entity ent = Utils.getTargetedEntity(p, 3, Entity.class);
                    if(ent == null)
                    {
                        m.send(cs, "Du musst auf ein Objekt gerichtet sein.");
                        return true;
                    }                                 
                    ent.setSilent(true);
                    m.send(cs, "Das Objekt sollte nun still sein.");
                    return true;    
                }
                case "name-entity":
                {
                    if(arg.length < 2)
                    {
                        break;
                    }
                    Entity ent = Utils.getTargetedEntity(p, 3, Entity.class);
                    if(ent == null)
                    {
                        m.send(cs, "Du musst auf ein Objekt gerichtet sein.");
                        return true;
                    }                                
                    String s = ChatManager.colorMessage(Utils.connectSpaces(arg, 1), p);
                    ent.setCustomNameTag(s);
                    m.send(cs, "Das Objekt träg nun den Namen '" + s + "§r'.");
                    return true; 
                }
                case "name-item":
                {
                    if(arg.length < 2)
                    { 
                        break;
                    }
                    ItemStack hand = p.getHeldItemMainhand();
                    if(hand == ItemStack.EMPTY)
                    {
                        m.send(cs, "Du musst ein Item in der Hand halten.");
                        return true;
                    }                          
                    String s = ChatManager.colorMessage(Utils.connectSpaces(arg, 1), p);
                    hand.setStackDisplayName(s);
                    m.send(cs, "Das Item trägt nun den Namen '" + s + "§r'.");
                    return true;
                }
                case "lore-item":
                    if(arg.length < 3)
                    {
                        break;
                    }
                    ItemStack hand = p.getHeldItemMainhand();
                    if(hand == ItemStack.EMPTY)
                    {
                        m.send(cs, "Du musst ein Item in der Hand halten.");
                        return true;
                    }                          
                    int line;
                    try
                    {
                        line = Integer.parseInt(arg[1]);
                        if(line < 0)
                        {
                            throw new NumberFormatException();
                        }
                    }
                    catch(NumberFormatException ex)
                    {
                        m.send(cs, GlobalText.noNaturalNumber());
                        return true;
                    }            
                    ItemStackUtils.addLore(hand, ChatManager.colorMessage(Utils.connectSpaces(arg, 2), p), line);
                    m.send(cs, "Die neue Lore wurde hinzugefügt.");
                    return true;
            }
        }
        
        m.send(cs, "/datatools ...");
        m.sendHelpListElement(cs, "print-nbt", "Gibt Information über eine Entity");
        m.sendHelpListElement(cs, "flag <flag>", "Fügt dem ItemStack eine Flag hinzu");
        m.sendHelpListElement(cs, "attribute <a> <slot> <d> <op>", "Fügt ein Attribut hinzu");
        m.sendHelpListElement(cs, "hide-entity", "Macht eine Entitiy unsichtbar");
        m.sendHelpListElement(cs, "show-entity", "Macht umliegende Entities sichtbar");
        m.sendHelpListElement(cs, "silent-entity", "Macht eine Entitiy still");
        m.sendHelpListElement(cs, "name-entity <name>", "Setzt einen Namen für eine Entity");
        m.sendHelpListElement(cs, "name-item <name>", "Setzt einen Namen für ein Item");
        m.sendHelpListElement(cs, "lore-item <line> <lore>", "Setzt eine Lore für ein Item");
        return true;  
    }
}