package com.hypixel.hytale.server.npc.entities;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.component.ComponentAccessor;
import com.hypixel.hytale.component.ComponentType;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.component.Store;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.math.random.RandomExtra;
import com.hypixel.hytale.math.vector.Vector3d;
import com.hypixel.hytale.math.vector.Vector3f;
import com.hypixel.hytale.protocol.AnimationSlot;
import com.hypixel.hytale.protocol.BlockMaterial;
import com.hypixel.hytale.server.core.asset.type.entityeffect.config.ApplicationEffects;
import com.hypixel.hytale.server.core.asset.type.entityeffect.config.EntityEffect;
import com.hypixel.hytale.server.core.asset.type.environment.config.Environment;
import com.hypixel.hytale.server.core.asset.type.model.config.Model;
import com.hypixel.hytale.server.core.asset.type.model.config.ModelAsset;
import com.hypixel.hytale.server.core.entity.AnimationUtils;
import com.hypixel.hytale.server.core.entity.Entity;
import com.hypixel.hytale.server.core.entity.LivingEntity;
import com.hypixel.hytale.server.core.entity.effect.EffectControllerComponent;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.inventory.Inventory;
import com.hypixel.hytale.server.core.modules.entity.EntityModule;
import com.hypixel.hytale.server.core.modules.entity.component.ActiveAnimationComponent;
import com.hypixel.hytale.server.core.modules.entity.component.ModelComponent;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.npc.INonPlayerCharacter;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import com.hypixel.hytale.server.npc.NPCPlugin;
import com.hypixel.hytale.server.npc.blackboard.Blackboard;
import com.hypixel.hytale.server.npc.blackboard.view.blocktype.BlockTypeView;
import com.hypixel.hytale.server.npc.blackboard.view.event.EntityEventNotification;
import com.hypixel.hytale.server.npc.blackboard.view.event.EventNotification;
import com.hypixel.hytale.server.npc.blackboard.view.event.block.BlockEventType;
import com.hypixel.hytale.server.npc.blackboard.view.event.block.BlockEventView;
import com.hypixel.hytale.server.npc.blackboard.view.event.entity.EntityEventType;
import com.hypixel.hytale.server.npc.blackboard.view.event.entity.EntityEventView;
import com.hypixel.hytale.server.npc.components.messaging.EntityEventSupport;
import com.hypixel.hytale.server.npc.components.messaging.EventSupport;
import com.hypixel.hytale.server.npc.components.messaging.NPCBlockEventSupport;
import com.hypixel.hytale.server.npc.components.messaging.NPCEntityEventSupport;
import com.hypixel.hytale.server.npc.components.messaging.PlayerBlockEventSupport;
import com.hypixel.hytale.server.npc.components.messaging.PlayerEntityEventSupport;
import com.hypixel.hytale.server.npc.role.Role;
import com.hypixel.hytale.server.npc.role.RoleDebugFlags;
import com.hypixel.hytale.server.npc.storage.AlarmStore;
import com.hypixel.hytale.server.npc.util.DamageData;
import com.hypixel.hytale.server.spawning.assets.spawns.config.WorldNPCSpawn;
import it.unimi.dsi.fastutil.ints.IntList;
import it.unimi.dsi.fastutil.ints.IntSet;
import java.time.Instant;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class NPCEntity extends LivingEntity implements INonPlayerCharacter {
   public static final BuilderCodec<NPCEntity> CODEC = BuilderCodec.builder(NPCEntity.class, NPCEntity::new, LivingEntity.CODEC)
      .addField(new KeyedCodec<>("Env", Codec.STRING), (npcEntity, s) -> npcEntity.environmentIndex = Environment.getAssetMap().getIndex(s), npcEntity -> {
         Environment environment = Environment.getAssetMap().getAssetOrDefault(npcEntity.environmentIndex, null);
         return environment != null ? environment.getId() : null;
      })
      .addField(new KeyedCodec<>("HvrPhs", Codec.DOUBLE), (npcEntity, d) -> npcEntity.hoverPhase = d.floatValue(), npcEntity -> (double)npcEntity.hoverPhase)
      .addField(new KeyedCodec<>("HvrHght", Codec.DOUBLE), (npcEntity, d) -> npcEntity.hoverHeight = d, npcEntity -> npcEntity.hoverHeight)
      .addField(new KeyedCodec<>("SpawnName", Codec.STRING), (npcEntity, s) -> {
         npcEntity.spawnRoleName = s;
         npcEntity.spawnRoleIndex = NPCPlugin.get().getIndex(s);
      }, npcEntity -> npcEntity.spawnRoleName)
      .addField(
         new KeyedCodec<>("MdlScl", Codec.DOUBLE),
         (npcEntity, d) -> npcEntity.initialModelScale = d.floatValue(),
         npcEntity -> (double)npcEntity.initialModelScale
      )
      .addField(new KeyedCodec<>("SpawnConfig", Codec.STRING), (npcEntity, s) -> {
         npcEntity.spawnConfigurationName = s;
         npcEntity.spawnConfigurationIndex = WorldNPCSpawn.getAssetMap().getIndex(s);
      }, npcEntity -> npcEntity.spawnConfigurationName)
      .addField(new KeyedCodec<>("SpawnInstant", Codec.INSTANT), (npcEntity, instant) -> npcEntity.spawnInstant = instant, npcEntity -> npcEntity.spawnInstant)
      .append(new KeyedCodec<>("AlarmStore", AlarmStore.CODEC), (npcEntity, alarmStore) -> npcEntity.alarmStore = alarmStore, npcEntity -> npcEntity.alarmStore)
      .add()
      .addField(new KeyedCodec<>("WorldgenId", Codec.INTEGER), (npcEntity, i) -> npcEntity.worldgenId = i, npcEntity -> npcEntity.worldgenId)
      .append(new KeyedCodec<>("PathManager", PathManager.CODEC), (npcEntity, manager) -> npcEntity.pathManager = manager, npcEntity -> npcEntity.pathManager)
      .add()
      .addField(new KeyedCodec<>("LeashPos", Vector3d.CODEC), (npcEntity, v) -> {
         npcEntity.leashPoint.assign(v);
         npcEntity.hasLeashPosition = true;
      }, npcEntity -> npcEntity.requiresLeashPosition() ? npcEntity.leashPoint : null)
      .addField(
         new KeyedCodec<>("LeashHdg", Codec.DOUBLE),
         (npcEntity, v) -> npcEntity.leashHeading = v.floatValue(),
         npcEntity -> npcEntity.requiresLeashPosition() ? (double)npcEntity.leashHeading : null
      )
      .addField(
         new KeyedCodec<>("LeashPtch", Codec.DOUBLE),
         (npcEntity, v) -> npcEntity.leashPitch = v.floatValue(),
         npcEntity -> npcEntity.requiresLeashPosition() ? (double)npcEntity.leashPitch : null
      )
      .addField(new KeyedCodec<>("RoleName", Codec.STRING), (npcEntity, s) -> npcEntity.roleName = s, npcEntity -> npcEntity.roleName)
      .build();
   private String roleName;
   private int roleIndex = Integer.MIN_VALUE;
   @Nullable
   private Role role;
   private int spawnRoleIndex = Integer.MIN_VALUE;
   @Nullable
   private String spawnRoleName;
   @Nullable
   private String spawnConfigurationName;
   private int environmentIndex = Integer.MIN_VALUE;
   private int spawnConfigurationIndex = Integer.MIN_VALUE;
   private boolean isSpawnTracked;
   private boolean isDespawning;
   private boolean isPlayingDespawnAnim;
   private float despawnRemainingSeconds;
   private float despawnCheckRemainingSeconds = RandomExtra.randomRange(1.0F, 5.0F);
   private float despawnAnimationRemainingSeconds;
   private float cachedEntityHorizontalSpeedMultiplier = Float.MAX_VALUE;
   private final Vector3d leashPoint = new Vector3d();
   private float leashHeading;
   private float leashPitch;
   private boolean hasLeashPosition;
   private float hoverPhase;
   private double hoverHeight;
   private float initialModelScale = 1.0F;
   private Instant spawnInstant;
   @Nonnull
   private PathManager pathManager = new PathManager();
   private final DamageData damageData = new DamageData();
   @Nullable
   private BlockTypeView blackboardBlockTypeView;
   private IntList blackboardBlockTypeSets;
   private BlockEventView blackboardBlockChangeView;
   private Map<BlockEventType, IntSet> blackboardBlockChangeSets;
   private EntityEventView blackboardEntityEventView;
   private Map<EntityEventType, IntSet> blackboardEntityEventSets;
   private AlarmStore alarmStore;
   @Deprecated(forRemoval = true)
   private int worldgenId = 0;
   @Nonnull
   private final Set<UUID> reservedBy = new HashSet<>();
   private final Vector3d oldPosition = new Vector3d();

   @Nullable
   public static ComponentType<EntityStore, NPCEntity> getComponentType() {
      return EntityModule.get().getComponentType(NPCEntity.class);
   }

   public NPCEntity() {
      this.role = null;
   }

   public NPCEntity(@Nonnull World world) {
      super(world);
      this.role = null;
   }

   @Nonnull
   public AlarmStore getAlarmStore() {
      if (this.alarmStore == null) {
         this.alarmStore = new AlarmStore();
      }

      return this.alarmStore;
   }

   @Nonnull
   @Override
   protected Inventory createDefaultInventory() {
      return new Inventory((short)0, Inventory.DEFAULT_ARMOR_CAPACITY, (short)3, (short)0, (short)0);
   }

   @Nullable
   public Role getRole() {
      return this.role;
   }

   public void invalidateCachedHorizontalSpeedMultiplier() {
      this.cachedEntityHorizontalSpeedMultiplier = Float.MAX_VALUE;
   }

   public void storeTickStartPosition(@Nonnull Vector3d position) {
      this.oldPosition.assign(position);
   }

   public boolean tickDespawnAnimationRemainingSeconds(float dt) {
      return (this.despawnAnimationRemainingSeconds -= dt) <= 0.0F;
   }

   public void setDespawnAnimationRemainingSeconds(float seconds) {
      this.despawnAnimationRemainingSeconds = seconds;
   }

   public boolean tickDespawnRemainingSeconds(float dt) {
      return (this.despawnRemainingSeconds -= dt) <= 0.0F;
   }

   public void setDespawnRemainingSeconds(float seconds) {
      this.despawnRemainingSeconds = seconds;
   }

   public void setDespawning(boolean despawning) {
      this.isDespawning = despawning;
   }

   public void setPlayingDespawnAnim(boolean playingDespawnAnim) {
      this.isPlayingDespawnAnim = playingDespawnAnim;
   }

   public boolean tickDespawnCheckRemainingSeconds(float dt) {
      return (this.despawnCheckRemainingSeconds -= dt) <= 0.0F;
   }

   public void setDespawnCheckRemainingSeconds(float seconds) {
      this.despawnCheckRemainingSeconds = seconds;
   }

   public void setInitialModelScale(float scale) {
      this.initialModelScale = scale;
   }

   public Vector3d getOldPosition() {
      return this.oldPosition;
   }

   public void playAnimation(
      @Nonnull Ref<EntityStore> ref,
      @Nonnull AnimationSlot animationSlot,
      @Nullable String animationId,
      @Nonnull ComponentAccessor<EntityStore> componentAccessor
   ) {
      Model model = null;
      ModelComponent modelComponent = componentAccessor.getComponent(ref, ModelComponent.getComponentType());
      if (modelComponent != null) {
         model = modelComponent.getModel();
      }

      if (animationSlot != AnimationSlot.Action && animationId != null && model != null && !model.getAnimationSetMap().containsKey(animationId)) {
         ((HytaleLogger.Api)Entity.LOGGER.at(Level.WARNING).atMostEvery(1, TimeUnit.MINUTES))
            .log("Missing animation '%s' for Model '%s'", animationId, model.getModelAssetId());
      } else {
         ActiveAnimationComponent activeAnimationComponent = componentAccessor.getComponent(ref, ActiveAnimationComponent.getComponentType());
         if (activeAnimationComponent == null) {
            ((HytaleLogger.Api)Entity.LOGGER.at(Level.WARNING).atMostEvery(1, TimeUnit.MINUTES))
               .log("Missing active animation component for entity: %s", this.roleName);
         } else {
            String[] activeAnimations = activeAnimationComponent.getActiveAnimations();
            if (animationSlot == AnimationSlot.Action || !Objects.equals(activeAnimations[animationSlot.ordinal()], animationId)) {
               activeAnimations[animationSlot.ordinal()] = animationId;
               activeAnimationComponent.setPlayingAnimation(animationSlot, animationId);
               AnimationUtils.playAnimation(ref, animationSlot, animationId, componentAccessor);
            }
         }
      }
   }

   public void clearDamageData() {
      this.damageData.reset();
   }

   public void setToDespawn() {
      this.isDespawning = true;
   }

   public void setDespawnTime(float time) {
      if (this.isDespawning) {
         this.despawnRemainingSeconds = time;
      }
   }

   public double getDespawnTime() {
      return this.despawnRemainingSeconds;
   }

   @Override
   public boolean canBreathe(
      @Nonnull Ref<EntityStore> ref, @Nonnull BlockMaterial breathingMaterial, int fluidId, @Nonnull ComponentAccessor<EntityStore> componentAccessor
   ) {
      return this.role.canBreathe(breathingMaterial, fluidId);
   }

   public DamageData getDamageData() {
      return this.damageData;
   }

   public boolean getCanCauseDamage(@Nonnull Ref<EntityStore> attackerRef, @Nonnull ComponentAccessor<EntityStore> componentAccessor) {
      return this.role.getCombatSupport().getCanCauseDamage(attackerRef, componentAccessor);
   }

   public void onFlockSetState(
      @Nonnull Ref<EntityStore> ref, @Nonnull String state, @Nullable String subState, @Nonnull ComponentAccessor<EntityStore> componentAccessor
   ) {
      this.role.getStateSupport().setState(ref, state, subState, componentAccessor);
   }

   public void onFlockSetTarget(@Nonnull String targetSlot, @Nonnull Ref<EntityStore> target) {
      this.role.setMarkedTarget(targetSlot, target);
   }

   public void saveLeashInformation(@Nonnull Vector3d position, @Nonnull Vector3f rotation) {
      this.leashPoint.assign(position);
      this.leashHeading = rotation.getYaw();
      this.leashPitch = rotation.getPitch();
      this.saveLeashBlockType();
   }

   public void saveLeashBlockType() {
   }

   public boolean requiresLeashPosition() {
      return this.role != null ? this.role.requiresLeashPosition() : this.hasLeashPosition;
   }

   public Vector3d getLeashPoint() {
      return this.leashPoint;
   }

   public void setLeashPoint(@Nonnull Vector3d leashPoint) {
      this.leashPoint.assign(leashPoint);
   }

   public float getLeashHeading() {
      return this.leashHeading;
   }

   public void setLeashHeading(float leashHeading) {
      this.leashHeading = leashHeading;
   }

   public float getLeashPitch() {
      return this.leashPitch;
   }

   public void setLeashPitch(float leashPitch) {
      this.leashPitch = leashPitch;
   }

   public float getHoverPhase() {
      return this.hoverPhase;
   }

   public void setHoverPhase(float hoverPhase) {
      this.hoverPhase = hoverPhase;
   }

   public double getHoverHeight() {
      return this.hoverHeight;
   }

   public void setHoverHeight(double hoverHeight) {
      this.hoverHeight = hoverHeight;
   }

   public String getRoleName() {
      return this.roleName;
   }

   public void setRoleName(String roleName) {
      this.roleName = roleName;
   }

   public int getRoleIndex() {
      return this.roleIndex;
   }

   public void setRoleIndex(int roleIndex) {
      this.roleIndex = roleIndex;
   }

   public void setRole(Role role) {
      this.role = role;
   }

   public int getSpawnRoleIndex() {
      return this.spawnRoleIndex != Integer.MIN_VALUE ? this.spawnRoleIndex : this.roleIndex;
   }

   public void setSpawnRoleIndex(int spawnRoleIndex) {
      if (spawnRoleIndex == this.roleIndex) {
         spawnRoleIndex = Integer.MIN_VALUE;
      }

      this.spawnRoleIndex = spawnRoleIndex;
      if (spawnRoleIndex == Integer.MIN_VALUE) {
         this.spawnRoleName = null;
      } else {
         this.spawnRoleName = NPCPlugin.get().getName(spawnRoleIndex);
      }
   }

   @Nonnull
   public BlockTypeView getBlockTypeBlackboardView(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store) {
      if (this.blackboardBlockTypeView == null) {
         this.initBlockTypeBlackboardView(ref, store);
      }

      if (this.blackboardBlockTypeView.isOutdated(ref, store)) {
         this.blackboardBlockTypeView = this.blackboardBlockTypeView.getUpdatedView(ref, store);
      }

      return this.blackboardBlockTypeView;
   }

   @Nullable
   public BlockTypeView removeBlockTypeBlackboardView() {
      BlockTypeView view = this.blackboardBlockTypeView;
      this.blackboardBlockTypeView = null;
      return view;
   }

   public void initBlockTypeBlackboardView(@Nonnull Ref<EntityStore> ref, ComponentAccessor<EntityStore> componentAccessor) {
      if (this.blackboardBlockTypeSets != null) {
         this.blackboardBlockTypeView = componentAccessor.getResource(Blackboard.getResourceType()).getView(BlockTypeView.class, ref, componentAccessor);
         this.blackboardBlockTypeView.initialiseEntity(ref, this);
      }
   }

   public void initBlockChangeBlackboardView(@Nonnull Ref<EntityStore> ref, ComponentAccessor<EntityStore> componentAccessor) {
      if (this.blackboardBlockChangeSets != null) {
         this.blackboardBlockChangeView = componentAccessor.getResource(Blackboard.getResourceType()).getView(BlockEventView.class, ref, componentAccessor);
         this.blackboardBlockChangeView.initialiseEntity(ref, this);
      }

      if (this.blackboardEntityEventSets != null) {
         this.blackboardEntityEventView = componentAccessor.getResource(Blackboard.getResourceType()).getView(EntityEventView.class, ref, componentAccessor);
         this.blackboardEntityEventView.initialiseEntity(ref, this);
      }
   }

   public void addBlackboardBlockTypeSets(IntList blackboardBlockSets) {
      this.blackboardBlockTypeSets = blackboardBlockSets;
   }

   public IntList getBlackboardBlockTypeSets() {
      return this.blackboardBlockTypeSets;
   }

   public void addBlackboardBlockChangeSets(@Nonnull BlockEventType type, @Nonnull IntSet sets) {
      if (this.blackboardBlockChangeSets == null) {
         this.blackboardBlockChangeSets = new EnumMap<>(BlockEventType.class);
      }

      this.blackboardBlockChangeSets.put(type, sets);
   }

   public IntSet getBlackboardBlockChangeSet(BlockEventType type) {
      return this.blackboardBlockChangeSets.getOrDefault(type, null);
   }

   public Map<BlockEventType, IntSet> getBlackboardBlockChangeSets() {
      return this.blackboardBlockChangeSets;
   }

   public void notifyBlockChange(@Nonnull BlockEventType type, @Nonnull EventNotification notification) {
      Store<EntityStore> store = this.world.getEntityStore().getStore();
      Ref<EntityStore> initiator = notification.getInitiator();
      boolean isPlayer = store.getArchetype(initiator).contains(Player.getComponentType());
      EventSupport<BlockEventType, EventNotification> support;
      if (isPlayer) {
         support = store.getComponent(this.reference, PlayerBlockEventSupport.getComponentType());
      } else {
         support = store.getComponent(this.reference, NPCBlockEventSupport.getComponentType());
      }

      if (support != null) {
         support.postMessage(type, notification, this.getReference(), store);
      }
   }

   public void addBlackboardEntityEventSets(@Nonnull EntityEventType type, @Nonnull IntSet sets) {
      if (this.blackboardEntityEventSets == null) {
         this.blackboardEntityEventSets = new EnumMap<>(EntityEventType.class);
      }

      this.blackboardEntityEventSets.put(type, sets);
   }

   public IntSet getBlackboardEntityEventSet(@Nonnull EntityEventType type) {
      return this.blackboardEntityEventSets.getOrDefault(type, null);
   }

   public Map<EntityEventType, IntSet> getBlackboardEntityEventSets() {
      return this.blackboardEntityEventSets;
   }

   public void notifyEntityEvent(@Nonnull EntityEventType type, @Nonnull EntityEventNotification notification) {
      Store<EntityStore> store = this.world.getEntityStore().getStore();
      Ref<EntityStore> initiator = notification.getInitiator();
      boolean isPlayer = store.getArchetype(initiator).contains(Player.getComponentType());
      EntityEventSupport support;
      if (isPlayer) {
         support = store.getComponent(this.reference, PlayerEntityEventSupport.getComponentType());
      } else {
         support = store.getComponent(this.reference, NPCEntityEventSupport.getComponentType());
      }

      if (support != null) {
         support.postMessage(type, notification, this.reference, store);
      }
   }

   public void setEnvironment(int env) {
      this.environmentIndex = env;
   }

   public int getEnvironment() {
      return this.environmentIndex;
   }

   public int getSpawnConfiguration() {
      return this.spawnConfigurationIndex;
   }

   public void setSpawnConfiguration(int spawnConfigurationIndex) {
      if (spawnConfigurationIndex == Integer.MIN_VALUE) {
         this.spawnConfigurationIndex = Integer.MIN_VALUE;
         this.spawnConfigurationName = null;
      } else {
         String name = WorldNPCSpawn.getAssetMap().getAsset(spawnConfigurationIndex).getId();
         if (name == null) {
            throw new IllegalArgumentException("setSpawnConfiguration: Cannot find spawn configuration name for index: " + spawnConfigurationIndex);
         } else {
            this.spawnConfigurationIndex = spawnConfigurationIndex;
            this.spawnConfigurationName = name;
         }
      }
   }

   public boolean updateSpawnTrackingState(boolean newState) {
      boolean oldState = this.isSpawnTracked;
      this.isSpawnTracked = newState;
      return oldState;
   }

   public boolean isDespawning() {
      return this.isDespawning;
   }

   public boolean isPlayingDespawnAnim() {
      return this.isPlayingDespawnAnim;
   }

   public EnumSet<RoleDebugFlags> getRoleDebugFlags() {
      return this.role.getDebugSupport().getDebugFlags();
   }

   public void setRoleDebugFlags(@Nonnull EnumSet<RoleDebugFlags> flags) {
      this.role.getDebugSupport().setDebugFlags(flags);
   }

   public void setSpawnInstant(@Nonnull Instant spawned) {
      this.spawnInstant = spawned;
   }

   public Instant getSpawnInstant() {
      return this.spawnInstant;
   }

   public void setInventorySize(int hotbarCapacity, int inventoryCapacity, int offHandCapacity) {
      this.setInventory(new Inventory((short)inventoryCapacity, Inventory.DEFAULT_ARMOR_CAPACITY, (short)hotbarCapacity, (short)offHandCapacity, (short)0));
   }

   @Deprecated(forRemoval = true)
   public int getLegacyWorldgenId() {
      return this.worldgenId;
   }

   @Nonnull
   public PathManager getPathManager() {
      return this.pathManager;
   }

   public static boolean setAppearance(@Nonnull Ref<EntityStore> ref, @Nonnull String name, @Nonnull ComponentAccessor<EntityStore> componentAccessor) {
      if (name.isEmpty()) {
         throw new IllegalArgumentException("Appearance can't be changed to empty");
      } else {
         ModelComponent modelComponent = componentAccessor.getComponent(ref, ModelComponent.getComponentType());
         if (modelComponent == null) {
            return false;
         } else {
            Model model = modelComponent.getModel();
            if (name.equals(model.getModelAssetId())) {
               return true;
            } else {
               NPCEntity npcComponent = componentAccessor.getComponent(ref, getComponentType());

               assert npcComponent != null;

               ModelAsset modelAsset = ModelAsset.getAssetMap().getAsset(name);
               if (modelAsset == null) {
                  NPCPlugin.get().getLogger().at(Level.SEVERE).log("Role '%s': Cannot find model '%s'", npcComponent.roleName, name);
                  return false;
               } else {
                  npcComponent.setAppearance(ref, modelAsset, componentAccessor);
                  return true;
               }
            }
         }
      }
   }

   public void setAppearance(@Nonnull Ref<EntityStore> ref, @Nonnull ModelAsset modelAsset, @Nonnull ComponentAccessor<EntityStore> componentAccessor) {
      Model model = Model.createScaledModel(modelAsset, this.initialModelScale);
      componentAccessor.putComponent(ref, ModelComponent.getComponentType(), new ModelComponent(model));
      this.role.updateMotionControllers(ref, model, model.getBoundingBox(), componentAccessor);
   }

   public float getCurrentHorizontalSpeedMultiplier(@Nullable Ref<EntityStore> ref, @Nullable ComponentAccessor<EntityStore> componentAccessor) {
      if (this.cachedEntityHorizontalSpeedMultiplier != Float.MAX_VALUE) {
         return this.cachedEntityHorizontalSpeedMultiplier;
      } else {
         this.cachedEntityHorizontalSpeedMultiplier = 1.0F;
         if (ref != null && componentAccessor != null) {
            EffectControllerComponent effectControllerComponent = componentAccessor.getComponent(ref, EffectControllerComponent.getComponentType());
            if (effectControllerComponent == null) {
               return this.cachedEntityHorizontalSpeedMultiplier;
            } else {
               int[] cachedEffectIndexes = effectControllerComponent.getActiveEffectIndexes();
               if (cachedEffectIndexes == null) {
                  return this.cachedEntityHorizontalSpeedMultiplier;
               } else {
                  for (int cachedEffectIndex : cachedEffectIndexes) {
                     EntityEffect effect = EntityEffect.getAssetMap().getAsset(cachedEffectIndex);
                     if (effect != null) {
                        ApplicationEffects applicationEffects = effect.getApplicationEffects();
                        if (applicationEffects != null) {
                           float multiplier = applicationEffects.getHorizontalSpeedMultiplier();
                           if (multiplier >= 0.0F) {
                              this.cachedEntityHorizontalSpeedMultiplier *= multiplier;
                           }
                        }
                     }
                  }

                  return this.cachedEntityHorizontalSpeedMultiplier;
               }
            }
         } else {
            return this.cachedEntityHorizontalSpeedMultiplier;
         }
      }
   }

   @Nonnull
   @Override
   public String toString() {
      return "NPCEntity{role="
         + this.role
         + ", spawnRoleIndex="
         + this.spawnRoleIndex
         + ", spawnPoint="
         + this.leashPoint
         + ", spawnHeading="
         + this.leashHeading
         + ", spawnPitch="
         + this.leashPitch
         + ", environmentIndex='"
         + this.environmentIndex
         + "'} "
         + super.toString();
   }

   @Override
   public String getNPCTypeId() {
      return this.roleName;
   }

   @Override
   public int getNPCTypeIndex() {
      return this.roleIndex;
   }

   public void addReservation(@Nonnull UUID playerUUID) {
      this.reservedBy.add(playerUUID);
   }

   public void removeReservation(@Nonnull UUID playerUUID) {
      this.reservedBy.remove(playerUUID);
   }

   public boolean isReserved() {
      return !this.reservedBy.isEmpty();
   }

   public boolean isReservedBy(@Nonnull UUID playerUUID) {
      return this.reservedBy.contains(playerUUID);
   }
}