package net.minecraft.world.entity.animal.sniffer;

import com.mojang.serialization.Dynamic;
import io.netty.buffer.ByteBuf;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.function.IntFunction;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import net.minecraft.core.BlockPos;
import net.minecraft.core.GlobalPos;
import net.minecraft.core.particles.BlockParticleOption;
import net.minecraft.core.particles.ParticleTypes;
import net.minecraft.network.codec.ByteBufCodecs;
import net.minecraft.network.codec.StreamCodec;
import net.minecraft.network.protocol.game.DebugPackets;
import net.minecraft.network.syncher.EntityDataAccessor;
import net.minecraft.network.syncher.EntityDataSerializers;
import net.minecraft.network.syncher.SynchedEntityData;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.sounds.SoundEvent;
import net.minecraft.sounds.SoundEvents;
import net.minecraft.sounds.SoundSource;
import net.minecraft.tags.BlockTags;
import net.minecraft.tags.ItemTags;
import net.minecraft.util.ByIdMap;
import net.minecraft.util.Mth;
import net.minecraft.util.ByIdMap.OutOfBoundsStrategy;
import net.minecraft.util.profiling.Profiler;
import net.minecraft.util.profiling.ProfilerFiller;
import net.minecraft.world.InteractionHand;
import net.minecraft.world.InteractionResult;
import net.minecraft.world.damagesource.DamageSource;
import net.minecraft.world.entity.AgeableMob;
import net.minecraft.world.entity.AnimationState;
import net.minecraft.world.entity.EntityDimensions;
import net.minecraft.world.entity.EntitySpawnReason;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.entity.Pose;
import net.minecraft.world.entity.ai.Brain;
import net.minecraft.world.entity.ai.attributes.Attributes;
import net.minecraft.world.entity.ai.attributes.AttributeSupplier.Builder;
import net.minecraft.world.entity.ai.memory.MemoryModuleType;
import net.minecraft.world.entity.ai.util.LandRandomPos;
import net.minecraft.world.entity.animal.Animal;
import net.minecraft.world.entity.item.ItemEntity;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.Items;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.RenderShape;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.gameevent.GameEvent;
import net.minecraft.world.level.gameevent.GameEvent.Context;
import net.minecraft.world.level.pathfinder.Path;
import net.minecraft.world.level.pathfinder.PathType;
import net.minecraft.world.level.storage.loot.BuiltInLootTables;
import net.minecraft.world.phys.Vec3;

public class Sniffer extends Animal {
	private static final int DIGGING_PARTICLES_DELAY_TICKS = 1700;
	private static final int DIGGING_PARTICLES_DURATION_TICKS = 6000;
	private static final int DIGGING_PARTICLES_AMOUNT = 30;
	private static final int DIGGING_DROP_SEED_OFFSET_TICKS = 120;
	private static final int SNIFFER_BABY_AGE_TICKS = 48000;
	private static final float DIGGING_BB_HEIGHT_OFFSET = 0.4F;
	private static final EntityDimensions DIGGING_DIMENSIONS = EntityDimensions.scalable(EntityType.SNIFFER.getWidth(), EntityType.SNIFFER.getHeight() - 0.4F)
		.withEyeHeight(0.81F);
	private static final EntityDataAccessor<Sniffer.State> DATA_STATE = SynchedEntityData.defineId(Sniffer.class, EntityDataSerializers.SNIFFER_STATE);
	private static final EntityDataAccessor<Integer> DATA_DROP_SEED_AT_TICK = SynchedEntityData.defineId(Sniffer.class, EntityDataSerializers.INT);
	public final AnimationState feelingHappyAnimationState = new AnimationState();
	public final AnimationState scentingAnimationState = new AnimationState();
	public final AnimationState sniffingAnimationState = new AnimationState();
	public final AnimationState diggingAnimationState = new AnimationState();
	public final AnimationState risingAnimationState = new AnimationState();

	public static Builder createAttributes() {
		return Animal.createAnimalAttributes().add(Attributes.MOVEMENT_SPEED, 0.1F).add(Attributes.MAX_HEALTH, 14.0);
	}

	public Sniffer(EntityType<? extends Animal> entityType, Level level) {
		super(entityType, level);
		this.getNavigation().setCanFloat(true);
		this.setPathfindingMalus(PathType.WATER, -1.0F);
		this.setPathfindingMalus(PathType.DANGER_POWDER_SNOW, -1.0F);
		this.setPathfindingMalus(PathType.DAMAGE_CAUTIOUS, -1.0F);
	}

	@Override
	protected void defineSynchedData(net.minecraft.network.syncher.SynchedEntityData.Builder builder) {
		super.defineSynchedData(builder);
		builder.define(DATA_STATE, Sniffer.State.IDLING);
		builder.define(DATA_DROP_SEED_AT_TICK, 0);
	}

	@Override
	public void onPathfindingStart() {
		super.onPathfindingStart();
		if (this.isOnFire() || this.isInWater()) {
			this.setPathfindingMalus(PathType.WATER, 0.0F);
		}
	}

	@Override
	public void onPathfindingDone() {
		this.setPathfindingMalus(PathType.WATER, -1.0F);
	}

	@Override
	public EntityDimensions getDefaultDimensions(Pose pose) {
		return this.getState() == Sniffer.State.DIGGING ? DIGGING_DIMENSIONS.scale(this.getAgeScale()) : super.getDefaultDimensions(pose);
	}

	public boolean isSearching() {
		return this.getState() == Sniffer.State.SEARCHING;
	}

	public boolean isTempted() {
		return (Boolean)this.brain.getMemory(MemoryModuleType.IS_TEMPTED).orElse(false);
	}

	public boolean canSniff() {
		return !this.isTempted() && !this.isPanicking() && !this.isInWater() && !this.isInLove() && this.onGround() && !this.isPassenger() && !this.isLeashed();
	}

	public boolean canPlayDiggingSound() {
		return this.getState() == Sniffer.State.DIGGING || this.getState() == Sniffer.State.SEARCHING;
	}

	private BlockPos getHeadBlock() {
		Vec3 vec3 = this.getHeadPosition();
		return BlockPos.containing(vec3.x(), this.getY() + 0.2F, vec3.z());
	}

	private Vec3 getHeadPosition() {
		return this.position().add(this.getForward().scale(2.25));
	}

	private Sniffer.State getState() {
		return this.entityData.get(DATA_STATE);
	}

	private Sniffer setState(Sniffer.State state) {
		this.entityData.set(DATA_STATE, state);
		return this;
	}

	@Override
	public void onSyncedDataUpdated(EntityDataAccessor<?> dataAccessor) {
		if (DATA_STATE.equals(dataAccessor)) {
			Sniffer.State state = this.getState();
			this.resetAnimations();
			switch (state) {
				case FEELING_HAPPY:
					this.feelingHappyAnimationState.startIfStopped(this.tickCount);
					break;
				case SCENTING:
					this.scentingAnimationState.startIfStopped(this.tickCount);
					break;
				case SNIFFING:
					this.sniffingAnimationState.startIfStopped(this.tickCount);
				case SEARCHING:
				default:
					break;
				case DIGGING:
					this.diggingAnimationState.startIfStopped(this.tickCount);
					break;
				case RISING:
					this.risingAnimationState.startIfStopped(this.tickCount);
			}

			this.refreshDimensions();
		}

		super.onSyncedDataUpdated(dataAccessor);
	}

	private void resetAnimations() {
		this.diggingAnimationState.stop();
		this.sniffingAnimationState.stop();
		this.risingAnimationState.stop();
		this.feelingHappyAnimationState.stop();
		this.scentingAnimationState.stop();
	}

	public Sniffer transitionTo(Sniffer.State state) {
		switch (state) {
			case IDLING:
				this.setState(Sniffer.State.IDLING);
				break;
			case FEELING_HAPPY:
				this.playSound(SoundEvents.SNIFFER_HAPPY, 1.0F, 1.0F);
				this.setState(Sniffer.State.FEELING_HAPPY);
				break;
			case SCENTING:
				this.setState(Sniffer.State.SCENTING).onScentingStart();
				break;
			case SNIFFING:
				this.playSound(SoundEvents.SNIFFER_SNIFFING, 1.0F, 1.0F);
				this.setState(Sniffer.State.SNIFFING);
				break;
			case SEARCHING:
				this.setState(Sniffer.State.SEARCHING);
				break;
			case DIGGING:
				this.setState(Sniffer.State.DIGGING).onDiggingStart();
				break;
			case RISING:
				this.playSound(SoundEvents.SNIFFER_DIGGING_STOP, 1.0F, 1.0F);
				this.setState(Sniffer.State.RISING);
		}

		return this;
	}

	private Sniffer onScentingStart() {
		this.playSound(SoundEvents.SNIFFER_SCENTING, 1.0F, this.isBaby() ? 1.3F : 1.0F);
		return this;
	}

	private Sniffer onDiggingStart() {
		this.entityData.set(DATA_DROP_SEED_AT_TICK, this.tickCount + 120);
		this.level().broadcastEntityEvent(this, (byte)63);
		return this;
	}

	public Sniffer onDiggingComplete(boolean storeExploredPosition) {
		if (storeExploredPosition) {
			this.storeExploredPosition(this.getOnPos());
		}

		return this;
	}

	Optional<BlockPos> calculateDigPosition() {
		return IntStream.range(0, 5)
			.mapToObj(i -> LandRandomPos.getPos(this, 10 + 2 * i, 3))
			.filter(Objects::nonNull)
			.map(BlockPos::containing)
			.filter(blockPos -> this.level().getWorldBorder().isWithinBounds(blockPos))
			.map(BlockPos::below)
			.filter(this::canDig)
			.findFirst();
	}

	boolean canDig() {
		return !this.isPanicking()
			&& !this.isTempted()
			&& !this.isBaby()
			&& !this.isInWater()
			&& this.onGround()
			&& !this.isPassenger()
			&& this.canDig(this.getHeadBlock().below());
	}

	private boolean canDig(BlockPos pos) {
		return this.level().getBlockState(pos).is(BlockTags.SNIFFER_DIGGABLE_BLOCK)
			&& this.getExploredPositions().noneMatch(globalPos -> GlobalPos.of(this.level().dimension(), pos).equals(globalPos))
			&& (Boolean)Optional.ofNullable(this.getNavigation().createPath(pos, 1)).map(Path::canReach).orElse(false);
	}

	private void dropSeed() {
		if (this.level() instanceof ServerLevel serverLevel && this.entityData.get(DATA_DROP_SEED_AT_TICK) == this.tickCount) {
			BlockPos blockPos = this.getHeadBlock();
			this.dropFromGiftLootTable(serverLevel, BuiltInLootTables.SNIFFER_DIGGING, (serverLevelx, itemStack) -> {
				ItemEntity itemEntity = new ItemEntity(this.level(), blockPos.getX(), blockPos.getY(), blockPos.getZ(), itemStack);
				itemEntity.setDefaultPickUpDelay();
				serverLevelx.addFreshEntity(itemEntity);
			});
			this.playSound(SoundEvents.SNIFFER_DROP_SEED, 1.0F, 1.0F);
		}
	}

	private Sniffer emitDiggingParticles(AnimationState animationState) {
		boolean bl = animationState.getTimeInMillis(this.tickCount) > 1700L && animationState.getTimeInMillis(this.tickCount) < 6000L;
		if (bl) {
			BlockPos blockPos = this.getHeadBlock();
			BlockState blockState = this.level().getBlockState(blockPos.below());
			if (blockState.getRenderShape() != RenderShape.INVISIBLE) {
				for (int i = 0; i < 30; i++) {
					Vec3 vec3 = Vec3.atCenterOf(blockPos).add(0.0, -0.65F, 0.0);
					this.level().addParticle(new BlockParticleOption(ParticleTypes.BLOCK, blockState), vec3.x, vec3.y, vec3.z, 0.0, 0.0, 0.0);
				}

				if (this.tickCount % 10 == 0) {
					this.level().playLocalSound(this.getX(), this.getY(), this.getZ(), blockState.getSoundType().getHitSound(), this.getSoundSource(), 0.5F, 0.5F, false);
				}
			}
		}

		if (this.tickCount % 10 == 0) {
			this.level().gameEvent(GameEvent.ENTITY_ACTION, this.getHeadBlock(), Context.of(this));
		}

		return this;
	}

	private Sniffer storeExploredPosition(BlockPos pos) {
		List<GlobalPos> list = (List<GlobalPos>)this.getExploredPositions().limit(20L).collect(Collectors.toList());
		list.add(0, GlobalPos.of(this.level().dimension(), pos));
		this.getBrain().setMemory(MemoryModuleType.SNIFFER_EXPLORED_POSITIONS, list);
		return this;
	}

	private Stream<GlobalPos> getExploredPositions() {
		return this.getBrain().getMemory(MemoryModuleType.SNIFFER_EXPLORED_POSITIONS).stream().flatMap(Collection::stream);
	}

	@Override
	public void jumpFromGround() {
		super.jumpFromGround();
		double d = this.moveControl.getSpeedModifier();
		if (d > 0.0) {
			double e = this.getDeltaMovement().horizontalDistanceSqr();
			if (e < 0.01) {
				this.moveRelative(0.1F, new Vec3(0.0, 0.0, 1.0));
			}
		}
	}

	@Override
	public void spawnChildFromBreeding(ServerLevel level, Animal mate) {
		ItemStack itemStack = new ItemStack(Items.SNIFFER_EGG);
		ItemEntity itemEntity = new ItemEntity(level, this.position().x(), this.position().y(), this.position().z(), itemStack);
		itemEntity.setDefaultPickUpDelay();
		this.finalizeSpawnChildFromBreeding(level, mate, null);
		this.playSound(SoundEvents.SNIFFER_EGG_PLOP, 1.0F, (this.random.nextFloat() - this.random.nextFloat()) * 0.2F + 0.5F);
		level.addFreshEntity(itemEntity);
	}

	@Override
	public void die(DamageSource damageSource) {
		this.transitionTo(Sniffer.State.IDLING);
		super.die(damageSource);
	}

	@Override
	public void tick() {
		switch (this.getState()) {
			case SEARCHING:
				this.playSearchingSound();
				break;
			case DIGGING:
				this.emitDiggingParticles(this.diggingAnimationState).dropSeed();
		}

		super.tick();
	}

	@Override
	public InteractionResult mobInteract(Player player, InteractionHand hand) {
		ItemStack itemStack = player.getItemInHand(hand);
		boolean bl = this.isFood(itemStack);
		InteractionResult interactionResult = super.mobInteract(player, hand);
		if (interactionResult.consumesAction() && bl) {
			this.playEatingSound();
		}

		return interactionResult;
	}

	@Override
	protected void playEatingSound() {
		this.level().playSound(null, this, SoundEvents.SNIFFER_EAT, SoundSource.NEUTRAL, 1.0F, Mth.randomBetween(this.level().random, 0.8F, 1.2F));
	}

	private void playSearchingSound() {
		if (this.level().isClientSide() && this.tickCount % 20 == 0) {
			this.level().playLocalSound(this.getX(), this.getY(), this.getZ(), SoundEvents.SNIFFER_SEARCHING, this.getSoundSource(), 1.0F, 1.0F, false);
		}
	}

	@Override
	protected void playStepSound(BlockPos pos, BlockState state) {
		this.playSound(SoundEvents.SNIFFER_STEP, 0.15F, 1.0F);
	}

	@Override
	protected SoundEvent getAmbientSound() {
		return Set.of(Sniffer.State.DIGGING, Sniffer.State.SEARCHING).contains(this.getState()) ? null : SoundEvents.SNIFFER_IDLE;
	}

	@Override
	protected SoundEvent getHurtSound(DamageSource damageSource) {
		return SoundEvents.SNIFFER_HURT;
	}

	@Override
	protected SoundEvent getDeathSound() {
		return SoundEvents.SNIFFER_DEATH;
	}

	@Override
	public int getMaxHeadYRot() {
		return 50;
	}

	@Override
	public void setBaby(boolean baby) {
		this.setAge(baby ? -48000 : 0);
	}

	@Override
	public AgeableMob getBreedOffspring(ServerLevel level, AgeableMob otherParent) {
		return EntityType.SNIFFER.create(level, EntitySpawnReason.BREEDING);
	}

	@Override
	public boolean canMate(Animal otherAnimal) {
		if (!(otherAnimal instanceof Sniffer sniffer)) {
			return false;
		} else {
			Set<Sniffer.State> set = Set.of(Sniffer.State.IDLING, Sniffer.State.SCENTING, Sniffer.State.FEELING_HAPPY);
			return set.contains(this.getState()) && set.contains(sniffer.getState()) && super.canMate(otherAnimal);
		}
	}

	@Override
	public boolean isFood(ItemStack stack) {
		return stack.is(ItemTags.SNIFFER_FOOD);
	}

	@Override
	protected Brain<?> makeBrain(Dynamic<?> dynamic) {
		return SnifferAi.makeBrain(this.brainProvider().makeBrain(dynamic));
	}

	@Override
	public Brain<Sniffer> getBrain() {
		return (Brain<Sniffer>)super.getBrain();
	}

	@Override
	protected Brain.Provider<Sniffer> brainProvider() {
		return Brain.provider(SnifferAi.MEMORY_TYPES, SnifferAi.SENSOR_TYPES);
	}

	@Override
	protected void customServerAiStep(ServerLevel level) {
		ProfilerFiller profilerFiller = Profiler.get();
		profilerFiller.push("snifferBrain");
		this.getBrain().tick(level, this);
		profilerFiller.popPush("snifferActivityUpdate");
		SnifferAi.updateActivity(this);
		profilerFiller.pop();
		super.customServerAiStep(level);
	}

	@Override
	protected void sendDebugPackets() {
		super.sendDebugPackets();
		DebugPackets.sendEntityBrain(this);
	}

	public static enum State {
		IDLING(0),
		FEELING_HAPPY(1),
		SCENTING(2),
		SNIFFING(3),
		SEARCHING(4),
		DIGGING(5),
		RISING(6);

		public static final IntFunction<Sniffer.State> BY_ID = ByIdMap.continuous(Sniffer.State::id, values(), OutOfBoundsStrategy.ZERO);
		public static final StreamCodec<ByteBuf, Sniffer.State> STREAM_CODEC = ByteBufCodecs.idMapper(BY_ID, Sniffer.State::id);
		private final int id;

		private State(final int id) {
			this.id = id;
		}

		public int id() {
			return this.id;
		}
	}
}