import java.util.ArrayList;
import java.util.Collections;
import java.util.Stack;
import javax.ejb.Stateless;

/**
 * @author Andrzej
 */

@Stateless
public class Solid implements ISolidRemote{

    private ArrayList<Point> listaPunktow;
    private Stack<Point> stosPunktow;
    private Point pierwszyPunkt;

    /**
     * Oblicza powierzchnie boczna
     *
     * @param points lista punktow
     * @return powierzchnia boczna
     */
    @Override
    public String getSurfaceArea(ArrayList<Point> points) {
        this.listaPunktow = points;
        this.stosPunktow = new Stack<Point>();
        //double h = getHeight();
        pierwszyPunkt = findFirstPoint();
        points.remove(pierwszyPunkt);
        zmianaKolej();
        graham();
        double result = calculateConvexArea();
        return String.format("%.5f", result);
    }

     private double calculateConvexArea() {
        double areaResult = 0.0;
        int stackSize = stosPunktow.size();
        int j = stackSize - 1;

        for (int i = 0; i < stackSize; i++) {
            Point p1 = stosPunktow.get(i);
            Point p2 = stosPunktow.get((j));
             areaResult += (p1.getX() + p2.getX()) * (p1.getY() - p2.getY());
             j = i;
        }
        areaResult = Math.abs(areaResult / 2);

        return areaResult;
    }
    /**
     * @return punkt poczatkowy o minimalnym y jezeli istnieje wiele punktow o
     * minimalnym y wybierz taki, ktory ma minimalna wartosc x
     */
    private Point findFirstPoint() {
        Point minimum = listaPunktow.get(0);
        for (int j = 1; j < listaPunktow.size(); j++) {
            minimum = getMinimum(minimum, listaPunktow.get(j));
        }
        return minimum;
    }

    /**
     * @param a pierwszy punkt
     * @param b drugi punkt
     * @return punkt o minimalnym y jezeli istnieje wiele punktow o minimalnym y
     * wybierz taki, ktory ma minimalna wartosc x
     */
    private Point getMinimum(Point Aa, Point Ba) {
        if (Aa.getY() < Ba.getY()) {
            return Aa;
        }
        if (Aa.getY() > Ba.getY()) {
            return Ba;
        }
        if (Aa.getX() < Ba.getX()) {
            return Aa;
        } else {
            return Ba;
        }
    }

    /**
     * sortowanie punktow wzgledem kata
     */
    private void zmianaKolej() {
        for (Point punkt : listaPunktow) {
            double x = punkt.getX() - pierwszyPunkt.getX();
            double z = punkt.getY() - pierwszyPunkt.getY();

            if (x < 0.0) {
                punkt.setKont(2 - (z / (Math.abs(x) + Math.abs(z))));
            } else {
                punkt.setKont(z / (Math.abs(x) + Math.abs(z)));
            }
        }

        Collections.sort(listaPunktow);
    }

    /**
     * algorytm Grahama do wyznaczania otoczki wypuklej
     */
    private void graham() {
        stosPunktow.push(pierwszyPunkt);
        stosPunktow.push(listaPunktow.get(0));
        stosPunktow.push(listaPunktow.get(1));

        for (int i = 2; i < listaPunktow.size(); i++) {
            while (isRight(
                    stosPunktow.get(stosPunktow.size() - 2),
                    stosPunktow.get(stosPunktow.size() - 1),
                    listaPunktow.get(i)
            )) {
                stosPunktow.pop();
            }
            stosPunktow.push(listaPunktow.get(i));
        }
    }

    /**
     * @param a pierwszy punkt
     * @param b drugi punkt
     * @param c trzeci punkt
     * @return true - jezeli skret w prawo
     */
    private boolean isRight(Point Aa, Point Ba, Point Ca) {
        double dir = Aa.getX() * Ba.getY()
                + Ba.getX() * Ca.getY()
                + Ca.getX() * Aa.getY()
                - Ca.getX() * Ba.getY()
                - Aa.getX() * Ca.getY()
                - Ba.getX() * Aa.getY();

        return dir < 0.0;
    }

    /*private double calculateSurArea() {
        double res = 0.0;
        for (int j = 0; j < stosPunktow.size(); j++) {
            Point aPunkt = stosPunktow.get(j);
            Point bPunkt = stosPunktow.get((j + 1) % stosPunktow.size());

            double x = aPunkt.getX() - bPunkt.getX();
            double z = aPunkt.getZ() - bPunkt.getZ();
            res += x * z;
        }
        return res;
    }*/





    /**
     * Klasa wewnetrzna opisujaca punkt
     */
    public static class Point implements Comparable<Point> {

        private double Xa;
        private double Ya;
        private double Za;
        private double kont;

        public Point(double x, double y, double z) {
            this.Xa = x;
            this.Ya = y;
            this.Za = z;
        }

        public double getX() {
            return Xa;
        }

        public double getY() {
            return Ya;
        }

        public double getZ() {
            return Za;
        }

        public double getKont() {
            return kont;
        }

        private void setKont(double kont) {
            this.kont = kont;
        }

        @Override
        public int compareTo(Point xo) {
            if (this.kont < xo.getKont()) {
                return -1;
            } else if (this.kont > xo.getKont()) {
                return 1;
            }
            return 0;
        }
    }

}