/*

 * Copyright (c) 2007, 2015, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.java2d.marlin;

import java.awt.BasicStroke;

import java.awt.Shape;

import java.awt.geom.AffineTransform;

import java.awt.geom.Path2D;

import java.awt.geom.PathIterator;

import java.lang.ref.Reference;

import java.security.AccessController;

import java.util.concurrent.ConcurrentLinkedQueue;

import static sun.java2d.marlin.MarlinUtils.logInfo;

import sun.awt.geom.PathConsumer2D;

import sun.java2d.pipe.AATileGenerator;

import sun.java2d.pipe.Region;

import sun.java2d.pipe.RenderingEngine;

import sun.security.action.GetPropertyAction;

/**

 * Marlin RendererEngine implementation (derived from Pisces)

 */

public class MarlinRenderingEngine extends RenderingEngine

                                   implements MarlinConst

{

    private static enum NormMode {ON_WITH_AA, ON_NO_AA, OFF}

    private static final float MIN_PEN_SIZE = 1f / NORM_SUBPIXELS;

    /**

     * Public constructor

     */

    public MarlinRenderingEngine() {

        super();

        logSettings(MarlinRenderingEngine.class.getName());

    }

    /**

     * Create a widened path as specified by the parameters.

     * <p>

     * The specified {@code src} {@link Shape} is widened according

     * to the specified attribute parameters as per the

     * {@link BasicStroke} specification.

     *

     * @param src the source path to be widened

     * @param width the width of the widened path as per {@code BasicStroke}

     * @param caps the end cap decorations as per {@code BasicStroke}

     * @param join the segment join decorations as per {@code BasicStroke}

     * @param miterlimit the miter limit as per {@code BasicStroke}

     * @param dashes the dash length array as per {@code BasicStroke}

     * @param dashphase the initial dash phase as per {@code BasicStroke}

     * @return the widened path stored in a new {@code Shape} object

     * @since 1.7

     */

    @Override

    public Shape createStrokedShape(Shape src,

                                    float width,

                                    int caps,

                                    int join,

                                    float miterlimit,

                                    float dashes[],

                                    float dashphase)

    {

        final RendererContext rdrCtx = getRendererContext();

        try {

            // initialize a large copyable Path2D to avoid a lot of array growing:

            final Path2D.Float p2d =

                    (rdrCtx.p2d == null) ?

                    (rdrCtx.p2d = new Path2D.Float(Path2D.WIND_NON_ZERO,

                                                   INITIAL_MEDIUM_ARRAY))

                    : rdrCtx.p2d;

            // reset

            p2d.reset();

            strokeTo(rdrCtx,

                     src,

                     null,

                     width,

                     NormMode.OFF,

                     caps,

                     join,

                     miterlimit,

                     dashes,

                     dashphase,

                     rdrCtx.transformerPC2D.wrapPath2d(p2d)

                    );

            // Use Path2D copy constructor (trim)

            return new Path2D.Float(p2d);

        } finally {

            // recycle the RendererContext instance

            returnRendererContext(rdrCtx);

        }

    }

    /**

     * Sends the geometry for a widened path as specified by the parameters

     * to the specified consumer.

     * <p>

     * The specified {@code src} {@link Shape} is widened according

     * to the parameters specified by the {@link BasicStroke} object.

     * Adjustments are made to the path as appropriate for the

     * {@link VALUE_STROKE_NORMALIZE} hint if the {@code normalize}

     * boolean parameter is true.

     * Adjustments are made to the path as appropriate for the

     * {@link VALUE_ANTIALIAS_ON} hint if the {@code antialias}

     * boolean parameter is true.

     * <p>

     * The geometry of the widened path is forwarded to the indicated

     * {@link PathConsumer2D} object as it is calculated.

     *

     * @param src the source path to be widened

     * @param bs the {@code BasicSroke} object specifying the

     *           decorations to be applied to the widened path

     * @param normalize indicates whether stroke normalization should

     *                  be applied

     * @param antialias indicates whether or not adjustments appropriate

     *                  to antialiased rendering should be applied

     * @param consumer the {@code PathConsumer2D} instance to forward

     *                 the widened geometry to

     * @since 1.7

     */

    @Override

    public void strokeTo(Shape src,

                         AffineTransform at,

                         BasicStroke bs,

                         boolean thin,

                         boolean normalize,

                         boolean antialias,

                         final PathConsumer2D consumer)

    {

        final NormMode norm = (normalize) ?

                ((antialias) ? NormMode.ON_WITH_AA : NormMode.ON_NO_AA)

                : NormMode.OFF;

        final RendererContext rdrCtx = getRendererContext();

        try {

            strokeTo(rdrCtx, src, at, bs, thin, norm, antialias, consumer);

        } finally {

            // recycle the RendererContext instance

            returnRendererContext(rdrCtx);

        }

    }

    final void strokeTo(final RendererContext rdrCtx,

                        Shape src,

                        AffineTransform at,

                        BasicStroke bs,

                        boolean thin,

                        NormMode normalize,

                        boolean antialias,

                        PathConsumer2D pc2d)

    {

        float lw;

        if (thin) {

            if (antialias) {

                lw = userSpaceLineWidth(at, MIN_PEN_SIZE);

            } else {

                lw = userSpaceLineWidth(at, 1.0f);

            }

        } else {

            lw = bs.getLineWidth();

        }

        strokeTo(rdrCtx,

                 src,

                 at,

                 lw,

                 normalize,

                 bs.getEndCap(),

                 bs.getLineJoin(),

                 bs.getMiterLimit(),

                 bs.getDashArray(),

                 bs.getDashPhase(),

                 pc2d);

    }

    private final float userSpaceLineWidth(AffineTransform at, float lw) {

        float widthScale;

        if (at == null) {

            widthScale = 1.0f;

        } else if ((at.getType() & (AffineTransform.TYPE_GENERAL_TRANSFORM  |

                                    AffineTransform.TYPE_GENERAL_SCALE)) != 0) {

            widthScale = (float)Math.sqrt(at.getDeterminant());

        } else {

            // First calculate the "maximum scale" of this transform.

            double A = at.getScaleX();       // m00

            double C = at.getShearX();       // m01

            double B = at.getShearY();       // m10

            double D = at.getScaleY();       // m11

            /*

             * Given a 2 x 2 affine matrix [ A B ] such that

             *                             [ C D ]

             * v' = [x' y'] = [Ax + Cy, Bx + Dy], we want to

             * find the maximum magnitude (norm) of the vector v'

             * with the constraint (x^2 + y^2 = 1).

             * The equation to maximize is

             *     |v'| = sqrt((Ax+Cy)^2+(Bx+Dy)^2)

             * or  |v'| = sqrt((AA+BB)x^2 + 2(AC+BD)xy + (CC+DD)y^2).

             * Since sqrt is monotonic we can maximize |v'|^2

             * instead and plug in the substitution y = sqrt(1 - x^2).

             * Trigonometric equalities can then be used to get

             * rid of most of the sqrt terms.

             */

            double EA = A*A + B*B;          // x^2 coefficient

            double EB = 2.0*(A*C + B*D);    // xy coefficient

            double EC = C*C + D*D;          // y^2 coefficient

            /*

             * There is a lot of calculus omitted here.

             *

             * Conceptually, in the interests of understanding the

             * terms that the calculus produced we can consider

             * that EA and EC end up providing the lengths along

             * the major axes and the hypot term ends up being an

             * adjustment for the additional length along the off-axis

             * angle of rotated or sheared ellipses as well as an

             * adjustment for the fact that the equation below

             * averages the two major axis lengths.  (Notice that

             * the hypot term contains a part which resolves to the

             * difference of these two axis lengths in the absence

             * of rotation.)

             *

             * In the calculus, the ratio of the EB and (EA-EC) terms

             * ends up being the tangent of 2*theta where theta is

             * the angle that the long axis of the ellipse makes

             * with the horizontal axis.  Thus, this equation is

             * calculating the length of the hypotenuse of a triangle

             * along that axis.

             */

            double hypot = Math.sqrt(EB*EB + (EA-EC)*(EA-EC));

            // sqrt omitted, compare to squared limits below.

            double widthsquared = ((EA + EC + hypot)/2.0);

            widthScale = (float)Math.sqrt(widthsquared);

        }

        return (lw / widthScale);

    }

    final void strokeTo(final RendererContext rdrCtx,

                        Shape src,

                        AffineTransform at,

                        float width,

                        NormMode normalize,

                        int caps,

                        int join,

                        float miterlimit,

                        float dashes[],

                        float dashphase,

                        PathConsumer2D pc2d)

    {

        // We use strokerat and outat so that in Stroker and Dasher we can work only

        // with the pre-transformation coordinates. This will repeat a lot of

        // computations done in the path iterator, but the alternative is to

        // work with transformed paths and compute untransformed coordinates

        // as needed. This would be faster but I do not think the complexity

        // of working with both untransformed and transformed coordinates in

        // the same code is worth it.

        // However, if a path's width is constant after a transformation,

        // we can skip all this untransforming.

        // If normalization is off we save some transformations by not

        // transforming the input to pisces. Instead, we apply the

        // transformation after the path processing has been done.

        // We can't do this if normalization is on, because it isn't a good

        // idea to normalize before the transformation is applied.

        AffineTransform strokerat = null;

        AffineTransform outat = null;

        PathIterator pi;

        int dashLen = -1;

        boolean recycleDashes = false;

        if (at != null && !at.isIdentity()) {

            final double a = at.getScaleX();

            final double b = at.getShearX();

            final double c = at.getShearY();

            final double d = at.getScaleY();

            final double det = a * d - c * b;

            if (Math.abs(det) <= (2f * Float.MIN_VALUE)) {

                // this rendering engine takes one dimensional curves and turns

                // them into 2D shapes by giving them width.

                // However, if everything is to be passed through a singular

                // transformation, these 2D shapes will be squashed down to 1D

                // again so, nothing can be drawn.

                // Every path needs an initial moveTo and a pathDone. If these

                // are not there this causes a SIGSEGV in libawt.so (at the time

                // of writing of this comment (September 16, 2010)). Actually,

                // I am not sure if the moveTo is necessary to avoid the SIGSEGV

                // but the pathDone is definitely needed.

                pc2d.moveTo(0f, 0f);

                pc2d.pathDone();

                return;

            }

            // If the transform is a constant multiple of an orthogonal transformation

            // then every length is just multiplied by a constant, so we just

            // need to transform input paths to stroker and tell stroker

            // the scaled width. This condition is satisfied if

            // a*b == -c*d && a*a+c*c == b*b+d*d. In the actual check below, we

            // leave a bit of room for error.

            if (nearZero(a*b + c*d) && nearZero(a*a + c*c - (b*b + d*d))) {

                final float scale = (float) Math.sqrt(a*a + c*c);

                if (dashes != null) {

                    recycleDashes = true;

                    dashLen = dashes.length;

                    final float[] newDashes;

                    if (dashLen <= INITIAL_ARRAY) {

                        newDashes = rdrCtx.dasher.dashes_initial;

                    } else {

                        if (doStats) {

                            RendererContext.stats.stat_array_dasher_dasher

                                .add(dashLen);

                        }

                        newDashes = rdrCtx.getDirtyFloatArray(dashLen);

                    }

                    System.arraycopy(dashes, 0, newDashes, 0, dashLen);

                    dashes = newDashes;

                    for (int i = 0; i < dashLen; i++) {

                        dashes[i] = scale * dashes[i];

                    }

                    dashphase = scale * dashphase;

                }

                width = scale * width;

                pi = getNormalizingPathIterator(rdrCtx, normalize,

                                                src.getPathIterator(at));

                // by now strokerat == null && outat == null. Input paths to

                // stroker (and maybe dasher) will have the full transform at

                // applied to them and nothing will happen to the output paths.

            } else {

                if (normalize != NormMode.OFF) {

                    strokerat = at;

                    pi = getNormalizingPathIterator(rdrCtx, normalize,

                                                    src.getPathIterator(at));

                    // by now strokerat == at && outat == null. Input paths to

                    // stroker (and maybe dasher) will have the full transform at

                    // applied to them, then they will be normalized, and then

                    // the inverse of *only the non translation part of at* will

                    // be applied to the normalized paths. This won't cause problems

                    // in stroker, because, suppose at = T*A, where T is just the

                    // translation part of at, and A is the rest. T*A has already

                    // been applied to Stroker/Dasher's input. Then Ainv will be

                    // applied. Ainv*T*A is not equal to T, but it is a translation,

                    // which means that none of stroker's assumptions about its

                    // input will be violated. After all this, A will be applied

                    // to stroker's output.

                } else {

                    outat = at;

                    pi = src.getPathIterator(null);

                    // outat == at && strokerat == null. This is because if no

                    // normalization is done, we can just apply all our

                    // transformations to stroker's output.

                }

            }

        } else {

            // either at is null or it's the identity. In either case

            // we don't transform the path.

            pi = getNormalizingPathIterator(rdrCtx, normalize,

                                            src.getPathIterator(null));

        }

        if (useSimplifier) {

            // Use simplifier after stroker before Renderer

            // to remove collinear segments (notably due to cap square)

            pc2d = rdrCtx.simplifier.init(pc2d);

        }

        // by now, at least one of outat and strokerat will be null. Unless at is not

        // a constant multiple of an orthogonal transformation, they will both be

        // null. In other cases, outat == at if normalization is off, and if

        // normalization is on, strokerat == at.

        final TransformingPathConsumer2D transformerPC2D = rdrCtx.transformerPC2D;

        pc2d = transformerPC2D.transformConsumer(pc2d, outat);

        pc2d = transformerPC2D.deltaTransformConsumer(pc2d, strokerat);

        pc2d = rdrCtx.stroker.init(pc2d, width, caps, join, miterlimit);

        if (dashes != null) {

            if (!recycleDashes) {

                dashLen = dashes.length;

            }

            pc2d = rdrCtx.dasher.init(pc2d, dashes, dashLen, dashphase,

                                      recycleDashes);

        }

        pc2d = transformerPC2D.inverseDeltaTransformConsumer(pc2d, strokerat);

        pathTo(rdrCtx, pi, pc2d);

        /*

         * Pipeline seems to be:

         *    shape.getPathIterator

         * -> NormalizingPathIterator

         * -> inverseDeltaTransformConsumer

         * -> Dasher

         * -> Stroker

         * -> deltaTransformConsumer OR transformConsumer

         *

         * -> CollinearSimplifier to remove redundant segments

         *

         * -> pc2d = Renderer (bounding box)

         */

    }

    private static boolean nearZero(final double num) {

        return Math.abs(num) < 2.0 * Math.ulp(num);

    }

    PathIterator getNormalizingPathIterator(final RendererContext rdrCtx,

                                            final NormMode mode,

                                            final PathIterator src)

    {

        switch (mode) {

            case ON_WITH_AA:

                // NormalizingPathIterator NearestPixelCenter:

                return rdrCtx.nPCPathIterator.init(src);

            case ON_NO_AA:

                // NearestPixel NormalizingPathIterator:

                return rdrCtx.nPQPathIterator.init(src);

            case OFF:

                // return original path iterator if normalization is disabled:

                return src;

            default:

                throw new InternalError("Unrecognized normalization mode");

        }

    }

    abstract static class NormalizingPathIterator implements PathIterator {

        private PathIterator src;

        // the adjustment applied to the current position.

        private float curx_adjust, cury_adjust;

        // the adjustment applied to the last moveTo position.

        private float movx_adjust, movy_adjust;

        private final float[] tmp;

        NormalizingPathIterator(final float[] tmp) {

            this.tmp = tmp;

        }

        final NormalizingPathIterator init(final PathIterator src) {

            this.src = src;

            return this; // fluent API

        }

        /**

         * Disposes this path iterator:

         * clean up before reusing this instance

         */

        final void dispose() {

            // free source PathIterator:

            this.src = null;

        }

        @Override

        public final int currentSegment(final float[] coords) {

            if (doMonitors) {

                RendererContext.stats.mon_npi_currentSegment.start();

            }

            int lastCoord;

            final int type = src.currentSegment(coords);

            switch(type) {

                case PathIterator.SEG_MOVETO:

                case PathIterator.SEG_LINETO:

                    lastCoord = 0;

                    break;

                case PathIterator.SEG_QUADTO:

                    lastCoord = 2;

                    break;

                case PathIterator.SEG_CUBICTO:

                    lastCoord = 4;

                    break;

                case PathIterator.SEG_CLOSE:

                    // we don't want to deal with this case later. We just exit now

                    curx_adjust = movx_adjust;

                    cury_adjust = movy_adjust;

                    if (doMonitors) {

                        RendererContext.stats.mon_npi_currentSegment.stop();

                    }

                    return type;

                default:

                    throw new InternalError("Unrecognized curve type");

            }

            // TODO: handle NaN, Inf and overflow

            // normalize endpoint

            float coord, x_adjust, y_adjust;

            coord = coords[lastCoord];

            x_adjust = normCoord(coord); // new coord

            coords[lastCoord] = x_adjust;

            x_adjust -= coord;