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

package com.hypixel.hytale.server.core.universe.world.commands.block;

import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
import java.util.Iterator;
import java.util.Set;
import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
import java.util.function.Function;
import java.util.Comparator;
import com.hypixel.hytale.server.core.util.WildcardMatch;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import com.hypixel.hytale.math.shape.Box;
import com.hypixel.hytale.math.Axis;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.math.util.ChunkUtil;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.Rotation;
import com.hypixel.hytale.server.core.asset.type.blockhitbox.BlockBoundingBoxes;
import java.util.List;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.math.vector.Vector3d;
import java.util.Collection;
import com.hypixel.hytale.common.util.StringUtil;
import com.hypixel.hytale.server.core.command.system.CommandUtil;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
import com.hypixel.hytale.server.core.Message;
import com.hypixel.hytale.server.core.command.system.arguments.system.Argument;
import com.hypixel.hytale.server.core.modules.entity.component.HeadRotation;
import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.PlayerRef;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import com.hypixel.hytale.component.Store;
import javax.annotation.Nonnull;
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.RequiredArg;
import com.hypixel.hytale.server.core.command.system.basecommands.AbstractPlayerCommand;

public class BlockRowCommand extends AbstractPlayerCommand
{
    private final RequiredArg<String> queryArg;
    private static final int MAX_MATCHES = 64;
    
    public BlockRowCommand() {
        super("row", "server.commands.block.row.desc");
        this.queryArg = this.withRequiredArg("wildcard block query", "server.commands.block.row.arg.desc", ArgTypes.STRING);
    }
    
    @Override
    protected void execute(@Nonnull final CommandContext context, @Nonnull final Store<EntityStore> store, @Nonnull final Ref<EntityStore> ref, @Nonnull final PlayerRef playerRef, @Nonnull final World world) {
        final TransformComponent transformComponent = store.getComponent(ref, TransformComponent.getComponentType());
        assert transformComponent != null;
        final HeadRotation headRotationComponent = store.getComponent(ref, HeadRotation.getComponentType());
        assert headRotationComponent != null;
        final Vector3d playerPos = transformComponent.getPosition();
        final Vector3i axisDirection = getDominantCardinal(headRotationComponent.getDirection());
        final String query = context.get((Argument<?, String>)this.queryArg);
        final List<BlockType> blockTypes = this.findBlockTypes(query);
        if (blockTypes.isEmpty()) {
            playerRef.sendMessage(Message.translation("server.commands.block.row.nonefound").param("query", query));
            final List<String> fuzzyMatches = StringUtil.sortByFuzzyDistance(query, (Collection<String>)BlockType.getAssetMap().getAssetMap().keySet(), CommandUtil.RECOMMEND_COUNT);
            if (!fuzzyMatches.isEmpty()) {
                playerRef.sendMessage(Message.translation("server.commands.block.row.fuzzymatches").param("choices", fuzzyMatches.toString()));
            }
            return;
        }
        if (blockTypes.size() >= 64000) {
            playerRef.sendMessage(Message.translation("server.commands.block.row.toomanymatches").param("max", 64));
            return;
        }
        this.spawnBlocksRow(world, playerPos, axisDirection, blockTypes);
    }
    
    private void spawnBlocksRow(@Nonnull final World world, @Nonnull final Vector3d origin, @Nonnull final Vector3i direction, @Nonnull final List<BlockType> blockTypes) {
        final IndexedLookupTableAssetMap<String, BlockBoundingBoxes> boundingBoxes = BlockBoundingBoxes.getAssetMap();
        final Axis axis = getAxis(direction);
        for (int step = 25, x = 0; x < blockTypes.size(); x += step) {
            double distance = 1.0;
            for (int i = 0; i < step; ++i) {
                final BlockType blockType = blockTypes.get(i + x);
                final Box boundingBox = boundingBoxes.getAsset(blockType.getHitboxTypeIndex()).get(0).getBoundingBox();
                final double dimension = Math.ceil(boundingBox.dimension(axis));
                distance += Math.floor(dimension) + 1.0;
                final Vector3i blockPos = origin.clone().add(direction.clone().scale(distance)).add(Rotation.Ninety.rotateY(direction, new Vector3i()).scale(x / step * 2)).toVector3i();
                final long chunkIndex = ChunkUtil.indexChunkFromBlock(blockPos.x, blockPos.z);
                world.getChunkAsync(chunkIndex).thenAccept(chunk -> {
                    final int settings = 196;
                    chunk.setBlock(blockPos.x, blockPos.y, blockPos.z, blockType, 196);
                    return;
                });
            }
        }
    }
    
    @Nonnull
    private static Vector3i getDominantCardinal(@Nonnull final Vector3d direction) {
        final double ax = Math.abs(direction.x);
        final double ay = Math.abs(direction.y);
        final double az = Math.abs(direction.z);
        if (ax > ay && ax > az) {
            return new Vector3i((int)Math.signum(direction.x), 0, 0);
        }
        if (ay > az) {
            return new Vector3i(0, (int)Math.signum(direction.y), 0);
        }
        return new Vector3i(0, 0, (int)Math.signum(direction.z));
    }
    
    @Nonnull
    private static Axis getAxis(@Nonnull final Vector3i direction) {
        if (direction.x != 0) {
            return Axis.X;
        }
        if (direction.z != 0) {
            return Axis.Z;
        }
        return Axis.Y;
    }
    
    @Nonnull
    private List<BlockType> findBlockTypes(final String wildcardQuery) {
        List<BlockType> results = new ObjectArrayList<BlockType>();
        final BlockTypeAssetMap<String, BlockType> blockTypeAssets = BlockType.getAssetMap();
        final Set<String> parentKeys = blockTypeAssets.getAssetMap().keySet();
        for (final String blockName : parentKeys) {
            if (WildcardMatch.test(blockName, wildcardQuery)) {
                final BlockType blockType = blockTypeAssets.getAsset(blockName);
                results.add(blockType);
            }
        }
        results = results.stream().sorted(Comparator.comparing((Function<? super BlockType, ? extends Comparable>)BlockType::getId)).toList();
        return results;
    }
}