package net.minecraft.client.renderer;

import com.mojang.blaze3d.buffers.GpuBuffer;
import com.mojang.blaze3d.buffers.GpuBufferSlice;
import com.mojang.blaze3d.buffers.Std140Builder;
import com.mojang.blaze3d.buffers.Std140SizeCalculator;
import com.mojang.blaze3d.pipeline.RenderPipeline;
import com.mojang.blaze3d.pipeline.RenderTarget;
import com.mojang.blaze3d.platform.NativeImage;
import com.mojang.blaze3d.systems.RenderPass;
import com.mojang.blaze3d.systems.RenderSystem;
import com.mojang.blaze3d.textures.GpuTextureView;
import com.mojang.blaze3d.vertex.VertexFormat;
import com.mojang.logging.LogUtils;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.OptionalInt;
import net.fabricmc.api.EnvType;
import net.fabricmc.api.Environment;
import net.minecraft.client.CloudStatus;
import net.minecraft.client.Minecraft;
import net.minecraft.core.Direction;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.server.packs.resources.ResourceManager;
import net.minecraft.server.packs.resources.SimplePreparableReloadListener;
import net.minecraft.util.ARGB;
import net.minecraft.util.Mth;
import net.minecraft.util.profiling.ProfilerFiller;
import net.minecraft.world.phys.Vec3;
import org.jetbrains.annotations.Nullable;
import org.joml.Matrix4f;
import org.joml.Vector3f;
import org.joml.Vector4f;
import org.slf4j.Logger;

@Environment(EnvType.CLIENT)
public class CloudRenderer extends SimplePreparableReloadListener<Optional<CloudRenderer.TextureData>> implements AutoCloseable {
	private static final int FLAG_INSIDE_FACE = 16;
	private static final int FLAG_USE_TOP_COLOR = 32;
	private static final int MAX_RADIUS_CHUNKS = 128;
	private static final float CELL_SIZE_IN_BLOCKS = 12.0F;
	private static final int UBO_SIZE = new Std140SizeCalculator().putVec4().putVec3().putVec3().get();
	private static final Logger LOGGER = LogUtils.getLogger();
	private static final ResourceLocation TEXTURE_LOCATION = ResourceLocation.withDefaultNamespace("textures/environment/clouds.png");
	private static final float BLOCKS_PER_SECOND = 0.6F;
	private static final long EMPTY_CELL = 0L;
	private static final int COLOR_OFFSET = 4;
	private static final int NORTH_OFFSET = 3;
	private static final int EAST_OFFSET = 2;
	private static final int SOUTH_OFFSET = 1;
	private static final int WEST_OFFSET = 0;
	private boolean needsRebuild = true;
	private int prevCellX = Integer.MIN_VALUE;
	private int prevCellZ = Integer.MIN_VALUE;
	private CloudRenderer.RelativeCameraPos prevRelativeCameraPos = CloudRenderer.RelativeCameraPos.INSIDE_CLOUDS;
	@Nullable
	private CloudStatus prevType;
	@Nullable
	private CloudRenderer.TextureData texture;
	private int quadCount = 0;
	private final RenderSystem.AutoStorageIndexBuffer indices = RenderSystem.getSequentialBuffer(VertexFormat.Mode.QUADS);
	private final MappableRingBuffer ubo = new MappableRingBuffer(() -> "Cloud UBO", 130, UBO_SIZE);
	@Nullable
	private MappableRingBuffer utb;

	/**
	 * Performs any reloading that can be done off-thread, such as file IO
	 */
	protected Optional<CloudRenderer.TextureData> prepare(ResourceManager resourceManager, ProfilerFiller profiler) {
		try {
			InputStream inputStream = resourceManager.open(TEXTURE_LOCATION);

			Optional var20;
			try (NativeImage nativeImage = NativeImage.read(inputStream)) {
				int i = nativeImage.getWidth();
				int j = nativeImage.getHeight();
				long[] ls = new long[i * j];

				for (int k = 0; k < j; k++) {
					for (int l = 0; l < i; l++) {
						int m = nativeImage.getPixel(l, k);
						if (isCellEmpty(m)) {
							ls[l + k * i] = 0L;
						} else {
							boolean bl = isCellEmpty(nativeImage.getPixel(l, Math.floorMod(k - 1, j)));
							boolean bl2 = isCellEmpty(nativeImage.getPixel(Math.floorMod(l + 1, j), k));
							boolean bl3 = isCellEmpty(nativeImage.getPixel(l, Math.floorMod(k + 1, j)));
							boolean bl4 = isCellEmpty(nativeImage.getPixel(Math.floorMod(l - 1, j), k));
							ls[l + k * i] = packCellData(m, bl, bl2, bl3, bl4);
						}
					}
				}

				var20 = Optional.of(new CloudRenderer.TextureData(ls, i, j));
			} catch (Throwable var18) {
				if (inputStream != null) {
					try {
						inputStream.close();
					} catch (Throwable var15) {
						var18.addSuppressed(var15);
					}
				}

				throw var18;
			}

			if (inputStream != null) {
				inputStream.close();
			}

			return var20;
		} catch (IOException var19) {
			LOGGER.error("Failed to load cloud texture", (Throwable)var19);
			return Optional.empty();
		}
	}

	private static int getSizeForCloudDistance(int cloudDistance) {
		int i = 4;
		int j = (cloudDistance + 1) * 2 * (cloudDistance + 1) * 2 / 2;
		int k = j * 4 + 54;
		return k * 3;
	}

	protected void apply(Optional<CloudRenderer.TextureData> object, ResourceManager resourceManager, ProfilerFiller profiler) {
		this.texture = (CloudRenderer.TextureData)object.orElse(null);
		this.needsRebuild = true;
	}

	private static boolean isCellEmpty(int color) {
		return ARGB.alpha(color) < 10;
	}

	private static long packCellData(int color, boolean northEmpty, boolean eastEmpty, boolean southEmpty, boolean westEmpty) {
		return (long)color << 4 | (northEmpty ? 1 : 0) << 3 | (eastEmpty ? 1 : 0) << 2 | (southEmpty ? 1 : 0) << 1 | (westEmpty ? 1 : 0) << 0;
	}

	private static boolean isNorthEmpty(long cellData) {
		return (cellData >> 3 & 1L) != 0L;
	}

	private static boolean isEastEmpty(long cellData) {
		return (cellData >> 2 & 1L) != 0L;
	}

	private static boolean isSouthEmpty(long cellData) {
		return (cellData >> 1 & 1L) != 0L;
	}

	private static boolean isWestEmpty(long cellData) {
		return (cellData >> 0 & 1L) != 0L;
	}

	public void render(int cloudColor, CloudStatus cloudStatus, float height, Vec3 cameraPosition, float ticks) {
		if (this.texture != null) {
			int i = Math.min(Minecraft.getInstance().options.cloudRange().get(), 128) * 16;
			int j = Mth.ceil(i / 12.0F);
			int k = getSizeForCloudDistance(j);
			if (this.utb == null || this.utb.currentBuffer().size() != k) {
				if (this.utb != null) {
					this.utb.close();
				}

				this.utb = new MappableRingBuffer(() -> "Cloud UTB", 258, k);
			}

			float f = (float)(height - cameraPosition.y);
			float g = f + 4.0F;
			CloudRenderer.RelativeCameraPos relativeCameraPos;
			if (g < 0.0F) {
				relativeCameraPos = CloudRenderer.RelativeCameraPos.ABOVE_CLOUDS;
			} else if (f > 0.0F) {
				relativeCameraPos = CloudRenderer.RelativeCameraPos.BELOW_CLOUDS;
			} else {
				relativeCameraPos = CloudRenderer.RelativeCameraPos.INSIDE_CLOUDS;
			}

			double d = cameraPosition.x + ticks * 0.030000001F;
			double e = cameraPosition.z + 3.96F;
			double h = this.texture.width * 12.0;
			double l = this.texture.height * 12.0;
			d -= Mth.floor(d / h) * h;
			e -= Mth.floor(e / l) * l;
			int m = Mth.floor(d / 12.0);
			int n = Mth.floor(e / 12.0);
			float o = (float)(d - m * 12.0F);
			float p = (float)(e - n * 12.0F);
			boolean bl = cloudStatus == CloudStatus.FANCY;
			RenderPipeline renderPipeline = bl ? RenderPipelines.CLOUDS : RenderPipelines.FLAT_CLOUDS;
			if (this.needsRebuild || m != this.prevCellX || n != this.prevCellZ || relativeCameraPos != this.prevRelativeCameraPos || cloudStatus != this.prevType) {
				this.needsRebuild = false;
				this.prevCellX = m;
				this.prevCellZ = n;
				this.prevRelativeCameraPos = relativeCameraPos;
				this.prevType = cloudStatus;
				this.utb.rotate();

				try (GpuBuffer.MappedView mappedView = RenderSystem.getDevice().createCommandEncoder().mapBuffer(this.utb.currentBuffer(), false, true)) {
					this.buildMesh(relativeCameraPos, mappedView.data(), m, n, bl, j);
					this.quadCount = mappedView.data().position() / 3;
				}
			}

			if (this.quadCount != 0) {
				try (GpuBuffer.MappedView mappedView = RenderSystem.getDevice().createCommandEncoder().mapBuffer(this.ubo.currentBuffer(), false, true)) {
					Std140Builder.intoBuffer(mappedView.data())
						.putVec4(ARGB.redFloat(cloudColor), ARGB.greenFloat(cloudColor), ARGB.blueFloat(cloudColor), 1.0F)
						.putVec3(-o, f, -p)
						.putVec3(12.0F, 4.0F, 12.0F);
				}

				GpuBufferSlice gpuBufferSlice = RenderSystem.getDynamicUniforms()
					.writeTransform(RenderSystem.getModelViewMatrix(), new Vector4f(1.0F, 1.0F, 1.0F, 1.0F), new Vector3f(), new Matrix4f(), 0.0F);
				RenderTarget renderTarget = Minecraft.getInstance().getMainRenderTarget();
				RenderTarget renderTarget2 = Minecraft.getInstance().levelRenderer.getCloudsTarget();
				RenderSystem.AutoStorageIndexBuffer autoStorageIndexBuffer = RenderSystem.getSequentialBuffer(VertexFormat.Mode.QUADS);
				GpuBuffer gpuBuffer = autoStorageIndexBuffer.getBuffer(6 * this.quadCount);
				GpuTextureView gpuTextureView;
				GpuTextureView gpuTextureView2;
				if (renderTarget2 != null) {
					gpuTextureView = renderTarget2.getColorTextureView();
					gpuTextureView2 = renderTarget2.getDepthTextureView();
				} else {
					gpuTextureView = renderTarget.getColorTextureView();
					gpuTextureView2 = renderTarget.getDepthTextureView();
				}

				try (RenderPass renderPass = RenderSystem.getDevice()
						.createCommandEncoder()
						.createRenderPass(() -> "Clouds", gpuTextureView, OptionalInt.empty(), gpuTextureView2, OptionalDouble.empty())) {
					renderPass.setPipeline(renderPipeline);
					RenderSystem.bindDefaultUniforms(renderPass);
					renderPass.setUniform("DynamicTransforms", gpuBufferSlice);
					renderPass.setIndexBuffer(gpuBuffer, autoStorageIndexBuffer.type());
					renderPass.setVertexBuffer(0, RenderSystem.getQuadVertexBuffer());
					renderPass.setUniform("CloudInfo", this.ubo.currentBuffer());
					renderPass.setUniform("CloudFaces", this.utb.currentBuffer());
					renderPass.setPipeline(renderPipeline);
					renderPass.drawIndexed(0, 0, 6 * this.quadCount, 1);
				}
			}
		}
	}

	private void buildMesh(CloudRenderer.RelativeCameraPos relativeCameraPos, ByteBuffer buffer, int cellX, int cellZ, boolean fancyClouds, int size) {
		if (this.texture != null) {
			long[] ls = this.texture.cells;
			int i = this.texture.width;
			int j = this.texture.height;

			for (int k = 0; k <= 2 * size; k++) {
				for (int l = -k; l <= k; l++) {
					int m = k - Math.abs(l);
					if (m >= 0 && m <= size && l * l + m * m <= size * size) {
						if (m != 0) {
							this.tryBuildCell(relativeCameraPos, buffer, cellX, cellZ, fancyClouds, l, i, -m, j, ls);
						}

						this.tryBuildCell(relativeCameraPos, buffer, cellX, cellZ, fancyClouds, l, i, m, j, ls);
					}
				}
			}
		}
	}

	private void tryBuildCell(
		CloudRenderer.RelativeCameraPos relativeCameraPos,
		ByteBuffer buffer,
		int cellX,
		int cellZ,
		boolean fancyClouds,
		int x,
		int width,
		int z,
		int height,
		long[] cells
	) {
		int i = Math.floorMod(cellX + x, width);
		int j = Math.floorMod(cellZ + z, height);
		long l = cells[i + j * width];
		if (l != 0L) {
			if (fancyClouds) {
				this.buildExtrudedCell(relativeCameraPos, buffer, x, z, l);
			} else {
				this.buildFlatCell(buffer, x, z);
			}
		}
	}

	private void buildFlatCell(ByteBuffer buffer, int cellX, int cellZ) {
		this.encodeFace(buffer, cellX, cellZ, Direction.DOWN, 32);
	}

	private void encodeFace(ByteBuffer buffer, int cellX, int cellZ, Direction face, int offset) {
		int i = face.get3DDataValue() | offset;
		i |= (cellX & 1) << 7;
		i |= (cellZ & 1) << 6;
		buffer.put((byte)(cellX >> 1)).put((byte)(cellZ >> 1)).put((byte)i);
	}

	private void buildExtrudedCell(CloudRenderer.RelativeCameraPos relativeCameraPos, ByteBuffer buffer, int cellX, int cellZ, long cellData) {
		if (relativeCameraPos != CloudRenderer.RelativeCameraPos.BELOW_CLOUDS) {
			this.encodeFace(buffer, cellX, cellZ, Direction.UP, 0);
		}

		if (relativeCameraPos != CloudRenderer.RelativeCameraPos.ABOVE_CLOUDS) {
			this.encodeFace(buffer, cellX, cellZ, Direction.DOWN, 0);
		}

		if (isNorthEmpty(cellData) && cellZ > 0) {
			this.encodeFace(buffer, cellX, cellZ, Direction.NORTH, 0);
		}

		if (isSouthEmpty(cellData) && cellZ < 0) {
			this.encodeFace(buffer, cellX, cellZ, Direction.SOUTH, 0);
		}

		if (isWestEmpty(cellData) && cellX > 0) {
			this.encodeFace(buffer, cellX, cellZ, Direction.WEST, 0);
		}

		if (isEastEmpty(cellData) && cellX < 0) {
			this.encodeFace(buffer, cellX, cellZ, Direction.EAST, 0);
		}

		boolean bl = Math.abs(cellX) <= 1 && Math.abs(cellZ) <= 1;
		if (bl) {
			for (Direction direction : Direction.values()) {
				this.encodeFace(buffer, cellX, cellZ, direction, 16);
			}
		}
	}

	public void markForRebuild() {
		this.needsRebuild = true;
	}

	public void endFrame() {
		this.ubo.rotate();
	}

	public void close() {
		this.ubo.close();
		if (this.utb != null) {
			this.utb.close();
		}
	}

	@Environment(EnvType.CLIENT)
	static enum RelativeCameraPos {
		ABOVE_CLOUDS,
		INSIDE_CLOUDS,
		BELOW_CLOUDS;
	}

	@Environment(EnvType.CLIENT)
	public record TextureData(long[] cells, int width, int height) {
	}
}