/*
 * This file is part of McIDAS-V
 *
 * Copyright 2007-2025
 * Space Science and Engineering Center (SSEC)
 * University of Wisconsin - Madison
 * 1225 W. Dayton Street, Madison, WI 53706, USA
 * https://www.ssec.wisc.edu/mcidas/
 * 
 * All Rights Reserved
 * 
 * McIDAS-V is built on Unidata's IDV and SSEC's VisAD libraries, and
 * some McIDAS-V source code is based on IDV and VisAD source code.  
 * 
 * McIDAS-V is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 * 
 * McIDAS-V 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 Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser Public License
 * along with this program.  If not, see https://www.gnu.org/licenses/.
 */

package edu.wisc.ssec.mcidasv.control;

import static edu.wisc.ssec.mcidasv.probes.ReadoutProbe.makeEarth2dTuple;
import static java.util.Objects.requireNonNull;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.GridBagConstraints;
import java.awt.GridLayout;
import java.awt.Insets;
import java.awt.Rectangle;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.geom.Rectangle2D;
import java.io.FileWriter;
import java.io.IOException;
import java.rmi.RemoteException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Hashtable;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;

import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.event.MouseInputListener;
import javax.swing.plaf.basic.BasicTableUI;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import ucar.unidata.idv.ControlContext;
import ucar.unidata.idv.IdvConstants;
import ucar.unidata.idv.MapViewManager;
import ucar.unidata.idv.control.FlaggedDisplayable;
import ucar.unidata.idv.control.McVHistogramWrapper;
import ucar.unidata.idv.ui.IdvWindow;
import ucar.visad.display.XYDisplay;

import visad.Data;
import visad.DataReference;
import visad.DataReferenceImpl;
import visad.DisplayRealType;
import visad.FlatField;
import visad.Real;
import visad.RealTuple;
import visad.Unit;
import visad.VisADException;
import visad.georef.MapProjection;

import ucar.unidata.data.DataChoice;
import ucar.unidata.data.DataSelection;
import ucar.unidata.idv.DisplayControl;
import ucar.unidata.idv.DisplayConventions;
import ucar.unidata.idv.ViewManager;
import ucar.unidata.idv.control.ControlWidget;
import ucar.unidata.idv.control.WrapperWidget;
import ucar.unidata.idv.ui.ParamDefaultsEditor;
import ucar.unidata.util.ColorTable;
import ucar.unidata.util.FileManager;
import ucar.unidata.util.GuiUtils;
import ucar.unidata.util.LogUtil;
import ucar.unidata.util.Misc;
import ucar.unidata.util.Range;
import ucar.visad.display.DisplayMaster;
import ucar.visad.display.DisplayableData;

import edu.wisc.ssec.mcidasv.Constants;
import edu.wisc.ssec.mcidasv.McIDASV;
import edu.wisc.ssec.mcidasv.data.hydra.MultiSpectralData;
import edu.wisc.ssec.mcidasv.data.hydra.MultiSpectralDataSource;
import edu.wisc.ssec.mcidasv.data.hydra.SpectrumAdapter;
import edu.wisc.ssec.mcidasv.display.hydra.MultiSpectralDisplay;
import edu.wisc.ssec.mcidasv.probes.ProbeEvent;
import edu.wisc.ssec.mcidasv.probes.ProbeListener;
import edu.wisc.ssec.mcidasv.probes.ReadoutProbe;
import edu.wisc.ssec.mcidasv.ui.UIManager;

public class MultiSpectralControl extends HydraControl {

    private static final Logger logger =
        LoggerFactory.getLogger(MultiSpectralControl.class);

    private String PARAM = "BrightnessTemp";

    // So MultiSpectralDisplay can consistently update the wavelength label
    // Note hacky leading spaces - needed because GUI builder does not
    // accept a horizontal strut component.
    public static String WAVENUMLABEL = "   Wavelength: ";
    
    private JLabel wavelengthLabel = new JLabel();

    private static final int DEFAULT_FLAGS = 
        FLAG_COLORTABLE | FLAG_ZPOSITION;

    private MultiSpectralDisplay display;

    private DisplayMaster displayMaster;

    private final JTextField wavenumbox =  
        new JTextField(Float.toString(0f), 12);

    final JTextField minBox = new JTextField(6);
    final JTextField maxBox = new JTextField(6);

    private final List<Hashtable<String, Object>> spectraProperties = new ArrayList<>();
    private final List<Spectrum> spectra = new ArrayList<>();

    private McVHistogramWrapper histoWrapper;

    private float rangeMin;
    private float rangeMax;
    
    private float origRangeMin;
    private float origRangeMax;

    // REALLY not thrilled with this...
    private int probesSeen = 0;

    // boring UI stuff
    private final JTable probeTable = new JTable(new ProbeTableModel(this, spectra));
    private final JScrollPane scrollPane = new JScrollPane(probeTable);
    private final JButton addProbe = new JButton("Add Probe");
    private final JButton removeProbe = new JButton("Remove Probe");
    private JCheckBox use360Box;

    private boolean blackBackground = true;
    private JRadioButton bgBlack;
    private JRadioButton bgWhite;
    private ButtonGroup bgColorGroup;

    /** Used to trigger the CSV export process. */
    private JButton saveAsCsv;

    /** Dialog that allows users to see export progress as well as cancel current export. */
    private CsvDialog exportCsvDialog;

    public MultiSpectralControl() {
        super();
        setHelpUrl("idv.controls.hydra.multispectraldisplaycontrol");
    }

    @Override public boolean init(final DataChoice choice)
        throws VisADException, RemoteException 
    {
        ((McIDASV)getIdv()).getMcvDataManager().setHydraControl(choice, this);
        Hashtable props = choice.getProperties();
        PARAM = (String) props.get(MultiSpectralDataSource.paramKey);

        List<DataChoice> choices = Collections.singletonList(choice);
        histoWrapper = new McVHistogramWrapper("Histogram", choices, this);

        Float fieldSelectorChannel =
            (Float)getDataSelection().getProperty(Constants.PROP_CHAN);

        display = new MultiSpectralDisplay(this);

        if (fieldSelectorChannel != null) {
            display.setWaveNumber(fieldSelectorChannel);
        }

        displayMaster = getViewManager().getMaster();

        // map the data choice to display.
        ((McIDASV) getIdv()).getMcvDataManager().setHydraDisplay(choice, display);

        // initialize the Displayable with data before adding to DisplayControl
        DisplayableData imageDisplay = display.getImageDisplay();
        FlatField image = display.getImageData();

        float[] rngvals = (image.getFloats(false))[0];
        float[] minmax = minmax(rngvals);
        rangeMin = minmax[0];
        rangeMax = minmax[1];
        
        origRangeMin = rangeMin;
        origRangeMax = rangeMax;

        imageDisplay.setData(display.getImageData());
        addDisplayable(imageDisplay, DEFAULT_FLAGS);

        // put the multispectral display into the layer controls
        addViewManager(display.getViewManager());

        // tell the idv what options to give the user
        setAttributeFlags(DEFAULT_FLAGS);

        setProjectionInView(true);

        // handle the user trying to add a new probe
        addProbe.addActionListener(e -> {
            addSpectrum(Color.YELLOW);
            probeTable.revalidate();
        });

        // handle the user trying to remove an existing probe
        removeProbe.addActionListener(e -> {
            int index = probeTable.getSelectedRow();
            if (index == -1) {
                return;
            }

            removeSpectrum(index);
        });
        removeProbe.setEnabled(false);

        // set up the table. in particular, enable/disable the remove button
        // depending on whether or not there is a selected probe to remove.
        probeTable.setDefaultRenderer(Color.class, new ColorRenderer(true));
        probeTable.setDefaultEditor(Color.class, new ColorEditor());
        probeTable.setPreferredScrollableViewportSize(new Dimension(500, 200));
        probeTable.setUI(new HackyDragDropRowUI());
        probeTable.getSelectionModel().addListSelectionListener(e -> {
            if (!probeTable.getSelectionModel().isSelectionEmpty()) {
                removeProbe.setEnabled(true);
            } else {
                removeProbe.setEnabled(false);
            }
        });

        final boolean use360 = getIdv().getStore().get(Constants.PROP_HYDRA_360, false);
        use360Box = new JCheckBox("0-360 Longitude Format", use360);
        use360Box.addActionListener(e -> {
            getIdv().getStore().put(Constants.PROP_HYDRA_360, use360Box.isSelected());
            ProbeTableModel model = (ProbeTableModel)probeTable.getModel();
            model.updateWith(spectra);
            model.fireTableDataChanged();
        });

        bgBlack = new JRadioButton("Black");
        bgBlack.addActionListener(e -> {
            logger.trace("selected black background");
            XYDisplay master = display.getMaster();
            master.setBackground(Color.black);
            master.setForeground(Color.white);
            setBlackBackground(true);
        });

        bgWhite = new JRadioButton("White");
        bgWhite.addActionListener(e -> {
            logger.trace("selected white background");
            XYDisplay master = display.getMaster();
            master.setBackground(Color.white);
            master.setForeground(Color.black);
            setBlackBackground(false);
        });

        bgColorGroup = new ButtonGroup();
        bgColorGroup.add(bgBlack);
        bgColorGroup.add(bgWhite);

        bgBlack.setSelected(getBlackBackground());
        bgWhite.setSelected(!getBlackBackground());

        setShowInDisplayList(true);

        return true;
    }
    
    /**
     * Updates the Wavelength label when user manipulates drag line UI
     * 
     * @param s full label text, prefix and numeric value
     * 
     */
    public void setWavelengthLabel(String s) {
        if (s != null) {
            wavelengthLabel.setText(s);
        }
    }

    @Override public void initAfterUnPersistence(ControlContext vc,
                                                 Hashtable properties,
                                                 List preSelectedDataChoices)
    {
        super.initAfterUnPersistence(vc, properties, preSelectedDataChoices);

        XYDisplay master = display.getMaster();
        if (getBlackBackground()) {
            master.setBackground(Color.black);
            master.setForeground(Color.white);
        } else {
            master.setBackground(Color.white);
            master.setForeground(Color.black);
        }
    }

    @Override public void initDone() {
        try {
            display.showChannelSelector();

            // TODO: this is ugly.
            Float fieldSelectorChannel =
                (Float)getDataSelection().getProperty(Constants.PROP_CHAN);
            if (fieldSelectorChannel == null) {
                fieldSelectorChannel = 0f;
            }
            handleChannelChange(fieldSelectorChannel, false);

            displayMaster.setDisplayInactive();

            // this if-else block is detecting whether or not a bundle is
            // being loaded; if true, then we'll have a list of spectra props.
            // otherwise just throw two default spectrums/probes on the screen.
            if (!spectraProperties.isEmpty()) {
                for (Hashtable<String, Object> table : spectraProperties) {
                    Color c = (Color)table.get("color");
                    Spectrum s = addSpectrum(c);
                    s.setProperties(table);
                }
                spectraProperties.clear();
            } else {
                addSpectra(Color.MAGENTA, Color.CYAN);
            }
            displayMaster.setDisplayActive();
        } catch (Exception e) {
            logException("MultiSpectralControl.initDone", e);
        }
    }

    /**
     * Overridden by McIDAS-V so that {@literal "hide"} probes when their display
     * is turned off. Otherwise users can wind up with probes on the screen which
     * aren't associated with any displayed data.
     * 
     * @param on {@code true} if we're visible, {@code false} otherwise.
     * 
     * @see DisplayControl#setDisplayVisibility(boolean)
     */
    
    @Override public void setDisplayVisibility(boolean on) {
        super.setDisplayVisibility(on);
        for (Spectrum s : spectra) {
            if (s.isVisible()) {
                s.getProbe().quietlySetVisible(on);
            }
        }
    }
    
    /**
     * Overridden so that the probes in the main display window can handle 
     * changes to z-axis.
     * 
     * @throws VisADException Problem creating VisAD object.
     * @throws RemoteException RemoteException Java RMI error.
     */
    @Override public void applyZPosition() 
        throws VisADException, RemoteException 
    {
        deactivateDisplays();
        double zpos = getVerticalValue(getZPosition());
        DisplayRealType drt = getNavigatedDisplay().getDisplayAltitudeType();
        for (int i = 0, n = displayables.size(); i < n; i++) {
            FlaggedDisplayable fd = (FlaggedDisplayable) displayables.get(i);
            if (!fd.ok(FLAG_ZPOSITION)) {
                continue;
            }
            fd.displayable.setConstantPosition(zpos, drt);
        }
        for (Spectrum s : spectra) {
            s.getProbe().getPointSelector().setZ(zpos);
        }
        activateDisplays();
    }
    
    /**
     * Overridden so that the probes can re-apply their current locations to
     * their {@link ReadoutProbe.PointSelector PointSelectors}.
     */
    @Override public void projectionChanged() {
        super.projectionChanged();
        MapProjection projection = 
            ((MapViewManager)getViewManager()).getMainProjection();
        for (Spectrum s : spectra) {
            ReadoutProbe rp = s.getProbe();
            rp.projectionChanged(projection);
        }
    }
    
    // this will get called before init() by the IDV's bundle magic.
    public void setSpectraProperties(final List<Hashtable<String, Object>> props) {
        spectraProperties.clear();
        spectraProperties.addAll(props);
    }

    public List<Hashtable<String, Object>> getSpectraProperties() {
        List<Hashtable<String, Object>> props = new ArrayList<>(spectra.size());
        for (Spectrum s : spectra) {
            props.add(s.getProperties());
        }
        return props;
    }

    protected void updateList(final List<Spectrum> updatedSpectra) {
        spectra.clear();

        List<String> dataRefIds = new ArrayList<>(updatedSpectra.size());
        for (Spectrum spectrum : updatedSpectra) {
            dataRefIds.add(spectrum.getSpectrumRefName());
            spectra.add(spectrum);
        }
        display.reorderDataRefsById(dataRefIds);
    }

    /**
     * Uses a variable-length array of {@link Color Colors} to create new
     * readout probes using the specified colors.
     * 
     * @param colors Variable length array of {@code Colors}.
     *               Shouldn't be {@code null}.
     */
    // TODO(jon): check for null.
    protected void addSpectra(final Color... colors) {
        Spectrum currentSpectrum = null;
        try {
            for (int i = colors.length-1; i >= 0; i--) {
                probesSeen++;
                Color color = colors[i];
                String id = "Probe "+probesSeen;
                currentSpectrum = new Spectrum(this, color, id);
                spectra.add(currentSpectrum);
            }
            ((ProbeTableModel)probeTable.getModel()).updateWith(spectra);
        } catch (Exception e) {
            LogUtil.logException("MultiSpectralControl.addSpectra: error while adding spectra", e);
        }
    }

    /**
     * Creates a new {@link ReadoutProbe} with the specified {@link Color}.
     * 
     * @param color {@code Color} of the new {@code ReadoutProbe}. 
     * {@code null} values are not allowed.
     * 
     * @return {@link Spectrum} wrapper for the newly created 
     * {@code ReadoutProbe}.
     * 
     * @throws NullPointerException if {@code color} is {@code null}.
     */
    public Spectrum addSpectrum(final Color color) {
        Spectrum spectrum = null;
        try {
            probesSeen++;
            String id = "Probe "+probesSeen;
            spectrum = new Spectrum(this, color, id);
            spectra.add(spectrum);
        } catch (Exception e) {
            LogUtil.logException("MultiSpectralControl.addSpectrum: error creating new spectrum", e);
        }
        ((ProbeTableModel)probeTable.getModel()).updateWith(spectra);
        return spectrum;
    }

    /**
     * Attempts to remove the {@link Spectrum} at the given {@code index}.
     * 
     * @param index Index of the probe to be removed (within {@link #spectra}).
     */
    public void removeSpectrum(final int index) {
        List<Spectrum> newSpectra = new ArrayList<>(spectra);
        int mappedIndex = newSpectra.size() - (index + 1);
        Spectrum removed = newSpectra.get(mappedIndex);
        newSpectra.remove(mappedIndex);
        try {
            removed.removeValueDisplay();
        } catch (Exception e) {
            LogUtil.logException("MultiSpectralControl.removeSpectrum: error removing spectrum", e);
        }

        updateList(newSpectra);

        // need to signal that the table should update?
        ProbeTableModel model = (ProbeTableModel)probeTable.getModel();
        model.updateWith(newSpectra);
        probeTable.revalidate();
    }

    /**
     * Iterates through the list of {@link Spectrum Spectrums} that manage each
     * {@link ReadoutProbe} associated with this display control and calls
     * {@link Spectrum#removeValueDisplay()} in an effort to remove this 
     * control's probes.
     * 
     * @see #spectra
     */
    public void removeSpectra() {
        try {
            for (Spectrum s : spectra) {
                s.removeValueDisplay();
            }
        } catch (Exception e) {
            LogUtil.logException("MultiSpectralControl.removeSpectra: error removing spectrum", e);
        }
    }

    /**
     * Makes each {@link ReadoutProbe} in this display control attempt to 
     * redisplay its readout value.
     * 
     * <p>Sometimes the probes don't initialize correctly and this method is 
     * a stop-gap solution.
     */
    public void pokeSpectra() {
        for (Spectrum s : spectra) {
            s.pokeValueDisplay();
        }
        try {
            //-display.refreshDisplay();
        } catch (Exception e) {
            LogUtil.logException("MultiSpectralControl.pokeSpectra: error refreshing display", e);
        }
    }

    @Override public DataSelection getDataSelection() {
        DataSelection selection = super.getDataSelection();
        if (display != null) {
            selection.putProperty(Constants.PROP_CHAN, display.getWaveNumber());
            try {
                selection.putProperty(SpectrumAdapter.channelIndex_name, display.getChannelIndex());
            } catch (Exception e) {
                LogUtil.logException("MultiSpectralControl.getDataSelection", e);
            }
        }
        return selection;
    }

    @Override public void setDataSelection(final DataSelection newSelection) {
        super.setDataSelection(newSelection);
    }

    @Override public MapProjection getDataProjection() {
        MapProjection mp = null;
        Rectangle2D rect =
            MultiSpectralData.getLonLatBoundingBox(display.getImageData());

        try {
            mp = new LambertAEA(rect);
        } catch (Exception e) {
            logException("MultiSpectralControl.getDataProjection", e);
        }

        return mp;
    }

    public static float[] minmax(float[] values) {
        float min =  Float.MAX_VALUE;
        float max = -Float.MAX_VALUE;
        for (int k = 0; k < values.length; k++) {
            float val = values[k];
            if ((val == val) && (val < Float.POSITIVE_INFINITY) && (val > Float.NEGATIVE_INFINITY)) {
                if (val < min) {
                    min = val;
                }
                if (val > max) {
                    max = val;
                }
            }
        }
        return new float[] { min, max };
    }

    /**
     * Convenience method for extracting the parameter name.
     *
     * @return Results from {@link DataChoice#getName()}, or {@link #PARAM} if
     * the {@code DataChoice} is (somehow) {@code null}.
     */
    private String getParameterName() {
        String parameterName = PARAM;
        DataChoice choice = getDataChoice();
        if (choice != null) {
            parameterName = choice.getName();
        }
        return parameterName;
    }

    /**
     * Get the initial {@link Range} for the data and color table.
     *
     * <p>Note: if there is a parameter default range associated with the
     * current parameter name, that will be returned. If there is <b>not</b> a
     * parameter default range match, a {@code Range} consisting of
     * {@link #rangeMin} and {@link #rangeMax} will be returned.
     * </p>
     *
     * @return Initial {@code Range} for data and color table.
     *
     * @throws VisADException if VisAD had problems.
     * @throws RemoteException if there was a Java RMI problem.
     */
    @Override protected Range getInitialRange() throws VisADException,
        RemoteException
    {
        String parameterName = getParameterName();
        Unit dispUnit = getDisplayUnit();
        DisplayConventions conventions = getDisplayConventions();
        Range paramRange = conventions.getParamRange(parameterName, dispUnit);
        if (paramRange == null) {
            paramRange = new Range(rangeMin, rangeMax);
        }
        return paramRange;
    }
    
    /**
     * Get the initial {@link ColorTable} associated with this control's
     * parameter name.
     *
     * <p>Note: if there is a parameter default color table associated with
     * the parameter name, that color table will be returned. If there are
     * <b>no</b> parameter defaults associated with the parameter name,
     * then the {@code ColorTable} associated with {@literal "BrightnessTemp"}
     * is returned (this is a {@literal "legacy"} behavior).
     * </p>
     *
     * @return {@code ColorTable} to use.
     */
    @Override protected ColorTable getInitialColorTable() {
        String parameterName = getParameterName();
        DisplayConventions conventions = getDisplayConventions();
        ParamDefaultsEditor defaults = conventions.getParamDefaultsEditor();
        ColorTable ct = defaults.getParamColorTable(parameterName, false);
        if (ct == null) {
            ct = conventions.getParamColorTable(PARAM);
        }
        return ct;
    }

    @Override public Container doMakeContents() {
        try {
            JTabbedPane pane = new JTabbedPane();
            pane.add("Display", GuiUtils.inset(getDisplayTab(), 5));
            pane.add("Settings", 
                     GuiUtils.inset(GuiUtils.top(doMakeWidgetComponent()), 5));
            pane.add("Histogram", GuiUtils.inset(GuiUtils.top(getHistogramTabComponent()), 5));
            GuiUtils.handleHeavyWeightComponentsInTabs(pane);
            return pane;
        } catch (Exception e) {
            logException("MultiSpectralControl.doMakeContents", e);
        }
        return null;
    }

    @Override public void doRemove() throws VisADException, RemoteException {
        // forcibly clear the value displays when the user has elected to kill
        // the display. the readouts will persist otherwise.
        removeSpectra();
        super.doRemove();
    }

    /**
     *  Runs through the list of ViewManager-s and tells each to destroy.
     *  Creates a new viewManagers list.
     */
    @Override protected void clearViewManagers() {
        if (viewManagers == null) {
            return;
        }

        List<ViewManager> tmp = new ArrayList<>(viewManagers);
        viewManagers = null;
        for (ViewManager vm : tmp) {
            if (vm != null) {
                vm.destroy();
            }
        }
    }

    @SuppressWarnings("unchecked")
    @Override protected JComponent doMakeWidgetComponent() {
        List<Component> widgetComponents;
        try {
            List<ControlWidget> controlWidgets = new ArrayList<>(15);
            getControlWidgets(controlWidgets);
            controlWidgets.add(new WrapperWidget(this, GuiUtils.rLabel("Background Color:"), GuiUtils.hbox(bgBlack, bgWhite)));
            controlWidgets.add(new WrapperWidget(this, GuiUtils.rLabel("Readout Probes:"), scrollPane));
            controlWidgets.add(new WrapperWidget(this, GuiUtils.rLabel(" "), GuiUtils.hbox(addProbe, removeProbe, GuiUtils.right(use360Box))));
            widgetComponents = ControlWidget.fillList(controlWidgets);
        } catch (Exception e) {
            LogUtil.logException("Problem building the MultiSpectralControl settings", e);
            widgetComponents = new ArrayList<>(5);
            widgetComponents.add(new JLabel("Error building component..."));
        }

        GuiUtils.tmpInsets = new Insets(4, 8, 4, 8);
        GuiUtils.tmpFill = GridBagConstraints.HORIZONTAL;
        return GuiUtils.doLayout(widgetComponents, 2, GuiUtils.WT_NY, GuiUtils.WT_N);
    }

    protected MultiSpectralDisplay getMultiSpectralDisplay() {
        return display;
    }

    public boolean updateImage(final float newChan) {
        if (!display.setWaveNumber(newChan)) {
            return false;
        }
        
        DisplayableData imageDisplay = display.getImageDisplay();
        
        try {
            FlatField image = display.getImageData();
            displayMaster.setDisplayInactive(); //try to consolidate display transforms
            imageDisplay.setData(image);
            pokeSpectra();
            displayMaster.setDisplayActive();
            updateHistogramTab();
            
            // Inquiry 2784 Request 3
            // NOTE: updateHistogramTab updates the rangeMin/rangeMax fields,
            // so it *must* be called before the following setRange call.
            // this ensures the color table/map updates as expected.
            setRange(new Range(rangeMin, rangeMax));
            // end Inquiry 2784 Request 3 stuff
        } catch (Exception e) {
            LogUtil.logException("MultiSpectralControl.updateImage", e);
            return false;
        }

        return true;
    }

    // be sure to update the displayed image even if a channel change 
    // originates from the msd itself.
    @Override public void handleChannelChange(final float newChan) {
        handleChannelChange(newChan, true);
    }

    public void handleChannelChange(final float newChan, boolean update) {
        if (update) {
            if (updateImage(newChan)) {
                wavenumbox.setText(Float.toString(newChan));
            }
        } else {
            wavenumbox.setText(Float.toString(newChan));
        }
    }

    private JComponent getDisplayTab() {
        List<JComponent> compList = new ArrayList<>(5);

        saveAsCsv = new JButton("Save...");
        saveAsCsv.addActionListener(e-> writeToCSV());

        if (display.getBandSelectComboBox() == null) {
          final JButton nameLabel = new JButton("Wavenumber");
          nameLabel.addActionListener(e -> {
              if (nameLabel.getText().equals("Wavenumber")) {
                  nameLabel.setText("Wavelength");
                  String tmp = wavenumbox.getText().trim();
                  wavenumbox.setText(String.valueOf(1/Float.valueOf(tmp)));
              } else {
                  nameLabel.setText("Wavenumber");
                  String tmp = wavenumbox.getText().trim();
                  wavenumbox.setText(String.valueOf(1/Float.valueOf(tmp)));
              }
          });

          wavenumbox.addActionListener(e -> {
              if (nameLabel.getText().equals("Wavenumber")) {
                  String tmp = wavenumbox.getText().trim();
                  updateImage(Float.valueOf(tmp));
              } else {
                  String tmp = wavenumbox.getText().trim();
                  updateImage(1/Float.valueOf(tmp));
              }
          });

          compList.add(nameLabel);
          compList.add(wavenumbox);
        } else {
          final JComboBox bandBox = display.getBandSelectComboBox();
          bandBox.addActionListener(e -> {
             String bandName = (String) bandBox.getSelectedItem();
             Float channel = (Float)display.getMultiSpectralData().getBandNameMap().get(bandName);
             updateImage(channel.floatValue());
          });
          JLabel nameLabel = new JLabel("Band: ");

          compList.add(nameLabel);
          compList.add(bandBox);
        }
        compList.add(saveAsCsv);

        JPanel waveNo = GuiUtils.center(GuiUtils.doLayout(compList, compList.size(), GuiUtils.WT_N, GuiUtils.WT_N));
        return GuiUtils.centerBottom(display.getDisplayComponent(), waveNo);
    }

    /**
     * Write multispectral data to a CSV file.
     *
     * <p>Now with file choosers!</p>
     */
    public void writeToCSV() {
        // McIDAS Inquiry #2535-3141
        String filename = FileManager.getWriteFile(Misc.newList(FileManager.FILTER_CSV), FileManager.SUFFIX_CSV);
        if (filename == null) {
            return;
        }

        CsvTask task = new CsvTask(filename);
        task.addPropertyChangeListener(evt -> {
//            logger.trace("property changed: {}", evt);
            switch (evt.getPropertyName()) {
                case "state":
                    if (evt.getNewValue() == SwingWorker.StateValue.DONE) {
                        saveAsCsv.setEnabled(true);
                        if (exportCsvDialog != null) {
                            SwingUtilities.invokeLater(() -> exportCsvDialog.taskOver());
                        }
                    } else {
                        saveAsCsv.setEnabled(false);
                        if (exportCsvDialog != null) {
                            SwingUtilities.invokeLater(() -> exportCsvDialog.setVisible(true));
                        }
                    }
                    break;
                case "progress":
                    int value = (Integer)evt.getNewValue();
                    if (exportCsvDialog != null) {
                        exportCsvDialog.setProgress(value);
                        SwingUtilities.invokeLater(() -> exportCsvDialog.setProgress(value));
                    }
                    break;
                default:
//                    logger.trace("unknown evt type: {}", evt);
                    if (exportCsvDialog != null) {
                        SwingUtilities.invokeLater(() -> exportCsvDialog.taskOver());
                    } else {
                        task.cancel(true);
                    }
                    saveAsCsv.setEnabled(true);
                    break;
            }
        });

        createCsvDialog(task);
        task.execute();
    }

    /**
     * Create the dialog used to show our CSV export progress.
     *
     * <p>Be aware that the dialog will not be visible until {@link CsvTask#execute() execute} is called.</p>
     *
     * <p>The {@link CsvDialog} will automatically close upon completion or the user cancelling.</p>
     *
     * @param task CSV export task. Cannot be {@code null}.
     */
    private void createCsvDialog(CsvTask task) {
        // attempting to center the modal CsvDialog over the data explorer window.
        // if it somehow does not exist, try main display window.
        UIManager mcvUI = (UIManager)McIDASV.getStaticMcv().getIdvUIManager();
        IdvWindow window = mcvUI.getDashboardWindow();
        if (window == null) {
            // not sure how this would be possible, given that the multispectralcontrol
            // is embedded within the Data Explorer window!
            window = IdvWindow.getActiveWindow();
        }
        exportCsvDialog = new CsvDialog(
                window.getWindow(),
                getOuterContents(),
                "Exporting values...",
                task);
    }


    private JComponent getHistogramTabComponent() {
        updateHistogramTab();
        JComponent histoComp = histoWrapper.doMakeContents();
        JLabel rangeLabel = GuiUtils.rLabel("Range   ");
        JLabel minLabel = GuiUtils.rLabel("Min");
        JLabel maxLabel = GuiUtils.rLabel("   Max");
        List<JComponent> rangeComps = new ArrayList<>();
        rangeComps.add(rangeLabel);
        rangeComps.add(minLabel);
        rangeComps.add(minBox);
        rangeComps.add(maxLabel);
        rangeComps.add(maxBox);
        minBox.addActionListener(ae -> {
            rangeMin = Float.valueOf(minBox.getText().trim());
            rangeMax = Float.valueOf(maxBox.getText().trim());
            histoWrapper.modifyRange((int) rangeMin, (int) rangeMax);
        });
        maxBox.addActionListener(ae -> {
            rangeMin = Float.valueOf(minBox.getText().trim());
            rangeMax = Float.valueOf(maxBox.getText().trim());
            histoWrapper.modifyRange((int) rangeMin, (int) rangeMax);
        });
        JPanel rangePanel =
            GuiUtils.center(GuiUtils.doLayout(rangeComps, 5, GuiUtils.WT_N, GuiUtils.WT_N));
        JButton resetButton = new JButton("Reset");
        resetButton.addActionListener(ae -> resetColorTable());

        JPanel resetPanel = 
            GuiUtils.center(GuiUtils.inset(GuiUtils.wrap(resetButton), 4));

        return GuiUtils.topCenterBottom(histoComp, rangePanel, resetPanel);
    }

    private void updateHistogramTab() {
        try {
            FlatField ff = display.getImageData();
            histoWrapper.loadData(ff);
            org.jfree.data.Range range = histoWrapper.getRange();
            rangeMin = (float)range.getLowerBound();
            rangeMax = (float)range.getUpperBound();
            minBox.setText(Integer.toString((int)rangeMin));
            maxBox.setText(Integer.toString((int)rangeMax));
        } catch (IllegalArgumentException e) {
            histoWrapper.clearHistogram();
            histoWrapper.resetPlot();
            rangeMin = Float.NaN;
            rangeMax = Float.NaN;
            minBox.setText("NaN");
            maxBox.setText("NaN");
        } catch (RemoteException | VisADException e) {
            logException("MultiSpectralControl.getHistogramTabComponent", e);
        }
    }

    public void resetColorTable() {
        histoWrapper.doReset();
        histoWrapper.modifyRange((int) origRangeMin, (int) origRangeMax);
        // TJJ Jan 2019 - make sure and reset the min/max input boxes too
        minBox.setText(Integer.toString((int) origRangeMin));
        maxBox.setText(Integer.toString((int) origRangeMax));
    }

    protected void contrastStretch(final double low, final double high) {
        try {
            org.jfree.data.Range range = histoWrapper.getRange();
            rangeMin = (float)range.getLowerBound();
            rangeMax = (float)range.getUpperBound();
            minBox.setText(Integer.toString((int)rangeMin));
            maxBox.setText(Integer.toString((int)rangeMax));
            setRange(getInitialColorTable().getName(), new Range(low, high));
        } catch (Exception e) {
            logException("MultiSpectralControl.contrastStretch", e);
        }
    }

    // sole use is for persistence!
    public boolean getBlackBackground() {
        return blackBackground;
    }

    // sole use is for persistence!
    public void setBlackBackground(boolean value) {
        blackBackground = value;
    }

    class CsvDialog extends JDialog {
        private final JProgressBar progressBar;

        CsvDialog(Window parentWindow, Component parentComponent,
                  String title, CsvTask task) {
            super(parentWindow, title);
            setModalityType(ModalityType.APPLICATION_MODAL);
            setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);

            getContentPane().setLayout(new GridLayout(1,1));

            JPanel mainPanel = new JPanel(new BorderLayout(10, 10));
            mainPanel.setBorder(BorderFactory.createEmptyBorder(15, 10, 5, 10));

            JPanel centerPanel = new JPanel(new BorderLayout());
            mainPanel.add(centerPanel, BorderLayout.CENTER);

            JPanel southPanel = new JPanel(new BorderLayout());
            mainPanel.add(southPanel, BorderLayout.SOUTH);

            this.progressBar = new JProgressBar(0, 100);
            this.progressBar.setStringPainted(true);
            southPanel.add(progressBar, BorderLayout.CENTER);

            JPanel buttonsPanel = new JPanel(new FlowLayout());
            southPanel.add(buttonsPanel, BorderLayout.SOUTH);

            JButton cancelButton = new JButton("Cancel");
            cancelButton.addActionListener(e -> task.cancel(true));
            buttonsPanel.add(cancelButton);
            getContentPane().add(mainPanel);
            pack();
            setLocationRelativeTo(parentComponent);
        }

        void setProgress(int percent) {
            this.progressBar.setValue(percent);
        }

        void taskOver() {
            setVisible(false);
            dispose();
        }
    }

    class CsvTask extends SwingWorker<String, Object> {
        private final String path;

        /**
         * Creates a CSV exporting task that's meant to store its values in the file specified by {@code path}.
         *
         * @param path File to write to. Cannot be {@code null}.
         */
        public CsvTask(String path) {
            this.path = Objects.requireNonNull(path, "path cannot be null");
        }

        /**
         * Does the work of exporting and formatting CSV values from a {@link MultiSpectralControl} in a
         * background thread.
         *
         * @return String representing the contents to write to a CSV file. May be {@code null}.
         */
        @Override public String doInBackground() {
            String csvContents = null;
            try {
                csvContents = exportSpectra();
            } catch (Exception e) {
                logger.warn("Something went wrong extracting values", e);
            }
            return csvContents;
        }

        /**
         * Called (on the event dispatch thread) when {@link #doInBackground()} has completed.
         */
        @Override protected void done() {
            try {
                String contents = get();
                if (contents == null) {
                    logger.error("Could not extract CSV values, contents are null.");
                } else {
                    writeToPath(contents);
                }
            } catch (CancellationException e) {
                firePropertyChange("state", StateValue.STARTED, SwingWorker.StateValue.DONE);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } catch (ExecutionException e) {
                String why = null;
                Throwable cause = e.getCause();
                why = Objects.requireNonNullElse(cause, e).getMessage();
                logger.warn("Error writing to path: " + path, why);
            }
        }

        /**
         * Write the given string to {@link #path}.
         *
         * @param csvContents CSV file contents. Should not be {@code null}.
         */
        private void writeToPath(String csvContents) {
            try (FileWriter writer = new FileWriter(this.path)) {
                writer.write(csvContents);
                writer.flush();
            } catch (IOException ex) {
                logger.warn("Could not write to file", ex);
            }
        }

        /**
         * Iterates through each channel/wavenumber and extracts the value of the existing ReadoutProbes
         * at their current positions.
         *
         * <p>Be warned, this can be slow when there are thousands of channels. Definitely do not
         * run this method on the event dispatch thread.</p>
         *
         * @param wavelengths Array containing all the channels/wavenumbers. Cannot be {@code null}.
         *
         * @return Two-dimensional array of doubles. First array represents the probes,
         * second dimension is the value of a probe at each channel/wavenumber.
         *
         * @throws VisADException if there was a problem
         * @throws RemoteException if there was somehow an RMI problem
         */
        private double[][] collectValues(double[] wavelengths) throws VisADException, RemoteException{
            double[][] values = new double[spectra.size()][wavelengths.length];

            RealTuple[] probeLocations = new RealTuple[spectra.size()];
            for (int i = 0; i < spectra.size(); i++) {
                Spectrum s = spectra.get(i);
                RealTuple location = s.getProbe().getEarthPosition();
                double[] locVals = location.getValues();
                if (locVals[1] < -180) {
                    locVals[1] += 360f;
                }

                if (locVals[0] > 180) {
                    locVals[0] -= 360f;
                }
                probeLocations[i] = makeEarth2dTuple(locVals[0], locVals[1]);
            }
            for (int i = 0; (i < wavelengths.length) && !isCancelled(); i++) {
                FlatField imageData = display.getImageDataFrom((float)wavelengths[i]);
                for (int j = 0; j < probeLocations.length; j++) {
                    RealTuple probeLoc = probeLocations[j];
                    Real realVal = (Real)imageData.evaluate(probeLoc, Data.NEAREST_NEIGHBOR, Data.NO_ERRORS);
                    values[j][i] = realVal.getValue();
                }
                // set percentage complete. iterating via display.getImageDataFrom(...)
                // is easily the slowest part of the CSV export process, so simply
                // figuring out the number of wavelengths processed likely suffices for
                // a simple progress bar.
                setProgress((int)(100 * ((float)i / (float)wavelengths.length)));
            }
            return values;
        }

        /**
         * Coordinates the collecting of probe data as well as creating a string representing
         * the contents of the CSV file.
         *
         * @return String value that can be written to a CSV file.
         *
         * @throws Exception if there was some problem
         */
        private String exportSpectra() throws Exception {
            DecimalFormat format = new DecimalFormat(getStore().get(Constants.PREF_LATLON_FORMAT, "##0.0"));
            boolean use360 = false;
            if (use360Box != null) {
                use360 = use360Box.isSelected();
            }

            double[] wavelengths = display.getDomainSet().getDoubles()[0];
            double[][] values = collectValues(wavelengths);

            // each wavelen,value1,value2 generally less than 50 chars,
            // will need wavelengths.length of 'em.
            // +200 to account for the length of the column headers
            StringBuilder builder = new StringBuilder(wavelengths.length * 50 + 200);
            // Wavelen, Probe 1 LATLON BrightnessTemp, Probe 2 LATLON BrightnessTemp, Probe 3 LatLon BrightnessTemp
            builder.append("Wavelength,");
            for (int i = 0; i < spectra.size(); i++) {
                Spectrum s = spectra.get(i);
                double lon = use360
                        ? ProbeTableModel.clamp360(s.getLongitude())
                        : ProbeTableModel.clamp180(s.getLongitude());
                builder.append(s.getId())
                        .append(" (Latitude: ").append(format.format(s.getLatitude()))
                        .append("; Longitude: ").append(format.format(lon)).append(')');
                if (i < spectra.size() - 1) {
                    builder.append(',');
                }
            }
            builder.append('\n');
            for (int i = 0; i < wavelengths.length; i++) {
                builder.append(wavelengths[i]).append(',');
                for (int j = 0; j < spectra.size(); j++) {
                    builder.append(values[j][i]);
                    if (j < spectra.size() - 1) {
                        builder.append(',');
                    }
                }
                builder.append('\n');
            }
            return builder.toString();
        }
    }

    private static class Spectrum implements ProbeListener {

        private static final Logger logger = LoggerFactory.getLogger(Spectrum.class);

        private final MultiSpectralControl control;

        /** 
         * Display that is displaying the spectrum associated with 
         * {@code probe}'s location. 
         */
        private final MultiSpectralDisplay display;

        /** VisAD's reference to this spectrum. */
        private final DataReference spectrumRef;

        /** 
         * Probe that appears in the {@literal "image display"} associated with
         * the current display control. 
         */
        private ReadoutProbe probe;

        /** Whether or not {@code probe} is visible. */
        private boolean isVisible = true;

        /** 
         * Human-friendly ID for this spectrum and probe. Used in 
         * {@link MultiSpectralControl#probeTable}. 
         */
        private final String myId;

        /**
         * Initializes a new Spectrum that is {@literal "bound"} to
         * {@code control} and whose color is {@code color}.
         * 
         * @param control Display control that contains this spectrum and the
         * associated {@link ReadoutProbe}. Cannot be null.
         * @param color Color of {@code probe}. Cannot be {@code null}.
         * @param myId Human-friendly ID used a reference for this
         * spectrum/probe. Cannot be {@code null}.
         * 
         * @throws NullPointerException if {@code control}, {@code color}, or 
         * {@code myId} is {@code null}.
         * @throws VisADException if VisAD-land had some problems.
         * @throws RemoteException if VisAD's RMI stuff had problems.
         */
        public Spectrum(final MultiSpectralControl control, final Color color, final String myId) throws VisADException, RemoteException {
            this.control = control;
            this.display = control.getMultiSpectralDisplay();
            this.myId = myId;
            spectrumRef = new DataReferenceImpl(hashCode() + "_spectrumRef");
            display.addRef(spectrumRef, color);
            String pattern = control.getStore().get(IdvConstants.PREF_LATLON_FORMAT, "##0.0");
            probe = new ReadoutProbe(control, display.getImageData(), color, pattern, control.getDisplayVisibility());
            this.updatePosition(probe.getEarthPosition());
            probe.addProbeListener(this);
    
            control.addAttributedDisplayable(probe.getValueDisplay(), FLAG_ZPOSITION);
        }

        public void probePositionChanged(final ProbeEvent<RealTuple> e) {
            RealTuple position = e.getNewValue();
            updatePosition(position);
        }

        public void probeFormatPatternChanged(final ProbeEvent<String> e) {

        }

        public void updatePosition(RealTuple position) {
            try {
                FlatField spectrum = display.getMultiSpectralData().getSpectrum(position);
                spectrumRef.setData(spectrum);
            } catch (Exception ex) {
                logger.error("Error updating postion.", ex);
            }
        }

        public String getValue() {
            return probe.getValue();
        }

        public double getLatitude() {
            return probe.getLatitude();
        }

        public double getLongitude() {
            return probe.getLongitude();
        }

        public Color getColor() {
            return probe.getColor();
        }

        public String getId() {
            return myId;
        }

        public DataReference getSpectrumRef() {
            return spectrumRef;
        }

        public String getSpectrumRefName() {
            return hashCode() + "_spectrumRef";
        }

        public void setColor(final Color color) {
            if (color == null) {
                throw new NullPointerException("Can't use a null color");
            }

            try {
                display.updateRef(spectrumRef, color);
                probe.quietlySetColor(color);
            } catch (Exception ex) {
                logger.error("Error setting color", ex);
            }
        }

        /**
         * Shows and hides this spectrum/probe. Note that an {@literal "hidden"}
         * spectrum merely uses an alpha value of zero for the spectrum's 
         * color--nothing is actually removed!
         * 
         * <p>Also note that if our {@link MultiSpectralControl} has its visibility 
         * toggled {@literal "off"}, the probe itself will not be shown. 
         * <b>It will otherwise behave as if it is visible!</b>
         * 
         * @param visible {@code true} for {@literal "visible"}, {@code false} otherwise.
         */
        public void setVisible(final boolean visible) {
            isVisible = visible;
            Color c = probe.getColor();
            int alpha = visible ? 255 : 0;
            c = new Color(c.getRed(), c.getGreen(), c.getBlue(), alpha);
            try {
                display.updateRef(spectrumRef, c);
                // only bother actually *showing* the probe if its display is 
                // actually visible.
                if (control.getDisplayVisibility()) {
                    probe.quietlySetVisible(visible);
                }
            } catch (Exception e) {
                LogUtil.logException("There was a problem setting the visibility of probe \""+spectrumRef+"\" to "+visible, e);
            }
        }

        public boolean isVisible() {
            return isVisible;
        }

        protected ReadoutProbe getProbe() {
            return probe;
        }

        public void probeColorChanged(final ProbeEvent<Color> e) {
            logger.trace("color change event={}", e);
        }

        public void probeVisibilityChanged(final ProbeEvent<Boolean> e) {
            logger.trace("probe event={}", e);
            Boolean newVal = e.getNewValue();
            if (newVal != null) {
                isVisible = newVal;
            }
        }

        public Hashtable<String, Object> getProperties() {
            Hashtable<String, Object> table = new Hashtable<>();
            table.put("color", probe.getColor());
            table.put("visibility", isVisible);
            table.put("lat", probe.getLatitude());
            table.put("lon", probe.getLongitude());
            return table;
        }

        public void setProperties(final Hashtable<String, Object> table) {
            if (table == null) {
                throw new NullPointerException("properties table cannot be null");
            }
            Color color = (Color)table.get("color");
            Double lat = (Double)table.get("lat");
            Double lon = (Double)table.get("lon");
            Boolean visibility = (Boolean)table.get("visibility");
            probe.setLatLon(lat, lon);
            probe.setColor(color);
            setVisible(visibility);
        }

        public void pokeValueDisplay() {
            probe.setField(display.getImageData());
            try {
                //FlatField spectrum = display.getMultiSpectralData().getSpectrum(probe.getEarthPosition());
                //spectrumRef.setData(spectrum);
            } catch (Exception e) { }
        }

        public void removeValueDisplay() throws VisADException, RemoteException {
            probe.handleProbeRemoval();
            display.removeRef(spectrumRef);
        }
    }

    // TODO(jon): MultiSpectralControl should become the table model.
    private static class ProbeTableModel extends AbstractTableModel implements ProbeListener {
//        private static final String[] COLUMNS = { 
//            "Visibility", "Probe ID", "Value", "Spectrum", "Latitude", "Longitude", "Color" 
//        };

        private static final String[] COLUMNS = { 
            "Visibility", "Probe ID", "Value", "Latitude", "Longitude", "Color" 
        };

        private final Map<ReadoutProbe, Integer> probeToIndex = new LinkedHashMap<>();
        private final Map<Integer, Spectrum> indexToSpectrum = new LinkedHashMap<>();
        private final MultiSpectralControl control;

        public ProbeTableModel(final MultiSpectralControl control, final List<Spectrum> probes) {
            this.control = requireNonNull(control);
            updateWith(requireNonNull(probes));
        }

        public void probeColorChanged(final ProbeEvent<Color> e) {
            ReadoutProbe probe = e.getProbe();
            if (!probeToIndex.containsKey(probe)) {
                return;
            }
            int index = probeToIndex.get(probe);
            fireTableCellUpdated(index, 5);
        }

        public void probeVisibilityChanged(final ProbeEvent<Boolean> e) {
            ReadoutProbe probe = e.getProbe();
            if (!probeToIndex.containsKey(probe)) {
                return;
            }
            int index = probeToIndex.get(probe);
            fireTableCellUpdated(index, 0);
        }

        public void probePositionChanged(final ProbeEvent<RealTuple> e) {
            ReadoutProbe probe = e.getProbe();
            if (!probeToIndex.containsKey(probe)) {
                return;
            }
            int index = probeToIndex.get(probe);
            fireTableRowsUpdated(index, index);
        }

        public void probeFormatPatternChanged(final ProbeEvent<String> e) {
            ReadoutProbe probe = e.getProbe();
            if (!probeToIndex.containsKey(probe)) {
                return;
            }
            int index = probeToIndex.get(probe);
            fireTableRowsUpdated(index, index);
        }

        public void updateWith(final List<Spectrum> updatedSpectra) {
            requireNonNull(updatedSpectra);

            probeToIndex.clear();
            indexToSpectrum.clear();

            for (int i = 0, j = updatedSpectra.size()-1; i < updatedSpectra.size(); i++, j--) {
                Spectrum spectrum = updatedSpectra.get(j);
                ReadoutProbe probe = spectrum.getProbe();
                if (!probe.hasListener(this)) {
                    probe.addProbeListener(this);
                }
                probeToIndex.put(spectrum.getProbe(), i);
                indexToSpectrum.put(i, spectrum);
            }
        }

        public int getColumnCount() {
            return COLUMNS.length;
        }

        public int getRowCount() {
            if (probeToIndex.size() != indexToSpectrum.size()) {
                throw new AssertionError("");
            }
            return probeToIndex.size();
        }

//        public Object getValueAt(final int row, final int column) {
//            Spectrum spectrum = indexToSpectrum.get(row);
//            switch (column) {
//                case 0: return spectrum.isVisible();
//                case 1: return spectrum.getId();
//                case 2: return spectrum.getValue();
//                case 3: return "notyet";
//                case 4: return formatPosition(spectrum.getLatitude());
//                case 5: return formatPosition(spectrum.getLongitude());
//                case 6: return spectrum.getColor();
//                default: throw new AssertionError("uh oh");
//            }
//        }
        public Object getValueAt(final int row, final int column) {
            DecimalFormat format = new DecimalFormat(control.getIdv().getStore().get(Constants.PREF_LATLON_FORMAT, "##0.0"));
            boolean use360 = control.use360Box.isSelected();
            Spectrum spectrum = indexToSpectrum.get(row);
            switch (column) {
                case 0: return spectrum.isVisible();
                case 1: return spectrum.getId();
                case 2: return spectrum.getValue();
                case 3: return format.format(spectrum.getLatitude());
                case 4: return format.format(use360 ? clamp360(spectrum.getLongitude()) : clamp180(spectrum.getLongitude()));
                case 5: return spectrum.getColor();
                default: throw new AssertionError("uh oh");
            }
        }

        public boolean isCellEditable(final int row, final int column) {
            switch (column) {
                case 0: return true;
                case 5: return true;
                default: return false;
            }
        }

        public void setValueAt(final Object value, final int row, final int column) {
            Spectrum spectrum = indexToSpectrum.get(row);
            boolean didUpdate = true;
            switch (column) {
                case 0: spectrum.setVisible((Boolean)value); break;
                case 5: spectrum.setColor((Color)value); break;
                default: didUpdate = false; break;
            }

            if (didUpdate) {
                fireTableCellUpdated(row, column);
            }
        }

        public void moveRow(final int origin, final int destination) {
            // get the dragged spectrum (and probe)
            Spectrum dragged = indexToSpectrum.get(origin);
            ReadoutProbe draggedProbe = dragged.getProbe();

            // get the current spectrum (and probe)
            Spectrum current = indexToSpectrum.get(destination);
            ReadoutProbe currentProbe = current.getProbe();

            // update references in indexToSpetrum
            indexToSpectrum.put(destination, dragged);
            indexToSpectrum.put(origin, current);

            // update references in probeToIndex
            probeToIndex.put(draggedProbe, destination);
            probeToIndex.put(currentProbe, origin);

            // build a list of the spectra, ordered by index
            List<Spectrum> updated = new ArrayList<>(indexToSpectrum.size());
            for (int i = indexToSpectrum.size()-1; i >= 0; i--) {
                updated.add(indexToSpectrum.get(i));
            }

            // send it to control.
            control.updateList(updated);
        }

        public String getColumnName(final int column) {
            return COLUMNS[column];
        }

        public Class<?> getColumnClass(final int column) {
            return getValueAt(0, column).getClass();
        }

        public static double clamp180(double value) {
            return ((((value + 180.0) % 360.0) + 360.0) % 360.0) - 180.0;
        }

        public static double clamp360(double value) {
            boolean positive = value > 0.0;
            value = ((value % 360.0) + 360.0) % 360.0;
            if ((value == 0.0) && positive) {
                value = 360.0;
            }
            return value;
        }
    }

    public class ColorEditor extends AbstractCellEditor implements TableCellEditor, ActionListener {
        private Color currentColor = Color.CYAN;
        private final JButton button = new JButton();
        private final JColorChooser colorChooser = new JColorChooser();
        private JDialog dialog;
        protected static final String EDIT = "edit";

//        private final JComboBox combobox = new JComboBox(GuiUtils.COLORS); 

        public ColorEditor() {
            button.setActionCommand(EDIT);
            button.addActionListener(this);
            button.setBorderPainted(false);

//            combobox.setActionCommand(EDIT);
//            combobox.addActionListener(this);
//            combobox.setBorder(new EmptyBorder(0, 0, 0, 0));
//            combobox.setOpaque(true);
//            ColorRenderer whut = new ColorRenderer(true);
//            combobox.setRenderer(whut);
//            
//            dialog = JColorChooser.createDialog(combobox, "pick a color", true, colorChooser, this, null);
            dialog = JColorChooser.createDialog(button, "pick a color", true, colorChooser, this, null);
        }
        public void actionPerformed(ActionEvent e) {
            if (EDIT.equals(e.getActionCommand())) {
                //The user has clicked the cell, so
                //bring up the dialog.
//                button.setBackground(currentColor);
                colorChooser.setColor(currentColor);
                dialog.setVisible(true);

                //Make the renderer reappear.
                fireEditingStopped();

            } else { //User pressed dialog's "OK" button.
                currentColor = colorChooser.getColor();
            }
        }

        //Implement the one CellEditor method that AbstractCellEditor doesn't.
        public Object getCellEditorValue() {
            return currentColor;
        }

        //Implement the one method defined by TableCellEditor.
        public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
            currentColor = (Color)value;
            return button;
//            return combobox;
        }
    }

    public class ColorRenderer extends JLabel implements TableCellRenderer, ListCellRenderer {
        Border unselectedBorder = null;
        Border selectedBorder = null;
        boolean isBordered = true;

        public ColorRenderer(boolean isBordered) {
            this.isBordered = isBordered;
            setHorizontalAlignment(CENTER);
            setVerticalAlignment(CENTER);
            setOpaque(true);
        }

        public Component getTableCellRendererComponent(JTable table, Object color, boolean isSelected, boolean hasFocus, int row, int column) {
            Color newColor = (Color)color;
            setBackground(newColor);
            if (isBordered) {
                if (isSelected) {
                    if (selectedBorder == null) {
                        selectedBorder = BorderFactory.createMatteBorder(2, 5, 2, 5, table.getSelectionBackground());
                    }
                    setBorder(selectedBorder);
                } else {
                    if (unselectedBorder == null) {
                        unselectedBorder = BorderFactory.createMatteBorder(2, 5, 2, 5, table.getBackground());
                    }
                    setBorder(unselectedBorder);
                }
            }

            setToolTipText(String.format("RGB: red=%d, green=%d, blue=%d", newColor.getRed(), newColor.getGreen(), newColor.getBlue()));
            return this;
        }

        public Component getListCellRendererComponent(JList list, Object color, int index, boolean isSelected, boolean cellHasFocus) {
            Color newColor = (Color)color;
            setBackground(newColor);
            if (isBordered) {
                if (isSelected) {
                    if (selectedBorder == null) {
                        selectedBorder = BorderFactory.createMatteBorder(2, 5, 2, 5, list.getSelectionBackground());
                    }
                    setBorder(selectedBorder);
                } else {
                    if (unselectedBorder == null) {
                        unselectedBorder = BorderFactory.createMatteBorder(2, 5, 2, 5, list.getBackground());
                    }
                    setBorder(unselectedBorder);
                }
            }
            setToolTipText(String.format("RGB: red=%d, green=%d, blue=%d", newColor.getRed(), newColor.getGreen(), newColor.getBlue()));
            return this;
        }
    }

    public class HackyDragDropRowUI extends BasicTableUI {

        private boolean inDrag = false;
        private int start;
        private int offset;

        protected MouseInputListener createMouseInputListener() {
            return new HackyMouseInputHandler();
        }

        public void paint(Graphics g, JComponent c) {
            super.paint(g, c);

            if (!inDrag) {
                return;
            }

            int width = table.getWidth();
            int height = table.getRowHeight();
            g.setColor(table.getParent().getBackground());
            Rectangle rect = table.getCellRect(table.getSelectedRow(), 0, false);
            g.copyArea(rect.x, rect.y, width, height, rect.x, offset);

            if (offset < 0) {
                g.fillRect(rect.x, rect.y + (height + offset), width, (offset * -1));
            } else {
                g.fillRect(rect.x, rect.y, width, offset);
            }
        }

        class HackyMouseInputHandler extends MouseInputHandler {

            public void mouseDragged(MouseEvent e) {
                int row = table.getSelectedRow();
                if (row < 0) {
                    return;
                }

                inDrag = true;

                int height = table.getRowHeight();
                int middleOfSelectedRow = (height * row) + (height / 2);

                int toRow = -1;
                int yLoc = (int)e.getPoint().getY();

                // goin' up?
                if (yLoc < (middleOfSelectedRow - height)) {
                    toRow = row - 1;
                } else if (yLoc > (middleOfSelectedRow + height)) {
                    toRow = row + 1;
                }

                ProbeTableModel model = (ProbeTableModel)table.getModel();
                if ((toRow >= 0) && (toRow < table.getRowCount())) {
                    model.moveRow(row, toRow);
                    table.setRowSelectionInterval(toRow, toRow);
                    start = yLoc;
                }

                offset = (start - yLoc) * -1;
                table.repaint();
            }

            public void mousePressed(MouseEvent e) {
                super.mousePressed(e);
                start = (int)e.getPoint().getY();
            }

            public void mouseReleased(MouseEvent e){
                super.mouseReleased(e);
                inDrag = false;
                table.repaint();
            }
        }
    }
}