package net.minecraft.world.phys;

import net.minecraft.world.phys.shapes.VoxelShape;

import com.bergerkiller.generated.net.minecraft.world.phys.AxisAlignedBBHandle;
import com.bergerkiller.generated.net.minecraft.world.phys.shapes.VoxelShapeHandle;
import com.bergerkiller.generated.net.minecraft.core.EnumDirectionHandle.EnumAxisHandle;

class AxisAlignedBB {
#if version >= 1.13.2
    public final double minX;
    public final double minY;
    public final double minZ;
    public final double maxX;
    public final double maxY;
    public final double maxZ;
#else
    public final double minX:a;
    public final double minY:b;
    public final double minZ:c;
    public final double maxX:d;
    public final double maxY:e;
    public final double maxZ:f;
#endif

    public (AxisAlignedBBHandle) AxisAlignedBB(double x1, double y1, double z1, double x2, double y2, double z2);

#if version >= 1.18
    public (AxisAlignedBBHandle) AxisAlignedBB grow:inflate(double sx, double sy, double sz);
#else
    public (AxisAlignedBBHandle) AxisAlignedBB grow(double sx, double sy, double sz);
#endif

    <code>
    public AxisAlignedBBHandle growUniform(double size) {
        return grow(size, size, size);
    }

    public AxisAlignedBBHandle shrinkUniform(double size) {
        return growUniform(-size);
    }
    </code>

#if version >= 1.18
    public (AxisAlignedBBHandle) AxisAlignedBB transformB:expandTowards(double lx, double ly, double lz);

    public (AxisAlignedBBHandle) AxisAlignedBB translate:move(double dx, double dy, double dz);

    public boolean bbTransformA:intersects((AxisAlignedBBHandle) AxisAlignedBB paramAxisAlignedBB);
#elseif version >= 1.11
    public (AxisAlignedBBHandle) AxisAlignedBB transformB:b(double lx, double ly, double lz);

    public (AxisAlignedBBHandle) AxisAlignedBB translate:d(double dx, double dy, double dz);

    public boolean bbTransformA:c((AxisAlignedBBHandle) AxisAlignedBB paramAxisAlignedBB);
#else
    public (AxisAlignedBBHandle) AxisAlignedBB transformB:a(double lx, double ly, double lz);

    public (AxisAlignedBBHandle) AxisAlignedBB translate:c(double dx, double dy, double dz);

    public boolean bbTransformA:b((AxisAlignedBBHandle) AxisAlignedBB paramAxisAlignedBB);
#endif

#if version >= 1.13.2
    // These methods were removed in MC 1.13, and min/max x/y/z fields changed names on 1.13.2
    public double calcSomeX((AxisAlignedBBHandle) AxisAlignedBB axisalignedbb, double d0) {
        if (axisalignedbb.maxY > instance.minY && axisalignedbb.minY < instance.maxY && axisalignedbb.maxZ > instance.minZ && axisalignedbb.minZ < instance.maxZ) {
            double d1;

            if (d0 > 0.0D && axisalignedbb.maxX <= instance.minX) {
                d1 = instance.minX - axisalignedbb.maxX;
                if (d1 < d0) {
                    d0 = d1;
                }
            } else if (d0 < 0.0D && axisalignedbb.minX >= instance.maxX) {
                d1 = instance.maxX - axisalignedbb.minX;
                if (d1 > d0) {
                    d0 = d1;
                }
            }

            return d0;
        } else {
            return d0;
        }
    }
    public double calcSomeY((AxisAlignedBBHandle) AxisAlignedBB axisalignedbb, double d0) {
        if (axisalignedbb.maxX > instance.minX && axisalignedbb.minX < instance.maxX && axisalignedbb.maxZ > instance.minZ && axisalignedbb.minZ < instance.maxZ) {
            double d1;

            if (d0 > 0.0D && axisalignedbb.maxY <= instance.minY) {
                d1 = instance.minY - axisalignedbb.maxY;
                if (d1 < d0) {
                    d0 = d1;
                }
            } else if (d0 < 0.0D && axisalignedbb.minY >= instance.maxY) {
                d1 = instance.maxY - axisalignedbb.minY;
                if (d1 > d0) {
                    d0 = d1;
                }
            }

            return d0;
        } else {
            return d0;
        }
    }
    public double calcSomeZ((AxisAlignedBBHandle) AxisAlignedBB axisalignedbb, double d0) {
        if (axisalignedbb.maxX > instance.minX && axisalignedbb.minX < instance.maxX && axisalignedbb.maxY > instance.minY && axisalignedbb.minY < instance.maxY) {
            double d1;

            if (d0 > 0.0D && axisalignedbb.maxZ <= instance.minZ) {
                d1 = instance.minZ - axisalignedbb.maxZ;
                if (d1 < d0) {
                    d0 = d1;
                }
            } else if (d0 < 0.0D && axisalignedbb.minZ >= instance.maxZ) {
                d1 = instance.maxZ - axisalignedbb.minZ;
                if (d1 > d0) {
                    d0 = d1;
                }
            }

            return d0;
        } else {
            return d0;
        }
    }
#elseif version >= 1.13
    // These methods were removed in MC 1.13
    public double calcSomeX((AxisAlignedBBHandle) AxisAlignedBB axisalignedbb, double d0) {
        if (axisalignedbb.e > instance.b && axisalignedbb.b < instance.e && axisalignedbb.f > instance.c && axisalignedbb.c < instance.f) {
            double d1;

            if (d0 > 0.0D && axisalignedbb.d <= instance.a) {
                d1 = instance.a - axisalignedbb.d;
                if (d1 < d0) {
                    d0 = d1;
                }
            } else if (d0 < 0.0D && axisalignedbb.a >= instance.d) {
                d1 = instance.d - axisalignedbb.a;
                if (d1 > d0) {
                    d0 = d1;
                }
            }

            return d0;
        } else {
            return d0;
        }
    }
    public double calcSomeY((AxisAlignedBBHandle) AxisAlignedBB axisalignedbb, double d0) {
        if (axisalignedbb.d > instance.a && axisalignedbb.a < instance.d && axisalignedbb.f > instance.c && axisalignedbb.c < instance.f) {
            double d1;

            if (d0 > 0.0D && axisalignedbb.e <= instance.b) {
                d1 = instance.b - axisalignedbb.e;
                if (d1 < d0) {
                    d0 = d1;
                }
            } else if (d0 < 0.0D && axisalignedbb.b >= instance.e) {
                d1 = instance.e - axisalignedbb.b;
                if (d1 > d0) {
                    d0 = d1;
                }
            }

            return d0;
        } else {
            return d0;
        }
    }
    public double calcSomeZ((AxisAlignedBBHandle) AxisAlignedBB axisalignedbb, double d0) {
        if (axisalignedbb.d > instance.a && axisalignedbb.a < instance.d && axisalignedbb.e > instance.b && axisalignedbb.b < instance.e) {
            double d1;

            if (d0 > 0.0D && axisalignedbb.f <= instance.c) {
                d1 = instance.c - axisalignedbb.f;
                if (d1 < d0) {
                    d0 = d1;
                }
            } else if (d0 < 0.0D && axisalignedbb.c >= instance.f) {
                d1 = instance.f - axisalignedbb.c;
                if (d1 > d0) {
                    d0 = d1;
                }
            }

            return d0;
        } else {
            return d0;
        }
    }
#else
    public double calcSomeX:a((AxisAlignedBBHandle) AxisAlignedBB axisalignedbb, double d0);
    public double calcSomeY:b((AxisAlignedBBHandle) AxisAlignedBB axisalignedbb, double d0);
    public double calcSomeZ:c((AxisAlignedBBHandle) AxisAlignedBB axisalignedbb, double d0);
#endif
}
