/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/**
 * @author Denis M. Kishenko
 * @version $Revision$
 */

package java.awt.geom;

import java.awt.Rectangle;
import java.awt.Shape;
import java.util.NoSuchElementException;

import org.apache.harmony.awt.internal.nls.Messages;

/**
 * The Class Line2D represents a line whose data is given in high-precision
 * values appropriate for graphical operations.
 * 
 * @since Android 1.0
 */
public abstract class Line2D implements Shape, Cloneable {

    /**
     * The Class Float is the subclass of Line2D that has all of its data values
     * stored with float-level precision.
     * 
     * @since Android 1.0
     */
    public static class Float extends Line2D {

        /**
         * The x coordinate of the starting point.
         */
        public float x1;

        /**
         * The y coordinate of the starting point.
         */
        public float y1;

        /**
         * The x coordinate of the end point.
         */
        public float x2;

        /**
         * The y coordinate of the end point.
         */
        public float y2;

        /**
         * Instantiates a new float-valued Line2D with its data values set to
         * zero.
         */
        public Float() {
        }

        /**
         * Instantiates a new float-valued Line2D with the specified endpoints.
         * 
         * @param x1
         *            the x coordinate of the starting point.
         * @param y1
         *            the y coordinate of the starting point.
         * @param x2
         *            the x coordinate of the end point.
         * @param y2
         *            the y coordinate of the end point.
         */
        public Float(float x1, float y1, float x2, float y2) {
            setLine(x1, y1, x2, y2);
        }

        /**
         * Instantiates a new float-valued Line2D with the specified endpoints.
         * 
         * @param p1
         *            the starting point.
         * @param p2
         *            the end point.
         */
        public Float(Point2D p1, Point2D p2) {
            setLine(p1, p2);
        }

        @Override
        public double getX1() {
            return x1;
        }

        @Override
        public double getY1() {
            return y1;
        }

        @Override
        public double getX2() {
            return x2;
        }

        @Override
        public double getY2() {
            return y2;
        }

        @Override
        public Point2D getP1() {
            return new Point2D.Float(x1, y1);
        }

        @Override
        public Point2D getP2() {
            return new Point2D.Float(x2, y2);
        }

        @Override
        public void setLine(double x1, double y1, double x2, double y2) {
            this.x1 = (float)x1;
            this.y1 = (float)y1;
            this.x2 = (float)x2;
            this.y2 = (float)y2;
        }

        /**
         * Sets the data values that define the line.
         * 
         * @param x1
         *            the x coordinate of the starting point.
         * @param y1
         *            the y coordinate of the starting point.
         * @param x2
         *            the x coordinate of the end point.
         * @param y2
         *            the y coordinate of the end point.
         */
        public void setLine(float x1, float y1, float x2, float y2) {
            this.x1 = x1;
            this.y1 = y1;
            this.x2 = x2;
            this.y2 = y2;
        }

        public Rectangle2D getBounds2D() {
            float rx, ry, rw, rh;
            if (x1 < x2) {
                rx = x1;
                rw = x2 - x1;
            } else {
                rx = x2;
                rw = x1 - x2;
            }
            if (y1 < y2) {
                ry = y1;
                rh = y2 - y1;
            } else {
                ry = y2;
                rh = y1 - y2;
            }
            return new Rectangle2D.Float(rx, ry, rw, rh);
        }
    }

    /**
     * The Class Double is the subclass of Line2D that has all of its data
     * values stored with double-level precision.
     * 
     * @since Android 1.0
     */
    public static class Double extends Line2D {

        /**
         * The x coordinate of the starting point.
         */
        public double x1;

        /**
         * The y coordinate of the starting point.
         */
        public double y1;

        /**
         * The x coordinate of the end point.
         */
        public double x2;

        /**
         * The y coordinate of the end point.
         */
        public double y2;

        /**
         * Instantiates a new double-valued Line2D with its data values set to
         * zero.
         */
        public Double() {
        }

        /**
         * Instantiates a new double-valued Line2D with the specified endpoints.
         * 
         * @param x1
         *            the x coordinate of the starting point.
         * @param y1
         *            the y coordinate of the starting point.
         * @param x2
         *            the x coordinate of the end point.
         * @param y2
         *            the y coordinate of the end point.
         */
        public Double(double x1, double y1, double x2, double y2) {
            setLine(x1, y1, x2, y2);
        }

        /**
         * Instantiates a new double-valued Line2D with the specified endpoints.
         * 
         * @param p1
         *            the starting point.
         * @param p2
         *            the end point.
         */
        public Double(Point2D p1, Point2D p2) {
            setLine(p1, p2);
        }

        @Override
        public double getX1() {
            return x1;
        }

        @Override
        public double getY1() {
            return y1;
        }

        @Override
        public double getX2() {
            return x2;
        }

        @Override
        public double getY2() {
            return y2;
        }

        @Override
        public Point2D getP1() {
            return new Point2D.Double(x1, y1);
        }

        @Override
        public Point2D getP2() {
            return new Point2D.Double(x2, y2);
        }

        @Override
        public void setLine(double x1, double y1, double x2, double y2) {
            this.x1 = x1;
            this.y1 = y1;
            this.x2 = x2;
            this.y2 = y2;
        }

        public Rectangle2D getBounds2D() {
            double rx, ry, rw, rh;
            if (x1 < x2) {
                rx = x1;
                rw = x2 - x1;
            } else {
                rx = x2;
                rw = x1 - x2;
            }
            if (y1 < y2) {
                ry = y1;
                rh = y2 - y1;
            } else {
                ry = y2;
                rh = y1 - y2;
            }
            return new Rectangle2D.Double(rx, ry, rw, rh);
        }
    }

    /*
     * Line2D path iterator
     */
    /**
     * The subclass of PathIterator to traverse a Line2D.
     */
    class Iterator implements PathIterator {

        /**
         * The x coordinate of the start line point.
         */
        double x1;

        /**
         * The y coordinate of the start line point.
         */
        double y1;

        /**
         * The x coordinate of the end line point.
         */
        double x2;

        /**
         * The y coordinate of the end line point.
         */
        double y2;

        /**
         * The path iterator transformation.
         */
        AffineTransform t;

        /**
         * The current segment index.
         */
        int index;

        /**
         * Constructs a new Line2D.Iterator for given line and transformation.
         * 
         * @param l
         *            the source Line2D object.
         * @param at
         *            the AffineTransform object to apply rectangle path.
         */
        Iterator(Line2D l, AffineTransform at) {
            this.x1 = l.getX1();
            this.y1 = l.getY1();
            this.x2 = l.getX2();
            this.y2 = l.getY2();
            this.t = at;
        }

        public int getWindingRule() {
            return WIND_NON_ZERO;
        }

        public boolean isDone() {
            return index > 1;
        }

        public void next() {
            index++;
        }

        public int currentSegment(double[] coords) {
            if (isDone()) {
                // awt.4B=Iterator out of bounds
                throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
            }
            int type;
            if (index == 0) {
                type = SEG_MOVETO;
                coords[0] = x1;
                coords[1] = y1;
            } else {
                type = SEG_LINETO;
                coords[0] = x2;
                coords[1] = y2;
            }
            if (t != null) {
                t.transform(coords, 0, coords, 0, 1);
            }
            return type;
        }

        public int currentSegment(float[] coords) {
            if (isDone()) {
                // awt.4B=Iterator out of bounds
                throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
            }
            int type;
            if (index == 0) {
                type = SEG_MOVETO;
                coords[0] = (float)x1;
                coords[1] = (float)y1;
            } else {
                type = SEG_LINETO;
                coords[0] = (float)x2;
                coords[1] = (float)y2;
            }
            if (t != null) {
                t.transform(coords, 0, coords, 0, 1);
            }
            return type;
        }

    }

    /**
     * Instantiates a new Line2D.
     */
    protected Line2D() {
    }

    /**
     * Gets the x coordinate of the starting point.
     * 
     * @return the x coordinate of the starting point.
     */
    public abstract double getX1();

    /**
     * Gets the y coordinate of the starting point.
     * 
     * @return the y coordinate of the starting point.
     */
    public abstract double getY1();

    /**
     * Gets the x coordinate of the end point.
     * 
     * @return the x2.
     */
    public abstract double getX2();

    /**
     * Gets the y coordinate of the end point.
     * 
     * @return the y coordinate of the end point.
     */
    public abstract double getY2();

    /**
     * Gets the p the starting point.
     * 
     * @return the p the starting point.
     */
    public abstract Point2D getP1();

    /**
     * Gets the p end point.
     * 
     * @return the p end point.
     */
    public abstract Point2D getP2();

    /**
     * Sets the line's endpoints.
     * 
     * @param x1
     *            the x coordinate of the starting point.
     * @param y1
     *            the y coordinate of the starting point.
     * @param x2
     *            the x coordinate of the end point.
     * @param y2
     *            the y coordinate of the end point.
     */
    public abstract void setLine(double x1, double y1, double x2, double y2);

    /**
     * Sets the line's endpoints.
     * 
     * @param p1
     *            the starting point.
     * @param p2
     *            the end point.
     */
    public void setLine(Point2D p1, Point2D p2) {
        setLine(p1.getX(), p1.getY(), p2.getX(), p2.getY());
    }

    /**
     * Sets the line's endpoints by copying the data from another Line2D.
     * 
     * @param line
     *            the Line2D to copy the endpoint data from.
     */
    public void setLine(Line2D line) {
        setLine(line.getX1(), line.getY1(), line.getX2(), line.getY2());
    }

    public Rectangle getBounds() {
        return getBounds2D().getBounds();
    }

    /**
     * Tells where the point is with respect to the line segment, given the
     * orientation of the line segment. If the ray found by extending the line
     * segment from its starting point is rotated, this method tells whether the
     * ray should rotate in a clockwise direction or a counter-clockwise
     * direction to hit the point first. The return value is 0 if the point is
     * on the line segment, it's 1 if the point is on the ray or if the ray
     * should rotate in a counter-clockwise direction to get to the point, and
     * it's -1 if the ray should rotate in a clockwise direction to get to the
     * point or if the point is on the line determined by the line segment but
     * not on the ray from the segment's starting point and through its end
     * point.
     * 
     * @param x1
     *            the x coordinate of the starting point of the line segment.
     * @param y1
     *            the y coordinate of the starting point of the line segment.
     * @param x2
     *            the x coordinate of the end point of the line segment.
     * @param y2
     *            the y coordinate of the end point of the line segment.
     * @param px
     *            the x coordinate of the test point.
     * @param py
     *            the p coordinate of the test point.
     * @return the value that describes where the point is with respect to the
     *         line segment, given the orientation of the line segment.
     */
    public static int relativeCCW(double x1, double y1, double x2, double y2, double px, double py) {
        /*
         * A = (x2-x1, y2-y1) P = (px-x1, py-y1)
         */
        x2 -= x1;
        y2 -= y1;
        px -= x1;
        py -= y1;
        double t = px * y2 - py * x2; // PxA
        if (t == 0.0) {
            t = px * x2 + py * y2; // P*A
            if (t > 0.0) {
                px -= x2; // B-A
                py -= y2;
                t = px * x2 + py * y2; // (P-A)*A
                if (t < 0.0) {
                    t = 0.0;
                }
            }
        }

        return t < 0.0 ? -1 : (t > 0.0 ? 1 : 0);
    }

    /**
     * Tells where the point is with respect to this line segment, given the
     * orientation of this line segment. If the ray found by extending the line
     * segment from its starting point is rotated, this method tells whether the
     * ray should rotate in a clockwise direction or a counter-clockwise
     * direction to hit the point first. The return value is 0 if the point is
     * on the line segment, it's 1 if the point is on the ray or if the ray
     * should rotate in a counter-clockwise direction to get to the point, and
     * it's -1 if the ray should rotate in a clockwise direction to get to the
     * point or if the point is on the line determined by the line segment but
     * not on the ray from the segment's starting point and through its end
     * point.
     * 
     * @param px
     *            the x coordinate of the test point.
     * @param py
     *            the p coordinate of the test point.
     * @return the value that describes where the point is with respect to this
     *         line segment, given the orientation of this line segment.
     */
    public int relativeCCW(double px, double py) {
        return relativeCCW(getX1(), getY1(), getX2(), getY2(), px, py);
    }

    /**
     * Tells where the point is with respect to this line segment, given the
     * orientation of this line segment. If the ray found by extending the line
     * segment from its starting point is rotated, this method tells whether the
     * ray should rotate in a clockwise direction or a counter-clockwise
     * direction to hit the point first. The return value is 0 if the point is
     * on the line segment, it's 1 if the point is on the ray or if the ray
     * should rotate in a counter-clockwise direction to get to the point, and
     * it's -1 if the ray should rotate in a clockwise direction to get to the
     * point or if the point is on the line determined by the line segment but
     * not on the ray from the segment's starting point and through its end
     * point.
     * 
     * @param p
     *            the test point.
     * @return the value that describes where the point is with respect to this
     *         line segment, given the orientation of this line segment.
     */
    public int relativeCCW(Point2D p) {
        return relativeCCW(getX1(), getY1(), getX2(), getY2(), p.getX(), p.getY());
    }

    /**
     * Tells whether the two line segments cross.
     * 
     * @param x1
     *            the x coordinate of the starting point of the first segment.
     * @param y1
     *            the y coordinate of the starting point of the first segment.
     * @param x2
     *            the x coordinate of the end point of the first segment.
     * @param y2
     *            the y coordinate of the end point of the first segment.
     * @param x3
     *            the x coordinate of the starting point of the second segment.
     * @param y3
     *            the y coordinate of the starting point of the second segment.
     * @param x4
     *            the x coordinate of the end point of the second segment.
     * @param y4
     *            the y coordinate of the end point of the second segment.
     * @return true, if the two line segments cross.
     */
    public static boolean linesIntersect(double x1, double y1, double x2, double y2, double x3,
            double y3, double x4, double y4) {
        /*
         * A = (x2-x1, y2-y1) B = (x3-x1, y3-y1) C = (x4-x1, y4-y1) D = (x4-x3,
         * y4-y3) = C-B E = (x1-x3, y1-y3) = -B F = (x2-x3, y2-y3) = A-B Result
         * is ((AxB) (AxC) <=0) and ((DxE) (DxF) <= 0) DxE = (C-B)x(-B) =
         * BxB-CxB = BxC DxF = (C-B)x(A-B) = CxA-CxB-BxA+BxB = AxB+BxC-AxC
         */

        x2 -= x1; // A
        y2 -= y1;
        x3 -= x1; // B
        y3 -= y1;
        x4 -= x1; // C
        y4 -= y1;

        double AvB = x2 * y3 - x3 * y2;
        double AvC = x2 * y4 - x4 * y2;

        // Online
        if (AvB == 0.0 && AvC == 0.0) {
            if (x2 != 0.0) {
                return (x4 * x3 <= 0.0)
                        || ((x3 * x2 >= 0.0) && (x2 > 0.0 ? x3 <= x2 || x4 <= x2 : x3 >= x2
                                || x4 >= x2));
            }
            if (y2 != 0.0) {
                return (y4 * y3 <= 0.0)
                        || ((y3 * y2 >= 0.0) && (y2 > 0.0 ? y3 <= y2 || y4 <= y2 : y3 >= y2
                                || y4 >= y2));
            }
            return false;
        }

        double BvC = x3 * y4 - x4 * y3;

        return (AvB * AvC <= 0.0) && (BvC * (AvB + BvC - AvC) <= 0.0);
    }

    /**
     * Tells whether the specified line segments crosses this line segment.
     * 
     * @param x1
     *            the x coordinate of the starting point of the test segment.
     * @param y1
     *            the y coordinate of the starting point of the test segment.
     * @param x2
     *            the x coordinate of the end point of the test segment.
     * @param y2
     *            the y coordinate of the end point of the test segment.
     * @return true, if the specified line segments crosses this line segment.
     */
    public boolean intersectsLine(double x1, double y1, double x2, double y2) {
        return linesIntersect(x1, y1, x2, y2, getX1(), getY1(), getX2(), getY2());
    }

    /**
     * Tells whether the specified line segments crosses this line segment.
     * 
     * @param l
     *            the test segment.
     * @return true, if the specified line segments crosses this line segment.
     * @throws NullPointerException
     *             if l is null.
     */
    public boolean intersectsLine(Line2D l) {
        return linesIntersect(l.getX1(), l.getY1(), l.getX2(), l.getY2(), getX1(), getY1(),
                getX2(), getY2());
    }

    /**
     * Gives the square of the distance between the point and the line segment.
     * 
     * @param x1
     *            the x coordinate of the starting point of the line segment.
     * @param y1
     *            the y coordinate of the starting point of the line segment.
     * @param x2
     *            the x coordinate of the end point of the line segment.
     * @param y2
     *            the y coordinate of the end point of the line segment.
     * @param px
     *            the x coordinate of the test point.
     * @param py
     *            the y coordinate of the test point.
     * @return the the square of the distance between the point and the line
     *         segment.
     */
    public static double ptSegDistSq(double x1, double y1, double x2, double y2, double px,
            double py) {
        /*
         * A = (x2 - x1, y2 - y1) P = (px - x1, py - y1)
         */
        x2 -= x1; // A = (x2, y2)
        y2 -= y1;
        px -= x1; // P = (px, py)
        py -= y1;
        double dist;
        if (px * x2 + py * y2 <= 0.0) { // P*A
            dist = px * px + py * py;
        } else {
            px = x2 - px; // P = A - P = (x2 - px, y2 - py)
            py = y2 - py;
            if (px * x2 + py * y2 <= 0.0) { // P*A
                dist = px * px + py * py;
            } else {
                dist = px * y2 - py * x2;
                dist = dist * dist / (x2 * x2 + y2 * y2); // pxA/|A|
            }
        }
        if (dist < 0) {
            dist = 0;
        }
        return dist;
    }

    /**
     * Gives the distance between the point and the line segment.
     * 
     * @param x1
     *            the x coordinate of the starting point of the line segment.
     * @param y1
     *            the y coordinate of the starting point of the line segment.
     * @param x2
     *            the x coordinate of the end point of the line segment.
     * @param y2
     *            the y coordinate of the end point of the line segment.
     * @param px
     *            the x coordinate of the test point.
     * @param py
     *            the y coordinate of the test point.
     * @return the the distance between the point and the line segment.
     */
    public static double ptSegDist(double x1, double y1, double x2, double y2, double px, double py) {
        return Math.sqrt(ptSegDistSq(x1, y1, x2, y2, px, py));
    }

    /**
     * Gives the square of the distance between the point and this line segment.
     * 
     * @param px
     *            the x coordinate of the test point.
     * @param py
     *            the y coordinate of the test point.
     * @return the the square of the distance between the point and this line
     *         segment.
     */
    public double ptSegDistSq(double px, double py) {
        return ptSegDistSq(getX1(), getY1(), getX2(), getY2(), px, py);
    }

    /**
     * Gives the square of the distance between the point and this line segment.
     * 
     * @param p
     *            the test point.
     * @return the square of the distance between the point and this line
     *         segment.
     */
    public double ptSegDistSq(Point2D p) {
        return ptSegDistSq(getX1(), getY1(), getX2(), getY2(), p.getX(), p.getY());
    }

    /**
     * Gives the distance between the point and this line segment.
     * 
     * @param px
     *            the x coordinate of the test point.
     * @param py
     *            the y coordinate of the test point.
     * @return the distance between the point and this line segment.
     */
    public double ptSegDist(double px, double py) {
        return ptSegDist(getX1(), getY1(), getX2(), getY2(), px, py);
    }

    /**
     * Gives the distance between the point and this line segment.
     * 
     * @param p
     *            the test point.
     * @return the distance between the point and this line segment.
     */
    public double ptSegDist(Point2D p) {
        return ptSegDist(getX1(), getY1(), getX2(), getY2(), p.getX(), p.getY());
    }

    /**
     * Gives the square of the distance between the point and the line.
     * 
     * @param x1
     *            the x coordinate of the starting point of the line segment.
     * @param y1
     *            the y coordinate of the starting point of the line segment.
     * @param x2
     *            the x coordinate of the end point of the line segment.
     * @param y2
     *            the y coordinate of the end point of the line segment.
     * @param px
     *            the x coordinate of the test point.
     * @param py
     *            the y coordinate of the test point.
     * @return the square of the distance between the point and the line.
     */
    public static double ptLineDistSq(double x1, double y1, double x2, double y2, double px,
            double py) {
        x2 -= x1;
        y2 -= y1;
        px -= x1;
        py -= y1;
        double s = px * y2 - py * x2;
        return s * s / (x2 * x2 + y2 * y2);
    }

    /**
     * Gives the square of the distance between the point and the line.
     * 
     * @param x1
     *            the x coordinate of the starting point of the line segment.
     * @param y1
     *            the y coordinate of the starting point of the line segment.
     * @param x2
     *            the x coordinate of the end point of the line segment.
     * @param y2
     *            the y coordinate of the end point of the line segment.
     * @param px
     *            the x coordinate of the test point.
     * @param py
     *            the y coordinate of the test point.
     * @return the square of the distance between the point and the line.
     */
    public static double ptLineDist(double x1, double y1, double x2, double y2, double px, double py) {
        return Math.sqrt(ptLineDistSq(x1, y1, x2, y2, px, py));
    }

    /**
     * Gives the square of the distance between the point and the line
     * determined by this Line2D.
     * 
     * @param px
     *            the x coordinate of the test point.
     * @param py
     *            the y coordinate of the test point.
     * @return the square of the distance between the point and the line
     *         determined by this Line2D.
     */
    public double ptLineDistSq(double px, double py) {
        return ptLineDistSq(getX1(), getY1(), getX2(), getY2(), px, py);
    }

    /**
     * Gives the square of the distance between the point and the line
     * determined by this Line2D.
     * 
     * @param p
     *            the test point.
     * @return the square of the distance between the point and the line
     *         determined by this Line2D.
     */
    public double ptLineDistSq(Point2D p) {
        return ptLineDistSq(getX1(), getY1(), getX2(), getY2(), p.getX(), p.getY());
    }

    /**
     * Gives the distance between the point and the line determined by this
     * Line2D.
     * 
     * @param px
     *            the x coordinate of the test point.
     * @param py
     *            the y coordinate of the test point.
     * @return the distance between the point and the line determined by this
     *         Line2D.
     */
    public double ptLineDist(double px, double py) {
        return ptLineDist(getX1(), getY1(), getX2(), getY2(), px, py);
    }

    /**
     * Gives the distance between the point and the line determined by this
     * Line2D.
     * 
     * @param p
     *            the test point.
     * @return the distance between the point and the line determined by this
     *         Line2D.
     */
    public double ptLineDist(Point2D p) {
        return ptLineDist(getX1(), getY1(), getX2(), getY2(), p.getX(), p.getY());
    }

    public boolean contains(double px, double py) {
        return false;
    }

    public boolean contains(Point2D p) {
        return false;
    }

    public boolean contains(Rectangle2D r) {
        return false;
    }

    public boolean contains(double rx, double ry, double rw, double rh) {
        return false;
    }

    public boolean intersects(double rx, double ry, double rw, double rh) {
        return intersects(new Rectangle2D.Double(rx, ry, rw, rh));
    }

    public boolean intersects(Rectangle2D r) {
        return r.intersectsLine(getX1(), getY1(), getX2(), getY2());
    }

    public PathIterator getPathIterator(AffineTransform at) {
        return new Iterator(this, at);
    }

    public PathIterator getPathIterator(AffineTransform at, double flatness) {
        return new Iterator(this, at);
    }

    @Override
    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }

}