/* ================================================================

 * Cewolf : Chart enabling Web Objects Framework

 * ================================================================

 *

 * Project Info:  http://cewolf.sourceforge.net

 * Project Lead:  Guido Laures (guido@laures.de);

 *

 * (C) Copyright 2002, by Guido Laures

 *

 * This library is free software; you can redistribute it and/or modify it under the terms

 * of the GNU Lesser General Public License as published by the Free Software Foundation;

 * either version 2.1 of

 * the License, or (at your option) any later version.

 *

 * This library 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 Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License along with this

 * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,

 * Boston, MA 02111-1307, USA.

 */

package de.laures.cewolf.taglib;

import java.awt.Image;

import java.awt.Paint;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.jfree.chart.JFreeChart;

import org.jfree.chart.title.LegendTitle;

import org.jfree.ui.RectangleEdge;

import de.laures.cewolf.ChartHolder;

import de.laures.cewolf.ChartPostProcessor;

import de.laures.cewolf.ChartValidationException;

import de.laures.cewolf.DatasetProduceException;

import de.laures.cewolf.PostProcessingException;

import de.laures.cewolf.event.ChartImageRenderListener;

import de.laures.cewolf.util.ImageHelper;

import de.laures.cewolf.util.RenderedImage;

/**

 * Serializable implementaton of a ChartDefinition.

 * @author glaures

 * @see de.laures.cewolf.ChartHolder

 */

public abstract class AbstractChartDefinition implements ChartHolder, Serializable, TaglibConstants, ChartImageRenderListener {

    protected static Log log = LogFactory.getLog(AbstractChartDefinition.class);

    protected String title;

	protected String xAxisLabel;

	protected String yAxisLabel;

	protected String type;

    private boolean antialias = true;

    private String background;

    private float backgroundImageAlpha = 1.0f;

    private Paint paint;

    private int legendAnchor = ANCHOR_SOUTH;

    private boolean showLegend = true;

    private transient List postProcessors = new ArrayList();

    private List postProcessorsParams = new ArrayList();

    private transient JFreeChart chart;

	protected abstract JFreeChart produceChart() throws DatasetProduceException, ChartValidationException;

    //gets first legend in the list

    public LegendTitle getLegend()

    {

      //i need to find the legend now.

      LegendTitle legend = null;

      List subTitles = chart.getSubtitles();

      Iterator iter = subTitles.iterator();

      while (iter.hasNext())

      {

        Object o = iter.next();

        if (o instanceof LegendTitle)

        {

          legend = (LegendTitle) o;

          break;

        }

      }

      return legend;

    }

    //removes first legend in the list

    public void removeLegend()

    {

      List subTitles = chart.getSubtitles();

      Iterator iter = subTitles.iterator();

      while (iter.hasNext())

      {

        Object o = iter.next();

        if (o instanceof LegendTitle)

        {

          iter.remove();

          break;

        }

      }

    }

    /**

     * This method triggers the dataset and chart production. It is only

     * from outside if there is no cached image available in the the

     * image cache.

     */

    public Object getChart() throws DatasetProduceException, ChartValidationException, PostProcessingException {

        if (chart == null) {

            chart = produceChart();

            chart.setAntiAlias(antialias);

            if (background != null) {

                Image image = ImageHelper.loadImage(background);

                chart.setBackgroundImage(image);

                chart.setBackgroundImageAlpha(backgroundImageAlpha);

            }

            if (paint != null) {

                chart.setBackgroundPaint(paint);

            }

            if (showLegend) 

            {

                LegendTitle legend = this.getLegend();

                switch (legendAnchor) 

                {

                    case ANCHOR_NORTH :

                        legend.setPosition(RectangleEdge.TOP);

                        break;

                    case ANCHOR_WEST :

                      legend.setPosition(RectangleEdge.RIGHT);

                        break;

                    case ANCHOR_EAST :

                      legend.setPosition(RectangleEdge.LEFT);

                        break;

                    default :

                      legend.setPosition(RectangleEdge.BOTTOM);

                }

            } 

            else 

            {

              this.removeLegend();

            }

            // postProcessing

            for (int i = 0; i < postProcessors.size(); i++) {

                ChartPostProcessor pp = (ChartPostProcessor)postProcessors.get(i);

                try {

                    pp.processChart(chart, (Map)postProcessorsParams.get(i));

                } catch (Throwable t) {

                	log.error(t);

                    throw new PostProcessingException(t.getClass().getName() + " raised by post processor '" +

                    		pp + "'.\nPost processing of this post processor " + "has been ignored.");

                }

            }

        }

        return chart;

    }

    /**

     * Sets the antialias.

     * @param antialias The antialias to set

     */

    public void setAntialias(boolean antialias) {

        this.antialias = antialias;

    }

    /**

     * Sets the background.

     * @param background The background to set

     */

    public void setBackground(String background) {

        this.background = background;

    }

    /**

     * Sets the backgroundImageAlpha.

     * @param backgroundImageAlpha The backgroundImageAlpha to set

     */

    public void setBackgroundImageAlpha(float backgroundImageAlpha) {

        this.backgroundImageAlpha = backgroundImageAlpha;

    }

    /**

     * Sets the legendAnchor.

     * @param legendAnchor The legendAnchor to set

     */

    public void setLegendAnchor(int legendAnchor) {

        this.legendAnchor = legendAnchor;

    }

    /**

     * Sets the paint.

     * @param paint The paint to set

     */

    public void setPaint(Paint paint) {

        this.paint = paint;

    }

    /**

     * Sets the showLegend.

     * @param showLegend The showLegend to set

     */

    public void setShowLegend(boolean showLegend) {

        this.showLegend = showLegend;

    }

    /**

     * Sets the title.

     * @param title The title to set

     */

    public void setTitle(String title) {

        this.title = title;

    }

    /**

     * Sets the type.

     * @param type The type to set

     */

    public void setType(String type) {

        this.type = type;

    }

    /**

     * Sets the xAxisLabel.

     * @param xAxisLabel The xAxisLabel to set

     */

    public void setXAxisLabel(String xAxisLabel) {

        this.xAxisLabel = xAxisLabel;

    }

    /**

     * Sets the yAxisLabel.

     * @param yAxisLabel The yAxisLabel to set

     */

    public void setYAxisLabel(String yAxisLabel) {

        this.yAxisLabel = yAxisLabel;

    }

    public void addPostProcessor(ChartPostProcessor pp) {

        postProcessors.add(pp);

    }

    public void addPostProcessorParams(Map params) {

        postProcessorsParams.add(params);

    }

	/**

	 * Callback right after a new image gets rendered.

	 * Implemented, so if postprocessors implement the ImageRenderListener interface

	 * then they will be called back also

	 * 

	 * @param renderedImage The fresh image just got rendered

	 */

	public void onImageRendered (RenderedImage renderedImage) {

		// if the postprocessor implements ImageRenderListener interface call it!

        for (int i = 0; i < postProcessors.size(); i++) {

            ChartPostProcessor pp = (ChartPostProcessor)postProcessors.get(i);

            if (pp instanceof ChartImageRenderListener) {

            	((ChartImageRenderListener) pp).onImageRendered(renderedImage);

            }

        }		

	}

}