// 
// Decompiled by Procyon v0.6.0
// 

package com.hypixel.hytale.server.core.command.commands.player;

import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
import java.util.UUID;
import java.util.Iterator;
import java.util.Collection;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.component.Store;
import java.util.concurrent.Executor;
import com.hypixel.hytale.server.core.universe.Universe;
import com.hypixel.hytale.server.core.entity.UUIDComponent;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import com.hypixel.hytale.server.core.Message;
import java.util.concurrent.CompletableFuture;
import com.hypixel.hytale.server.core.command.system.CommandContext;
import com.hypixel.hytale.server.core.command.system.arguments.types.ArgumentType;
import com.hypixel.hytale.server.core.command.system.arguments.types.ArgTypes;
import com.hypixel.hytale.server.core.command.system.arguments.system.OptionalArg;
import javax.annotation.Nonnull;
import com.hypixel.hytale.server.core.universe.PlayerRef;
import com.hypixel.hytale.server.core.command.system.arguments.system.RequiredArg;
import com.hypixel.hytale.server.core.command.system.basecommands.AbstractAsyncCommand;
import com.hypixel.hytale.server.core.command.system.AbstractCommand;
import com.hypixel.hytale.server.core.command.system.basecommands.AbstractCommandCollection;

public class HideCommand extends AbstractCommandCollection
{
    public HideCommand() {
        super("hide", "server.commands.hide.desc");
        this.addUsageVariant(new HidePlayerCommand());
        this.addSubCommand(new ShowPlayerCommand());
        this.addSubCommand(new HideAllCommand());
        this.addSubCommand(new ShowAllCommand());
    }
    
    static class HidePlayerCommand extends AbstractAsyncCommand
    {
        @Nonnull
        private final RequiredArg<PlayerRef> playerArg;
        @Nonnull
        private final OptionalArg<PlayerRef> targetArg;
        
        HidePlayerCommand() {
            super("server.commands.hide.player.desc");
            this.playerArg = this.withRequiredArg("player", "server.commands.argtype.player.desc", ArgTypes.PLAYER_REF);
            this.targetArg = this.withOptionalArg("target", "server.commands.hide.target.desc", ArgTypes.PLAYER_REF);
        }
        
        @Nonnull
        @Override
        protected CompletableFuture<Void> executeAsync(@Nonnull final CommandContext context) {
            final PlayerRef playerRef = this.playerArg.get(context);
            final Ref<EntityStore> ref = playerRef.getReference();
            if (ref == null || !ref.isValid()) {
                context.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
                return CompletableFuture.completedFuture((Void)null);
            }
            final Store<EntityStore> store = ref.getStore();
            final World world = store.getExternalData().getWorld();
            return this.runAsync(context, () -> {
                final Player playerComponent = store.getComponent(ref, Player.getComponentType());
                if (playerComponent == null) {
                    context.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
                }
                else {
                    final UUIDComponent uuidComponent = store.getComponent(ref, UUIDComponent.getComponentType());
                    if (uuidComponent == null) {
                        context.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
                    }
                    else {
                        final UUID playerUuid = uuidComponent.getUuid();
                        if (this.targetArg.provided(context)) {
                            final PlayerRef targetPlayerRef = this.targetArg.get(context);
                            final Ref<EntityStore> targetRef = targetPlayerRef.getReference();
                            if (targetRef == null || !targetRef.isValid()) {
                                context.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
                            }
                            else if (targetRef.equals(ref)) {
                                context.sendMessage(Message.translation("server.commands.hide.cantHideFromSelf"));
                            }
                            else {
                                final Store<EntityStore> targetStore = targetRef.getStore();
                                final Player targetPlayerComponent = targetStore.getComponent(targetRef, Player.getComponentType());
                                if (targetPlayerComponent == null) {
                                    context.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
                                }
                                else {
                                    targetPlayerRef.getHiddenPlayersManager().hidePlayer(playerUuid);
                                    context.sendMessage(Message.translation("server.commands.hide.hiddenFrom").param("username", playerRef.getUsername()).param("targetUsername", targetPlayerRef.getUsername()));
                                }
                            }
                        }
                        else {
                            Universe.get().getWorlds().forEach((name, w) -> w.execute(() -> {
                                final Collection<PlayerRef> playerRefs = w.getPlayerRefs();
                                for (final PlayerRef targetPlayerRef2 : playerRefs) {
                                    final Ref<EntityStore> targetRef2 = targetPlayerRef2.getReference();
                                    if (targetRef2 != null) {
                                        if (!targetRef2.isValid()) {
                                            continue;
                                        }
                                        else if (targetRef2.equals(ref)) {
                                            continue;
                                        }
                                        else {
                                            final Store<EntityStore> targetStore2 = targetRef2.getStore();
                                            final Player targetPlayerComponent2 = targetStore2.getComponent(targetRef2, Player.getComponentType());
                                            if (targetPlayerComponent2 == null) {
                                                continue;
                                            }
                                            else {
                                                targetPlayerRef2.getHiddenPlayersManager().hidePlayer(playerUuid);
                                            }
                                        }
                                    }
                                }
                            }));
                            context.sendMessage(Message.translation("server.commands.hide.hiddenFromAll").param("username", playerRef.getUsername()));
                        }
                    }
                }
            }, world);
        }
    }
    
    static class ShowPlayerCommand extends AbstractAsyncCommand
    {
        @Nonnull
        private final RequiredArg<PlayerRef> playerArg;
        @Nonnull
        private final OptionalArg<PlayerRef> targetArg;
        
        ShowPlayerCommand() {
            super("show", "server.commands.hide.showPlayer.desc");
            this.playerArg = this.withRequiredArg("player", "server.commands.argtype.player.desc", ArgTypes.PLAYER_REF);
            this.targetArg = this.withOptionalArg("target", "server.commands.hide.target.desc", ArgTypes.PLAYER_REF);
        }
        
        @Nonnull
        @Override
        protected CompletableFuture<Void> executeAsync(@Nonnull final CommandContext context) {
            final PlayerRef playerRef = this.playerArg.get(context);
            final Ref<EntityStore> ref = playerRef.getReference();
            if (ref == null || !ref.isValid()) {
                context.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
                return CompletableFuture.completedFuture((Void)null);
            }
            final Store<EntityStore> store = ref.getStore();
            final World world = store.getExternalData().getWorld();
            return this.runAsync(context, () -> {
                final Player playerComponent = store.getComponent(ref, Player.getComponentType());
                if (playerComponent == null) {
                    context.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
                }
                else {
                    final UUIDComponent uuidComponent = store.getComponent(ref, UUIDComponent.getComponentType());
                    if (uuidComponent == null) {
                        context.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
                    }
                    else {
                        final UUID playerUuid = uuidComponent.getUuid();
                        if (this.targetArg.provided(context)) {
                            final PlayerRef targetPlayerRef = this.targetArg.get(context);
                            final Ref<EntityStore> targetRef = targetPlayerRef.getReference();
                            if (targetRef == null || !targetRef.isValid()) {
                                context.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
                            }
                            else if (targetRef.equals(ref)) {
                                context.sendMessage(Message.translation("server.commands.hide.cantHideFromSelf"));
                            }
                            else {
                                final Store<EntityStore> targetStore = targetRef.getStore();
                                final Player targetPlayerComponent = targetStore.getComponent(targetRef, Player.getComponentType());
                                if (targetPlayerComponent == null) {
                                    context.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
                                }
                                else {
                                    targetPlayerRef.getHiddenPlayersManager().showPlayer(playerUuid);
                                    context.sendMessage(Message.translation("server.commands.hide.shownTo").param("username", playerRef.getUsername()).param("targetUsername", targetPlayerRef.getUsername()));
                                }
                            }
                        }
                        else {
                            Universe.get().getWorlds().forEach((name, w) -> w.execute(() -> {
                                final Collection<PlayerRef> playerRefs = w.getPlayerRefs();
                                for (final PlayerRef targetPlayerRef2 : playerRefs) {
                                    final Ref<EntityStore> targetRef2 = targetPlayerRef2.getReference();
                                    if (targetRef2 != null) {
                                        if (!targetRef2.isValid()) {
                                            continue;
                                        }
                                        else if (targetRef2.equals(ref)) {
                                            continue;
                                        }
                                        else {
                                            final Store<EntityStore> targetStore2 = targetRef2.getStore();
                                            final Player targetPlayerComponent2 = targetStore2.getComponent(targetRef2, Player.getComponentType());
                                            if (targetPlayerComponent2 == null) {
                                                continue;
                                            }
                                            else {
                                                targetPlayerRef2.getHiddenPlayersManager().showPlayer(playerUuid);
                                            }
                                        }
                                    }
                                }
                            }));
                            context.sendMessage(Message.translation("server.commands.hide.shownToAll").param("username", playerRef.getUsername()));
                        }
                    }
                }
            }, world);
        }
    }
    
    static class HideAllCommand extends CommandBase
    {
        HideAllCommand() {
            super("all", "server.commands.hide.all.desc");
        }
        
        @Override
        protected void executeSync(@Nonnull final CommandContext context) {
            Universe.get().getWorlds().forEach((name, world) -> world.execute(() -> {
                final Collection<PlayerRef> playerRefs = world.getPlayerRefs();
                for (final PlayerRef playerRef1 : playerRefs) {
                    final Ref<EntityStore> ref1 = playerRef1.getReference();
                    if (ref1 != null) {
                        if (!ref1.isValid()) {
                            continue;
                        }
                        else {
                            final Store<EntityStore> store1 = ref1.getStore();
                            final Player playerComponent1 = store1.getComponent(ref1, Player.getComponentType());
                            if (playerComponent1 == null) {
                                continue;
                            }
                            else {
                                for (final PlayerRef playerRef2 : playerRefs) {
                                    if (playerRef1.equals(playerRef2)) {
                                        continue;
                                    }
                                    else {
                                        final Ref<EntityStore> ref2 = playerRef2.getReference();
                                        if (ref2 != null) {
                                            if (!ref2.isValid()) {
                                                continue;
                                            }
                                            else {
                                                final UUIDComponent uuidComponent = store1.getComponent(ref2, UUIDComponent.getComponentType());
                                                if (uuidComponent == null) {
                                                    continue;
                                                }
                                                else {
                                                    playerRef1.getHiddenPlayersManager().hidePlayer(uuidComponent.getUuid());
                                                }
                                            }
                                        }
                                        else {
                                            continue;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }));
            context.sendMessage(Message.translation("server.commands.hide.allHiddenFromAll"));
        }
    }
    
    static class ShowAllCommand extends CommandBase
    {
        ShowAllCommand() {
            super("showall", "server.commands.hide.showAll.desc");
        }
        
        @Override
        protected void executeSync(@Nonnull final CommandContext context) {
            Universe.get().getWorlds().forEach((name, world) -> world.execute(() -> {
                final Collection<PlayerRef> playerRefs = world.getPlayerRefs();
                for (final PlayerRef playerRef1 : playerRefs) {
                    final Ref<EntityStore> ref1 = playerRef1.getReference();
                    if (ref1 != null) {
                        if (!ref1.isValid()) {
                            continue;
                        }
                        else {
                            final Store<EntityStore> store1 = ref1.getStore();
                            final Player playerComponent1 = store1.getComponent(ref1, Player.getComponentType());
                            if (playerComponent1 == null) {
                                continue;
                            }
                            else {
                                for (final PlayerRef playerRef2 : playerRefs) {
                                    if (playerRef1.equals(playerRef2)) {
                                        continue;
                                    }
                                    else {
                                        final Ref<EntityStore> ref2 = playerRef2.getReference();
                                        if (ref2 != null) {
                                            if (!ref2.isValid()) {
                                                continue;
                                            }
                                            else {
                                                final UUIDComponent uuidComponent = store1.getComponent(ref2, UUIDComponent.getComponentType());
                                                if (uuidComponent == null) {
                                                    continue;
                                                }
                                                else {
                                                    playerRef1.getHiddenPlayersManager().showPlayer(uuidComponent.getUuid());
                                                }
                                            }
                                        }
                                        else {
                                            continue;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }));
            context.sendMessage(Message.translation("server.commands.hide.allShownToAll"));
        }
    }
}