import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

public class IntersectionPoint implements Iterable<Double[]> {
    private ArrayList<Double[][]> points;

    public IntersectionPoint(ArrayList<Double[][]> points) {
        this.points = points;
    }


    public Iterator<Double[]> iterator() {
        return new IntersectionIterator();
    }

    private class IntersectionIterator implements Iterator<Double[]> {
        private Double[] p = new Double[2];
        private int ind1, ind2;


        IntersectionIterator() {
            ind1 = 0;
            ind2 = 1;
        }

        public boolean hasNext() {

            return (ind1 + 1) < points.size();
        }


        public Double[] next() {
            double x1, x2, x3, x4;
            double y1, y2, y3, y4;
            while (ind1 < points.size()) {
                x1 = points.get(ind1)[0][0];
                y1 = points.get(ind1)[0][1];
                x2 = points.get(ind1)[1][0];
                y2 = points.get(ind1)[1][1];
                while (ind2 < points.size()) {
                    x3 = points.get(ind2)[0][0];
                    y3 = points.get(ind2)[0][1];
                    x4 = points.get(ind2)[1][0];
                    y4 = points.get(ind2)[1][1];

                    if (x2 < x1) {
                        double a, b;
                        a = x2;
                        x2 = x1;
                        x1 = a;
                        b = y2;
                        y2 = y1;
                        y1 = b;
                    }
                    if (x4 < x3) {
                        double a, b;
                        a = x4;
                        x4= x3;
                        x3 = a;
                        b = y4;
                        y4 = y3;
                        y3 = b;
                    }

                    if (x2 > x3) {
                        //если оба отрезка вертикальные
                        if ((x1 - x2 == 0) && (x3 - x4 == 0)) {
                //если они лежат на одном X
                            if (x1 == x3) {
                //проверим пересекаются ли они, т.е. есть ли у них общий Y
                                if (((Math.max(y1, y2) < Math.min(y3, y4)) || (Math.min(y1, y2) > Math.max(y3, y4)))) {
                                    return null;

                                }

                                //если первый отрезок вертикальный
                                if (x1 - x2 == 0) {
                                //найдём p[0], p[1] - точки пересечения двух прямых
                                    p[0] = x1;
                                    double A2 = (y3 - y4) / (x3 - x4);
                                    double b2 = y3 - A2 * x3;
                                    p[1] = A2 * p[0] + b2;
                                    if (x3 <= p[0] && x4 >= p[0] && Math.min(y1, y2) <= p[1] && Math.max(y1, y2) >= p[1])
                                        return p;
                                    else
                                        return null;
                                }

                                //если второй отрезок вертикальный
                                if (x3 - x4 == 0) {
                                    //найдём p[0], p[1] - точки пересечения двух прямых
                                    p[0] = x3;
                                    double A1 = (y1 - y2) / (x1 - x2);
                                    double b1 = y1 - A1 * x1;
                                    p[1] = A1 * p[0] + b1;
                                    if (x1 <= p[0] && x2 >= p[0] && Math.min(y3, y4) <= p[1] && Math.max(y3, y4) >= p[1])
                                        return p;
                                    else
                                        return null;
                                }
                                //оба отрезка невертикальные
                                double A1 = (y1 - y2) / (x1 - x2);
                                double A2 = (y3 - y4) / (x3 - x4);
                                double b1 = y1 - A1 * x1;
                                double b2 = y3 - A2 * x3;
                                if (A1 != A2) {
                                     //отрезки не параллельны

                                //p[0] - абсцисса точки пересечения двух прямых
                                    p[0] = (b2 - b1) / (A1 - A2);
                                    if ((p[0] < Math.max(x1, x3)) || (p[0] > Math.min(x2, x4))) {
                                        return null; //точка p[0] находится вне пересечения проекций отрезков на ось X
                                    } else {
                                        return p;
                                    }
                                }
                            }
                        }
                    }
                    ind2++;

                    p[0] = ((x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4)) / ((x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4));
                    p[1] = ((x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4)) / ((x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4));
                    return p;
                }
                ind1++;
                ind1 = ind1 + 1;
            }
            return null;
        }
    }
}


//для прямых
/*public Double[] next() {
            double x1 = 0.0, x2 = 0.0, x3 = 0.0, x4 = 0.0;
            double y1 = 0.0,y2 = 0.0,y3 = 0.0,y4 = 0.0;
                while (ind1 < points.size()) {
                    //ind2 = ind1 + 1;
                    x1 = points.get(ind1)[0][0];
                    y1 = points.get(ind1)[0][1];
                    x2 = points.get(ind1)[1][0];
                    y2 = points.get(ind1)[1][1];
                    while (ind2 < points.size()) {
                        x3 = points.get(ind2)[0][0];
                        y3 = points.get(ind2)[0][1];
                        x4 = points.get(ind2)[1][0];
                        y4 = points.get(ind2)[1][1];
                        if ((x4 - x3) / (y4 - y3) != (x2 - x1) / (y2 - y1)) {
                            p[0] = ((x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4)) / ((x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4));
                            p[1] = ((x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4)) / ((x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4));

                           String.format("%.2f",p[0]);
                            String.format("%.2f",p[1]);
                        }

                        ind2++;
                        System.out.print("Intersection points: ");
                        return p;
                    }

                    ind1++;
                    ind2 = ind1 + 1;
                    //return p;

                }
            return p;
        }*/