frontend/client/src/autotest/tko/MetricsPlotFrontend.java

package autotest.tko;

import autotest.common.Utils;
import autotest.common.ui.ExtendedListBox;
import autotest.common.ui.NotifyManager;
import autotest.common.ui.TabView;
import autotest.tko.SeriesSelector.Series;

import com.google.gwt.event.dom.client.ChangeEvent;
import com.google.gwt.event.dom.client.ChangeHandler;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.google.gwt.user.client.ui.Panel;
import com.google.gwt.user.client.ui.RadioButton;
import com.google.gwt.user.client.ui.TextBox;
import com.google.gwt.user.client.ui.VerticalPanel;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MetricsPlotFrontend extends DynamicGraphingFrontend implements ClickHandler {
    
    public static final String NORMALIZE_SINGLE = "single";
    public static final String NORMALIZE_FIRST = "first";
    public static final String NORMALIZE_SERIES_PREFIX = "series__";
    public static final String NORMALIZE_X_PREFIX = "x__";
    
    protected FilterSelector globalFilter = new FilterSelector(DBColumnSelector.PERF_VIEW);
    private ExtendedListBox plotSelector = new ExtendedListBox();
    private ExtendedListBox xAxis = new DBColumnSelector(DBColumnSelector.PERF_VIEW, true);
    private RadioButton noNormalizeMultiple =
        new RadioButton("normalize", "No normalization (multiple subplots)");
    private RadioButton noNormalizeSingle =
        new RadioButton("normalize", "No normalization (single plot)");
    private RadioButton normalizeFirst = new RadioButton("normalize", "First data point");
    private RadioButton normalizeSeries = new RadioButton("normalize", "Specified series:");
    private ExtendedListBox normalizeSeriesSelect = new ExtendedListBox();
    private RadioButton normalizeX = new RadioButton("normalize", "Specified X-axis value:");
    private TextBox normalizeXSelect = new TextBox();
    private SeriesSelector seriesSelector = new SeriesSelector(new ChangeHandler() {
        public void onChange(ChangeEvent event) {
            refreshSeries();
        }
    });
    
    public MetricsPlotFrontend(final TabView parent) {
        super(parent, new MetricsPlot(), "metrics");

        noNormalizeSingle.setValue(true);

        noNormalizeMultiple.addClickHandler(this);
        noNormalizeSingle.addClickHandler(this);
        normalizeFirst.addClickHandler(this);
        normalizeSeries.addClickHandler(this);
        normalizeX.addClickHandler(this);

        normalizeSeriesSelect.setEnabled(false);
        normalizeXSelect.setEnabled(false);

        plotSelector.addItem("Line");
        plotSelector.addItem("Bar");
        plotSelector.addChangeHandler(new ChangeHandler() {
            public void onChange(ChangeEvent event) {
                checkNormalizeInput();
            }
        });

        Panel normalizePanel = new VerticalPanel();
        normalizePanel.add(noNormalizeMultiple);
        normalizePanel.add(noNormalizeSingle);
        Panel seriesPanel = new HorizontalPanel();
        seriesPanel.add(normalizeSeries);
        seriesPanel.add(normalizeSeriesSelect);
        normalizePanel.add(seriesPanel);
        normalizePanel.add(normalizeFirst);
        Panel baselinePanel = new HorizontalPanel();
        baselinePanel.add(normalizeX);
        baselinePanel.add(normalizeXSelect);
        normalizePanel.add(baselinePanel);
        
        addControl("Preconfigured:", preconfig);
        addControl("Plot:", plotSelector);
        addControl("X-axis values:", xAxis);
        addControl("Global filters:", globalFilter);
        addControl("Series:", seriesSelector);
        addControl("Normalize to:", normalizePanel);
        
        commonInitialization();
    }

    @Override
    public void onClick(ClickEvent event) {
        if (event.getSource() != noNormalizeSingle && event.getSource() != noNormalizeMultiple 
                && event.getSource() != normalizeSeries && event.getSource() != normalizeX) {
            super.onClick(event);
            return;
        }

        normalizeSeriesSelect.setEnabled(false);
        normalizeXSelect.setEnabled(false);
        if (event.getSource() == normalizeSeries) {
            normalizeSeriesSelect.setEnabled(true);
            refreshSeries();
        } else if (event.getSource() == normalizeX) {
            normalizeXSelect.setEnabled(true);
        }

        checkInvertible();
    }
    
    private void addNormalizeParameter(String plotType, Map<String, String> parameters) {
        String normalizationType = null;
        if (plotType.equals("Line") && noNormalizeSingle.getValue()) {
            normalizationType = NORMALIZE_SINGLE;
        } else if (normalizeFirst.getValue()) {
            normalizationType = NORMALIZE_FIRST;
        } else if (normalizeSeries.getValue()) {
            String series = normalizeSeriesSelect.getSelectedValue();
            normalizationType = NORMALIZE_SERIES_PREFIX + series;
        } else if (normalizeX.getValue()) {
            String baseline = normalizeXSelect.getText();
            normalizationType = NORMALIZE_X_PREFIX + baseline;
        }
        
        if (normalizationType != null) {
            parameters.put("normalize", normalizationType);
        }
    }

    @Override
    public void addToHistory(Map<String, String> args) {
        String plot = plotSelector.getValue(plotSelector.getSelectedIndex());
        args.put("plot", plot);
        args.put("xAxis", xAxis.getSelectedValue());
        globalFilter.addToHistory(args, "globalFilter");
        seriesSelector.addToHistory(args);
        addNormalizeParameter(plot, args);
    }
    
    @Override
    public void handleHistoryArguments(Map<String, String> args) {
        setVisible(false);
        plot.setVisible(false);
        embeddingLink.setVisible(false);
        globalFilter.reset();
        seriesSelector.reset();
        for (int i = 0; i < plotSelector.getItemCount(); i++) {
            if (plotSelector.getValue(i).equals(args.get("plot"))) {
                plotSelector.setSelectedIndex(i);
                break;
            }
        }
        
        xAxis.selectByValue(args.get("xAxis"));
        globalFilter.handleHistoryArguments(args, "globalFilter");
        seriesSelector.handleHistoryArguments(args);
        
        refreshSeries();
        noNormalizeMultiple.setValue(true);
        normalizeSeriesSelect.setEnabled(false);
        normalizeXSelect.setEnabled(false);
        String normalizeString = args.get("normalize");
        if (normalizeString != null) {
            if (normalizeString.equals(NORMALIZE_SINGLE)) {
                noNormalizeSingle.setValue(true);
            } else if (normalizeString.equals(NORMALIZE_FIRST)) {
                normalizeFirst.setValue(true);
            } else if (normalizeString.startsWith(NORMALIZE_SERIES_PREFIX)) {
                normalizeSeries.setValue(true);
                String series = normalizeString.substring(NORMALIZE_SERIES_PREFIX.length());
                for (int i = 0; i < normalizeSeriesSelect.getItemCount(); i++) {
                    if (normalizeSeriesSelect.getValue(i).equals(series)) {
                        normalizeSeriesSelect.setSelectedIndex(i);
                        break;
                    }
                }
                normalizeSeriesSelect.setEnabled(true);
            } else if (normalizeString.startsWith(NORMALIZE_X_PREFIX)) {
                normalizeX.setValue(true);
                normalizeXSelect.setText(normalizeString.substring(NORMALIZE_X_PREFIX.length()));
                normalizeXSelect.setEnabled(true);
            }
        }
        checkNormalizeInput();
        checkInvertible();

        setVisible(true);
    }
    
    @Override
    protected void addAdditionalEmbeddingParams(JSONObject params) {
        params.put("graph_type", new JSONString("metrics"));
        params.put("params", buildParams());
    }
    
    private void refreshSeries() {
        String selectedValue = normalizeSeriesSelect.getSelectedValue();
        normalizeSeriesSelect.clear();
        for (Series selector : seriesSelector.getAllSeries()) {
            normalizeSeriesSelect.addItem(selector.getName());
            if (selector.getName().equals(selectedValue)) {
                normalizeSeriesSelect.setSelectedIndex(normalizeSeriesSelect.getItemCount() - 1);
            }
        }
    }

    // Disable "No Normalization (multiple)" for bar charts
    private void checkNormalizeInput() {
        if (plotSelector.getValue(plotSelector.getSelectedIndex()).equals("Line")) {
            noNormalizeMultiple.setEnabled(true);
        } else {
            noNormalizeMultiple.setEnabled(false);
            if (noNormalizeMultiple.getValue()) {
                noNormalizeSingle.setValue(true);
            }
        }
    }
    
    private JSONObject buildQueries() {
        List<Series> seriesList = seriesSelector.getAllSeries();
        JSONObject queries = new JSONObject();
        StringBuilder sql = new StringBuilder();
        
        sql.append("SELECT ");
        sql.append(xAxis.getSelectedValue());
        for (Series series : seriesList) {
            addSeriesSelects(series, sql);
        }
        
        sql.append(" FROM tko_perf_view_2");
            
        String xFilterString = globalFilter.getFilterString();
        if (xFilterString.equals("")) {
            NotifyManager.getInstance().showError("You must enter a global filter");
            return null;
        }
        
        sql.append(" WHERE ");
        sql.append(xFilterString);

        sql.append(" GROUP BY ");
        sql.append(xAxis.getSelectedValue());
        queries.put("__main__", new JSONString(sql.toString()));
        
        for (Series series : seriesList) {
            String drilldownQuery = getSeriesDrilldownQuery(series, xFilterString);
            queries.put("__" + series.getName() + "__", new JSONString(drilldownQuery));
        }
        
        return queries;
    }

    private String getSeriesDrilldownQuery(Series series, String xFilterString) {
        StringBuilder sql;
        sql = new StringBuilder();
        ExtendedListBox valueSelector = series.getDBColumnSelector();
        
        sql.append("SELECT test_idx, ");
        sql.append(valueSelector.getSelectedValue());
        sql.append(" FROM tko_perf_view_2 WHERE ");
        
        String seriesFilter = series.getFilterString();
        if (!xFilterString.equals("") || !seriesFilter.equals("")) {
            sql.append(xFilterString.replace("%", "%%"));
            if (!xFilterString.equals("") && !seriesFilter.equals("")) {
                sql.append(" AND ");
            }
            sql.append(seriesFilter.replace("%", "%%"));
            sql.append(" AND ");
        }
        
        sql.append(xAxis.getSelectedValue());
        sql.append(" = %s ORDER BY ");
        sql.append(valueSelector.getSelectedValue());
        return sql.toString();
    }

    private void addSeriesSelects(Series series, StringBuilder sql) {
        ExtendedListBox valueSelector = series.getDBColumnSelector();
        
        StringBuilder ifClause = new StringBuilder();
        String seriesFilter = series.getFilterString();
        if (!seriesFilter.equals("")) {
            ifClause.append("IF(");
            ifClause.append(seriesFilter);
            ifClause.append(", ");
        }
        ifClause.append(valueSelector.getSelectedValue());
        if (!seriesFilter.equals("")) {
            ifClause.append(", NULL)");   
        }
        
        sql.append(", ");
        sql.append(series.getAggregation());
        sql.append(ifClause.toString());
        sql.append(") '");
        sql.append(series.getName());
        sql.append("'");
        if (series.wantErrorBars()) {
            sql.append(", STDDEV(");
            sql.append(ifClause.toString());
            sql.append(") 'errors-");
            sql.append(series.getName());
            sql.append("'");
        }
    }
    
    // Disable the "Invert y-axis" checkboxes if inversion doesn't make sense
    private void checkInvertible() {
        boolean invertible = noNormalizeMultiple.getValue() || normalizeFirst.getValue()
                             || normalizeX.getValue();
        seriesSelector.setInvertible(invertible);
    }
    
    @Override
    protected JSONObject buildParams() {
        JSONObject queries = buildQueries();
        if (queries == null) {
            return null;
        }
        
        Map<String, String> params = new HashMap<String, String>();
        String plot = plotSelector.getSelectedValue();
        params.put("plot", plot);
        addNormalizeParameter(plot, params);

        JSONObject jsonParams = Utils.mapToJsonObject(params);
        jsonParams.put("invert", Utils.stringsToJSON(seriesSelector.getInverted()));
        jsonParams.put("queries", queries);
        return jsonParams;
    }

    @Override
    public String getFrontendId() {
        return "metrics_plot";
    }
}