package divideconquer;

import java.util.ArrayList;
import java.util.Comparator;

/**
 * @author dimgrichr
 * <p>Space complexity: O(n) Time complexity: O(nlogn), because it is a divide and conquer
 * algorithm
 */
public class SkylineAlgorithm {
 private ArrayList<Point> points;

 /**
 * Main constructor of the application. ArrayList points gets created, which represents the sum of
 * all edges.
 */
 public SkylineAlgorithm() {
 points = new ArrayList<>();
 }

 /** @return points, the ArrayList that includes all points. */
 public ArrayList<Point> getPoints() {
 return points;
 }

 /**
 * The main divide and conquer, and also recursive algorithm. It gets an ArrayList full of points
 * as an argument. If the size of that ArrayList is 1 or 2, the ArrayList is returned as it is, or
 * with one less point (if the initial size is 2 and one of it's points, is dominated by the other
 * one). On the other hand, if the ArrayList's size is bigger than 2, the function is called
 * again, twice, with arguments the corresponding half of the initial ArrayList each time. Once
 * the flashback has ended, the function produceFinalSkyLine gets called, in order to produce the
 * final skyline, and return it.
 *
 * @param list, the initial list of points
 * @return leftSkyLine, the combination of first half's and second half's skyline
 * @see Point
 */
 public ArrayList<Point> produceSubSkyLines(ArrayList<Point> list) {

 // part where function exits flashback
 int size = list.size();
 if (size == 1) {
 return list;
 } else if (size == 2) {
 if (list.get(0).dominates(list.get(1))) {
 list.remove(1);
 } else {
 if (list.get(1).dominates(list.get(0))) {
 list.remove(0);
 }
 }
 return list;
 }

 // recursive part of the function
 ArrayList<Point> leftHalf = new ArrayList<>();
 ArrayList<Point> rightHalf = new ArrayList<>();
 for (int i = 0; i < list.size(); i++) {
 if (i < list.size() / 2) {
 leftHalf.add(list.get(i));
 } else {
 rightHalf.add(list.get(i));
 }
 }
 ArrayList<Point> leftSubSkyLine = produceSubSkyLines(leftHalf);
 ArrayList<Point> rightSubSkyLine = produceSubSkyLines(rightHalf);

 // skyline is produced
 return produceFinalSkyLine(leftSubSkyLine, rightSubSkyLine);
 }

 /**
 * The first half's skyline gets cleared from some points that are not part of the final skyline
 * (Points with same x-value and different y=values. The point with the smallest y-value is kept).
 * Then, the minimum y-value of the points of first half's skyline is found. That helps us to
 * clear the second half's skyline, because, the points of second half's skyline that have greater
 * y-value of the minimum y-value that we found before, are dominated, so they are not part of the
 * final skyline. Finally, the "cleaned" first half's and second half's skylines, are combined,
 * producing the final skyline, which is returned.
 *
 * @param left the skyline of the left part of points
 * @param right the skyline of the right part of points
 * @return left the final skyline
 */
 public ArrayList<Point> produceFinalSkyLine(ArrayList<Point> left, ArrayList<Point> right) {

 // dominated points of ArrayList left are removed
 for (int i = 0; i < left.size() - 1; i++) {
 if (left.get(i).x == left.get(i + 1).x && left.get(i).y > left.get(i + 1).y) {
 left.remove(i);
 i--;
 }
 }

 // minimum y-value is found
 int min = left.get(0).y;
 for (int i = 1; i < left.size(); i++) {
 if (min > left.get(i).y) {
 min = left.get(i).y;
 if (min == 1) {
 i = left.size();
 }
 }
 }

 // dominated points of ArrayList right are removed
 for (int i = 0; i < right.size(); i++) {
 if (right.get(i).y >= min) {
 right.remove(i);
 i--;
 }
 }

 // final skyline found and returned
 left.addAll(right);
 return left;
 }

 public static class Point {
 private int x;
 private int y;

 /**
 * The main constructor of Point Class, used to represent the 2 Dimension points.
 *
 * @param x the point's x-value.
 * @param y the point's y-value.
 */
 public Point(int x, int y) {
 this.x = x;
 this.y = y;
 }

 /** @return x, the x-value */
 public int getX() {
 return x;
 }

 /** @return y, the y-value */
 public int getY() {
 return y;
 }

 /**
 * Based on the skyline theory, it checks if the point that calls the function dominates the
 * argument point.
 *
 * @param p1 the point that is compared
 * @return true if the point wich calls the function dominates p1 false otherwise.
 */
 public boolean dominates(Point p1) {
 // checks if p1 is dominated
 return (this.x < p1.x && this.y <= p1.y) || (this.x <= p1.x && this.y < p1.y);
 }
 }

 /**
 * It is used to compare the 2 Dimension points, based on their x-values, in order get sorted
 * later.
 */
 class XComparator implements Comparator<Point> {
 @Override
 public int compare(Point a, Point b) {
 return Integer.compare(a.x, b.x);
 }
 }
}