package net.minecraft.world.phys;

import java.util.List;
import java.util.Optional;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.util.Mth;
import net.minecraft.world.level.levelgen.structure.BoundingBox;
import org.jetbrains.annotations.Nullable;
import org.joml.Vector3f;
import org.joml.Vector3fc;

public class AABB {
	private static final double EPSILON = 1.0E-7;
	public final double minX;
	public final double minY;
	public final double minZ;
	public final double maxX;
	public final double maxY;
	public final double maxZ;

	public AABB(double x1, double y1, double z1, double x2, double y2, double z2) {
		this.minX = Math.min(x1, x2);
		this.minY = Math.min(y1, y2);
		this.minZ = Math.min(z1, z2);
		this.maxX = Math.max(x1, x2);
		this.maxY = Math.max(y1, y2);
		this.maxZ = Math.max(z1, z2);
	}

	public AABB(BlockPos pos) {
		this(pos.getX(), pos.getY(), pos.getZ(), pos.getX() + 1, pos.getY() + 1, pos.getZ() + 1);
	}

	public AABB(Vec3 start, Vec3 end) {
		this(start.x, start.y, start.z, end.x, end.y, end.z);
	}

	public static AABB of(BoundingBox mutableBox) {
		return new AABB(mutableBox.minX(), mutableBox.minY(), mutableBox.minZ(), mutableBox.maxX() + 1, mutableBox.maxY() + 1, mutableBox.maxZ() + 1);
	}

	public static AABB unitCubeFromLowerCorner(Vec3 vector) {
		return new AABB(vector.x, vector.y, vector.z, vector.x + 1.0, vector.y + 1.0, vector.z + 1.0);
	}

	public static AABB encapsulatingFullBlocks(BlockPos startPos, BlockPos endPos) {
		return new AABB(
			Math.min(startPos.getX(), endPos.getX()),
			Math.min(startPos.getY(), endPos.getY()),
			Math.min(startPos.getZ(), endPos.getZ()),
			Math.max(startPos.getX(), endPos.getX()) + 1,
			Math.max(startPos.getY(), endPos.getY()) + 1,
			Math.max(startPos.getZ(), endPos.getZ()) + 1
		);
	}

	public AABB setMinX(double minX) {
		return new AABB(minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ);
	}

	public AABB setMinY(double minY) {
		return new AABB(this.minX, minY, this.minZ, this.maxX, this.maxY, this.maxZ);
	}

	public AABB setMinZ(double minZ) {
		return new AABB(this.minX, this.minY, minZ, this.maxX, this.maxY, this.maxZ);
	}

	public AABB setMaxX(double maxX) {
		return new AABB(this.minX, this.minY, this.minZ, maxX, this.maxY, this.maxZ);
	}

	public AABB setMaxY(double maxY) {
		return new AABB(this.minX, this.minY, this.minZ, this.maxX, maxY, this.maxZ);
	}

	public AABB setMaxZ(double maxZ) {
		return new AABB(this.minX, this.minY, this.minZ, this.maxX, this.maxY, maxZ);
	}

	public double min(Direction.Axis axis) {
		return axis.choose(this.minX, this.minY, this.minZ);
	}

	public double max(Direction.Axis axis) {
		return axis.choose(this.maxX, this.maxY, this.maxZ);
	}

	public boolean equals(Object object) {
		if (this == object) {
			return true;
		} else if (!(object instanceof AABB aABB)) {
			return false;
		} else if (Double.compare(aABB.minX, this.minX) != 0) {
			return false;
		} else if (Double.compare(aABB.minY, this.minY) != 0) {
			return false;
		} else if (Double.compare(aABB.minZ, this.minZ) != 0) {
			return false;
		} else if (Double.compare(aABB.maxX, this.maxX) != 0) {
			return false;
		} else {
			return Double.compare(aABB.maxY, this.maxY) != 0 ? false : Double.compare(aABB.maxZ, this.maxZ) == 0;
		}
	}

	public int hashCode() {
		long l = Double.doubleToLongBits(this.minX);
		int i = (int)(l ^ l >>> 32);
		l = Double.doubleToLongBits(this.minY);
		i = 31 * i + (int)(l ^ l >>> 32);
		l = Double.doubleToLongBits(this.minZ);
		i = 31 * i + (int)(l ^ l >>> 32);
		l = Double.doubleToLongBits(this.maxX);
		i = 31 * i + (int)(l ^ l >>> 32);
		l = Double.doubleToLongBits(this.maxY);
		i = 31 * i + (int)(l ^ l >>> 32);
		l = Double.doubleToLongBits(this.maxZ);
		return 31 * i + (int)(l ^ l >>> 32);
	}

	/**
	 * Creates a new {@link AABB} that has been contracted by the given amount, with positive changes decreasing max values and negative changes increasing min values.
	 * <br/>
	 * If the amount to contract by is larger than the length of a side, then the side will wrap (still creating a valid AABB - see last sample).
	 * 
	 * <h3>Samples:</h3>
	 * <table>
	 * <tr><th>Input</th><th>Result</th></tr>
	 * <tr><td><pre><code>new AABB(0, 0, 0, 4, 4, 4).contract(2, 2, 2)</code></pre></td><td><pre><samp>box[0.0, 0.0, 0.0 -> 2.0, 2.0, 2.0]</samp></pre></td></tr>
	 * <tr><td><pre><code>new AABB(0, 0, 0, 4, 4, 4).contract(-2, -2, -2)</code></pre></td><td><pre><samp>box[2.0, 2.0, 2.0 -> 4.0, 4.0, 4.0]</samp></pre></td></tr>
	 * <tr><td><pre><code>new AABB(5, 5, 5, 7, 7, 7).contract(0, 1, -1)</code></pre></td><td><pre><samp>box[5.0, 5.0, 6.0 -> 7.0, 6.0, 7.0]</samp></pre></td></tr>
	 * <tr><td><pre><code>new AABB(-2, -2, -2, 2, 2, 2).contract(4, -4, 0)</code></pre></td><td><pre><samp>box[-8.0, 2.0, -2.0 -> -2.0, 8.0, 2.0]</samp></pre></td></tr>
	 * </table>
	 * 
	 * <h3>See Also:</h3>
	 * <ul>
	 * <li>{@link #expand(double, double, double)} - like this, except for expanding.</li>
	 * <li>{@link #grow(double, double, double)} and {@link #grow(double)} - expands in all directions.</li>
	 * <li>{@link #shrink(double)} - contracts in all directions (like {@link #grow(double)})</li>
	 * </ul>
	 * 
	 * @return A new modified bounding box.
	 */
	public AABB contract(double x, double y, double z) {
		double d = this.minX;
		double e = this.minY;
		double f = this.minZ;
		double g = this.maxX;
		double h = this.maxY;
		double i = this.maxZ;
		if (x < 0.0) {
			d -= x;
		} else if (x > 0.0) {
			g -= x;
		}

		if (y < 0.0) {
			e -= y;
		} else if (y > 0.0) {
			h -= y;
		}

		if (z < 0.0) {
			f -= z;
		} else if (z > 0.0) {
			i -= z;
		}

		return new AABB(d, e, f, g, h, i);
	}

	public AABB expandTowards(Vec3 vector) {
		return this.expandTowards(vector.x, vector.y, vector.z);
	}

	/**
	 * Creates a new {@link AABB} that has been expanded by the given amount, with positive changes increasing max values and negative changes decreasing min values.
	 * 
	 * <h3>Samples:</h3>
	 * <table>
	 * <tr><th>Input</th><th>Result</th></tr>
	 * <tr><td><pre><code>new AABB(0, 0, 0, 1, 1, 1).expand(2, 2, 2)</code></pre></td><td><pre><samp>box[0, 0, 0 -> 3, 3, 3]</samp></pre></td><td>
	 * <tr><td><pre><code>new AABB(0, 0, 0, 1, 1, 1).expand(-2, -2, -2)</code></pre></td><td><pre><samp>box[-2, -2, -2 -> 1, 1, 1]</samp></pre></td><td>
	 * <tr><td><pre><code>new AABB(5, 5, 5, 7, 7, 7).expand(0, 1, -1)</code></pre></td><td><pre><samp>box[5, 5, 4, 7, 8, 7]</samp></pre></td><td>
	 * </table>
	 * 
	 * <h3>See Also:</h3>
	 * <ul>
	 * <li>{@link #contract(double, double, double)} - like this, except for shrinking.</li>
	 * <li>{@link #grow(double, double, double)} and {@link #grow(double)} - expands in all directions.</li>
	 * <li>{@link #shrink(double)} - contracts in all directions (like {@link #grow(double)})</li>
	 * </ul>
	 * 
	 * @return A modified bounding box that will always be equal or greater in volume to this bounding box.
	 */
	public AABB expandTowards(double x, double y, double z) {
		double d = this.minX;
		double e = this.minY;
		double f = this.minZ;
		double g = this.maxX;
		double h = this.maxY;
		double i = this.maxZ;
		if (x < 0.0) {
			d += x;
		} else if (x > 0.0) {
			g += x;
		}

		if (y < 0.0) {
			e += y;
		} else if (y > 0.0) {
			h += y;
		}

		if (z < 0.0) {
			f += z;
		} else if (z > 0.0) {
			i += z;
		}

		return new AABB(d, e, f, g, h, i);
	}

	/**
	 * Creates a new {@link AABB} that has been contracted by the given amount in both directions. Negative values will shrink the AABB instead of expanding it.
	 * <br/>
	 * Side lengths will be increased by 2 times the value of the parameters, since both min and max are changed.
	 * <br/>
	 * If contracting and the amount to contract by is larger than the length of a side, then the side will wrap (still creating a valid AABB - see last ample).
	 * 
	 * <h3>Samples:</h3>
	 * <table>
	 * <tr><th>Input</th><th>Result</th></tr>
	 * <tr><td><pre><code>new AABB(0, 0, 0, 1, 1, 1).grow(2, 2, 2)</code></pre></td><td><pre><samp>box[-2.0, -2.0, -2.0 -> 3.0, 3.0, 3.0]</samp></pre></td></tr>
	 * <tr><td><pre><code>new AABB(0, 0, 0, 6, 6, 6).grow(-2, -2, -2)</code></pre></td><td><pre><samp>box[2.0, 2.0, 2.0 -> 4.0, 4.0, 4.0]</samp></pre></td></tr>
	 * <tr><td><pre><code>new AABB(5, 5, 5, 7, 7, 7).grow(0, 1, -1)</code></pre></td><td><pre><samp>box[5.0, 4.0, 6.0 -> 7.0, 8.0, 6.0]</samp></pre></td></tr>
	 * <tr><td><pre><code>new AABB(1, 1, 1, 3, 3, 3).grow(-4, -2, -3)</code></pre></td><td><pre><samp>box[-1.0, 1.0, 0.0 -> 5.0, 3.0, 4.0]</samp></pre></td></tr>
	 * </table>
	 * 
	 * <h3>See Also:</h3>
	 * <ul>
	 * <li>{@link #expand(double, double, double)} - expands in only one direction.</li>
	 * <li>{@link #contract(double, double, double)} - contracts in only one direction.</li>
	 * <lu>{@link #grow(double)} - version of this that expands in all directions from one parameter.</li>
	 * <li>{@link #shrink(double)} - contracts in all directions</li>
	 * </ul>
	 * 
	 * @return A modified bounding box.
	 */
	public AABB inflate(double x, double y, double z) {
		double d = this.minX - x;
		double e = this.minY - y;
		double f = this.minZ - z;
		double g = this.maxX + x;
		double h = this.maxY + y;
		double i = this.maxZ + z;
		return new AABB(d, e, f, g, h, i);
	}

	/**
	 * Creates a new {@link AABB} that is expanded by the given value in all directions. Equivalent to {@link #grow(double, double, double)} with the given value for all 3 params. Negative values will shrink the AABB.
	 * <br/>
	 * Side lengths will be increased by 2 times the value of the parameter, since both min and max are changed.
	 * <br/>
	 * If contracting and the amount to contract by is larger than the length of a side, then the side will wrap (still creating a valid AABB - see samples on {@link #grow(double, double, double)}).
	 * 
	 * @return A modified AABB.
	 */
	public AABB inflate(double value) {
		return this.inflate(value, value, value);
	}

	public AABB intersect(AABB other) {
		double d = Math.max(this.minX, other.minX);
		double e = Math.max(this.minY, other.minY);
		double f = Math.max(this.minZ, other.minZ);
		double g = Math.min(this.maxX, other.maxX);
		double h = Math.min(this.maxY, other.maxY);
		double i = Math.min(this.maxZ, other.maxZ);
		return new AABB(d, e, f, g, h, i);
	}

	public AABB minmax(AABB other) {
		double d = Math.min(this.minX, other.minX);
		double e = Math.min(this.minY, other.minY);
		double f = Math.min(this.minZ, other.minZ);
		double g = Math.max(this.maxX, other.maxX);
		double h = Math.max(this.maxY, other.maxY);
		double i = Math.max(this.maxZ, other.maxZ);
		return new AABB(d, e, f, g, h, i);
	}

	/**
	 * Offsets the current bounding box by the specified amount.
	 */
	public AABB move(double x, double y, double z) {
		return new AABB(this.minX + x, this.minY + y, this.minZ + z, this.maxX + x, this.maxY + y, this.maxZ + z);
	}

	public AABB move(BlockPos pos) {
		return new AABB(
			this.minX + pos.getX(), this.minY + pos.getY(), this.minZ + pos.getZ(), this.maxX + pos.getX(), this.maxY + pos.getY(), this.maxZ + pos.getZ()
		);
	}

	public AABB move(Vec3 vec) {
		return this.move(vec.x, vec.y, vec.z);
	}

	public AABB move(Vector3f vec) {
		return this.move(vec.x, vec.y, vec.z);
	}

	/**
	 * Checks if the bounding box intersects with another.
	 */
	public boolean intersects(AABB other) {
		return this.intersects(other.minX, other.minY, other.minZ, other.maxX, other.maxY, other.maxZ);
	}

	public boolean intersects(double x1, double y1, double z1, double x2, double y2, double z2) {
		return this.minX < x2 && this.maxX > x1 && this.minY < y2 && this.maxY > y1 && this.minZ < z2 && this.maxZ > z1;
	}

	public boolean intersects(Vec3 min, Vec3 max) {
		return this.intersects(
			Math.min(min.x, max.x), Math.min(min.y, max.y), Math.min(min.z, max.z), Math.max(min.x, max.x), Math.max(min.y, max.y), Math.max(min.z, max.z)
		);
	}

	public boolean intersects(BlockPos pos) {
		return this.intersects(pos.getX(), pos.getY(), pos.getZ(), pos.getX() + 1, pos.getY() + 1, pos.getZ() + 1);
	}

	/**
	 * Returns if the supplied Vec3D is completely inside the bounding box
	 */
	public boolean contains(Vec3 vec) {
		return this.contains(vec.x, vec.y, vec.z);
	}

	public boolean contains(double x, double y, double z) {
		return x >= this.minX && x < this.maxX && y >= this.minY && y < this.maxY && z >= this.minZ && z < this.maxZ;
	}

	/**
	 * Returns the average length of the edges of the bounding box.
	 */
	public double getSize() {
		double d = this.getXsize();
		double e = this.getYsize();
		double f = this.getZsize();
		return (d + e + f) / 3.0;
	}

	public double getXsize() {
		return this.maxX - this.minX;
	}

	public double getYsize() {
		return this.maxY - this.minY;
	}

	public double getZsize() {
		return this.maxZ - this.minZ;
	}

	public AABB deflate(double x, double y, double z) {
		return this.inflate(-x, -y, -z);
	}

	/**
	 * Creates a new {@link AABB} that is expanded by the given value in all directions. Equivalent to {@link #grow(double)} with value set to the negative of the value provided here. Passing a negative value to this method values will grow the AABB.
	 * <br/>
	 * Side lengths will be decreased by 2 times the value of the parameter, since both min and max are changed.
	 * <br/>
	 * If contracting and the amount to contract by is larger than the length of a side, then the side will wrap (still creating a valid AABB - see samples on {@link #grow(double, double, double)}).
	 * 
	 * @return A modified AABB.
	 */
	public AABB deflate(double value) {
		return this.inflate(-value);
	}

	public Optional<Vec3> clip(Vec3 from, Vec3 to) {
		return clip(this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ, from, to);
	}

	public static Optional<Vec3> clip(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, Vec3 from, Vec3 to) {
		double[] ds = new double[]{1.0};
		double d = to.x - from.x;
		double e = to.y - from.y;
		double f = to.z - from.z;
		Direction direction = getDirection(minX, minY, minZ, maxX, maxY, maxZ, from, ds, null, d, e, f);
		if (direction == null) {
			return Optional.empty();
		} else {
			double g = ds[0];
			return Optional.of(from.add(g * d, g * e, g * f));
		}
	}

	@Nullable
	public static BlockHitResult clip(Iterable<AABB> boxes, Vec3 start, Vec3 end, BlockPos pos) {
		double[] ds = new double[]{1.0};
		Direction direction = null;
		double d = end.x - start.x;
		double e = end.y - start.y;
		double f = end.z - start.z;

		for (AABB aABB : boxes) {
			direction = getDirection(aABB.move(pos), start, ds, direction, d, e, f);
		}

		if (direction == null) {
			return null;
		} else {
			double g = ds[0];
			return new BlockHitResult(start.add(g * d, g * e, g * f), direction, pos, false);
		}
	}

	@Nullable
	private static Direction getDirection(AABB aabb, Vec3 start, double[] minDistance, @Nullable Direction facing, double deltaX, double deltaY, double deltaZ) {
		return getDirection(aabb.minX, aabb.minY, aabb.minZ, aabb.maxX, aabb.maxY, aabb.maxZ, start, minDistance, facing, deltaX, deltaY, deltaZ);
	}

	@Nullable
	private static Direction getDirection(
		double minX,
		double minY,
		double minZ,
		double maxX,
		double maxY,
		double maxZ,
		Vec3 start,
		double[] mineDistance,
		@Nullable Direction facing,
		double deltaX,
		double deltaY,
		double deltaZ
	) {
		if (deltaX > 1.0E-7) {
			facing = clipPoint(mineDistance, facing, deltaX, deltaY, deltaZ, minX, minY, maxY, minZ, maxZ, Direction.WEST, start.x, start.y, start.z);
		} else if (deltaX < -1.0E-7) {
			facing = clipPoint(mineDistance, facing, deltaX, deltaY, deltaZ, maxX, minY, maxY, minZ, maxZ, Direction.EAST, start.x, start.y, start.z);
		}

		if (deltaY > 1.0E-7) {
			facing = clipPoint(mineDistance, facing, deltaY, deltaZ, deltaX, minY, minZ, maxZ, minX, maxX, Direction.DOWN, start.y, start.z, start.x);
		} else if (deltaY < -1.0E-7) {
			facing = clipPoint(mineDistance, facing, deltaY, deltaZ, deltaX, maxY, minZ, maxZ, minX, maxX, Direction.UP, start.y, start.z, start.x);
		}

		if (deltaZ > 1.0E-7) {
			facing = clipPoint(mineDistance, facing, deltaZ, deltaX, deltaY, minZ, minX, maxX, minY, maxY, Direction.NORTH, start.z, start.x, start.y);
		} else if (deltaZ < -1.0E-7) {
			facing = clipPoint(mineDistance, facing, deltaZ, deltaX, deltaY, maxZ, minX, maxX, minY, maxY, Direction.SOUTH, start.z, start.x, start.y);
		}

		return facing;
	}

	@Nullable
	private static Direction clipPoint(
		double[] minDistance,
		@Nullable Direction prevDirection,
		double distanceSide,
		double distanceOtherA,
		double distanceOtherB,
		double minSide,
		double minOtherA,
		double maxOtherA,
		double minOtherB,
		double maxOtherB,
		Direction hitSide,
		double startSide,
		double startOtherA,
		double startOtherB
	) {
		double d = (minSide - startSide) / distanceSide;
		double e = startOtherA + d * distanceOtherA;
		double f = startOtherB + d * distanceOtherB;
		if (0.0 < d && d < minDistance[0] && minOtherA - 1.0E-7 < e && e < maxOtherA + 1.0E-7 && minOtherB - 1.0E-7 < f && f < maxOtherB + 1.0E-7) {
			minDistance[0] = d;
			return hitSide;
		} else {
			return prevDirection;
		}
	}

	public boolean collidedAlongVector(Vec3 vector, List<AABB> boxes) {
		Vec3 vec3 = this.getCenter();
		Vec3 vec32 = vec3.add(vector);

		for (AABB aABB : boxes) {
			AABB aABB2 = aABB.inflate(this.getXsize() * 0.5, this.getYsize() * 0.5, this.getZsize() * 0.5);
			if (aABB2.contains(vec32) || aABB2.contains(vec3)) {
				return true;
			}

			if (aABB2.clip(vec3, vec32).isPresent()) {
				return true;
			}
		}

		return false;
	}

	public double distanceToSqr(Vec3 vec) {
		double d = Math.max(Math.max(this.minX - vec.x, vec.x - this.maxX), 0.0);
		double e = Math.max(Math.max(this.minY - vec.y, vec.y - this.maxY), 0.0);
		double f = Math.max(Math.max(this.minZ - vec.z, vec.z - this.maxZ), 0.0);
		return Mth.lengthSquared(d, e, f);
	}

	public double distanceToSqr(AABB box) {
		double d = Math.max(Math.max(this.minX - box.maxX, box.minX - this.maxX), 0.0);
		double e = Math.max(Math.max(this.minY - box.maxY, box.minY - this.maxY), 0.0);
		double f = Math.max(Math.max(this.minZ - box.maxZ, box.minZ - this.maxZ), 0.0);
		return Mth.lengthSquared(d, e, f);
	}

	public String toString() {
		return "AABB[" + this.minX + ", " + this.minY + ", " + this.minZ + "] -> [" + this.maxX + ", " + this.maxY + ", " + this.maxZ + "]";
	}

	public boolean hasNaN() {
		return Double.isNaN(this.minX)
			|| Double.isNaN(this.minY)
			|| Double.isNaN(this.minZ)
			|| Double.isNaN(this.maxX)
			|| Double.isNaN(this.maxY)
			|| Double.isNaN(this.maxZ);
	}

	public Vec3 getCenter() {
		return new Vec3(Mth.lerp(0.5, this.minX, this.maxX), Mth.lerp(0.5, this.minY, this.maxY), Mth.lerp(0.5, this.minZ, this.maxZ));
	}

	public Vec3 getBottomCenter() {
		return new Vec3(Mth.lerp(0.5, this.minX, this.maxX), this.minY, Mth.lerp(0.5, this.minZ, this.maxZ));
	}

	public Vec3 getMinPosition() {
		return new Vec3(this.minX, this.minY, this.minZ);
	}

	public Vec3 getMaxPosition() {
		return new Vec3(this.maxX, this.maxY, this.maxZ);
	}

	public static AABB ofSize(Vec3 center, double xSize, double ySize, double zSize) {
		return new AABB(
			center.x - xSize / 2.0, center.y - ySize / 2.0, center.z - zSize / 2.0, center.x + xSize / 2.0, center.y + ySize / 2.0, center.z + zSize / 2.0
		);
	}

	public static class Builder {
		private float minX = Float.POSITIVE_INFINITY;
		private float minY = Float.POSITIVE_INFINITY;
		private float minZ = Float.POSITIVE_INFINITY;
		private float maxX = Float.NEGATIVE_INFINITY;
		private float maxY = Float.NEGATIVE_INFINITY;
		private float maxZ = Float.NEGATIVE_INFINITY;

		public void include(Vector3fc pos) {
			this.minX = Math.min(this.minX, pos.x());
			this.minY = Math.min(this.minY, pos.y());
			this.minZ = Math.min(this.minZ, pos.z());
			this.maxX = Math.max(this.maxX, pos.x());
			this.maxY = Math.max(this.maxY, pos.y());
			this.maxZ = Math.max(this.maxZ, pos.z());
		}

		public AABB build() {
			return new AABB(this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ);
		}
	}
}