/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/**
 * @author Oleg V. Khaschansky
 * @version $Revision$
 */
/*
 * Created on 18.01.2005
 */
package org.apache.harmony.awt.gl.image;

import java.awt.image.ImageConsumer;
import java.awt.image.ImageProducer;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * This is an abstract class that encapsulates a main part of ImageProducer functionality
 * for the images being decoded by the native decoders, like PNG, JPEG and GIF.
 * It helps to integrate image decoders into producer/consumer model. It provides
 * functionality for working with several decoder instances and several image consumers
 * simultaneously.
 */
public abstract class DecodingImageSource implements ImageProducer {
    List<ImageConsumer> consumers = new ArrayList<ImageConsumer>(5);
    List<ImageDecoder> decoders = new ArrayList<ImageDecoder>(5);
    boolean loading;

    ImageDecoder decoder;

    protected abstract boolean checkConnection();

    protected abstract InputStream getInputStream();

    public synchronized void addConsumer(ImageConsumer ic) {
        if (!checkConnection()) { // No permission for this consumer
            ic.imageComplete(ImageConsumer.IMAGEERROR);
            return;
        }

        ImageConsumer cons = findConsumer(consumers, ic);

        if (cons == null) { // Try to look in the decoders
            ImageDecoder d = null;

            // Check for all existing decoders
            for (Iterator<ImageDecoder> i = decoders.iterator(); i.hasNext();) {
                d = i.next();
                cons = findConsumer(d.consumers, ic);
                if (cons != null) {
                    break;
                }
            }
        }

        if (cons == null) { // Not found, add this consumer
            consumers.add(ic);
        }
    }

    /**
     * This method stops sending data to the given consumer
     * @param ic - consumer
     */
    private void abortConsumer(ImageConsumer ic) {
        ic.imageComplete(ImageConsumer.IMAGEERROR);
        consumers.remove(ic);
    }

    /**
     * This method stops sending data to the list of consumers.
     * @param consumersList - list of consumers
     */
    private void abortAllConsumers(List<ImageConsumer> consumersList) {
        for (ImageConsumer imageConsumer : consumersList) {
            abortConsumer(imageConsumer);
        }
    }

    public synchronized void removeConsumer(ImageConsumer ic) {
        ImageDecoder d = null;

        // Remove in all existing decoders
        for (Iterator<ImageDecoder> i = decoders.iterator(); i.hasNext();) {
            d = i.next();
            removeConsumer(d.consumers, ic);
            if (d.consumers.size() <= 0) {
                d.terminate();
            }
        }

        // Remove in the current queue of consumers
        removeConsumer(consumers, ic);
    }

    /**
     * Static implementation of removeConsumer method
     * @param consumersList - list of consumers
     * @param ic - consumer to be removed
     */
    private static void removeConsumer(List<ImageConsumer> consumersList, ImageConsumer ic) {
        ImageConsumer cons = null;

        for (Iterator<ImageConsumer> i = consumersList.iterator(); i.hasNext();) {
            cons = i.next();
            if (cons.equals(ic)) {
                i.remove();
            }
        }
    }

    public void requestTopDownLeftRightResend(ImageConsumer consumer) {
        // Do nothing
    }

    public synchronized void startProduction(ImageConsumer ic) {
        if (ic != null) {
            addConsumer(ic);
        }

        if (!loading && consumers.size() > 0) {
            ImageLoader.addImageSource(this);
            loading = true;
        }
    }

    public synchronized boolean isConsumer(ImageConsumer ic) {
        ImageDecoder d = null;

        // Check for all existing decoders
        for (Iterator<ImageDecoder> i = decoders.iterator(); i.hasNext();) {
            d = i.next();
            if (findConsumer(d.consumers, ic) != null) {
                return true;
            }
        }

        // Check current queue of consumers
        return findConsumer(consumers, ic) != null;
    }

    /**
     * Checks if the consumer is in the list and returns it it is there
     * @param consumersList - list of consumers
     * @param ic - consumer
     * @return consumer if found, null otherwise
     */
    private static ImageConsumer findConsumer(List<ImageConsumer> consumersList, ImageConsumer ic) {
        ImageConsumer res = null;

        for (Iterator<ImageConsumer> i = consumersList.iterator(); i.hasNext();) {
            res = i.next();
            if (res.equals(ic)) {
                return res;
            }
        }

        return null;
    }

    /**
     * Use this method to finish decoding or lock the list of consumers
     * for a particular decoder
     * @param d - decoder
     */
    synchronized void lockDecoder(ImageDecoder d) {
        if (d == decoder) {
            decoder = null;
            startProduction(null);
        }
    }

    /**
     * Tries to find an appropriate decoder for the input stream and adds it
     * to the list of decoders
     * @return created decoder
     */
    private ImageDecoder createDecoder() {
        InputStream is = getInputStream();

        ImageDecoder decoder;

        if (is == null) {
            decoder = null;
        } else {
            decoder = ImageDecoder.createDecoder(this, is);
        }

        if (decoder != null) {
            synchronized (this) {
                decoders.add(decoder);
                this.decoder = decoder;
                loading = false;
                consumers = new ArrayList<ImageConsumer>(5); // Reset queue
            }

            return decoder;
        }
        // We were not able to find appropriate decoder
        List<ImageConsumer> cs;
        synchronized (this) {
            cs = consumers;
            consumers = new ArrayList<ImageConsumer>(5);
            loading = false;
        }
        abortAllConsumers(cs);

        return null;
    }

    /**
     * Stop the given decoder and remove it from the list
     * @param dr - decoder
     */
    private synchronized void removeDecoder(ImageDecoder dr) {
        lockDecoder(dr);
        decoders.remove(dr);
    }

    /**
     * This method serves as an entry point.
     * It starts the decoder and loads the image data.
     */
    public void load() {
        synchronized (this) {
            if (consumers.size() == 0) {
                loading = false;
                return;
            }
        }

        ImageDecoder d = createDecoder();
        if (d != null) {
            try {
                decoder.decodeImage();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                removeDecoder(d);
                abortAllConsumers(d.consumers);
            }
        }
    }
}