/*

 * 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.util.Arrays;

import sun.awt.geom.PathConsumer2D;

import sun.java2d.marlin.TransformingPathConsumer2D.CurveBasicMonotonizer;

import sun.java2d.marlin.TransformingPathConsumer2D.CurveClipSplitter;

/**

 * The <code>Dasher</code> class takes a series of linear commands

 * (<code>moveTo</code>, <code>lineTo</code>, <code>close</code> and

 * <code>end</code>) and breaks them into smaller segments according to a

 * dash pattern array and a starting dash phase.

 *

 * <p> Issues: in J2Se, a zero length dash segment as drawn as a very

 * short dash, whereas Pisces does not draw anything.  The PostScript

 * semantics are unclear.

 *

 */

final class Dasher implements PathConsumer2D, MarlinConst {

    /* huge circle with radius ~ 2E9 only needs 12 subdivision levels */

    static final int REC_LIMIT = 16;

    static final float CURVE_LEN_ERR = MarlinProperties.getCurveLengthError(); // 0.01

    static final float MIN_T_INC = 1.0f / (1 << REC_LIMIT);

    // More than 24 bits of mantissa means we can no longer accurately

    // measure the number of times cycled through the dash array so we

    // punt and override the phase to just be 0 past that point.

    static final float MAX_CYCLES = 16000000.0f;

    private PathConsumer2D out;

    private float[] dash;

    private int dashLen;

    private float startPhase;

    private boolean startDashOn;

    private int startIdx;

    private boolean starting;

    private boolean needsMoveTo;

    private int idx;

    private boolean dashOn;

    private float phase;

    // The starting point of the path

    private float sx0, sy0;

    // the current point

    private float cx0, cy0;

    // temporary storage for the current curve

    private final float[] curCurvepts;

    // per-thread renderer context

    final RendererContext rdrCtx;

    // flag to recycle dash array copy

    boolean recycleDashes;

    // We don't emit the first dash right away. If we did, caps would be

    // drawn on it, but we need joins to be drawn if there's a closePath()

    // So, we store the path elements that make up the first dash in the

    // buffer below.

    private float[] firstSegmentsBuffer; // dynamic array

    private int firstSegidx;

    // dashes ref (dirty)

    final FloatArrayCache.Reference dashes_ref;

    // firstSegmentsBuffer ref (dirty)

    final FloatArrayCache.Reference firstSegmentsBuffer_ref;

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

    private float[] clipRect;

    // the outcode of the current point

    private int cOutCode = 0;

    private boolean subdivide = DO_CLIP_SUBDIVIDER;

    private final LengthIterator li = new LengthIterator();

    private final CurveClipSplitter curveSplitter;

    private float cycleLen;

    private boolean outside;

    private float totalSkipLen;

    /**

     * Constructs a <code>Dasher</code>.

     * @param rdrCtx per-thread renderer context

     */

    Dasher(final RendererContext rdrCtx) {

        this.rdrCtx = rdrCtx;

        dashes_ref = rdrCtx.newDirtyFloatArrayRef(INITIAL_ARRAY); // 1K

        firstSegmentsBuffer_ref = rdrCtx.newDirtyFloatArrayRef(INITIAL_ARRAY); // 1K

        firstSegmentsBuffer     = firstSegmentsBuffer_ref.initial;

        // we need curCurvepts to be able to contain 2 curves because when

        // dashing curves, we need to subdivide it

        curCurvepts = new float[8 * 2];

        this.curveSplitter = rdrCtx.curveClipSplitter;

    }

    /**

     * Initialize the <code>Dasher</code>.

     *

     * @param out an output <code>PathConsumer2D</code>.

     * @param dash an array of <code>float</code>s containing the dash pattern

     * @param dashLen length of the given dash array

     * @param phase a <code>float</code> containing the dash phase

     * @param recycleDashes true to indicate to recycle the given dash array

     * @return this instance

     */

    {

        this.out = out;

        // Normalize so 0 <= phase < dash[0]

        int sidx = 0;

        dashOn = true;

        float sum = 0.0f;

        }

        this.cycleLen = sum;

        float cycles = phase / sum;

        if (phase < 0.0f) {

            if (-cycles >= MAX_CYCLES) {

                phase = 0.0f;

            } else {

                int fullcycles = FloatMath.floor_int(-cycles);

                    dashOn = !dashOn;

                }

                phase += fullcycles * sum;

                while (phase < 0.0f) {

                    if (--sidx < 0) {

                    }

                    phase += dash[sidx];

                    dashOn = !dashOn;

                }

            }

        } else if (phase > 0.0f) {

            if (cycles >= MAX_CYCLES) {

                phase = 0.0f;

            } else {

                int fullcycles = FloatMath.floor_int(cycles);

                    dashOn = !dashOn;

                }

                phase -= fullcycles * sum;

                float d;

                while (phase >= (d = dash[sidx])) {

                    phase -= d;

                    dashOn = !dashOn;

                }

            }

        }

        this.dash = dash;

        this.dashLen = dashLen;

        this.phase = phase;

        this.startPhase = phase;

        this.startDashOn = dashOn;

        this.startIdx = sidx;

        this.starting = true;

        this.needsMoveTo = false;

        this.firstSegidx = 0;

        this.recycleDashes = recycleDashes;

        if (rdrCtx.doClip) {

            this.clipRect = rdrCtx.clipRect;

        } else {

            this.clipRect = null;

            this.cOutCode = 0;

        }

        return this; // fluent API

    }

    /**

     * Disposes this dasher:

     * clean up before reusing this instance

     */

    void dispose() {

        if (DO_CLEAN_DIRTY) {

            // Force zero-fill dirty arrays:

            Arrays.fill(curCurvepts, 0.0f);

        }

        // Return arrays:

        if (recycleDashes) {

            dash = dashes_ref.putArray(dash);

        }

        firstSegmentsBuffer = firstSegmentsBuffer_ref.putArray(firstSegmentsBuffer);

    }

    float[] copyDashArray(final float[] dashes) {

        final int len = dashes.length;

        final float[] newDashes;

        if (len <= MarlinConst.INITIAL_ARRAY) {

            newDashes = dashes_ref.initial;

        } else {

            if (DO_STATS) {

                rdrCtx.stats.stat_array_dasher_dasher.add(len);

            }

            newDashes = dashes_ref.getArray(len);

        }

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

        return newDashes;

    }

    @Override

    public void moveTo(final float x0, final float y0) {

        if (firstSegidx != 0) {

            out.moveTo(sx0, sy0);

            emitFirstSegments();

        }

        this.needsMoveTo = true;

        this.idx = startIdx;

        this.dashOn = this.startDashOn;

        this.phase = this.startPhase;

        this.cx0 = x0;

        this.cy0 = y0;

        // update starting point:

        this.sx0 = x0;

        this.sy0 = y0;

        this.starting = true;

        if (clipRect != null) {

            final int outcode = Helpers.outcode(x0, y0, clipRect);

            this.cOutCode = outcode;

            this.outside = false;

            this.totalSkipLen = 0.0f;

        }

    }

    private void emitSeg(float[] buf, int off, int type) {

        switch (type) {

        case 8:

            out.curveTo(buf[off    ], buf[off + 1],

                        buf[off + 2], buf[off + 3],

                        buf[off + 4], buf[off + 5]);

            return;

        case 6:

            out.quadTo(buf[off    ], buf[off + 1],

                       buf[off + 2], buf[off + 3]);

            return;

        case 4:

            out.lineTo(buf[off], buf[off + 1]);

            return;

        default:

        }

    }

    private void emitFirstSegments() {

        final float[] fSegBuf = firstSegmentsBuffer;

        for (int i = 0, len = firstSegidx; i < len; ) {

            int type = (int)fSegBuf[i];

            emitSeg(fSegBuf, i + 1, type);

            i += (type - 1);

        }

        firstSegidx = 0;

    }

    // precondition: pts must be in relative coordinates (relative to x0,y0)

    private void goTo(final float[] pts, final int off, final int type,

                      final boolean on)

    {

        final int index = off + type;

        final float x = pts[index - 4];

        final float y = pts[index - 3];

        if (on) {

            if (starting) {

                goTo_starting(pts, off, type);

            } else {

                if (needsMoveTo) {

                    needsMoveTo = false;

                    out.moveTo(cx0, cy0);

                }

                emitSeg(pts, off, type);

            }

        } else {

            if (starting) {

                // low probability test (hotspot)

                starting = false;

            }

            needsMoveTo = true;

        }

        this.cx0 = x;

        this.cy0 = y;

    }

    private void goTo_starting(final float[] pts, final int off, final int type) {

        int len = type - 1; // - 2 + 1

        int segIdx = firstSegidx;

        float[] buf = firstSegmentsBuffer;

        if (segIdx + len  > buf.length) {

            if (DO_STATS) {

                rdrCtx.stats.stat_array_dasher_firstSegmentsBuffer

                    .add(segIdx + len);

            }

            firstSegmentsBuffer = buf

                = firstSegmentsBuffer_ref.widenArray(buf, segIdx,

                                                     segIdx + len);

        }

        buf[segIdx++] = type;

        len--;

        // small arraycopy (2, 4 or 6) but with offset:

        System.arraycopy(pts, off, buf, segIdx, len);

        firstSegidx = segIdx + len;

    }

    @Override

    public void lineTo(final float x1, final float y1) {

        final int outcode0 = this.cOutCode;

        if (clipRect != null) {

            final int outcode1 = Helpers.outcode(x1, y1, clipRect);

            // Should clip

            final int orCode = (outcode0 | outcode1);

            if (orCode != 0) {

                final int sideCode = outcode0 & outcode1;

                // basic rejection criteria:

                if (sideCode == 0) {

                    // ovelap clip:

                    if (subdivide) {

                        // avoid reentrance

                        subdivide = false;

                        // subdivide curve => callback with subdivided parts:

                        boolean ret = curveSplitter.splitLine(cx0, cy0, x1, y1,

                                                              orCode, this);

                        // reentrance is done:

                        subdivide = true;

                        if (ret) {

                            return;

                        }

                    }

                    // already subdivided so render it

                } else {

                    this.cOutCode = outcode1;

                    skipLineTo(x1, y1);

                    return;

                }

            }

            this.cOutCode = outcode1;

            if (this.outside) {

                this.outside = false;

                // Adjust current index, phase & dash:

                skipLen();

            }

        }

        _lineTo(x1, y1);

    }

    private void _lineTo(final float x1, final float y1) {

        final float dx = x1 - cx0;

        final float dy = y1 - cy0;

        float len = dx * dx + dy * dy;

        if (len == 0.0f) {

            return;

        }

        len = (float) Math.sqrt(len);

        // The scaling factors needed to get the dx and dy of the

        // transformed dash segments.

        final float cx = dx / len;

        final float cy = dy / len;

        final float[] _curCurvepts = curCurvepts;

        final float[] _dash = dash;

        final int _dashLen = this.dashLen;

        int _idx = idx;

        boolean _dashOn = dashOn;

        float _phase = phase;

        float leftInThisDashSegment, d;

        while (true) {

            d = _dash[_idx];

            leftInThisDashSegment = d - _phase;

            if (len <= leftInThisDashSegment) {

                _curCurvepts[0] = x1;

                _curCurvepts[1] = y1;

                goTo(_curCurvepts, 0, 4, _dashOn);

                // Advance phase within current dash segment

                _phase += len;

                // TODO: compare float values using epsilon:

                if (len == leftInThisDashSegment) {

                    _phase = 0.0f;

                    _idx = (_idx + 1) % _dashLen;

                    _dashOn = !_dashOn;

                }

                break;

            }

            if (_phase == 0.0f) {

                _curCurvepts[0] = cx0 + d * cx;

                _curCurvepts[1] = cy0 + d * cy;

            } else {

                _curCurvepts[0] = cx0 + leftInThisDashSegment * cx;

                _curCurvepts[1] = cy0 + leftInThisDashSegment * cy;

            }

            goTo(_curCurvepts, 0, 4, _dashOn);

            len -= leftInThisDashSegment;

            // Advance to next dash segment

            _idx = (_idx + 1) % _dashLen;

            _dashOn = !_dashOn;

            _phase = 0.0f;

        }

        // Save local state:

        idx = _idx;

        dashOn = _dashOn;

        phase = _phase;

    }

    private void skipLineTo(final float x1, final float y1) {

        final float dx = x1 - cx0;

        final float dy = y1 - cy0;

        float len = dx * dx + dy * dy;

        if (len != 0.0f) {

            len = (float)Math.sqrt(len);

        }

        // Accumulate skipped length:

        this.outside = true;

        this.totalSkipLen += len;

        // Fix initial move:

        this.needsMoveTo = true;

        this.starting = false;

        this.cx0 = x1;

        this.cy0 = y1;

    }

    public void skipLen() {

        float len = this.totalSkipLen;

        this.totalSkipLen = 0.0f;

        final float[] _dash = dash;

        final int _dashLen = this.dashLen;

        int _idx = idx;

        boolean _dashOn = dashOn;

        float _phase = phase;

        // -2 to ensure having 2 iterations of the post-loop

        // to compensate the remaining phase

        final long fullcycles = (long)Math.floor(len / cycleLen) - 2L;