/*

 * Copyright (c) 2007, 2010, 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.pisces;

import sun.awt.geom.PathConsumer2D;

    private class ScanlineIterator {

        private int[] crossings;

        // crossing bounds. The bounds are not necessarily tight (the scan line

        // at minY, for example, might have no crossings). The x bounds will

        // be accumulated as crossings are computed.

        private int nextY;

        // indices into the segment pointer lists. They indicate the "active"

        // sublist in the segment lists (the portion of the list that contains

        // all the segments that cross the next scan line).

        private static final int INIT_CROSSINGS_SIZE = 10;

        private ScanlineIterator() {

            crossings = new int[INIT_CROSSINGS_SIZE];

            // We don't care if we clip some of the line off with ceil, since

            // no scan line crossings will be eliminated (in fact, the ceil is

            // the y of the first scan line crossing).

        }

        private int next() {

                }

            }

            }

            }

            }

        }

        private boolean hasNext() {

            return nextY < maxY;

        }

        private int curY() {

            return nextY - 1;

        }

    }

//////////////////////////////////////////////////////////////////////////////

//  EDGE LIST

//////////////////////////////////////////////////////////////////////////////

// TODO(maybe): very tempting to use fixed point here. A lot of opportunities

// for shifts and just removing certain operations altogether.

    // common to all types of input path segments.

    // be homogenous, so every field is a float. However floats can represent

    // exactly up to 26 bit ints, so we're ok.

    private float edgeMinY = Float.POSITIVE_INFINITY;

    private float edgeMaxY = Float.NEGATIVE_INFINITY;

    private float edgeMinX = Float.POSITIVE_INFINITY;

    private float edgeMaxX = Float.NEGATIVE_INFINITY;

    private float[] edges = null;

    private int numEdges;

    private static final float DEC_BND = 20f;

    private static final float INC_BND = 8f;

    // Flattens using adaptive forward differencing. This only carries out

    // one iteration of the AFD loop. All it does is update AFD variables (i.e.

    // X0, Y0, D*[X|Y], COUNT; not variables used for computing scanline crossings).

            count <<= 1;

        }

        }

    }

        final int countlg = 3;

        // the dx and dy refer to forward differencing variables, not the last

        // coefficients of the "points" polynomial

        dddx = 2f * c.dax / (1 << (3 * countlg));

        dddy = 2f * c.day / (1 << (3 * countlg));

        ddx = dddx + c.dbx / (1 << (2 * countlg));

        ddy = dddy + c.dby / (1 << (2 * countlg));

        dx = c.ax / (1 << (3 * countlg)) + c.bx / (1 << (2 * countlg)) + c.cx / (1 << countlg);

        dy = c.ay / (1 << (3 * countlg)) + c.by / (1 << (2 * countlg)) + c.cy / (1 << countlg);

        }

    }

            return;

        }

    }

// END EDGE LIST

//////////////////////////////////////////////////////////////////////////////

    public static final int WIND_EVEN_ODD = 0;

    public static final int WIND_NON_ZERO = 1;

    // Antialiasing

    final private int SUBPIXEL_LG_POSITIONS_X;

    final private int SUBPIXEL_LG_POSITIONS_Y;

    final private int SUBPIXEL_POSITIONS_X;

    final private int SUBPIXEL_POSITIONS_Y;

    final private int SUBPIXEL_MASK_X;

    final private int SUBPIXEL_MASK_Y;

    final int MAX_AA_ALPHA;

    // Cache to store RLE-encoded coverage mask of the current primitive

    PiscesCache cache;

    // Bounds of the drawing region, at subpixel precision.

    private final int boundsMinX, boundsMinY, boundsMaxX, boundsMaxY;

    // Current winding rule

    private final int windingRule;

    // Current drawing position, i.e., final point of last segment

    private float x0, y0;

    // Position of most recent 'moveTo' command

    private float pix_sx0, pix_sy0;

    public Renderer(int subpixelLgPositionsX, int subpixelLgPositionsY,

                    int pix_boundsX, int pix_boundsY,

                    int pix_boundsWidth, int pix_boundsHeight,

                    int windingRule)

    {

        this.SUBPIXEL_LG_POSITIONS_X = subpixelLgPositionsX;

        this.SUBPIXEL_LG_POSITIONS_Y = subpixelLgPositionsY;

        this.SUBPIXEL_MASK_X = (1 << (SUBPIXEL_LG_POSITIONS_X)) - 1;

        this.SUBPIXEL_MASK_Y = (1 << (SUBPIXEL_LG_POSITIONS_Y)) - 1;

        this.SUBPIXEL_POSITIONS_X = 1 << (SUBPIXEL_LG_POSITIONS_X);

        this.SUBPIXEL_POSITIONS_Y = 1 << (SUBPIXEL_LG_POSITIONS_Y);

        this.MAX_AA_ALPHA = (SUBPIXEL_POSITIONS_X * SUBPIXEL_POSITIONS_Y);

        this.windingRule = windingRule;

        this.boundsMinX = pix_boundsX * SUBPIXEL_POSITIONS_X;

        this.boundsMinY = pix_boundsY * SUBPIXEL_POSITIONS_Y;

        this.boundsMaxX = (pix_boundsX + pix_boundsWidth) * SUBPIXEL_POSITIONS_X;

        this.boundsMaxY = (pix_boundsY + pix_boundsHeight) * SUBPIXEL_POSITIONS_Y;

    }

    private float tosubpixx(float pix_x) {

        return pix_x * SUBPIXEL_POSITIONS_X;

    }

    private float tosubpixy(float pix_y) {

        return pix_y * SUBPIXEL_POSITIONS_Y;

    }

    public void moveTo(float pix_x0, float pix_y0) {

        closePath();

        this.pix_sx0 = pix_x0;

        this.pix_sy0 = pix_y0;

        this.y0 = tosubpixy(pix_y0);

        this.x0 = tosubpixx(pix_x0);

    }

    public void lineTo(float pix_x1, float pix_y1) {

    }

    Curve c = new Curve();

    @Override public void curveTo(float x1, float y1,

                                  float x2, float y2,

                                  float x3, float y3)

    {

    }

    @Override public void quadTo(float x1, float y1, float x2, float y2) {

    }

    public void closePath() {

        // lineTo expects its input in pixel coordinates.

        lineTo(pix_sx0, pix_sy0);

    }

    public void pathDone() {

        closePath();

    }

    @Override

    public long getNativeConsumer() {

        throw new InternalError("Renderer does not use a native consumer.");

    }

    private void _endRendering(final int pix_bboxx0, final int pix_bboxy0,

                               final int pix_bboxx1, final int pix_bboxy1)

    {

        // Mask to determine the relevant bit of the crossing sum

        // 0x1 if EVEN_ODD, all bits if NON_ZERO

        int mask = (windingRule == WIND_EVEN_ODD) ? 0x1 : ~0x0;

        int bboxx0 = pix_bboxx0 << SUBPIXEL_LG_POSITIONS_X;

        int bboxx1 = pix_bboxx1 << SUBPIXEL_LG_POSITIONS_X;

        // Now we iterate through the scanlines. We must tell emitRow the coord

        // of the first non-transparent pixel, so we must keep accumulators for

        // the first and last pixels of the section of the current pixel row

        // that we will emit.

        // We also need to accumulate pix_bbox*, but the iterator does it

        // for us. We will just get the values from it once this loop is done

        int pix_maxX = Integer.MIN_VALUE;

        int pix_minX = Integer.MAX_VALUE;

        int y = boundsMinY; // needs to be declared here so we emit the last row properly.

        ScanlineIterator it = this.new ScanlineIterator();

        for ( ; it.hasNext(); ) {

            int numCrossings = it.next();

            int[] crossings = it.crossings;

            y = it.curY();

            if (numCrossings > 0) {

                int lowx = crossings[0] >> 1;

                int highx = crossings[numCrossings - 1] >> 1;

                int x0 = Math.max(lowx, bboxx0);

                int x1 = Math.min(highx, bboxx1);

                pix_minX = Math.min(pix_minX, x0 >> SUBPIXEL_LG_POSITIONS_X);

                pix_maxX = Math.max(pix_maxX, x1 >> SUBPIXEL_LG_POSITIONS_X);

            }

            int sum = 0;

            int prev = bboxx0;

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

                int curxo = crossings[i];

                int curx = curxo >> 1;

                if ((sum & mask) != 0) {

                    int x0 = Math.max(prev, bboxx0);

                    int x1 = Math.min(curx, bboxx1);

                    if (x0 < x1) {

                        x0 -= bboxx0; // turn x0, x1 from coords to indeces

                        x1 -= bboxx0; // in the alpha array.

                        int pix_x = x0 >> SUBPIXEL_LG_POSITIONS_X;

                        int pix_xmaxm1 = (x1 - 1) >> SUBPIXEL_LG_POSITIONS_X;