package net.minecraft.client.renderer.chunk;

import com.google.common.collect.Lists;
import com.google.common.collect.Queues;
import com.google.common.collect.Sets;
import com.mojang.blaze3d.buffers.BufferUsage;
import com.mojang.blaze3d.vertex.ByteBufferBuilder;
import com.mojang.blaze3d.vertex.MeshData;
import com.mojang.blaze3d.vertex.VertexBuffer;
import com.mojang.blaze3d.vertex.VertexSorting;
import com.mojang.blaze3d.vertex.MeshData.SortState;
import it.unimi.dsi.fastutil.objects.ObjectArraySet;
import java.util.Collection;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Queue;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
import net.fabricmc.api.EnvType;
import net.fabricmc.api.Environment;
import net.minecraft.CrashReport;
import net.minecraft.TracingExecutor;
import net.minecraft.client.Camera;
import net.minecraft.client.Minecraft;
import net.minecraft.client.multiplayer.ClientLevel;
import net.minecraft.client.renderer.LevelRenderer;
import net.minecraft.client.renderer.RenderBuffers;
import net.minecraft.client.renderer.RenderType;
import net.minecraft.client.renderer.SectionBufferBuilderPack;
import net.minecraft.client.renderer.SectionBufferBuilderPool;
import net.minecraft.client.renderer.block.BlockRenderDispatcher;
import net.minecraft.client.renderer.blockentity.BlockEntityRenderDispatcher;
import net.minecraft.client.renderer.chunk.SectionRenderDispatcher.CompiledSection.1;
import net.minecraft.client.renderer.chunk.SectionRenderDispatcher.CompiledSection.2;
import net.minecraft.client.renderer.chunk.SectionRenderDispatcher.RenderSection.CompileTask;
import net.minecraft.client.renderer.chunk.SectionRenderDispatcher.RenderSection.RebuildTask;
import net.minecraft.client.renderer.chunk.SectionRenderDispatcher.RenderSection.ResortTransparencyTask;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.SectionPos;
import net.minecraft.util.Mth;
import net.minecraft.util.profiling.Profiler;
import net.minecraft.util.profiling.Zone;
import net.minecraft.util.thread.ConsecutiveExecutor;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.chunk.status.ChunkStatus;
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.Vec3;
import org.jetbrains.annotations.Nullable;

@Environment(EnvType.CLIENT)
public class SectionRenderDispatcher {
	private final CompileTaskDynamicQueue compileQueue = new CompileTaskDynamicQueue();
	private final Queue<Runnable> toUpload = Queues.<Runnable>newConcurrentLinkedQueue();
	final SectionBufferBuilderPack fixedBuffers;
	private final SectionBufferBuilderPool bufferPool;
	private volatile int toBatchCount;
	private volatile boolean closed;
	private final ConsecutiveExecutor consecutiveExecutor;
	private final TracingExecutor executor;
	ClientLevel level;
	final LevelRenderer renderer;
	private Vec3 camera = Vec3.ZERO;
	final SectionCompiler sectionCompiler;

	public SectionRenderDispatcher(
		ClientLevel clientLevel,
		LevelRenderer levelRenderer,
		TracingExecutor tracingExecutor,
		RenderBuffers renderBuffers,
		BlockRenderDispatcher blockRenderDispatcher,
		BlockEntityRenderDispatcher blockEntityRenderDispatcher
	) {
		this.level = clientLevel;
		this.renderer = levelRenderer;
		this.fixedBuffers = renderBuffers.fixedBufferPack();
		this.bufferPool = renderBuffers.sectionBufferPool();
		this.executor = tracingExecutor;
		this.consecutiveExecutor = new ConsecutiveExecutor(tracingExecutor, "Section Renderer");
		this.consecutiveExecutor.schedule(this::runTask);
		this.sectionCompiler = new SectionCompiler(blockRenderDispatcher, blockEntityRenderDispatcher);
	}

	public void setLevel(ClientLevel level) {
		this.level = level;
	}

	private void runTask() {
		if (!this.closed && !this.bufferPool.isEmpty()) {
			CompileTask compileTask = this.compileQueue.poll(this.getCameraPosition());
			if (compileTask != null) {
				SectionBufferBuilderPack sectionBufferBuilderPack = (SectionBufferBuilderPack)Objects.requireNonNull(this.bufferPool.acquire());
				this.toBatchCount = this.compileQueue.size();
				CompletableFuture.supplyAsync(() -> compileTask.doTask(sectionBufferBuilderPack), this.executor.forName(compileTask.name()))
					.thenCompose(completableFuture -> completableFuture)
					.whenComplete((sectionTaskResult, throwable) -> {
						if (throwable != null) {
							Minecraft.getInstance().delayCrash(CrashReport.forThrowable(throwable, "Batching sections"));
						} else {
							compileTask.isCompleted.set(true);
							this.consecutiveExecutor.schedule(() -> {
								if (sectionTaskResult == SectionRenderDispatcher.SectionTaskResult.SUCCESSFUL) {
									sectionBufferBuilderPack.clearAll();
								} else {
									sectionBufferBuilderPack.discardAll();
								}

								this.bufferPool.release(sectionBufferBuilderPack);
								this.runTask();
							});
						}
					});
			}
		}
	}

	public String getStats() {
		return String.format(Locale.ROOT, "pC: %03d, pU: %02d, aB: %02d", this.toBatchCount, this.toUpload.size(), this.bufferPool.getFreeBufferCount());
	}

	public int getToBatchCount() {
		return this.toBatchCount;
	}

	public int getToUpload() {
		return this.toUpload.size();
	}

	public int getFreeBufferCount() {
		return this.bufferPool.getFreeBufferCount();
	}

	public void setCamera(Vec3 camera) {
		this.camera = camera;
	}

	public Vec3 getCameraPosition() {
		return this.camera;
	}

	public void uploadAllPendingUploads() {
		Runnable runnable;
		while ((runnable = (Runnable)this.toUpload.poll()) != null) {
			runnable.run();
		}
	}

	public void rebuildSectionSync(SectionRenderDispatcher.RenderSection section, RenderRegionCache regionCache) {
		section.compileSync(regionCache);
	}

	public void blockUntilClear() {
		this.clearBatchQueue();
	}

	public void schedule(CompileTask task) {
		if (!this.closed) {
			this.consecutiveExecutor.schedule(() -> {
				if (!this.closed) {
					this.compileQueue.add(task);
					this.toBatchCount = this.compileQueue.size();
					this.runTask();
				}
			});
		}
	}

	public CompletableFuture<Void> uploadSectionLayer(MeshData meshData, VertexBuffer vertexBuffer) {
		return this.closed ? CompletableFuture.completedFuture(null) : CompletableFuture.runAsync(() -> {
			if (vertexBuffer.isInvalid()) {
				meshData.close();
			} else {
				try (Zone zone = Profiler.get().zone("Upload Section Layer")) {
					vertexBuffer.bind();
					vertexBuffer.upload(meshData);
					VertexBuffer.unbind();
				}
			}
		}, this.toUpload::add);
	}

	public CompletableFuture<Void> uploadSectionIndexBuffer(ByteBufferBuilder.Result result, VertexBuffer vertexBuffer) {
		return this.closed ? CompletableFuture.completedFuture(null) : CompletableFuture.runAsync(() -> {
			if (vertexBuffer.isInvalid()) {
				result.close();
			} else {
				try (Zone zone = Profiler.get().zone("Upload Section Indices")) {
					vertexBuffer.bind();
					vertexBuffer.uploadIndexBuffer(result);
					VertexBuffer.unbind();
				}
			}
		}, this.toUpload::add);
	}

	private void clearBatchQueue() {
		this.compileQueue.clear();
		this.toBatchCount = 0;
	}

	public boolean isQueueEmpty() {
		return this.toBatchCount == 0 && this.toUpload.isEmpty();
	}

	public void dispose() {
		this.closed = true;
		this.clearBatchQueue();
		this.uploadAllPendingUploads();
	}

	@Environment(EnvType.CLIENT)
	public static class CompiledSection {
		public static final SectionRenderDispatcher.CompiledSection UNCOMPILED = new 1();
		public static final SectionRenderDispatcher.CompiledSection EMPTY = new 2();
		final Set<RenderType> hasBlocks = new ObjectArraySet<>(RenderType.chunkBufferLayers().size());
		final List<BlockEntity> renderableBlockEntities = Lists.<BlockEntity>newArrayList();
		VisibilitySet visibilitySet = new VisibilitySet();
		@Nullable
		SortState transparencyState;

		public boolean hasRenderableLayers() {
			return !this.hasBlocks.isEmpty();
		}

		public boolean isEmpty(RenderType renderType) {
			return !this.hasBlocks.contains(renderType);
		}

		public List<BlockEntity> getRenderableBlockEntities() {
			return this.renderableBlockEntities;
		}

		public boolean facesCanSeeEachother(Direction face1, Direction face2) {
			return this.visibilitySet.visibilityBetween(face1, face2);
		}
	}

	@Environment(EnvType.CLIENT)
	public class RenderSection {
		public static final int SIZE = 16;
		public final int index;
		public final AtomicReference<SectionRenderDispatcher.CompiledSection> compiled = new AtomicReference(SectionRenderDispatcher.CompiledSection.UNCOMPILED);
		public final AtomicReference<SectionRenderDispatcher.TranslucencyPointOfView> pointOfView = new AtomicReference(null);
		@Nullable
		private RebuildTask lastRebuildTask;
		@Nullable
		private ResortTransparencyTask lastResortTransparencyTask;
		private final Set<BlockEntity> globalBlockEntities = Sets.<BlockEntity>newHashSet();
		private final Map<RenderType, VertexBuffer> buffers = (Map<RenderType, VertexBuffer>)RenderType.chunkBufferLayers()
			.stream()
			.collect(Collectors.toMap(renderType -> renderType, renderType -> new VertexBuffer(BufferUsage.STATIC_WRITE)));
		private AABB bb;
		private boolean dirty = true;
		long sectionNode = SectionPos.asLong(-1, -1, -1);
		final BlockPos.MutableBlockPos origin = new BlockPos.MutableBlockPos(-1, -1, -1);
		private boolean playerChanged;

		public RenderSection(final int i, final long l) {
			this.index = i;
			this.setSectionNode(l);
		}

		private boolean doesChunkExistAt(long l) {
			return SectionRenderDispatcher.this.level.getChunk(SectionPos.x(l), SectionPos.z(l), ChunkStatus.FULL, false) != null;
		}

		public boolean hasAllNeighbors() {
			int i = 24;
			return !(this.getDistToPlayerSqr() > 576.0)
				? true
				: this.doesChunkExistAt(SectionPos.offset(this.sectionNode, Direction.WEST))
					&& this.doesChunkExistAt(SectionPos.offset(this.sectionNode, Direction.NORTH))
					&& this.doesChunkExistAt(SectionPos.offset(this.sectionNode, Direction.EAST))
					&& this.doesChunkExistAt(SectionPos.offset(this.sectionNode, Direction.SOUTH));
		}

		public AABB getBoundingBox() {
			return this.bb;
		}

		public VertexBuffer getBuffer(RenderType renderType) {
			return (VertexBuffer)this.buffers.get(renderType);
		}

		public void setSectionNode(long l) {
			this.reset();
			this.sectionNode = l;
			int i = SectionPos.sectionToBlockCoord(SectionPos.x(l));
			int j = SectionPos.sectionToBlockCoord(SectionPos.y(l));
			int k = SectionPos.sectionToBlockCoord(SectionPos.z(l));
			this.origin.set(i, j, k);
			this.bb = new AABB(i, j, k, i + 16, j + 16, k + 16);
		}

		protected double getDistToPlayerSqr() {
			Camera camera = Minecraft.getInstance().gameRenderer.getMainCamera();
			double d = this.bb.minX + 8.0 - camera.getPosition().x;
			double e = this.bb.minY + 8.0 - camera.getPosition().y;
			double f = this.bb.minZ + 8.0 - camera.getPosition().z;
			return d * d + e * e + f * f;
		}

		public SectionRenderDispatcher.CompiledSection getCompiled() {
			return (SectionRenderDispatcher.CompiledSection)this.compiled.get();
		}

		private void reset() {
			this.cancelTasks();
			this.compiled.set(SectionRenderDispatcher.CompiledSection.UNCOMPILED);
			this.pointOfView.set(null);
			this.dirty = true;
		}

		public void releaseBuffers() {
			this.reset();
			this.buffers.values().forEach(VertexBuffer::close);
		}

		public BlockPos getOrigin() {
			return this.origin;
		}

		public long getSectionNode() {
			return this.sectionNode;
		}

		public void setDirty(boolean playerChanged) {
			boolean bl = this.dirty;
			this.dirty = true;
			this.playerChanged = playerChanged | (bl && this.playerChanged);
		}

		public void setNotDirty() {
			this.dirty = false;
			this.playerChanged = false;
		}

		public boolean isDirty() {
			return this.dirty;
		}

		public boolean isDirtyFromPlayer() {
			return this.dirty && this.playerChanged;
		}

		public long getNeighborSectionNode(Direction direction) {
			return SectionPos.offset(this.sectionNode, direction);
		}

		public void resortTransparency(SectionRenderDispatcher sectionRenderDispatcher) {
			this.lastResortTransparencyTask = new ResortTransparencyTask(this, this.getCompiled());
			sectionRenderDispatcher.schedule(this.lastResortTransparencyTask);
		}

		public boolean hasTranslucentGeometry() {
			return this.getCompiled().hasBlocks.contains(RenderType.translucent());
		}

		public boolean transparencyResortingScheduled() {
			return this.lastResortTransparencyTask != null && !this.lastResortTransparencyTask.isCompleted.get();
		}

		protected void cancelTasks() {
			if (this.lastRebuildTask != null) {
				this.lastRebuildTask.cancel();
				this.lastRebuildTask = null;
			}

			if (this.lastResortTransparencyTask != null) {
				this.lastResortTransparencyTask.cancel();
				this.lastResortTransparencyTask = null;
			}
		}

		public CompileTask createCompileTask(RenderRegionCache regionCache) {
			this.cancelTasks();
			RenderChunkRegion renderChunkRegion = regionCache.createRegion(SectionRenderDispatcher.this.level, SectionPos.of(this.sectionNode));
			boolean bl = this.compiled.get() != SectionRenderDispatcher.CompiledSection.UNCOMPILED;
			this.lastRebuildTask = new RebuildTask(this, renderChunkRegion, bl);
			return this.lastRebuildTask;
		}

		public void rebuildSectionAsync(SectionRenderDispatcher sectionRenderDispatcher, RenderRegionCache regionCache) {
			CompileTask compileTask = this.createCompileTask(regionCache);
			sectionRenderDispatcher.schedule(compileTask);
		}

		void updateGlobalBlockEntities(Collection<BlockEntity> blockEntities) {
			Set<BlockEntity> set = Sets.<BlockEntity>newHashSet(blockEntities);
			Set<BlockEntity> set2;
			synchronized (this.globalBlockEntities) {
				set2 = Sets.<BlockEntity>newHashSet(this.globalBlockEntities);
				set.removeAll(this.globalBlockEntities);
				set2.removeAll(blockEntities);
				this.globalBlockEntities.clear();
				this.globalBlockEntities.addAll(blockEntities);
			}

			SectionRenderDispatcher.this.renderer.updateGlobalBlockEntities(set2, set);
		}

		public void compileSync(RenderRegionCache regionCache) {
			CompileTask compileTask = this.createCompileTask(regionCache);
			compileTask.doTask(SectionRenderDispatcher.this.fixedBuffers);
		}

		void setCompiled(SectionRenderDispatcher.CompiledSection compiled) {
			this.compiled.set(compiled);
			SectionRenderDispatcher.this.renderer.addRecentlyCompiledSection(this);
		}

		VertexSorting createVertexSorting() {
			Vec3 vec3 = SectionRenderDispatcher.this.getCameraPosition();
			return VertexSorting.byDistance((float)(vec3.x - this.origin.getX()), (float)(vec3.y - this.origin.getY()), (float)(vec3.z - this.origin.getZ()));
		}
	}

	@Environment(EnvType.CLIENT)
	static enum SectionTaskResult {
		SUCCESSFUL,
		CANCELLED;
	}

	@Environment(EnvType.CLIENT)
	public static final class TranslucencyPointOfView {
		private int x;
		private int y;
		private int z;

		public static SectionRenderDispatcher.TranslucencyPointOfView of(Vec3 vec3, long l) {
			return new SectionRenderDispatcher.TranslucencyPointOfView().set(vec3, l);
		}

		public SectionRenderDispatcher.TranslucencyPointOfView set(Vec3 vec3, long l) {
			this.x = getCoordinate(vec3.x(), SectionPos.x(l));
			this.y = getCoordinate(vec3.y(), SectionPos.y(l));
			this.z = getCoordinate(vec3.z(), SectionPos.z(l));
			return this;
		}

		private static int getCoordinate(double d, int i) {
			int j = SectionPos.blockToSectionCoord(d) - i;
			return Mth.clamp(j, -1, 1);
		}

		public boolean isAxisAligned() {
			return this.x == 0 || this.y == 0 || this.z == 0;
		}

		public boolean equals(Object object) {
			if (object == this) {
				return true;
			} else {
				return !(object instanceof SectionRenderDispatcher.TranslucencyPointOfView translucencyPointOfView)
					? false
					: this.x == translucencyPointOfView.x && this.y == translucencyPointOfView.y && this.z == translucencyPointOfView.z;
			}
		}
	}
}