// 
// Decompiled by Procyon v0.6.0
// 

package com.hypixel.hytale.server.core.modules.physics.util;

import com.hypixel.hytale.math.util.TrigMathUtil;
import javax.annotation.Nonnull;
import com.hypixel.hytale.math.shape.Box;
import com.hypixel.hytale.math.vector.Vector3d;

public class PhysicsMath
{
    public static final double DENSITY_AIR = 1.2;
    public static final double DENSITY_WATER = 998.0;
    public static final double AIR_DENSITY = 0.001225;
    public static final float HEADING_DIRECTION = 1.0f;
    
    public static double getAcceleration(final double speed, final double terminalSpeed) {
        final double ratio = Math.abs(speed / terminalSpeed);
        return 32.0 * (1.0 - ratio * ratio * ratio);
    }
    
    public static double getTerminalVelocity(final double mass, final double density, final double areaMillimetersSquared, final double dragCoefficient) {
        final double massGrams = mass * 1000.0;
        final double areaMetersSquared = areaMillimetersSquared * 1000000.0;
        return Math.sqrt(64.0 * massGrams / (density * areaMetersSquared * dragCoefficient));
    }
    
    public static double getRelativeDensity(final Vector3d position, final Box boundingBox) {
        return 0.001225;
    }
    
    public static double computeDragCoefficient(final double terminalSpeed, final double area, final double mass, final double gravity) {
        return mass * gravity / (area * terminalSpeed * terminalSpeed);
    }
    
    public static double computeTerminalSpeed(final double dragCoefficient, final double area, final double mass, final double gravity) {
        return Math.sqrt(mass * gravity / (area * dragCoefficient));
    }
    
    public static double computeProjectedArea(final double x, final double y, final double z, @Nonnull final Box box) {
        double area = 0.0;
        if (x != 0.0) {
            area += Math.abs(x) * box.depth() * box.height();
        }
        if (y != 0.0) {
            area += Math.abs(y) * box.depth() * box.width();
        }
        if (z != 0.0) {
            area += Math.abs(z) * box.width() * box.height();
        }
        return area;
    }
    
    public static double computeProjectedArea(@Nonnull final Vector3d direction, @Nonnull final Box box) {
        return computeProjectedArea(direction.x, direction.y, direction.z, box);
    }
    
    public static double volumeOfIntersection(@Nonnull final Box a, @Nonnull final Vector3d posA, @Nonnull final Box b, @Nonnull final Vector3d posB) {
        return volumeOfIntersection(a, posA, b, posB.x, posB.y, posB.z);
    }
    
    public static double volumeOfIntersection(@Nonnull final Box a, @Nonnull final Vector3d posA, @Nonnull final Box b, double posBX, double posBY, double posBZ) {
        posBX -= posA.x;
        posBY -= posA.y;
        posBZ -= posA.z;
        return lengthOfIntersection(a.min.x, a.max.x, posBX + b.min.x, posBX + b.max.x) * lengthOfIntersection(a.min.y, a.max.y, posBY + b.min.y, posBY + b.max.y) * lengthOfIntersection(a.min.z, a.max.z, posBZ + b.min.z, posBZ + b.max.z);
    }
    
    public static double lengthOfIntersection(final double aMin, final double aMax, final double bMin, final double bMax) {
        final double left = Math.max(aMin, bMin);
        final double right = Math.min(aMax, bMax);
        return Math.max(0.0, right - left);
    }
    
    public static float headingFromDirection(final double x, final double z) {
        return 1.0f * TrigMathUtil.atan2(-x, -z);
    }
    
    public static float normalizeAngle(float rad) {
        rad %= 6.2831855f;
        if (rad < 0.0f) {
            rad += 6.2831855f;
        }
        return rad;
    }
    
    public static float normalizeTurnAngle(float rad) {
        rad = normalizeAngle(rad);
        if (rad >= 3.1415927f) {
            rad -= 6.2831855f;
        }
        return rad;
    }
    
    public static float pitchFromDirection(final double x, final double y, final double z) {
        return TrigMathUtil.atan2(y, Math.sqrt(x * x + z * z));
    }
    
    @Nonnull
    public static Vector3d vectorFromAngles(final float heading, final float pitch, @Nonnull final Vector3d outDirection) {
        final float sx = pitchX(pitch);
        outDirection.y = pitchY(pitch);
        outDirection.x = headingX(heading) * sx;
        outDirection.z = headingZ(heading) * sx;
        return outDirection;
    }
    
    public static float pitchX(final float pitch) {
        return TrigMathUtil.cos(pitch);
    }
    
    public static float pitchY(final float pitch) {
        return TrigMathUtil.sin(pitch);
    }
    
    public static float headingX(final float heading) {
        return -TrigMathUtil.sin(1.0f * heading);
    }
    
    public static float headingZ(final float heading) {
        return -TrigMathUtil.cos(1.0f * heading);
    }
}