/*

 * Copyright (c) 2005, 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 com.sun.imageio.plugins.common;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.image.RenderedImage;

import java.awt.image.ColorModel;

import java.awt.image.SampleModel;

import java.awt.image.Raster;

import java.awt.image.WritableRaster;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Vector;

public abstract class SimpleRenderedImage implements RenderedImage {

    /** The X coordinate of the image's upper-left pixel. */

    protected int minX;

    /** The Y coordinate of the image's upper-left pixel. */

    protected int minY;

    /** The image's width in pixels. */

    protected int width;

    /** The image's height in pixels. */

    protected int height;

    /** The width of a tile. */

    protected int tileWidth;

    /** The height of a tile. */

    protected int tileHeight;

    /** The X coordinate of the upper-left pixel of tile (0, 0). */

    protected int tileGridXOffset = 0;

    /** The Y coordinate of the upper-left pixel of tile (0, 0). */

    protected int tileGridYOffset = 0;

    /** The image's SampleModel. */

    protected SampleModel sampleModel;

    /** The image's ColorModel. */

    protected ColorModel colorModel;

    /** The image's sources, stored in a Vector. */

    protected Vector<RenderedImage> sources = new Vector<RenderedImage>();

    /** A Hashtable containing the image properties. */

    protected Hashtable<String,Object> properties = new Hashtable<String,Object>();

    /** Returns the X coordinate of the leftmost column of the image. */

    public int getMinX() {

        return minX;

    }

    /**

     * Returns the X coordinate of the column immediatetely to the

     * right of the rightmost column of the image.  getMaxX() is

     * implemented in terms of getMinX() and getWidth() and so does

     * not need to be implemented by subclasses.

     */

    public final int getMaxX() {

        return getMinX() + getWidth();

    }

    /** Returns the X coordinate of the uppermost row of the image. */

    public int getMinY() {

        return minY;

    }

    /**

     * Returns the Y coordinate of the row immediately below the

     * bottom row of the image.  getMaxY() is implemented in terms of

     * getMinY() and getHeight() and so does not need to be

     * implemented by subclasses.

     */

    public final int getMaxY() {

        return getMinY() + getHeight();

    }

    /** Returns the width of the image. */

    public int getWidth() {

        return width;

    }

    /** Returns the height of the image. */

    public int getHeight() {

        return height;

    }

    /** Returns a Rectangle indicating the image bounds. */

    public Rectangle getBounds() {

        return new Rectangle(getMinX(), getMinY(), getWidth(), getHeight());

    }

    /** Returns the width of a tile. */

    public int getTileWidth() {

        return tileWidth;

    }

    /** Returns the height of a tile. */

    public int getTileHeight() {

        return tileHeight;

    }

    /**

     * Returns the X coordinate of the upper-left pixel of tile (0, 0).

     */

    public int getTileGridXOffset() {

        return tileGridXOffset;

    }

    /**

     * Returns the Y coordinate of the upper-left pixel of tile (0, 0).

     */

    public int getTileGridYOffset() {

        return tileGridYOffset;

    }

    /**

     * Returns the horizontal index of the leftmost column of tiles.

     * getMinTileX() is implemented in terms of getMinX()

     * and so does not need to be implemented by subclasses.

     */

    public int getMinTileX() {

        return XToTileX(getMinX());

    }

    /**

     * Returns the horizontal index of the rightmost column of tiles.

     * getMaxTileX() is implemented in terms of getMaxX()

     * and so does not need to be implemented by subclasses.

     */

    public int getMaxTileX() {

        return XToTileX(getMaxX() - 1);

    }

    /**

     * Returns the number of tiles along the tile grid in the

     * horizontal direction.  getNumXTiles() is implemented in terms

     * of getMinTileX() and getMaxTileX() and so does not need to be

     * implemented by subclasses.

     */

    public int getNumXTiles() {

        return getMaxTileX() - getMinTileX() + 1;

    }

    /**

     * Returns the vertical index of the uppermost row of tiles.  getMinTileY()

     * is implemented in terms of getMinY() and so does not need to be

     * implemented by subclasses.

     */

    public int getMinTileY() {

        return YToTileY(getMinY());

    }

    /**

     * Returns the vertical index of the bottom row of tiles.  getMaxTileY()

     * is implemented in terms of getMaxY() and so does not need to

     * be implemented by subclasses.

     */

    public int getMaxTileY() {

        return YToTileY(getMaxY() - 1);

    }

    /**

     * Returns the number of tiles along the tile grid in the vertical

     * direction.  getNumYTiles() is implemented in terms

     * of getMinTileY() and getMaxTileY() and so does not need to be

     * implemented by subclasses.

     */

    public int getNumYTiles() {

        return getMaxTileY() - getMinTileY() + 1;

    }

    /** Returns the SampleModel of the image. */

    public SampleModel getSampleModel() {

        return sampleModel;

    }

    /** Returns the ColorModel of the image. */

    public ColorModel getColorModel() {

        return colorModel;

    }

    /**

     * Gets a property from the property set of this image.  If the

     * property name is not recognized,

     * <code>java.awt.Image.UndefinedProperty</code> will be returned.

     *

     * @param name the name of the property to get, as a

     * <code>String</code>.  @return a reference to the property

     * <code>Object</code>, or the value

     * <code>java.awt.Image.UndefinedProperty.</code>

     */

    public Object getProperty(String name) {

        name = name.toLowerCase();

        Object value = properties.get(name);

        return value != null ? value : java.awt.Image.UndefinedProperty;

    }

    /**

     * Returns a list of the properties recognized by this image.  If

     * no properties are available, <code>null</code> will be

     * returned.

     *

     * @return an array of <code>String</code>s representing valid

     *         property names.

     */

    public String[] getPropertyNames() {

        String[] names = null;

        if(properties.size() > 0) {

            names = new String[properties.size()];

            int index = 0;

            Enumeration<String> e = properties.keys();

            while (e.hasMoreElements()) {

                String name = e.nextElement();

                names[index++] = name;

            }

        }

        return names;

    }

    /**

     * Returns an array of <code>String</code>s recognized as names by

     * this property source that begin with the supplied prefix.  If

     * no property names match, <code>null</code> will be returned.

     * The comparison is done in a case-independent manner.

     *

     * <p> The default implementation calls

     * <code>getPropertyNames()</code> and searches the list of names

     * for matches.

     *

     * @return an array of <code>String</code>s giving the valid

     * property names.

     */

    public String[] getPropertyNames(String prefix) {

        String propertyNames[] = getPropertyNames();

        if (propertyNames == null) {

            return null;

        }

        prefix = prefix.toLowerCase();

        Vector<String> names = new Vector<String>();

        for (int i = 0; i < propertyNames.length; i++) {

            if (propertyNames[i].startsWith(prefix)) {

                names.addElement(propertyNames[i]);

            }

        }

        if (names.size() == 0) {

            return null;

        }

        // Copy the strings from the Vector over to a String array.

        String prefixNames[] = new String[names.size()];

        int count = 0;

        for (Iterator<String> it = names.iterator(); it.hasNext(); ) {

            prefixNames[count++] = it.next();

        }

        return prefixNames;

    }

    // Utility methods.

    /**

     * Converts a pixel's X coordinate into a horizontal tile index

     * relative to a given tile grid layout specified by its X offset

     * and tile width.

     */

    public static int XToTileX(int x, int tileGridXOffset, int tileWidth) {

        x -= tileGridXOffset;

        if (x < 0) {

            x += 1 - tileWidth; // Force round to -infinity

        }

        return x/tileWidth;

    }

    /**

     * Converts a pixel's Y coordinate into a vertical tile index

     * relative to a given tile grid layout specified by its Y offset

     * and tile height.

     */

    public static int YToTileY(int y, int tileGridYOffset, int tileHeight) {

        y -= tileGridYOffset;

        if (y < 0) {

            y += 1 - tileHeight; // Force round to -infinity

        }

        return y/tileHeight;

    }

    /**

     * Converts a pixel's X coordinate into a horizontal tile index.

     * This is a convenience method.  No attempt is made to detect

     * out-of-range coordinates.

     *

     * @param x the X coordinate of a pixel.

     * @return the X index of the tile containing the pixel.

     */

    public int XToTileX(int x) {

        return XToTileX(x, getTileGridXOffset(), getTileWidth());

    }

    /**

     * Converts a pixel's Y coordinate into a vertical tile index.

     * This is a convenience method.  No attempt is made to detect

     * out-of-range coordinates.

     *

     * @param y the Y coordinate of a pixel.

     * @return the Y index of the tile containing the pixel.

     */

    public int YToTileY(int y) {

        return YToTileY(y, getTileGridYOffset(), getTileHeight());

    }

    /**

     * Converts a horizontal tile index into the X coordinate of its

     * upper left pixel relative to a given tile grid layout specified

     * by its X offset and tile width.

     */

    public static int tileXToX(int tx, int tileGridXOffset, int tileWidth) {

        return tx*tileWidth + tileGridXOffset;

    }

    /**

     * Converts a vertical tile index into the Y coordinate of

     * its upper left pixel relative to a given tile grid layout

     * specified by its Y offset and tile height.

     */

    public static int tileYToY(int ty, int tileGridYOffset, int tileHeight) {

        return ty*tileHeight + tileGridYOffset;

    }

    /**

     * Converts a horizontal tile index into the X coordinate of its

     * upper left pixel.  This is a convenience method.  No attempt is made

     * to detect out-of-range indices.

     *

     * @param tx the horizontal index of a tile.

     * @return the X coordinate of the tile's upper left pixel.

     */

    public int tileXToX(int tx) {

        return tx*tileWidth + tileGridXOffset;

    }

    /**

     * Converts a vertical tile index into the Y coordinate of its

     * upper left pixel.  This is a convenience method.  No attempt is made

     * to detect out-of-range indices.

     *

     * @param ty the vertical index of a tile.

     * @return the Y coordinate of the tile's upper left pixel.

     */

    public int tileYToY(int ty) {

        return ty*tileHeight + tileGridYOffset;

    }

    public Vector<RenderedImage> getSources() {

        return null;

    }

    /**

     * Returns the entire image in a single Raster.  For images with

     * multiple tiles this will require making a copy.

     *

     * <p> The returned Raster is semantically a copy.  This means

     * that updates to the source image will not be reflected in the

     * returned Raster.  For non-writable (immutable) source images,

     * the returned value may be a reference to the image's internal

     * data.  The returned Raster should be considered non-writable;

     * any attempt to alter its pixel data (such as by casting it to

     * WritableRaster or obtaining and modifying its DataBuffer) may

     * result in undefined behavior.  The copyData method should be

     * used if the returned Raster is to be modified.

     *

     * @return a Raster containing a copy of this image's data.

     */

    public Raster getData() {

        Rectangle rect = new Rectangle(getMinX(), getMinY(),

                                       getWidth(), getHeight());

        return getData(rect);

    }

    /**

     * Returns an arbitrary rectangular region of the RenderedImage

     * in a Raster.  The rectangle of interest will be clipped against

     * the image bounds.

     *

     * <p> The returned Raster is semantically a copy.  This means

     * that updates to the source image will not be reflected in the

     * returned Raster.  For non-writable (immutable) source images,

     * the returned value may be a reference to the image's internal

     * data.  The returned Raster should be considered non-writable;

     * any attempt to alter its pixel data (such as by casting it to

     * WritableRaster or obtaining and modifying its DataBuffer) may

     * result in undefined behavior.  The copyData method should be

     * used if the returned Raster is to be modified.

     *

     * @param bounds the region of the RenderedImage to be returned.

     */

    public Raster getData(Rectangle bounds) {

        // Get the image bounds.

        Rectangle imageBounds = getBounds();

        // Check for parameter validity.

        if(bounds == null) {

            bounds = imageBounds;

        } else if(!bounds.intersects(imageBounds)) {

            throw new IllegalArgumentException("The provided region doesn't intersect with the image bounds.");

        }

        // Determine tile limits for the prescribed bounds.

        int startX = XToTileX(bounds.x);

        int startY = YToTileY(bounds.y);

        int endX = XToTileX(bounds.x + bounds.width - 1);

        int endY = YToTileY(bounds.y + bounds.height - 1);

        // If the bounds are contained in a single tile, return a child

        // of that tile's Raster.

        if ((startX == endX) && (startY == endY)) {

            Raster tile = getTile(startX, startY);

            return tile.createChild(bounds.x, bounds.y,

                                    bounds.width, bounds.height,

                                    bounds.x, bounds.y, null);

        } else {

            // Recalculate the tile limits if the data bounds are not a

            // subset of the image bounds.

            if(!imageBounds.contains(bounds)) {

                Rectangle xsect = bounds.intersection(imageBounds);

                startX = XToTileX(xsect.x);

                startY = YToTileY(xsect.y);

                endX = XToTileX(xsect.x + xsect.width - 1);

                endY = YToTileY(xsect.y + xsect.height - 1);

            }

            // Create a WritableRaster of the desired size

            SampleModel sm =

                sampleModel.createCompatibleSampleModel(bounds.width,

                                                        bounds.height);

            // Translate it

            WritableRaster dest =

                Raster.createWritableRaster(sm, bounds.getLocation());

            // Loop over the tiles in the intersection.

            for (int j = startY; j <= endY; j++) {

                for (int i = startX; i <= endX; i++) {

                    // Retrieve the tile.

                    Raster tile = getTile(i, j);

                    // Create a child of the tile for the intersection of

                    // the tile bounds and the bounds of the requested area.

                    Rectangle tileRect = tile.getBounds();

                    Rectangle intersectRect =

                        bounds.intersection(tile.getBounds());

                    Raster liveRaster = tile.createChild(intersectRect.x,

                                                         intersectRect.y,

                                                         intersectRect.width,

                                                         intersectRect.height,

                                                         intersectRect.x,

                                                         intersectRect.y,

                                                         null);

                    // Copy the data from the child.

                    dest.setRect(liveRaster);

                }

            }

            return dest;

        }

    }

    /**

     * Copies an arbitrary rectangular region of the RenderedImage

     * into a caller-supplied WritableRaster.  The region to be

     * computed is determined by clipping the bounds of the supplied

     * WritableRaster against the bounds of the image.  The supplied

     * WritableRaster must have a SampleModel that is compatible with

     * that of the image.

     *

     * <p> If the raster argument is null, the entire image will

     * be copied into a newly-created WritableRaster with a SampleModel

     * that is compatible with that of the image.

     *

     * @param dest a WritableRaster to hold the returned portion of

     *        the image.

     * @return a reference to the supplied WritableRaster, or to a

     *         new WritableRaster if the supplied one was null.

     */

    public WritableRaster copyData(WritableRaster dest) {

        // Get the image bounds.

        Rectangle imageBounds = getBounds();

        Rectangle bounds;

        if (dest == null) {

            // Create a WritableRaster for the entire image.

            bounds = imageBounds;

            Point p = new Point(minX, minY);

            SampleModel sm =