/*

 * Copyright (c) 2007, 2018, 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.geom.AffineTransform;

import java.awt.geom.Path2D;

import java.util.Arrays;

import sun.java2d.marlin.DHelpers.IndexStack;

import sun.java2d.marlin.DHelpers.PolyStack;

final class DTransformingPathConsumer2D {

    // smaller uncertainty in double variant

    static final double CLIP_RECT_PADDING = 0.25d;

    private final DRendererContext rdrCtx;

    // recycled ClosedPathDetector instance from detectClosedPath()

    private final ClosedPathDetector   cpDetector;

    // recycled PathClipFilter instance from pathClipper()

    private final PathClipFilter       pathClipper;

    // recycled DPathConsumer2D instance from wrapPath2D()

    private final Path2DWrapper        wp_Path2DWrapper        = new Path2DWrapper();

    // recycled DPathConsumer2D instances from deltaTransformConsumer()

    private final DeltaScaleFilter     dt_DeltaScaleFilter     = new DeltaScaleFilter();

    private final DeltaTransformFilter dt_DeltaTransformFilter = new DeltaTransformFilter();

    // recycled DPathConsumer2D instances from inverseDeltaTransformConsumer()

    private final DeltaScaleFilter     iv_DeltaScaleFilter     = new DeltaScaleFilter();

    private final DeltaTransformFilter iv_DeltaTransformFilter = new DeltaTransformFilter();

    // recycled PathTracer instances from tracer...() methods

    private final PathTracer tracerInput      = new PathTracer("[Input]");

    private final PathTracer tracerCPDetector = new PathTracer("ClosedPathDetector");

    private final PathTracer tracerFiller     = new PathTracer("Filler");

    private final PathTracer tracerStroker    = new PathTracer("Stroker");

    private final PathTracer tracerDasher     = new PathTracer("Dasher");

    DTransformingPathConsumer2D(final DRendererContext rdrCtx) {

        // used by RendererContext

        this.rdrCtx = rdrCtx;

        this.cpDetector = new ClosedPathDetector(rdrCtx);

        this.pathClipper = new PathClipFilter(rdrCtx);

    }

    DPathConsumer2D wrapPath2D(Path2D.Double p2d) {

        return wp_Path2DWrapper.init(p2d);

    }

    DPathConsumer2D traceInput(DPathConsumer2D out) {

        return tracerInput.init(out);

    }

    DPathConsumer2D traceClosedPathDetector(DPathConsumer2D out) {

        return tracerCPDetector.init(out);

    }

    DPathConsumer2D traceFiller(DPathConsumer2D out) {

        return tracerFiller.init(out);

    }

    DPathConsumer2D traceStroker(DPathConsumer2D out) {

        return tracerStroker.init(out);

    }

    DPathConsumer2D traceDasher(DPathConsumer2D out) {

        return tracerDasher.init(out);

    }

    DPathConsumer2D detectClosedPath(DPathConsumer2D out) {

        return cpDetector.init(out);

    }

    DPathConsumer2D pathClipper(DPathConsumer2D out) {

        return pathClipper.init(out);

    }

    DPathConsumer2D deltaTransformConsumer(DPathConsumer2D out,

                                          AffineTransform at)

    {

        if (at == null) {

            return out;

        }

        final double mxx = at.getScaleX();

        final double mxy = at.getShearX();

        final double myx = at.getShearY();

        final double myy = at.getScaleY();

        if (mxy == 0.0d && myx == 0.0d) {

            if (mxx == 1.0d && myy == 1.0d) {

                return out;

            } else {

                // Scale only

                if (rdrCtx.doClip) {

                    // adjust clip rectangle (ymin, ymax, xmin, xmax):

                    rdrCtx.clipInvScale = adjustClipScale(rdrCtx.clipRect,

                        mxx, myy);

                }

                return dt_DeltaScaleFilter.init(out, mxx, myy);

            }

        } else {

            if (rdrCtx.doClip) {

                // adjust clip rectangle (ymin, ymax, xmin, xmax):

                rdrCtx.clipInvScale = adjustClipInverseDelta(rdrCtx.clipRect,

                    mxx, mxy, myx, myy);

            }

            return dt_DeltaTransformFilter.init(out, mxx, mxy, myx, myy);

        }

    }

    private static double adjustClipScale(final double[] clipRect,

                                          final double mxx, final double myy)

    {

        // Adjust the clipping rectangle (iv_DeltaScaleFilter):

        final double scaleY = 1.0d / myy;

        clipRect[0] *= scaleY;

        clipRect[1] *= scaleY;

        if (clipRect[1] < clipRect[0]) {

            double tmp = clipRect[0];

            clipRect[0] = clipRect[1];

            clipRect[1] = tmp;

        }

        final double scaleX = 1.0d / mxx;

        clipRect[2] *= scaleX;

        clipRect[3] *= scaleX;

        if (clipRect[3] < clipRect[2]) {

            double tmp = clipRect[2];

            clipRect[2] = clipRect[3];

            clipRect[3] = tmp;

        }

        if (MarlinConst.DO_LOG_CLIP) {

                MarlinUtils.logInfo("clipRect (ClipScale): "

                                    + Arrays.toString(clipRect));

        }

        return 0.5d * (Math.abs(scaleX) + Math.abs(scaleY));

    }

    private static double adjustClipInverseDelta(final double[] clipRect,

                                                 final double mxx, final double mxy,

                                                 final double myx, final double myy)

    {

        // Adjust the clipping rectangle (iv_DeltaTransformFilter):

        final double det = mxx * myy - mxy * myx;

        final double imxx =  myy / det;

        final double imxy = -mxy / det;

        final double imyx = -myx / det;

        final double imyy =  mxx / det;

        double xmin, xmax, ymin, ymax;

        double x, y;

        // xmin, ymin:

        x = clipRect[2] * imxx + clipRect[0] * imxy;

        y = clipRect[2] * imyx + clipRect[0] * imyy;

        xmin = xmax = x;

        ymin = ymax = y;

        // xmax, ymin:

        x = clipRect[3] * imxx + clipRect[0] * imxy;

        y = clipRect[3] * imyx + clipRect[0] * imyy;

        if (x < xmin) { xmin = x; } else if (x > xmax) { xmax = x; }

        if (y < ymin) { ymin = y; } else if (y > ymax) { ymax = y; }

        // xmin, ymax:

        x = clipRect[2] * imxx + clipRect[1] * imxy;

        y = clipRect[2] * imyx + clipRect[1] * imyy;

        if (x < xmin) { xmin = x; } else if (x > xmax) { xmax = x; }

        if (y < ymin) { ymin = y; } else if (y > ymax) { ymax = y; }

        // xmax, ymax:

        x = clipRect[3] * imxx + clipRect[1] * imxy;

        y = clipRect[3] * imyx + clipRect[1] * imyy;

        if (x < xmin) { xmin = x; } else if (x > xmax) { xmax = x; }

        if (y < ymin) { ymin = y; } else if (y > ymax) { ymax = y; }

        clipRect[0] = ymin;

        clipRect[1] = ymax;

        clipRect[2] = xmin;

        clipRect[3] = xmax;

        if (MarlinConst.DO_LOG_CLIP) {

                MarlinUtils.logInfo("clipRect (ClipInverseDelta): "

                                    + Arrays.toString(clipRect));

        }

        final double scaleX = Math.sqrt(imxx * imxx + imxy * imxy);

        final double scaleY = Math.sqrt(imyx * imyx + imyy * imyy);

        return 0.5d * (scaleX + scaleY);

    }

    DPathConsumer2D inverseDeltaTransformConsumer(DPathConsumer2D out,

                                                 AffineTransform at)

    {

        if (at == null) {

            return out;

        }

        double mxx = at.getScaleX();

        double mxy = at.getShearX();

        double myx = at.getShearY();

        double myy = at.getScaleY();

        if (mxy == 0.0d && myx == 0.0d) {

            if (mxx == 1.0d && myy == 1.0d) {

                return out;

            } else {

                return iv_DeltaScaleFilter.init(out, 1.0d / mxx, 1.0d / myy);

            }

        } else {

            final double det = mxx * myy - mxy * myx;

            return iv_DeltaTransformFilter.init(out,

                                                myy / det,

                                               -mxy / det,

                                               -myx / det,

                                                mxx / det);

        }

    }

    static final class DeltaScaleFilter implements DPathConsumer2D {

        private DPathConsumer2D out;

        private double sx, sy;

        DeltaScaleFilter() {}

        DeltaScaleFilter init(DPathConsumer2D out,

                              double mxx, double myy)

        {

            this.out = out;

            sx = mxx;

            sy = myy;

            return this; // fluent API

        }

        @Override

        public void moveTo(double x0, double y0) {

            out.moveTo(x0 * sx, y0 * sy);

        }

        @Override

        public void lineTo(double x1, double y1) {

            out.lineTo(x1 * sx, y1 * sy);

        }

        @Override

        public void quadTo(double x1, double y1,

                           double x2, double y2)

        {

            out.quadTo(x1 * sx, y1 * sy,

                       x2 * sx, y2 * sy);

        }

        @Override

        public void curveTo(double x1, double y1,

                            double x2, double y2,

                            double x3, double y3)

        {

            out.curveTo(x1 * sx, y1 * sy,

                        x2 * sx, y2 * sy,

                        x3 * sx, y3 * sy);

        }

        @Override

        public void closePath() {

            out.closePath();

        }

        @Override

        public void pathDone() {

            out.pathDone();

        }

        @Override

        public long getNativeConsumer() {

            return 0;

        }

    }

    static final class DeltaTransformFilter implements DPathConsumer2D {

        private DPathConsumer2D out;

        private double mxx, mxy, myx, myy;

        DeltaTransformFilter() {}

        DeltaTransformFilter init(DPathConsumer2D out,

                                  double mxx, double mxy,

                                  double myx, double myy)

        {

            this.out = out;

            this.mxx = mxx;

            this.mxy = mxy;

            this.myx = myx;

            this.myy = myy;

            return this; // fluent API

        }

        @Override

        public void moveTo(double x0, double y0) {

            out.moveTo(x0 * mxx + y0 * mxy,

                       x0 * myx + y0 * myy);

        }

        @Override

        public void lineTo(double x1, double y1) {

            out.lineTo(x1 * mxx + y1 * mxy,

                       x1 * myx + y1 * myy);

        }

        @Override

        public void quadTo(double x1, double y1,

                           double x2, double y2)

        {

            out.quadTo(x1 * mxx + y1 * mxy,

                       x1 * myx + y1 * myy,

                       x2 * mxx + y2 * mxy,

                       x2 * myx + y2 * myy);

        }

        @Override

        public void curveTo(double x1, double y1,

                            double x2, double y2,

                            double x3, double y3)

        {

            out.curveTo(x1 * mxx + y1 * mxy,

                        x1 * myx + y1 * myy,

                        x2 * mxx + y2 * mxy,

                        x2 * myx + y2 * myy,

                        x3 * mxx + y3 * mxy,

                        x3 * myx + y3 * myy);

        }

        @Override

        public void closePath() {

            out.closePath();

        }

        @Override

        public void pathDone() {

            out.pathDone();

        }

        @Override

        public long getNativeConsumer() {

            return 0;

        }

    }

    static final class Path2DWrapper implements DPathConsumer2D {

        private Path2D.Double p2d;

        Path2DWrapper() {}

        Path2DWrapper init(Path2D.Double p2d) {

            this.p2d = p2d;

            return this;

        }

        @Override

        public void moveTo(double x0, double y0) {

            p2d.moveTo(x0, y0);

        }

        @Override

        public void lineTo(double x1, double y1) {

            p2d.lineTo(x1, y1);

        }

        @Override

        public void closePath() {

            p2d.closePath();

        }

        @Override

        public void pathDone() {}

        @Override

        public void curveTo(double x1, double y1,

                            double x2, double y2,

                            double x3, double y3)

        {

            p2d.curveTo(x1, y1, x2, y2, x3, y3);

        }

        @Override

        public void quadTo(double x1, double y1, double x2, double y2) {

            p2d.quadTo(x1, y1, x2, y2);

        }

        @Override

        public long getNativeConsumer() {

            throw new InternalError("Not using a native peer");

        }

    }

    static final class ClosedPathDetector implements DPathConsumer2D {

        private final DRendererContext rdrCtx;

        private final PolyStack stack;

        private DPathConsumer2D out;

        ClosedPathDetector(final DRendererContext rdrCtx) {

            this.rdrCtx = rdrCtx;

            this.stack = (rdrCtx.stats != null) ?

                new PolyStack(rdrCtx,

                        rdrCtx.stats.stat_cpd_polystack_types,

                        rdrCtx.stats.stat_cpd_polystack_curves,

                        rdrCtx.stats.hist_cpd_polystack_curves,

                        rdrCtx.stats.stat_array_cpd_polystack_curves,

                        rdrCtx.stats.stat_array_cpd_polystack_types)

                : new PolyStack(rdrCtx);

        }

        ClosedPathDetector init(DPathConsumer2D out) {

            this.out = out;

            return this; // fluent API

        }

        /**

         * Disposes this instance:

         * clean up before reusing this instance

         */

        void dispose() {

            stack.dispose();

        }

        @Override

        public void pathDone() {

            // previous path is not closed:

            finish(false);

            out.pathDone();

            // TODO: fix possible leak if exception happened

            // Dispose this instance:

            dispose();

        }

        @Override

        public void closePath() {

            // path is closed

            finish(true);

            out.closePath();

        }

        @Override

        public void moveTo(double x0, double y0) {

            // previous path is not closed:

            finish(false);

            out.moveTo(x0, y0);

        }

        private void finish(final boolean closed) {

            rdrCtx.closedPath = closed;

            stack.pullAll(out);

        }

        @Override

        public void lineTo(double x1, double y1) {

            stack.pushLine(x1, y1);

        }

        @Override

        public void curveTo(double x3, double y3,

                            double x2, double y2,

                            double x1, double y1)

        {

            stack.pushCubic(x1, y1, x2, y2, x3, y3);

        }

        @Override

        public void quadTo(double x2, double y2, double x1, double y1) {

            stack.pushQuad(x1, y1, x2, y2);

        }

        @Override

        public long getNativeConsumer() {

            throw new InternalError("Not using a native peer");