/*

 * Copyright (c) 1997, 2014, 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 java.awt;

import java.awt.image.Raster;

import sun.awt.image.IntegerComponentRaster;

import java.awt.image.ColorModel;

import java.awt.image.DirectColorModel;

import java.awt.geom.Point2D;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.lang.ref.WeakReference;

class GradientPaintContext implements PaintContext {

    static ColorModel xrgbmodel =

        new DirectColorModel(24, 0x00ff0000, 0x0000ff00, 0x000000ff);

    static ColorModel xbgrmodel =

        new DirectColorModel(24, 0x000000ff, 0x0000ff00, 0x00ff0000);

    static ColorModel cachedModel;

    static WeakReference<Raster> cached;

    static synchronized Raster getCachedRaster(ColorModel cm, int w, int h) {

        if (cm == cachedModel) {

            if (cached != null) {

                Raster ras = cached.get();

                if (ras != null &&

                    ras.getWidth() >= w &&

                    ras.getHeight() >= h)

                {

                    cached = null;

                    return ras;

                }

            }

        }

        return cm.createCompatibleWritableRaster(w, h);

    }

    static synchronized void putCachedRaster(ColorModel cm, Raster ras) {

        if (cached != null) {

            Raster cras = cached.get();

            if (cras != null) {

                int cw = cras.getWidth();

                int ch = cras.getHeight();

                int iw = ras.getWidth();

                int ih = ras.getHeight();

                if (cw >= iw && ch >= ih) {

                    return;

                }

                if (cw * ch >= iw * ih) {

                    return;

                }

            }

        }

        cachedModel = cm;

        cached = new WeakReference<>(ras);

    }

    double x1;

    double y1;

    double dx;

    double dy;

    boolean cyclic;

    int interp[];

    Raster saved;

    ColorModel model;

    public GradientPaintContext(ColorModel cm,

                                Point2D p1, Point2D p2, AffineTransform xform,

                                Color c1, Color c2, boolean cyclic) {

        // First calculate the distance moved in user space when

        // we move a single unit along the X & Y axes in device space.

        Point2D xvec = new Point2D.Double(1, 0);

        Point2D yvec = new Point2D.Double(0, 1);

        try {

            AffineTransform inverse = xform.createInverse();

            inverse.deltaTransform(xvec, xvec);

            inverse.deltaTransform(yvec, yvec);

        } catch (NoninvertibleTransformException e) {

            xvec.setLocation(0, 0);

            yvec.setLocation(0, 0);

        }

        // Now calculate the (square of the) user space distance

        // between the anchor points. This value equals:

        //     (UserVec . UserVec)

        double udx = p2.getX() - p1.getX();

        double udy = p2.getY() - p1.getY();

        double ulenSq = udx * udx + udy * udy;

        if (ulenSq <= Double.MIN_VALUE) {

            dx = 0;

            dy = 0;

        } else {

            // Now calculate the proportional distance moved along the

            // vector from p1 to p2 when we move a unit along X & Y in

            // device space.

            //

            // The length of the projection of the Device Axis Vector is

            // its dot product with the Unit User Vector:

            //     (DevAxisVec . (UserVec / Len(UserVec))

            //

            // The "proportional" length is that length divided again

            // by the length of the User Vector:

            //     (DevAxisVec . (UserVec / Len(UserVec))) / Len(UserVec)

            // which simplifies to:

            //     ((DevAxisVec . UserVec) / Len(UserVec)) / Len(UserVec)

            // which simplifies to:

            //     (DevAxisVec . UserVec) / LenSquared(UserVec)

            dx = (xvec.getX() * udx + xvec.getY() * udy) / ulenSq;

            dy = (yvec.getX() * udx + yvec.getY() * udy) / ulenSq;

            if (cyclic) {

                dx = dx % 1.0;

                dy = dy % 1.0;

            } else {

                // We are acyclic

                if (dx < 0) {

                    // If we are using the acyclic form below, we need

                    // dx to be non-negative for simplicity of scanning

                    // across the scan lines for the transition points.

                    // To ensure that constraint, we negate the dx/dy

                    // values and swap the points and colors.

                    Point2D p = p1; p1 = p2; p2 = p;

                    Color c = c1; c1 = c2; c2 = c;

                    dx = -dx;

                    dy = -dy;

                }

            }

        }

        Point2D dp1 = xform.transform(p1, null);

        this.x1 = dp1.getX();

        this.y1 = dp1.getY();

        this.cyclic = cyclic;

        int rgb1 = c1.getRGB();

        int rgb2 = c2.getRGB();

        int a1 = (rgb1 >> 24) & 0xff;

        int r1 = (rgb1 >> 16) & 0xff;

        int g1 = (rgb1 >>  8) & 0xff;

        int b1 = (rgb1      ) & 0xff;

        int da = ((rgb2 >> 24) & 0xff) - a1;

        int dr = ((rgb2 >> 16) & 0xff) - r1;

        int dg = ((rgb2 >>  8) & 0xff) - g1;

        int db = ((rgb2      ) & 0xff) - b1;

        if (a1 == 0xff && da == 0) {

            model = xrgbmodel;

            if (cm instanceof DirectColorModel) {

                DirectColorModel dcm = (DirectColorModel) cm;

                int tmp = dcm.getAlphaMask();

                if ((tmp == 0 || tmp == 0xff) &&

                    dcm.getRedMask() == 0xff &&

                    dcm.getGreenMask() == 0xff00 &&

                    dcm.getBlueMask() == 0xff0000)

                {

                    model = xbgrmodel;

                    tmp = r1; r1 = b1; b1 = tmp;

                    tmp = dr; dr = db; db = tmp;

                }

            }

        } else {

            model = ColorModel.getRGBdefault();

        }

        interp = new int[cyclic ? 513 : 257];

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

            float rel = i / 256.0f;

            int rgb =

                (((int) (a1 + da * rel)) << 24) |

                (((int) (r1 + dr * rel)) << 16) |

                (((int) (g1 + dg * rel)) <<  8) |

                (((int) (b1 + db * rel))      );

            interp[i] = rgb;

            if (cyclic) {

                interp[512 - i] = rgb;

            }

        }

    }

    /**

     * Release the resources allocated for the operation.

     */

    public void dispose() {

        if (saved != null) {

            putCachedRaster(model, saved);

            saved = null;

        }

    }

    /**

     * Return the ColorModel of the output.

     */

    public ColorModel getColorModel() {

        return model;

    }

    /**

     * Return a Raster containing the colors generated for the graphics

     * operation.

     * @param x,y,w,h The area in device space for which colors are

     * generated.

     */

    public Raster getRaster(int x, int y, int w, int h) {

        double rowrel = (x - x1) * dx + (y - y1) * dy;

        Raster rast = saved;

        if (rast == null || rast.getWidth() < w || rast.getHeight() < h) {

            rast = getCachedRaster(model, w, h);

            saved = rast;

        }

        IntegerComponentRaster irast = (IntegerComponentRaster) rast;

        int off = irast.getDataOffset(0);

        int adjust = irast.getScanlineStride() - w;

        int[] pixels = irast.getDataStorage();

        if (cyclic) {

            cycleFillRaster(pixels, off, adjust, w, h, rowrel, dx, dy);

        } else {

            clipFillRaster(pixels, off, adjust, w, h, rowrel, dx, dy);

        }

        irast.markDirty();

        return rast;

    }

    void cycleFillRaster(int[] pixels, int off, int adjust, int w, int h,

                         double rowrel, double dx, double dy) {

        rowrel = rowrel % 2.0;

        int irowrel = ((int) (rowrel * (1 << 30))) << 1;

        int idx = (int) (-dx * (1 << 31));

        int idy = (int) (-dy * (1 << 31));

        while (--h >= 0) {

            int icolrel = irowrel;

            for (int j = w; j > 0; j--) {

                pixels[off++] = interp[icolrel >>> 23];

                icolrel += idx;

            }

            off += adjust;

            irowrel += idy;

        }

    }

    void clipFillRaster(int[] pixels, int off, int adjust, int w, int h,

                        double rowrel, double dx, double dy) {

        while (--h >= 0) {

            double colrel = rowrel;

            int j = w;

            if (colrel <= 0.0) {

                int rgb = interp[0];

                do {

                    pixels[off++] = rgb;

                    colrel += dx;

                } while (--j > 0 && colrel <= 0.0);

            }

            while (colrel < 1.0 && --j >= 0) {

                pixels[off++] = interp[(int) (colrel * 256)];

                colrel += dx;

            }

            if (j > 0) {

                int rgb = interp[256];

                do {

                    pixels[off++] = rgb;

                } while (--j > 0);

            }

            off += adjust;

            rowrel += dy;

        }

    }

}