/*

* Copyright (c) 1999 - 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

package javax.microedition.lcdui;

import java.io.InputStream;

import java.io.IOException;

import javax.microedition.lcdui.game.Sprite;

import com.nokia.mj.impl.rt.legacy.MemoryUtil;

import com.nokia.mj.impl.rt.legacy.NativeError;

import com.nokia.mj.impl.rt.support.Finalizer;

/**

 * Image API class.

 */

public class Image

{

    private static final int ATTRIB_WIDTH  = 0;

    private static final int ATTRIB_HEIGHT = 1;

    private static final int ATTRIB_TYPE   = 2;

    private static final int ATTRIB_SIZE   = 3;

    private static final int ATTRIB_COUNT  = 4;

    static final int TRANSPARENCY_NONE  = 0;

    static final int TRANSPARENCY_MASK  = 1;

    static final int TRANSPARENCY_ALPHA = 2;

    /**

     * Image width, 0 if unknown

     */

    private int     iWidth;

    /**

     * Image height 0 if unknown

     */

    private int     iHeight;

    /**

     * true if image is mutable

     */

    private boolean iMutable;

    /**

     * true if image has transparency

     */

    private int     iTransparency;

    /**

     *

     */

    private int     iSizeBytes;

    /**

     * Peer handle

     */

    int iHandle;

    /**

     * The owning MIDlets toolkit

     */

    Toolkit iToolkit;

    private Finalizer mFinalizer = new Finalizer()

    {

        public void finalizeImpl()

        {

            doFinalize();

        }

    };

    private Image()

    {

        iToolkit = Toolkit.getToolkit();

    }

    /**

     * Create an image wrapping a canvas native frame buffer.

     */

    Image(Canvas aCanvas)

    {

        this();

        checkToolkit(aCanvas.iToolkit);

        final int[] attribs = new int[ATTRIB_COUNT];

        synchronized (iToolkit)

        {

            final int toolkit = iToolkit.getHandle();

            iHandle = Toolkit.checkHandle(_createFromCanvas(toolkit, aCanvas.getContentHandle(), attribs));

        }

        setAttributes(attribs, true);

    }

    private Image(int aWidth, int aHeight, int aColor)

    {

        this();

        final int[] attribs = new int[ATTRIB_COUNT];

        synchronized (iToolkit)

        {

            final int toolkit = iToolkit.getHandle();

            iHandle = Toolkit.checkHandle(_createMutable(toolkit, aWidth, aHeight, aColor, attribs));

        }

        setAttributes(attribs, true);

    }

    private Image(ImageLoader aLoader)

    {

        this();

        checkToolkit(aLoader.iToolkit);

        final int[] attribs = new int[ATTRIB_COUNT];

        synchronized (iToolkit)

        {

            final int toolkit = iToolkit.getHandle();

            iHandle = Toolkit.checkHandle(_createImmutable(toolkit, aLoader.getHandle(), attribs));

        }

        setAttributes(attribs, false);

    }

    /**

     *

     */

    private Image(Image aSource, int aX, int aY, int aWidth, int aHeight, int aTransform)

    {

        this();

        checkToolkit(aSource.iToolkit);

        final int[] attribs = new int[ATTRIB_COUNT];

        synchronized (iToolkit)

        {

            final int toolkit = iToolkit.getHandle();

            final int source  = aSource.getHandle(true);

            iHandle = Toolkit.checkHandle(_createRegion(toolkit, source, aX, aY, aWidth, aHeight, aTransform,attribs));

        }

        setAttributes(attribs, false);

    }

    private Image(int[] aRgbArray, int aWidth, int aHeight, boolean aProcessAlpha)

    {

        this();

        final int[] attribs = new int[ATTRIB_COUNT];

        synchronized (iToolkit)

        {

            final int toolkit = iToolkit.getHandle();

            iHandle = Toolkit.checkHandle(_createRGB(toolkit, aRgbArray, aWidth, aHeight, aProcessAlpha, attribs));

        }

        setAttributes(attribs, false);

    }

    //

    // API

    //

    public static Image createImage(byte[] aData,int aOffset,int aLength)

    {

        final int space = aData.length - aOffset; // throws NullPointerException

        if ((aOffset < 0) || (space < aLength) || (aLength < 0))

        {

            throw new ArrayIndexOutOfBoundsException();

        }

        final Toolkit toolkit = Toolkit.getToolkit();

        ImageLoader loader = new ImageLoader(toolkit);

        try

        {

            loader.append(aData, aOffset, aLength);

            return loadImage(loader);

        }

        catch (Throwable t)

        {

            if (t instanceof OutOfMemoryError)

            {

                throw(OutOfMemoryError)t;

            }

            throw new IllegalArgumentException("bad image format");

        }

        finally

        {

            loader.dispose();

        }

    }

    //

    // API

    //

    public static Image createImage(Image aImage)

    {

        return createImage(aImage, 0, 0, aImage.getWidth(), aImage.getHeight(), 0);

    }

    //

    // API

    //

    public static Image createImage(Image aImage, int aX, int aY, int aWidth, int aHeight, int aTransform)

    {

        final int width  = aImage.getWidth();   // throws NullPointerException

        final int height = aImage.getHeight();

        if (aWidth <= 0 || aHeight <= 0)

        {

            throw new IllegalArgumentException("invalid width or height");

        }

        final int sx1  = aX;            // left column

        final int sx2  = aX + aWidth;   // right column

        final int sy1  = aY;            // top row (inclusive)

        final int sy2  = aY + aHeight;  // bottom row (exclusive)

        //

        // Check source x range lies within source image

        //

        final boolean xRangeError = (sx1 < 0) || (sx1 >= width) || (sx2 < 0) || (sx2 > width);

        final boolean yRangeError = (sy1 < 0) || (sy1 >= height) || (sy2 < 0) || (sy2 > height);

        if (xRangeError || yRangeError)

        {

            final String info = "args=("+aX+','+aY+','+aWidth+','+aHeight+"), rect=("+sx1 +','+sy1+','+sx2+','+sy2+"), image width="+width+",height="+height;

            throw new IllegalArgumentException("createImage: Exceeding bounds of source image: " + info);

        }

        if (aTransform < Sprite.TRANS_NONE || aTransform > Sprite.TRANS_MIRROR_ROT90)

        {

            throw new IllegalArgumentException("invalid transform");

        }

        //

        // Check for trival case for immutable images.

        //

        if ((!aImage.isMutable()) && (aWidth == width) && (aHeight == height) && (aTransform == Sprite.TRANS_NONE))

        {

            return aImage;

        }

        try

        {

            return new Image(aImage, aX, aY, aWidth, aHeight, aTransform);

        }

        catch (OutOfMemoryError oom)

        {

            MemoryUtil.freeNativeMemory();

            return new Image(aImage, aX, aY, aWidth, aHeight, aTransform);

        }

    }

    //

    // API

    //

    public static Image createImage(InputStream aStream) throws java.io.IOException

    {

        if (null == aStream)

        {

            throw new NullPointerException();

        }

        return createImageFromStream(aStream);

    }

    //

    // API

    //

    public static Image createImage(int aWidth,int aHeight)

    {

        if (aWidth <= 0 || aHeight <= 0)

        {

            throw new IllegalArgumentException();

        }

        try

        {

            return new Image(aWidth, aHeight, 0xffffffff);

        }

        catch (OutOfMemoryError oom)

        {

            MemoryUtil.freeNativeMemory();

            return new Image(aWidth, aHeight, 0xffffffff);

        }

    }

    //

    // API

    //

    public static Image createImage(String aName) throws java.io.IOException

    {

        if (aName == null)

        {

            throw new NullPointerException();

        }

        final Toolkit toolkit = Toolkit.getToolkit();

        InputStream stream = toolkit.getResourceAsStream(aName);

        if (stream == null)

        {

            // Retry that allows using relative name when image is in root level

            stream = toolkit.getResourceAsStream("/"+aName);

            if (stream == null)

            {

                throw new IOException();

            }

        }

        try

        {

            return createImageFromStream(stream);

        }

        finally

        {

            stream.close();

        }

    }

    public static Image createRGBImage(int[] aRgb, int aWidth, int aHeight, boolean aProcessAlpha)

    {

        if (aWidth <= 0 || aHeight <= 0)

        {

            throw new IllegalArgumentException();

        }

        try

        {

            return new Image(aRgb, aWidth, aHeight, aProcessAlpha);

        }

        catch (OutOfMemoryError oom)

        {

            MemoryUtil.freeNativeMemory();

            return new Image(aRgb, aWidth, aHeight, aProcessAlpha);

        }

    }

    private static Image createImageFromStream(InputStream aStream) throws java.io.IOException

    {

        //

        // maximum size of blocks to read from stream

        //

        final int    blocksize = 4096;

        final byte[] buffer    = new byte[blocksize];

        //

        // create image loader to accept encoded image data.

        //

        final ImageLoader loader = new ImageLoader(Toolkit.getToolkit());

        try

        {

            int bytesRead = 0;

            //

            // read blocks from stream and append to decoder buffer

            //

            while ((bytesRead = aStream.read(buffer, 0, buffer.length)) != -1)

            {

                if (loader.append(buffer, 0, bytesRead) == false)

                    throw new IOException("loader.iHandle null: can't append more data");

            }

            return loadImage(loader);

        }

        catch (Throwable t)

        {

            if (t instanceof OutOfMemoryError)

            {

                throw(OutOfMemoryError)t;

            }

            throw new IOException();

        }

        finally

        {

            loader.dispose();

        }

    }

    private static Image loadImage(ImageLoader aLoader)

    {

        //

        // This is where the image is first decoded and a native representation allocated.

        // It is more likely to fail than the image instantiation, but more risky to retry.

        //

        //

        // REMOVED  RETRY around the following line as it caused performance unit test

        // to panic.

        //

        aLoader.decode();

        //

        // This is where device specific bitmaps are created if the image was decoded in

        // the wrong format. This is less likely to OOM than the decode above - but can

        // be retried.

        //

        try

        {

            return new Image(aLoader);

        }

        catch (OutOfMemoryError oom)

        {

            MemoryUtil.freeNativeMemory();

            return new Image(aLoader);

        }

    }

    public void getRGB(int[] aRgbData,int aOffset,int aScanLength,int aX,int aY,int aWidth,int aHeight)

    {

        //

        // Image bounds

        //

        if (aWidth <= 0 || aHeight <= 0)

        {

            return;

        }

        //

        // Array bounds

        //

        final long limit = (long)(aRgbData.length) - 1; // throws NullPointerException

        //

        // aScanLength may be negative in which case rows are written

        // into the buffer in reverse order.

        //

        long start;

        long end;

        if (aScanLength > 0)

        {

            start = (long)aOffset;

            end   = (long)aOffset + (long)aScanLength*((long)aHeight-1) + (long)aWidth - 1;

        }

        else

        {

            end   = (long)aOffset + (long)aWidth - 1;

            start = (long)aOffset + (long)aScanLength*((long)aHeight-1);

        }

        final int width  = iWidth;

        final int height = iHeight;

        final int sx1  = aX;            // left column

        final int sx2  = aX + aWidth;   // right column

        final int sy1  = aY;            // top row (exclusive)

        final int sy2  = aY + aHeight;  // bottom row (exclusive)

        //

        // Check source x range lies within source image

        //

        final boolean xRangeError = (sx1 < 0) || (sx1 >= width) || (sx2 < 0) || (sx2 > width);

        final boolean yRangeError = (sy1 < 0) || (sy1 >= height) || (sy2 < 0) || (sy2 > height);

        if (xRangeError || yRangeError)

        {

            final String info = "args=("+aX+','+aY+','+aWidth+','+aHeight+"), rect=("+sx1 +','+sy1+','+sx2+','+sy2+"), image width="+width+",height="+height;

            throw new IllegalArgumentException("getRGB: Exceeding bounds of source image: " + info);

        }

        final int scanLength = Math.abs(aScanLength);

        if (scanLength < aWidth)

        {

            throw new IllegalArgumentException("abs(Scanlength) should be >= width");

        }

        synchronized (iToolkit)

        {

            final int toolkit = iToolkit.getHandle();

            final int handle  = getHandle(true);

            NativeError.check(_getPixels(toolkit, handle, aRgbData, aOffset, aScanLength, aX, aY, aWidth, aHeight));

        }

    }

    /**

     *@returns a newly allocated thread-safe Graphics instance.

     */

    public Graphics getGraphics()

    {

        if (!isMutable())

        {

            throw new IllegalStateException();

        }

        return new Graphics(iToolkit, this, getHandle(false), iWidth, iHeight);

    }

    public int getWidth()

    {

        return iWidth;

    }

    public int getHeight()

    {

        return iHeight;

    }

    public boolean isMutable()

    {

        return iMutable;

    }

    /**

     *@return true if this image has transparent pixels.

     *

     * May be used in game package to avoid native calls in collision

     * detection.