package jfreechart_demo;

import org.jfree.data.category.*;
import org.jfree.data.general.*;
import org.jfree.data.gantt.*;
import org.jfree.data.time.*;
import org.jfree.data.xy.*;
import org.jfree.data.statistics.*;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class DatasetCreator
{
    public DatasetCreator()
    {
    }

    public static final String cars = "Cars";
    public static final String trucks = "Trucks";
    public static final String buses = "Buses";

    public static final String newCarSales = "New car sales";
    public static final String usedCarSales = "Used car sales";
    public static final String leasing = "Leasing";
    public static final String service = "Service";
    public static final String others = "Others";

    public static DefaultCategoryDataset createDefaultCategoryDataset()
    {
        return createDefaultCategoryDataset(-1, -1);
    }

    public static DefaultCategoryDataset createDefaultCategoryDataset(int start, int end)
    {
        if (start == -1 && end == -1)
        {
            start = 0;
            end = 3;
        }
        if (start < 0)
            throw new IllegalArgumentException();

        DefaultCategoryDataset dataset = new DefaultCategoryDataset();

        for (int i = start; i < end; i++)
        {
            switch (i)
            {
                case 0:
                    dataset.addValue(50000, cars, newCarSales);
                    dataset.addValue(25000, cars, usedCarSales);
                    dataset.addValue(30000, cars, leasing);
                    dataset.addValue(40000, cars, service);
                    dataset.addValue(5000, cars, others);
                    break;
                case 1:
                    dataset.addValue(20000, trucks, newCarSales);
                    dataset.addValue(30000, trucks, usedCarSales);
                    dataset.addValue(15000, trucks, leasing);
                    dataset.addValue(25000, trucks, service);
                    dataset.addValue(10000, trucks, others);
                    break;
                case 2:
                    dataset.addValue(10000, buses, newCarSales);
                    dataset.addValue(1000, buses, usedCarSales);
                    dataset.addValue(20000, buses, leasing);
                    dataset.addValue(25000, buses, service);
                    dataset.addValue(2000, buses, others);
                    break;
                default:
                    String key = Integer.toString(i);
                    dataset.addValue(10000.0 * (Math.sin(0.3 * i) + 1), key, newCarSales);
                    dataset.addValue(10000.0 * (Math.sin(0.7 * i) + 1), key, usedCarSales);
                    dataset.addValue(10000.0 * (Math.sin(0.9 * i) + 1), key, leasing);
                    dataset.addValue(10000.0 * (Math.sin(1.2 * i) + 1), key, service);
                    dataset.addValue(10000.0 * (Math.sin(1.9 * i) + 1), key, others);
                    break;
            }
        }
        return dataset;
    }

    public static PieDataset createPieDataset()
    {
        PieDataset dataset = DatasetUtilities.createPieDatasetForRow(createDefaultCategoryDataset(), "Cars");
        return dataset;
    }

    public static DefaultHighLowDataset createDefaultHighLowDataset(int size)
    {
        Date[] date = new Date[size];
        double[] high = new double[size];
        double[] low = new double[size];
        double[] open = new double[size];
        double[] close = new double[size];
        double[] volume = new double[size];

        for (int i = 0; i < size; i++)
        {
            date[i] = date(2006, 1, i + 1);
            double base = 1000 + (Math.sin(0.1 * i) + 1) * 2000;
            double udiff = (0.1 + (Math.sin(11.0 * i) + 1)) * 500;
            double bdiff = ((Math.sin(29.0 * i) + 1)) * 500;
            double diff = udiff - bdiff;
            high[i] = base + udiff;
            low[i] = base + bdiff;
            open[i] = low[i] + ((Math.sin(103 * i) + 1) / 2) * diff;
            close[i] = low[i] + ((Math.sin(137 * i) + 1) / 2) * diff;
            volume[i] = 10000 + (Math.sin(0.1 * i) + Math.sin(7 * i) + 2) * 7000;
        }

        return new DefaultHighLowDataset("foo Inc.", date, high, low, open, close, volume);
    }

    private static Date date(int year, int month, int day)
    {
        Calendar calendar = Calendar.getInstance();
        calendar.set(year, month, day);
        return calendar.getTime();
    }

    public static IntervalCategoryDataset createTaskSeriesCollection()
    {
        String Task1 = "Task 1";
        String Task2 = "Task 2";
        String Task3 = "Task 3";
        String Task4 = "Task 4";
        TaskSeriesCollection collection = new TaskSeriesCollection();
        {
            TaskSeries s = new TaskSeries("Scheduled");
            s.add(new Task(Task1, new SimpleTimePeriod(date(2006, 3, 1), date(2006, 3, 15))));
            s.add(new Task(Task2, new Day(date(2006, 3, 20))));
            s.add(new Task(Task3, date(2006, 3, 25), date(2006, 4, 10)));
            s.add(new Task(Task4, date(2006, 4, 13), date(2006, 4, 15)));
            collection.add(s);
        }
        {
            TaskSeries s = new TaskSeries("Actual");
            s.add(new Task(Task1, new SimpleTimePeriod(date(2006, 3, 1), date(2006, 3, 20))));
            s.add(new Task(Task2, new Day(date(2006, 4, 7))));
            s.add(new Task(Task3, date(2006, 4, 10), date(2006, 4, 20)));
            s.add(new Task(Task4, date(2006, 4, 21), date(2006, 4, 23)));
            collection.add(s);
        }

        return collection;
    }

    public static BoxAndWhiskerCategoryDataset createBoxAndWhiskerCategoryDataset(int rowCount, int columnCount)
    {
        final int entityCount = 10;

        DefaultBoxAndWhiskerCategoryDataset dataset = new DefaultBoxAndWhiskerCategoryDataset();
        for (int rowIndex = 0; rowIndex < rowCount; rowIndex++)
        {
            for (int columnIndex = 0; columnIndex < columnCount; columnIndex++)
            {
                final List list = new ArrayList();
                for (int entityIndex = 0; entityIndex < entityCount; entityIndex++)
                {
                    double v = 100.0 
                        + ((rowIndex + columnIndex * 11 + entityIndex * 13) % 7) * 10
                        + Math.sin(rowIndex * 0.1 + columnIndex * 0.3 + entityIndex * 0.5) * 50.0;
                    list.add(new Double(v));
                }
                dataset.add(list, "Row " + Integer.toString(rowIndex), "Column " + Integer.toString(columnIndex));
            }
        }

        return dataset;
    }

    public static XYZDataset createXYZDataset()
    {
        return new SampleXYZDataset();
    }

    public static XYZDataset createXYZDataset(int seriesCount, int itemCount)
    {
        return new SampleXYZDataset(seriesCount, itemCount);
    }

    private static class SampleXYZDataset extends AbstractXYZDataset implements XYZDataset
    {
        private int seriesCount;
        private int itemCount;

        public SampleXYZDataset()
        {
            this(3, 10);
        }

        public SampleXYZDataset(int seriesCount, int itemCount)
        {
            this.seriesCount = seriesCount;
            this.itemCount = itemCount;
        }

        public int getSeriesCount()
        {
            return seriesCount;
        }

        public String getSeriesName(int series)
        {
            return "Series " + Integer.toString(series);
        }

        public int getItemCount(int series)
        {
            return itemCount;
        }

        public double getXValue(int series, int item)
        {
            item++;
            return 4 * ((double)(item - itemCount / 2) / itemCount) + Math.sin(series + item);
        }

        public double getYValue(int series, int item)
        {
            item++;
            return 20 * ((double)item / itemCount) + Math.sin(series * 2 + item * 3);
        }

        public double getZValue(int series, int item)
        {
            item++;
            return Math.sin(series * 5 + item * 7);
        }

        public Comparable getSeriesKey(int series)
        {
            return "Series " + Integer.toString(series);
        }

        public Number getX(int series, int item)
        {
            return new Double(getXValue(series, item));
        }

        public Number getY(int series, int item)
        {
            return new Double(getYValue(series, item));
        }

        public Number getZ(int series, int item)
        {
            return new Double(getZValue(series, item));
        }
    }
}