package geomss.ui;

import jahuwaldt.io.ExtFilenameFilter;
import jahuwaldt.js.datareader.*;
import jahuwaldt.swing.AppUtilities;
import jahuwaldt.swing.MDIApplication;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import static java.util.Objects.isNull;
import static java.util.Objects.nonNull;
import static java.util.Objects.requireNonNull;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.measure.quantity.Dimensionless;
import javax.measure.unit.Unit;
import javax.swing.*;
import javolution.util.FastTable;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.labels.StandardXYToolTipGenerator;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
import org.jfree.chart.title.LegendTitle;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.jfree.ui.RectangleEdge;

/**
 * An application window that displays a quick plot of the data contained in a DataSet
 * made up of DataCase objects containing sets of ArrayParam objects. This allows
 * "overlay" plots of identical parameters from different "runs" or cases.
 *
 * <p> Modified by: Joseph A. Huwaldt </p>
 *
 * @author Joseph A. Huwaldt Date: October 12, 2015
 * @version January 31, 2017
 */
public class PlotXYWindow extends AbstractPlotWindow {
    private static final long serialVersionUID = 1L;

    /**
     * The panel that contains the plot region of our window. Sub-classes may use this to
     * access the ChartPanel it contains in it's CENTER and the button panel it contains
     * in it's SOUTH.
     */
    protected JPanel _centerPanel = new JPanel(new BorderLayout());

    // A reference to the all the available data.
    private DataSet _allData;

    // A reference to the particular arrays we are doing the plot of.
    private final List<ArrayParam> _plottedData = new ArrayList<>();

    //  The independent parameters for each of the plotted arrays in _plottedData.
    private final List<ArrayParam> _indepData = new ArrayList<>();

    /**
     * Creates a new instance of a data plot window using the specified list of data
     * arrays.
     *
     * @param title Title of the window.
     * @param data  A DataCase containing a single case to be plotted.
     * @throws IllegalArgumentException if the input data set can not be plotted.
     */
    public PlotXYWindow(String title, DataCase data) throws IllegalArgumentException {
        super(title, title);

        DataSet tmpSet = DataSet.newInstance(title);
        tmpSet.add(requireNonNull(data));
        initialize(tmpSet);

    }

    /**
     * Creates a new instance of a data plot window using the specified list of data
     * arrays.
     *
     * @param title Title of the window.
     * @param data  DataSet containing the cases to be plotted (all cases must have the
     *              same set of parameters).
     * @throws IllegalArgumentException if the input data set can not be plotted.
     */
    public PlotXYWindow(String title, DataSet data) throws IllegalArgumentException {
        super(title, title);

        initialize(requireNonNull(data));
    }

    /**
     * Used to initialize this plot window.
     */
    private void initialize(DataSet data) throws IllegalArgumentException {

        //  Store the initially plotted parameters from each case.
        for (DataCase aCase : data) {
            List<ArrayParam> caseArrays = aCase.getAllArrays();
            _indepData.add(caseArrays.get(0));
            _plottedData.add(caseArrays.get(1));
            FastTable.recycle((FastTable<ArrayParam>)caseArrays);
        }

        // Set up some class variables.
        _allData = data;

        //  Layout the contents of this window.
        try {
            layoutWindow();
        } catch (NoSuchMethodException ex) {
            //  Shouldn't happen after early development.
            Logger.getLogger(PlotXYWindow.class.getName()).log(Level.WARNING, "", ex);
        }
    }

    /**
     * Method that lays out the contents of this window.
     */
    private void layoutWindow() throws NoSuchMethodException {

        // Set up this window's user interface.
        Container cp = getContentPane();
        cp.add(_centerPanel);

        //  Create user interface buttons.
        JButton closeButton = new JButton(RESOURCES.getString("closeItemText"));
        this.getRootPane().setDefaultButton(closeButton);
        closeButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent evt) {
                handleClose(null);
            }
        });
        closeButton.setToolTipText(RESOURCES.getString("closeItemToolTip"));

        //  Create a button panel and add all the buttons to it.
        Box buttonPanel = Box.createHorizontalBox();
        buttonPanel.setAlignmentX(Box.LEFT_ALIGNMENT);
        buttonPanel.add(Box.createGlue());
        buttonPanel.add(closeButton);
        buttonPanel.add(Box.createHorizontalStrut(20));
        buttonPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));

        //  Add the options and buttons to the bottom of the window.
        _centerPanel.add(buttonPanel, BorderLayout.SOUTH);

        //  Create the plot panel containing the plot itself.
        ChartPanel plotPanel = createPlotPanel(_plottedData, _indepData, _allData, this);
        _centerPanel.add(plotPanel, BorderLayout.CENTER);

    }

    /**
     * Method that will build an "Export" menu containing a list of all the DataReader
     * objects that are capable of writing to files.
     *
     * @param title The title for the menu that is created.
     * @return A JMenu instance containing a list of all DataReader objects that can write
     *         to files in various formats. If there are no appropriate readers available,
     *         null is returned.
     */
    @Override
    protected JMenu buildExportMenu(String title) {

        //  Get the list of data readers that are available.
        DataReader[] allReaders = DataReaderFactory.getAllReaders();
        if (isNull(allReaders) || allReaders.length < 1)
            return null;

        //  Create the menu
        JMenu menu = new JMenu(title);

        //  Loop over all the readers.
        boolean noneFound = true;
        int numReaders = allReaders.length;
        for (int i = 0; i < numReaders; ++i) {
            DataReader reader = allReaders[i];

            if (reader.canWriteData()) {
                //  Found a "writer".
                noneFound = false;

                //  Create a menu item for it.
                JMenuItem menuItem = new JMenuItem(reader.toString() + "...");
                menuItem.addActionListener(new ExportAsMenuListener(reader));
                menuItem.setActionCommand(reader.toString());
                menuItem.setEnabled(true);

                //  Add the menu item to the menu.
                menu.add(menuItem);
            }
        }

        if (noneFound)
            menu = null;

        return menu;
    }

    /**
     * Defines an action listener for our Export menu items.
     */
    private class ExportAsMenuListener implements ActionListener {

        //  Keep a reference to the reader used by this menu.

        private final DataReader reader;

        public ExportAsMenuListener(DataReader reader) {
            this.reader = reader;
        }

        @Override
        public void actionPerformed(ActionEvent evt) {
            handleSaveAs();
        }

        /**
         * Handles saving the data using this menu item's DataReader instance.
         */
        private void handleSaveAs() {

            //  Set up the file name filter.
            String extension = reader.getExtension();
            ExtFilenameFilter filter = new ExtFilenameFilter(extension, reader.toString() + " File");

            //  Build the directory and filename to prompt the user with.
            MDIApplication app = MDIApplication.getInstance();
            String dir = app.getPreferences().getLastPath();
            String fileName = getDataName();

            //  Replace any ":" characters with "_".
            fileName = fileName.replace(':', '_');

            //  Replace any "_ " with " ".
            fileName = fileName.replaceAll("_ ", " ");

            int idx = fileName.lastIndexOf(".");
            if (idx > 0)
                fileName = fileName.substring(0, idx);
            fileName += "." + extension;

            //  Ask the user to select a file for saving.
            File chosenFile = AppUtilities.selectFile4Save(PlotXYWindow.this,
                    MessageFormat.format(RESOURCES.getString("fileSaveDialog"), reader.toString()),
                    dir, fileName, filter, extension,
                    RESOURCES.getString("fileExists"), RESOURCES.getString("warningTitle"));
            if (nonNull(chosenFile)) {
                if (chosenFile.exists() && !chosenFile.canWrite()) {
                    JOptionPane.showMessageDialog(PlotXYWindow.this,
                            RESOURCES.getString("canNotWrite2File"),
                            RESOURCES.getString("ioErrorTitle"), JOptionPane.ERROR_MESSAGE);
                    return;
                }

                //  Export the data.
                exportData(reader, chosenFile);

            }
        }

        /**
         * Method that exports the specified data to the specified file using the
         * specified writer.
         *
         * @param writer  The DataReader to use to write out the data.
         * @param outFile Reference to the file path where the file should be written.
         */
        private void exportData(DataReader writer, File outFile) {

            //  Create a List of DataSet objects as required by the writer.
            List<DataSet> list = new ArrayList<>();
            list.add(_allData);

            // Write out the plotted tables using the specified writer.
            try (OutputStream output = new FileOutputStream(outFile)) {

                writer.write(output, list);

            } catch (IOException | ArrayIndexOutOfBoundsException e) {
                outFile.delete();
                JOptionPane.showMessageDialog(PlotXYWindow.this, e.getMessage(), RESOURCES.getString("ioErrorTitle"),
                        JOptionPane.ERROR_MESSAGE);
            }
        }

    }   //  end class ExportAsMenuListener

    /**
     * Creates a panel that contains the plot of the data.
     *
     * @param plottedData List of dependent ArrayParam objects to be plotted.
     * @param indepData   List of independent ArrayParam objects for each dependent array.
     * @param allData     The DataSet containing all the available data.
     * @param target      The object that receives the action events. Must have the
     *                    following methods defined: "handlePrint(ActionEvent e)", and
     *                    "handlePageSetup(ActionEvent e)".
     */
    private ChartPanel createPlotPanel(List<ArrayParam> depData, List<ArrayParam> indepData, DataSet allData, Object target)
            throws NoSuchMethodException {

        //  Create the chart.
        JFreeChart chart = createChart(depData, indepData, allData);

        //  Create a panel to put the chart in.
        createChartPanel(chart, target);

        //  Return a reference to the newly created chart panel.
        return getChartPanel();
    }

    /**
     * Organizes the input data into series for plotting and creates an XY chart object.
     */
    private static JFreeChart createChart(List<ArrayParam> depData, List<ArrayParam> indepData, DataSet allData) {

        //  Build up a run list.
        XYSeriesCollection runList = new XYSeriesCollection();

        List<String> depNames = new ArrayList<>();
        int depPos = 0;
        int numSets = indepData.size(); //  The indepData indicates how many sets of data are plotted.
        int numArrays = depData.size() / numSets;
        for (int setNum = 0; setNum < numSets; ++setNum) {
            ArrayParam indepArray = indepData.get(setNum);
            CharSequence dataSetName = allData.get(setNum).getName();

            //  Loop over the number of variables to be plotted in each set.
            for (int i = 0; i < numArrays; ++i) {
                ArrayParam depArray = depData.get(depPos);
                String depArrayName = createParamLabel(depArray);
                if (!depNames.contains(depArrayName)) {
                    depNames.add(depArrayName);
                }
                runList.addSeries(createRun(indepArray, depArray, dataSetName));
                ++depPos;
            }
        }

        //  Range axis label
        String yAxisLabel;
        if (depNames.size() < 2)
            //  There is only a single dependent parameter plotted for, potentially, multiple data sets.
            yAxisLabel = createParamLabel(depData.get(0));

        else {
            //  There are, potentially, multiple parameters plotted for a single data set.

            //  Build up a label made up of the names of all the plotted paramters.
            StringBuilder buffer = new StringBuilder();
            int size = depNames.size();
            for (int i = 0; i < size; ++i) {
                buffer.append(depNames.get(i));
                if (i != size - 1)
                    buffer.append(", ");
            }
            yAxisLabel = buffer.toString();
        }

        //  Domain axis label.
        String xAxisLabel = createParamLabel(indepData.get(0));

        //  Create the chart.
        JFreeChart chart = ChartFactory.createXYLineChart(
                null, //  No Title
                xAxisLabel, //  Domain axis label
                yAxisLabel, //  Range axis label
                runList, //  Data to be plotted
                PlotOrientation.VERTICAL, //  Vertical orientation
                true, //  Include legend
                true, //  Include tooltips
                false);                     //  Do not include URLs

        //  Adjust the legend position and hide it by default.
        LegendTitle legend = chart.getLegend();
        legend.setPosition(RectangleEdge.RIGHT);
        legend.setVisible(false);
        
        // Set the background color for the chart...
        chart.setBackgroundPaint(Color.WHITE);

        //  Get a reference to the plot.
        XYPlot plot = chart.getXYPlot();

        //  Create a renderer that shows lines, shows plot symbols, and has tool-tip values shown.
        XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(true, true);
        renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());

        //  Make the plot use the new renderer.
        plot.setRenderer(renderer);

        return chart;
    }

    /**
     * Creates a single series or run for plotting from the specified dependent &
     * independent arrays.
     */
    private static XYSeries createRun(ArrayParam indep, ArrayParam dependent, CharSequence runName) {

        XYSeries run = new XYSeries(runName.toString(), false);
        int length = indep.size();
        for (int i = 0; i < length; ++i) {
            double indValue = indep.getValue(i);
            double depValue = dependent.getValue(i);
            run.add(indValue, depValue);
        }

        return run;
    }

    /**
     * Method that creates a string representation of a parameter in the following format:
     * "[refData], name, [units]". If the reference data is null, it is not included. If
     * the units are Dimensionless, they are not included.
     */
    private static String createParamLabel(UnitParameter param) {
        StringBuilder buffer = new StringBuilder();

        Object refData = param.getUserObject();
        if (refData != null) {
            buffer.append(refData);
            buffer.append(", ");
        }
        buffer.append(param.getName());
        Unit unit = param.getUnit();
        if (!Dimensionless.UNIT.equals(unit)) {
            buffer.append(" (");
            buffer.append(unit);
            buffer.append(")");
        }

        return buffer.toString();
    }

    /**
     * Return a reference to the data set plotted in this window.
     * 
     * @return The data set that is plotted in this window.
     */
    public DataSet getDataSet() {
        return _allData;
    }
    
    /**
     * Returns the chart contained in this window.
     *
     * @return The chart contained in this window.
     */
    public JFreeChart getChart() {
        return getChartPanel().getChart();
    }

    /**
     * Return the XYPlot contained in this window.
     * 
     * @return The XYPlot contained in this window.
     */
    public XYPlot getXYPlot() {
        return getChart().getXYPlot();
    }
    
    /**
     * Return the line and shape rendered for the plot in this window.
     * 
     * @return The line and shape rendered for the plot in this window.
     */
    public XYLineAndShapeRenderer getLineAndShapeRenderer() {
        XYPlot plot = getXYPlot();
        XYLineAndShapeRenderer renderer = (XYLineAndShapeRenderer)plot.getRenderer();
        return renderer;
    }
    
    /**
     * Return the domain axis for the plot in this window.
     * 
     * @return The domain axis for the plot in this window.
     */
    public NumberAxis getDomainAxis() {
        XYPlot plot = getXYPlot();
        NumberAxis axis = (NumberAxis)plot.getDomainAxis();
        return axis;
    }
    
    /**
     * Return the range axis for the plot in this window.
     * 
     * @return The range axis for the plot in this window.
     */
    public NumberAxis getRangeAxis() {
        XYPlot plot = getXYPlot();
        NumberAxis axis = (NumberAxis)plot.getRangeAxis();
        return axis;
    }
    
    /**
     * Method that toggles the display of plot symbols/shapes for each data point plotted.
     *
     * @param visible Pass true to show plot symbols/shapes and false to hide them.
     */
    public void setShapesVisible(boolean visible) {
        XYLineAndShapeRenderer renderer = getLineAndShapeRenderer();
        renderer.setBaseShapesVisible(visible);
    }

    /**
     * Method that toggles the display of plot symbols/shapes for each data point plotted
     * in the given series.
     *
     * @param series  The series/case/run index (zero-based) to set the shape visibility
     *                for.
     * @param visible Pass true to show plot symbols/shapes and false to hide them.
     */
    public void setShapesVisible(int series, boolean visible) {
        XYLineAndShapeRenderer renderer = getLineAndShapeRenderer();
        renderer.setSeriesShapesVisible(series, visible);
    }

    /**
     * Method that toggles the display of lines between the data points being plotted.
     *
     * @param visible Pass true to show lines and false to hide them.
     */
    public void setLinesVisible(boolean visible) {
        XYLineAndShapeRenderer renderer = getLineAndShapeRenderer();
        renderer.setBaseLinesVisible(visible);
    }

    /**
     * Method that toggles the display of lines between the data points being plotted in
     * a given series.
     *
     * @param series  The series/case/run index (zero-based) to set the line visibility
     *                for.
     * @param visible Pass true to show lines and false to hide them.
     */
    public void setLinesVisible(int series, boolean visible) {
        XYLineAndShapeRenderer renderer = getLineAndShapeRenderer();
        renderer.setSeriesLinesVisible(series, visible);
    }

    /**
     * Set the series Paint for a specified series.
     * 
     * @param series  The series/case/run index (zero-based) to set the Paint for.
     * @param paint   The paint to set for the given series.
     */
    public void setSeriesPaint(int series, Paint paint) {
        XYLineAndShapeRenderer renderer = getLineAndShapeRenderer();
        renderer.setSeriesPaint(series, requireNonNull(paint));
    }
    
    /**
     * Set the base stroke for the chart.
     * 
     * @param stroke  The stroke to set as the base stroke.
     */
    public void setStroke(Stroke stroke) {
        XYLineAndShapeRenderer renderer = getLineAndShapeRenderer();
        renderer.setBaseStroke(requireNonNull(stroke));
    }
    
    /**
     * Set the series stroke for a specified series.
     * 
     * @param series  The series/case/run index (zero-based) to set the stroke for.
     * @param stroke  The stroke to set for the given series.
     */
    public void setStroke(int series, Stroke stroke) {
        XYLineAndShapeRenderer renderer = getLineAndShapeRenderer();
        renderer.setSeriesStroke(series, requireNonNull(stroke));
    }
    
    /**
     * Method that toggles the display of the plot legend.
     * 
     * @param visible Pass true to show the legend and false to hid it.
     */
    public void setLegendVisible(boolean visible) {
        getChart().getLegend().setVisible(visible);
    }
    
    /**
     * Sets the chart title. If there is an existing title, its text is updated, otherwise
     * a new title using the default font is added to the chart.
     *
     * @param title The title text (null is permitted and will hide the chart title).
     */
    public void setChartTitle(String title) {
        getChart().setTitle(requireNonNull(title));
    }
    
    /**
     * Return the domain or X-axis label for this chart.
     * @return The domain or X-axis label for this chart.
     */
    public String getDomainAxisLabel() {
        NumberAxis axis = getDomainAxis();
        return axis.getLabel();
    }
    
    /**
     * Sets the domain or X-axis label.
     * @param label The new label for the domain axis.
     */
    public void setDomainAxisLabel(String label) {
        NumberAxis axis = getDomainAxis();
        axis.setLabel(requireNonNull(label));
    }

    /**
     * Return the range or Y-axis label for this chart.
     * @return The range or Y-axis label for this chart.
     */
    public String getRangeAxisLabel() {
        NumberAxis axis = getRangeAxis();
        return axis.getLabel();
    }
    
    /**
     * Sets the range or Y-axis label.
     * @param label The new label for the range axis.
     */
    public void setRangeAxisLabel(String label) {
        NumberAxis axis = getRangeAxis();
        axis.setLabel(requireNonNull(label));
    }
    
    /**
     * Sets the domain axis range to the given values and sets the auto-range flag to
     * false.
     * 
     * @param lower the lower axis limit.
     * @param upper the upper axis limit.
     */
    public void setDomainAxisRange(double lower, double upper) {
        NumberAxis axis = getDomainAxis();
        axis.setRange(lower, upper);
    }

    /**
     * Sets the range axis range to the given values and sets the auto-range flag to
     * false.
     * 
     * @param lower the lower axis limit.
     * @param upper the upper axis limit.
     */
    public void setRangeAxisRange(double lower, double upper) {
        NumberAxis axis = getRangeAxis();
        axis.setRange(lower, upper);
    }
    
    /**
     * Sets the labels used to display all the legend items to the supplied String values.
     *
     * @param labels The list of String values to set the legend labels to. This list must
     *               not be larger than the number of plotted data series.
     */
    public void setLegendLabels(String... labels) {
        int numLabels = labels.length;
        XYPlot plot = getXYPlot();
        XYSeriesCollection runList = (XYSeriesCollection)plot.getDataset();
        if (numLabels > runList.getSeriesCount())
            throw new IllegalArgumentException(RESOURCES.getString("toManyLabels"));
        
        for (int i=0; i < numLabels; ++i) {
            XYSeries run = runList.getSeries(i);
            run.setKey(labels[i]);
        }
    }

    /**
     * Sets the labels used to display all the legend items to the supplied String values.
     *
     * @param index  The index of the plotted data series to change the label for.
     * @param label  The new label to apply to the specified data series.
     */
    public void setLegendLabel(int index, String label) {
        XYPlot plot = getXYPlot();
        XYSeriesCollection runList = (XYSeriesCollection)plot.getDataset();
        runList.getSeries(index).setKey(requireNonNull(label));
    }
}