package org.opentrafficsim.swing.graphs;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.LinkedHashMap;
import java.util.Map;

import javax.swing.ButtonGroup;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JMenu;
import javax.swing.JPopupMenu;
import javax.swing.JRadioButtonMenuItem;

import org.opentrafficsim.draw.graphs.AbstractContourPlot;
import org.opentrafficsim.draw.graphs.AbstractSpaceTimePlot;
import org.opentrafficsim.draw.graphs.ContourDataSource.Dimension;

/**
 * Embed a ContourPlot in a Swing JPanel.
 * <P>
 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
 * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
 * @author <a href="http://www.transport.citg.tudelft.nl">Wouter Schakel</a>
 */
public class SwingContourPlot extends SwingSpaceTimePlot
{

    /**  */
    private static final long serialVersionUID = 20190823L;

    /** Map to set time granularity. */
    private Map<JRadioButtonMenuItem, Double> timeGranularityButtons;

    /** Map to set space granularity. */
    private Map<JRadioButtonMenuItem, Double> spaceGranularityButtons;

    /** Check box for smoothing. */
    private JCheckBoxMenuItem smoothCheckBox;

    /** Check box for interpolation. */
    private JCheckBoxMenuItem interpolateCheckBox;

    /**
     * Create a new SwingContourPlot with embedded plot.
     * @param plot AbstractSpaceTimePlot; the plot to embed
     */
    public SwingContourPlot(final AbstractSpaceTimePlot plot)
    {
        super(plot);
    }

    /** {@inheritDoc} */
    @Override
    protected void addPopUpMenuItems(final JPopupMenu popupMenu)
    {
        timeGranularityButtons = new LinkedHashMap<>();
        spaceGranularityButtons = new LinkedHashMap<>();
        super.addPopUpMenuItems(popupMenu);
        JMenu spaceGranularityMenu = buildMenu("Distance granularity", "%.0f m", 1000, "%.0f km", "setSpaceGranularity",
                getPlot().getDataPool().getGranularities(Dimension.DISTANCE),
                getPlot().getDataPool().getGranularity(Dimension.DISTANCE), this.spaceGranularityButtons);
        popupMenu.insert(spaceGranularityMenu, 0);
        JMenu timeGranularityMenu = buildMenu("Time granularity", "%.0f s", 60.0, "%.0f min", "setTimeGranularity",
                getPlot().getDataPool().getGranularities(Dimension.TIME),
                getPlot().getDataPool().getGranularity(Dimension.TIME), this.timeGranularityButtons);
        popupMenu.insert(timeGranularityMenu, 1);
        this.smoothCheckBox = new JCheckBoxMenuItem("Adaptive smoothing method", false);
        this.smoothCheckBox.addActionListener(new ActionListener()
        {
            /** {@inheritDoc} */
            @Override
            public void actionPerformed(final ActionEvent e)
            {
                getPlot().getDataPool().setSmooth(((JCheckBoxMenuItem) e.getSource()).isSelected());
                getPlot().notifyPlotChange();
            }
        });
        popupMenu.insert(this.smoothCheckBox, 2);
        this.interpolateCheckBox = new JCheckBoxMenuItem("Bilinear interpolation", true);
        this.interpolateCheckBox.addActionListener(new ActionListener()
        {
            /** {@inheritDoc} */
            @Override
            public void actionPerformed(final ActionEvent e)
            {
                boolean interpolate = ((JCheckBoxMenuItem) e.getSource()).isSelected();
                getPlot().getBlockRenderer().setInterpolate(interpolate);
                getPlot().getDataPool().setInterpolate(interpolate);
                getPlot().notifyPlotChange();
            }
        });
        popupMenu.insert(this.interpolateCheckBox, 3);
    }

    /**
     * Create a JMenu to let the user set the granularity.
     * @param menuName String; caption for the new JMenu
     * @param format1 String; format string for the values in the items under the new JMenu, below formatValue
     * @param formatValue double; format value
     * @param format2 String; format string for the values in the items under the new JMenu, above and equal to formatValue
     * @param command String; prefix for the actionCommand of the items under the new JMenu
     * @param values double[]; array of values to be formatted using the format strings to yield the items under the new JMenu
     * @param initialValue double; the currently selected value (used to put the bullet on the correct item)
     * @param granularityButtons Map&lt;JRadioButtonMenuItem, Double&gt;; map in to which buttons should be added
     * @return JMenu with JRadioMenuItems for the values and a bullet on the currentValue item
     */
    private JMenu buildMenu(final String menuName, final String format1, final double formatValue, final String format2,
            final String command, final double[] values, final double initialValue,
            final Map<JRadioButtonMenuItem, Double> granularityButtons)
    {
        JMenu result = new JMenu(menuName);
        ButtonGroup group = new ButtonGroup();
        for (double value : values)
        {
            JRadioButtonMenuItem item = new JRadioButtonMenuItem(
                    String.format(value < formatValue ? format1 : format2, value < formatValue ? value : value / formatValue));
            granularityButtons.put(item, value);
            item.setSelected(value == initialValue);
            item.setActionCommand(command);
            item.addActionListener(new ActionListener()
            {
                /** {@inheritDoc} */
                @Override
                public void actionPerformed(final ActionEvent actionEvent)
                {
                    if (command.equalsIgnoreCase("setSpaceGranularity"))
                    {
                        double granularity = spaceGranularityButtons.get(actionEvent.getSource());
                        getPlot().getDataPool().setGranularity(Dimension.DISTANCE, granularity);
                    }
                    else if (command.equalsIgnoreCase("setTimeGranularity"))
                    {
                        double granularity = timeGranularityButtons.get(actionEvent.getSource());
                        getPlot().getDataPool().setGranularity(Dimension.TIME, granularity);
                    }
                    else
                    {
                        throw new RuntimeException("Unknown ActionEvent");
                    }
                }
            });
            result.add(item);
            group.add(item);
        }
        return result;
    }

    /** {@inheritDoc} */
    @Override
    public AbstractContourPlot<?> getPlot()
    {
        return (AbstractContourPlot<?>) super.getPlot();
    }

    /**
     * Sets the correct space granularity radio button to selected. This is done from a {@code DataPool} to keep multiple plots
     * consistent.
     * @param granularity double; space granularity
     */
    protected final void setSpaceGranularityRadioButton(final double granularity)
    {
        getPlot().setSpaceGranularity(granularity);
        for (JRadioButtonMenuItem button : this.spaceGranularityButtons.keySet())
        {
            button.setSelected(this.spaceGranularityButtons.get(button) == granularity);
        }
    }

    /**
     * Sets the correct time granularity radio button to selected. This is done from a {@code DataPool} to keep multiple plots
     * consistent.
     * @param granularity double; time granularity
     */
    protected final void setTimeGranularityRadioButton(final double granularity)
    {
        getPlot().setTimeGranularity(granularity);
        for (JRadioButtonMenuItem button : this.timeGranularityButtons.keySet())
        {
            button.setSelected(this.timeGranularityButtons.get(button) == granularity);
        }
    }

    /**
     * Sets the check box for smooth rendering. This is done from a {@code DataPool} to keep multiple plots consistent.
     * @param smooth boolean; selected or not
     */
    protected final void setSmoothing(final boolean smooth)
    {
        this.smoothCheckBox.setSelected(smooth);
    }

    /**
     * Sets the check box for interpolated rendering and block renderer setting. This is done from a {@code DataPool} to keep
     * multiple plots consistent.
     * @param interpolate boolean; selected or not
     */
    protected final void setInterpolation(final boolean interpolate)
    {
        getPlot().setInterpolation(interpolate);
        this.interpolateCheckBox.setSelected(interpolate);
    }

}