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

package com.hypixel.hytale.builtin.npccombatactionevaluator.corecomponents;

import com.hypixel.hytale.math.vector.Vector3d;
import com.hypixel.hytale.logger.HytaleLogger;
import it.unimi.dsi.fastutil.ints.Int2FloatOpenHashMap;
import com.hypixel.hytale.server.core.asset.type.attitude.Attitude;
import java.util.logging.Level;
import com.hypixel.hytale.builtin.npccombatactionevaluator.memory.TargetMemorySystems;
import com.hypixel.hytale.component.ComponentAccessor;
import com.hypixel.hytale.component.Ref;
import javax.annotation.Nonnull;
import com.hypixel.hytale.builtin.npccombatactionevaluator.memory.TargetMemory;
import javax.annotation.Nullable;
import com.hypixel.hytale.server.npc.role.Role;
import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import com.hypixel.hytale.component.ComponentType;
import com.hypixel.hytale.server.npc.corecomponents.ISensorEntityCollector;

public class CombatTargetCollector implements ISensorEntityCollector
{
    private static final ComponentType<EntityStore, TransformComponent> TRANSFORM_COMPONENT_TYPE;
    @Nullable
    private Role role;
    @Nullable
    private TargetMemory targetMemory;
    private double closestHostileDistanceSquared;
    
    public CombatTargetCollector() {
        this.closestHostileDistanceSquared = Double.MAX_VALUE;
    }
    
    @Override
    public void registerWithSupport(@Nonnull final Role role) {
        role.getWorldSupport().requireAttitudeCache();
    }
    
    @Override
    public void init(@Nonnull final Ref<EntityStore> ref, @Nonnull final Role role, @Nonnull final ComponentAccessor<EntityStore> componentAccessor) {
        this.targetMemory = componentAccessor.getComponent(ref, TargetMemory.getComponentType());
        this.role = role;
    }
    
    @Override
    public void collectMatching(@Nonnull final Ref<EntityStore> ref, @Nonnull final Ref<EntityStore> targetRef, @Nonnull final ComponentAccessor<EntityStore> componentAccessor) {
        if (this.targetMemory == null) {
            return;
        }
        final Attitude attitude = this.role.getWorldSupport().getAttitude(ref, targetRef, componentAccessor);
        switch (attitude) {
            case HOSTILE: {
                final Int2FloatOpenHashMap hostiles = this.targetMemory.getKnownHostiles();
                if (hostiles.put(targetRef.getIndex(), this.targetMemory.getRememberFor()) <= 0.0f) {
                    this.targetMemory.getKnownHostilesList().add(targetRef);
                    final HytaleLogger.Api context = TargetMemorySystems.LOGGER.at(Level.FINE);
                    if (context.isEnabled()) {
                        context.log("%s: Registered new hostile %s", ref, targetRef);
                    }
                }
                final TransformComponent transformComponent = componentAccessor.getComponent(ref, CombatTargetCollector.TRANSFORM_COMPONENT_TYPE);
                assert transformComponent != null;
                final Vector3d selfPos = transformComponent.getPosition();
                final TransformComponent targetTransformComponent = componentAccessor.getComponent(targetRef, CombatTargetCollector.TRANSFORM_COMPONENT_TYPE);
                assert targetTransformComponent != null;
                final Vector3d targetPos = targetTransformComponent.getPosition();
                final double distanceSquared = selfPos.distanceSquaredTo(targetPos);
                if (distanceSquared < this.closestHostileDistanceSquared) {
                    this.targetMemory.setClosestHostile(targetRef);
                    this.closestHostileDistanceSquared = distanceSquared;
                }
                break;
            }
            case FRIENDLY:
            case REVERED: {
                final Int2FloatOpenHashMap friendlies = this.targetMemory.getKnownFriendlies();
                if (friendlies.put(targetRef.getIndex(), this.targetMemory.getRememberFor()) > 0.0f) {
                    break;
                }
                this.targetMemory.getKnownFriendliesList().add(targetRef);
                final HytaleLogger.Api context = TargetMemorySystems.LOGGER.at(Level.FINE);
                if (context.isEnabled()) {
                    context.log("%s: Registered new friendly %s", ref, targetRef);
                    break;
                }
                break;
            }
        }
    }
    
    @Override
    public void collectNonMatching(@Nonnull final Ref<EntityStore> targetRef, @Nonnull final ComponentAccessor<EntityStore> componentAccessor) {
    }
    
    @Override
    public boolean terminateOnFirstMatch() {
        return this.targetMemory == null;
    }
    
    @Override
    public void cleanup() {
        this.role = null;
        this.targetMemory = null;
        this.closestHostileDistanceSquared = Double.MAX_VALUE;
    }
    
    static {
        TRANSFORM_COMPONENT_TYPE = TransformComponent.getComponentType();
    }
}