/* Glazed Lists                                                 (c) 2003-2006 */
/* http://publicobject.com/glazedlists/                      publicobject.com,*/
/*                                                     O'Dell Engineering Ltd.*/
package ca.odell.glazedlists.jfreechart;

import ca.odell.glazedlists.EventList;
import ca.odell.glazedlists.FunctionList;
import ca.odell.glazedlists.GroupingList;
import ca.odell.glazedlists.event.ListEvent;
import ca.odell.glazedlists.event.ListEventListener;
import org.jfree.data.general.AbstractDataset;
import org.jfree.data.general.DatasetChangeEvent;
import org.jfree.data.general.PieDataset;

import java.util.Comparator;
import java.util.List;

/**
 * This class adapts an {@link EventList} to the JFreeChart PieDataset
 * interface. Changes to the backing {@link EventList} are rebroadcast as
 * changes to this PieDataset.
 *
 * <p><table border="1" width="100%" cellpadding="3" cellspacing="0">
 * <tr class="TableHeadingColor"><td colspan="2"><font size="+2"><b>Extension: JFreeChart</b></font></td></tr>
 * <tr><td  colspan="2">This Glazed Lists <i>extension</i> requires the third party library <b>JFreeChart</b>.</td></tr>
 * <tr><td class="TableSubHeadingColor"><b>Tested Version:</b></td><td>1.0.0</td></tr>
 * <tr><td class="TableSubHeadingColor"><b>Home page:</b></td><td><a href="http://www.jfree.org/jfreechart/">http://www.jfree.org/jfreechart/</a></td></tr>
 * <tr><td class="TableSubHeadingColor"><b>License:</b></td><td><a href="http://www.jfree.org/lgpl.php">LGPL</a></td></tr>
 * </td></tr>
 * </table>
 *
 * <p> Note: The DataEvents broadcasted by this class occur on the Thread the
 * ListEvents arrive on. If this PieDataset is attached to a swing component,
 * like a {@link org.jfree.chart.ChartPanel}, it is the responsibility of the
 * client to ensure that the ListEvents are arriving on the Swing Event
 * Dispatch Thread, perhaps by using the
 * {@link ca.odell.glazedlists.impl.swing.SwingThreadProxyEventList}.
 *
 * @see ca.odell.glazedlists.impl.swing.SwingThreadProxyEventList
 *
 * @author James Lemieux
 */
public class EventListPieDataset<E,K> extends AbstractDataset implements PieDataset {

    /** The single immutable DatasetChangeEvent we fire each time this Dataset is changed. */
    private final DatasetChangeEvent immutableChangeEvent = new DatasetChangeEvent(this, this);

    // the list that is the source of all data
    private final EventList sourceList;

    // the list that groups the data into sections of the pie
    private final GroupingList groupingList;

    // a function that extracts keys from the groups
    private final FunctionList<List, Comparable> keyList;

    // a function that extracts values from the groups
    private final FunctionList<List, Number> valueList;

    // listen to changes in the {@link sourceList} and rebroadcast them as changes to this PieDataset
    private final ListEventListener datasetEventListener = new DatasetEventListener();

    /**
     * Adapts the given <code>source</code> to the PieDataset interface. The
     * given <code>keyFunction</code> is then applied to each element of the
     * <code>source</code> to produce the unique key for the element and the
     * given <code>valueFunction</code> is applied to produce the value for an
     * element.
     *
     * <p>This constructor should be used when the elements in
     * <code>source</code> do not need to be grouped together in order to
     * represent pie data.
     *
     * @param source the {@link EventList} containing the data to chart
     * @param keyFunction produces the keys of the source elements in the pie chart
     * @param valueFunction produces the values of the source elements in the pie chart
     */
    public EventListPieDataset(EventList<E> source, FunctionList.Function<E, Comparable<K>> keyFunction, FunctionList.Function<E, Number> valueFunction) {
        this.groupingList = null;
        this.sourceList = source;
        this.keyList = new FunctionList(source, keyFunction);
        this.valueList = new FunctionList(source, valueFunction);

        source.addListEventListener(this.datasetEventListener);
    }

    /**
     * Adapts the given <code>source</code> to the PieDataset interface by
     * applying the <code>groupingComparator</code> to forms groups to be
     * represented in the pie chart. The given <code>keyFunction</code> is then
     * applied to produce the key for a group and the given
     * <code>valueFunction</code> is applied to produce the value for a group.
     *
     * @param source the {@link EventList} containing the data to chart
     * @param groupingComparator produces the groups in the pie chart
     * @param keyFunction produces the keys of the groups in the pie chart
     * @param valueFunction produces the values of the groups in the pie chart
     */
    public EventListPieDataset(EventList<E> source, Comparator<E> groupingComparator, FunctionList.Function<List<E>, Comparable<K>> keyFunction, FunctionList.Function<List<E>, Number> valueFunction) {
        this.groupingList = new GroupingList(source, groupingComparator);
        this.sourceList = this.groupingList;
        this.keyList = new FunctionList(this.groupingList, keyFunction);
        this.valueList = new FunctionList(this.groupingList, valueFunction);

        this.groupingList.addListEventListener(this.datasetEventListener);
    }

    /**
     * Returns the key of the value at the given <code>index</code>.
     *
     * @param index the item index (zero-based)
     * @return the key
     *
     * @throws IndexOutOfBoundsException if <code>index</code> is out of bounds
     */
    public Comparable getKey(int index) {
        return this.keyList.get(index);
    }

    /**
     * Returns the index for a given key.
     *
     * @param key the key
     * @return the index, or <code>-1</code> if the key is unrecognised
     */
    public int getIndex(Comparable key) {
        return this.keyList.indexOf(key);
    }

    /**
     * Returns the keys for the values in this PieDataset. Note that you can
     * access the values in this PieDataset by key or by index. For this
     * reason, the key order is important - this method should return the keys
     * in order.  The returned list may be unmodifiable.
     *
     * @return the keys (never <code>null</code>).
     */
    public List getKeys() {
        return this.keyList;
    }

    /**
     * Returns the value for a given key.
     *
     * @param key the key
     * @return the value (possibly <code>null</code>)
     *
     * @throws org.jfree.data.UnknownKeyException if the key is not recognised
     */
    public Number getValue(Comparable key) {
        return getValue(this.getIndex(key));
    }

    /**
     * Returns the number of items (values).
     */
    public int getItemCount() {
        return this.keyList.size();
    }

    /**
     * Returns the value at the given <code>index</code>.
     *
     * @param index the index of interest (zero-based index).
     * @return the value
     */
    public Number getValue(int index) {
        return this.valueList.get(index);
    }

    /**
     * Releases the resources consumed by this EventListPieDataset so that it
     * may eventually be garbage collected. This is important when the
     * {@link EventList} that backs this EventListPieDataset should outlast
     * this EventListPieDataset. This method should be called as soon as this
     * EventListPieDataset is no longer useful.
     *
     * <p><strong><font color="#FF0000">Warning:</font></strong> It is an error
     * to call any method on an EventListPieDataset after it has been disposed.
     */
    public void dispose() {
        this.keyList.dispose();
        this.valueList.dispose();
        this.sourceList.removeListEventListener(this.datasetEventListener);

        if (this.groupingList != null)
            this.groupingList.dispose();
    }

    /**
     * We override this method for speed reasons, since the super needlessly
     * constructs a new DatasetChangedEvent each time this method is called.
     */
    @Override
    protected void fireDatasetChanged() {
        notifyListeners(immutableChangeEvent);
    }

    /**
     * This listener rebroadcasts ListEvents as DatasetChangeEvents.
     */
    private class DatasetEventListener implements ListEventListener {
        public void listChanged(ListEvent listChanges) {
            fireDatasetChanged();
        }
    }
}