import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;

/**
 * @author Wojciech Jargieło
 * @version 1
 */

public class Ellipsoid extends HttpServlet {

    private static final long serialVersionUID = 1L;

    private ArrayList<Defect> defect = new ArrayList<Defect>();
    private double a = 0;
    private double b = 0;
    private double c = 0;
    private double g = 0;
    private double v = 0;
    private double x = 0;
    private double y = 0;
    private double z = 0;
    private double r = 0;
    private static final int n = 10000000;

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse res)
            throws IOException {
        res.setContentType("text/html;charset=UTF-8");
        PrintWriter writer = res.getWriter();
        double result;

        a = Double.parseDouble(request.getParameter("a"));
        b = Double.parseDouble(request.getParameter("b"));
        c = Double.parseDouble(request.getParameter("c"));
        g = Double.parseDouble(request.getParameter("g"));
        v = Double.parseDouble(request.getParameter("v"));

        result = monteCarlo(g, v);

        writer.print(result);
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse res) {
        x = Double.parseDouble(request.getParameter("x"));
        y = Double.parseDouble(request.getParameter("y"));
        z = Double.parseDouble(request.getParameter("z"));
        r = Double.parseDouble(request.getParameter("r"));

        defect.add(new Defect(x, y, z, r));
    }

    protected static class Defect {

        private double x;
        private double y;
        private double z;
        private double r;

        Defect(double x, double y, double z, double r) {
            this.setX(x);
            this.setY(y);
            this.setZ(z);
            this.setR(r);
        }

        double getX() {
            return x;
        }

        void setX(double x) {
            this.x = x;
        }

        double getY() {
            return y;
        }

        void setY(double y) {
            this.y = y;
        }

        double getZ() {
            return z;
        }

        void setZ(double z) {
            this.z = z;
        }

        double getR() {
            return r;
        }

        void setR(double r) {
            this.r = r;
        }
    }

    /**
     * Metoda pozwala na obliczenie masy Ellipsoidy z wykorzysatniem MC
     *
     * @param g double
     * @param v double
     * @return double
     */
    private double monteCarlo(double g, double v) {

        int ellipsoidHits = 0;
        int defectHits = 0;
        int n = Ellipsoid.n;
        double volumeEllipsoid;
        double volumeDefects;
        double volumeCube = (2.0 * a) * (2.0 * b) * (2.0 * c);
        double x0;
        double y0;
        double z0;
        double mass;

        for (int i = 0; i < n; i++) {
            x0 = getRandomNumber(-a, a);
            y0 = getRandomNumber(-b, b);
            z0 = getRandomNumber(-c, c);

            if (inEllipsoid(x0, y0, z0)) {
                ellipsoidHits += 1;
                if (inDefect(x0, y0, z0)) {
                    defectHits += 1;
                }
            }
        }
        volumeEllipsoid = volumeCube * ellipsoidHits / n;
        volumeDefects = volumeEllipsoid * defectHits / ellipsoidHits;
        mass = (volumeEllipsoid - volumeDefects) * v + volumeDefects * g;
        return mass;
    }

    /**
     * losowanie liczb z przedziału ograniczonego przez prostopadłościan
     *
     * @param a double
     * @param b double
     * @return boolean
     */
    private double getRandomNumber(double a, double b) {

        return Math.random() * (b - a) + a;
    }

    /**
     * Sprawdzenie czy wylosowany pkt. znajduje się w defekcie
     *
     * @param x0 double
     * @param y0 double
     * @param z0 double
     * @return boolean
     */
    private boolean inDefect(double x0, double y0, double z0) {

        for (Defect d : defect) {
            if (Math.sqrt((x0 - d.getX()) * (x0 - d.getX()) + (y0 - d.getY()) *
                    (y0 - d.getY()) + (z0 - d.getZ()) * (z0 - d.getZ()))
                    <= d.getR()) {
                return true;
            }
        }
        return false;
    }

    /**
     * (x*x/a*a) + (y*y/b*b) + (z*z/c*c) <= 1
     * Sprawdzenie czy wylosowany pkt. znajduje się w Ellipsoidzie
     *
     * @param x0 double
     * @param y0 double
     * @param z0 double
     * @return boolean
     */
    private boolean inEllipsoid(double x0, double y0, double z0) {

        if ((x0 * x0 / (a * a)) + ((y0 * y0) / (b * b)) + ((z0 * z0) / (c * c))
                <= 1) {
            return true;
        }

        return false;
    }
}