// Copyright 2000-2005 the Contributors, as shown in the revision logs.
// Licensed under the GNU General Public License version 2 ("the License").
// You may not use this file except in compliance with the License.

package org.ibex.graphics;
import java.io.*;
import org.ibex.js.*;
import org.ibex.plat.*;
import org.ibex.util.*;

/** 
 *    The in-memory representation of a PNG or GIF image. It is
 *    read-only. It is usually passed to PixelBuffer.drawPicture()
 *
 *    Implementations of the Platform class should return objects
 *    supporting this interface from the createPicture() method. These
 *    implementations may choose to implement caching strategies (for
 *    example, using a Pixmap on X11).
 */
public class Picture {

    public Picture() { this.stream = null; }
    public Picture(JS r) { this.stream = r; }
    private static Cache cache = new Cache(100, true); ///< Picture, keyed by the Stream that loaded them

    public JS stream = null;                       ///< the stream we were loaded from
    public int width = -1;                         ///< the width of the image
    public int height = -1;                        ///< the height of the image
    public int[] data = null;                      ///< argb samples
    public boolean isLoaded = false;               ///< true iff the image is fully loaded

    public Picture(InputStream is) throws IOException { load(this, is); }

    public static void load(Picture p, InputStream in) throws IOException {
        PushbackInputStream pbis = new PushbackInputStream(in);
        int firstByte = pbis.read();
        if (firstByte == -1) throw new IOException("empty stream reading image");
        pbis.unread(firstByte);
        if ((firstByte & 0xff) == 'G') GIF.load(pbis, p);
        else if ((firstByte & 0xff) == 137)  PNG.load(pbis, p);
        else if ((firstByte & 0xff) == 0xff) Platform.decodeJPEG(pbis, p);
        else throw new IOException("couldn't figure out image type from first byte");
        p.loaded();
    }

    /** invoked when an image is fully loaded; subclasses can use this to initialize platform-specific constructs */
    protected void loaded() { isLoaded = true; }

    /** turns a stream into a Picture.Source and passes it to the callback */
    public static Picture load(final JS stream, final Callable callback) {
        if(stream == null) throw new NullPointerException();
        Picture ret = (Picture)cache.get(stream);
        if (ret == null) {
            ret = Platform.createPicture(stream);
            if(ret == null) throw new NullPointerException();
            cache.put(stream, ret);
        }
        final Picture p = ret;
        if (!ret.isLoaded && callback != null) {
            new java.lang.Thread() { public void run() {
                InputStream in = null;
                try {
                    in = JSU.getInputStream(stream);
                } catch (IOException e) { Log.error(Picture.class, e);
                //} catch (JSExn e) { Log.error(Picture.class, e);
                }
                if (in == null) { Log.warn(Picture.class, "couldn't load image for stream " + stream.unclone()); return; }
                try {
                    load(p, in);
                    Platform.Scheduler.add(callback);
                } catch (Exception e) {
                    Log.info(this, "exception while loading image");
                    Log.info(this, e);
                }
            } }.start();
        }
        return ret;
    }
}