package de.intevation.flys.client.client.ui;

import java.util.LinkedHashMap;
import java.util.List;

import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;

import com.smartgwt.client.data.Record;

import com.smartgwt.client.widgets.Canvas;
import com.smartgwt.client.widgets.Label;
import com.smartgwt.client.widgets.form.DynamicForm;
import com.smartgwt.client.widgets.form.fields.FormItem;
import com.smartgwt.client.widgets.form.fields.RadioGroupItem;
import com.smartgwt.client.widgets.form.fields.events.BlurHandler;
import com.smartgwt.client.widgets.form.fields.events.BlurEvent;
import com.smartgwt.client.widgets.form.fields.events.ChangeHandler;
import com.smartgwt.client.widgets.form.fields.events.ChangeEvent;
import com.smartgwt.client.widgets.layout.HLayout;
import com.smartgwt.client.widgets.layout.VLayout;
import com.smartgwt.client.widgets.grid.ListGrid;
import com.smartgwt.client.widgets.grid.ListGridField;
import com.smartgwt.client.widgets.grid.events.CellClickHandler;
import com.smartgwt.client.widgets.grid.events.CellClickEvent;

import de.intevation.flys.client.shared.model.Data;
import de.intevation.flys.client.shared.model.DataItem;
import de.intevation.flys.client.shared.model.DataList;
import de.intevation.flys.client.shared.model.DefaultData;
import de.intevation.flys.client.shared.model.DefaultDataItem;
import de.intevation.flys.client.shared.model.WQInfoObject;
import de.intevation.flys.client.shared.model.WQInfoRecord;
import de.intevation.flys.client.shared.model.ArtifactDescription;
import com.smartgwt.client.types.ListGridFieldType;

import de.intevation.flys.client.client.services.WQInfoService;
import de.intevation.flys.client.client.services.WQInfoServiceAsync;
import de.intevation.flys.client.client.FLYSConstants;
import de.intevation.flys.client.client.FLYSImages;
import de.intevation.flys.client.client.Config;


/**
 * This UIProvider creates a widget to enter W or Q data.
 *
 * @author <a href="mailto:ingo.weinzierl@intevation.de">Ingo Weinzierl</a>
 */
public class WQInputPanel
extends      AbstractUIProvider
implements   ChangeHandler, BlurHandler
{
    /** The message class that provides i18n strings.*/
    protected FLYSConstants MESSAGE = GWT.create(FLYSConstants.class);

    /** The interface that provides the image resources. */
    private FLYSImages IMAGES = GWT.create(FLYSImages.class);

    /** The DistanceInfoService used to retrieve locations about rivers.*/
    protected WQInfoServiceAsync wqInfoService =
        GWT.create(WQInfoService.class);

    /** The constant field name for choosing w or q mode.*/
    public static final String FIELD_WQ = "wq";

    /** The constant field value for W input mode.*/
    public static final String FIELD_WQ_W = "W";

    /** The constant field value for Q input mode.*/
    public static final String FIELD_WQ_Q = "Q";

    /** The constant field name for choosing single values or range.*/
    public static final String FIELD_MODE = "mode";

    /** The constant field value for single input mode.*/
    public static final String FIELD_MODE_SINGLE = "single";

    /** The constant field value for range input mode.*/
    public static final String FIELD_MODE_RANGE = "range";

    /** The constant value that determines the width of the left panel.*/
    public static final int WIDTH_LEFT = 200;


    /** The container that manages the w and q panels.*/
    protected HLayout container;

    /** The RadioGroupItem that determines the w/q input mode.*/
    protected DynamicForm modes;

    /** The min values for the 'from' property in the W-Range input mode.*/
    protected double minW;

    /** The min values for the 'from' property in the Q-Range input mode.*/
    protected double minQ;

    /** The max values for the 'from' property in the W-Range input mode.*/
    protected double maxW;

    /** The max values for the 'from' property in the Q-Range input mode.*/
    protected double maxQ;

    /** The 'from' value entered in the range W mode.*/
    protected double fromW;

    /** The 'to' value entered in the range W mode.*/
    protected double toW;

    /** The 'step' value entered in the range W mode.*/
    protected double stepW;

    /** The values entered in the single W mode.*/
    protected double[] valuesW;

    /** The 'from' value entered in the range Q mode.*/
    protected double fromQ;

    /** The 'to' value entered in the range Q mode.*/
    protected double toQ;

    /** The 'step' value entered in the range Q mode.*/
    protected double stepQ;

    /** The values entered in the single Q mode.*/
    protected double[] valuesQ;

    /** The WQ Data*/
    protected WQInfoObject[] tableData;

    /** The WQ Input Table*/
    protected ListGrid wqTable;

    /** The WQ input table for ranges.*/
    protected ListGrid wqRangeTable;

    /**
     * Creates a new WQInputPanel instance.
     */
    public WQInputPanel() {
        wqTable      = new ListGrid();
        wqRangeTable = new ListGrid();
    }


    /**
     * This method calls createWidget and puts a 'next' button to the bottom.
     *
     * @param data The data that is displayed.
     *
     * @return the widget.
     */
    public Canvas create(DataList data) {
        initDefaults(data);


        Canvas  widget = createWidget(data);
        Canvas  submit = getNextButton();
        Label   label  = new Label(MESSAGE.wqTitle());

        label.setHeight(25);

        VLayout layout = new VLayout();
        layout.setMembersMargin(10);

        layout.addMember(label);
        layout.addMember(widget);
        layout.addMember(submit);

        return layout;
    }


    public Canvas createOld(DataList dataList) {
        List<Data> items = dataList.getAll();

        Data dMode      = getData(items, "wq_mode");
        Data dSelection = getData(items, "wq_selection");
        Data dSingle    = getData(items, "wq_single");
        Data dFrom      = getData(items, "wq_from");
        Data dTo        = getData(items, "wq_to");
        Data dStep      = getData(items, "wq_step");

        DataItem[] mode = dMode.getItems();
        String strMode  = mode[0].getStringValue();
        boolean wMode   = strMode.equals(FIELD_WQ_W);

        HLayout layout = new HLayout();
        layout.setWidth("400px");

        Label label  = new Label(dataList.getLabel());
        label.setWidth("200px");

        String text = null;

        DataItem[] selItem = dSelection.getItems();
        String     sel     = selItem != null
            ? selItem[0].getStringValue()
            : "";

        if (sel.equals("single")) {
            DataItem[] single = dSingle.getItems();

            text = wMode
                ? createWString(single[0])
                : createQString(single[0]);
        }
        else {
            DataItem[] from = dFrom.getItems();
            DataItem[] to   = dTo.getItems();
            DataItem[] step = dStep.getItems();

            text = wMode
                ? createWString(from[0], to[0], step[0])
                : createQString(from[0], to[0], step[0]);
        }

        Label selected = new Label(text);
        selected.setWidth("130px");

        Canvas back = getBackButton(dataList.getState());

        layout.addMember(label);
        layout.addMember(selected);
        layout.addMember(back);

        return layout;
    }


    protected void createWQInputPanel() {
        wqTable.setWidth(450);
        wqTable.setShowRecordComponents(true);
        wqTable.setShowRecordComponentsByCell(true);
        wqTable.setHeight(300);

        wqRangeTable.setWidth(450);
        wqRangeTable.setShowRecordComponents(true);
        wqRangeTable.setShowRecordComponentsByCell(true);
        wqRangeTable.setHeight(300);

        ListGridField addWQ = new ListGridField("", "");
        addWQ.setType(ListGridFieldType.ICON);
        addWQ.setWidth(30);
        wqTable.addCellClickHandler(new CellClickHandler() {
            public void onCellClick(CellClickEvent e) {
                if (e.getColNum() == 0 && e.getRecord().getEnabled ()) {
                    Record r = e.getRecord ();
                    double val = r.getAttributeAsDouble("value");
//                    setValue(val);
                }
            }
        });
        addWQ.setCellIcon (IMAGES.markerGreen().getURL());

        ListGridField addWQMin = new ListGridField("", "");
        addWQMin.setType(ListGridFieldType.ICON);
        addWQMin.setWidth(30);
        ListGridField addWQMax = new ListGridField("", "");
        addWQMax.setType(ListGridFieldType.ICON);
        addWQMax.setWidth(30);

        wqRangeTable.addCellClickHandler(new CellClickHandler() {
            public void onCellClick(CellClickEvent e) {
                if (e.getColNum() == 0 && e.getRecord().getEnabled ()) {
                    Record r = e.getRecord ();
                    double val = r.getAttributeAsDouble("value");
//                    setValue(val);
                }
                else if (e.getColNum() == 1 && e.getRecord().getEnabled()) {

                }
            }
        });
        addWQMin.setCellIcon(IMAGES.markerGreen().getURL());
        addWQMax.setCellIcon(IMAGES.markerRed().getURL());

        ListGridField name = new ListGridField("name", MESSAGE.name());
        name.setType(ListGridFieldType.TEXT);
        name.setWidth("*");
        ListGridField type = new ListGridField("type", MESSAGE.type());
        type.setType(ListGridFieldType.TEXT);
        type.setWidth("50");
        ListGridField value = new ListGridField("value", MESSAGE.wq_value());
        value.setType(ListGridFieldType.TEXT);
        type.setWidth("50");

        ListGridField name_r = new ListGridField("name", MESSAGE.name());
        name_r.setType(ListGridFieldType.TEXT);
        name_r.setWidth("*");
        ListGridField type_r = new ListGridField("type", MESSAGE.type());
        type_r.setType(ListGridFieldType.TEXT);
        type_r.setWidth("50");
        ListGridField value_r = new ListGridField("value", MESSAGE.wq_value());
        value_r.setType(ListGridFieldType.TEXT);
        type_r.setWidth("50");


        wqTable.setFields(addWQ, name, type, value);
        wqRangeTable.setFields(addWQMin, addWQMax, name_r, type_r, value_r);
    }

    /**
     * This method reads the default values defined in the DataItems of the Data
     * objects in <i>list</i>.
     *
     * @param list The DataList container that stores the Data objects.
     */
    protected void initDefaults(DataList list) {
        Data f = getData(list.getAll(), "wq_from");
        Data t = getData(list.getAll(), "wq_to");
        Data s = getData(list.getAll(), "wq_step");

        DataItem fQItem = getDataItem(f.getItems(), "minQ");
        DataItem fWItem = getDataItem(f.getItems(), "minW");
        DataItem tQItem = getDataItem(t.getItems(), "maxQ");
        DataItem tWItem = getDataItem(t.getItems(), "maxW");
        DataItem sQItem = getDataItem(s.getItems(), "stepQ");
        DataItem sWItem = getDataItem(s.getItems(), "stepW");

        minW  = Double.valueOf(fWItem.getStringValue());
        maxW  = Double.valueOf(tWItem.getStringValue());
        stepW = Double.valueOf(sWItem.getStringValue());

        minQ  = Double.valueOf(fQItem.getStringValue());
        maxQ  = Double.valueOf(tQItem.getStringValue());
        stepQ = Double.valueOf(sQItem.getStringValue());

        this.fromW = minW;
        this.toW   = maxW;
        this.stepW = stepW;

        this.fromQ = minQ;
        this.toQ   = maxQ;
        this.stepQ = stepQ;
    }


    protected String createWString(DataItem from, DataItem to, DataItem step) {
        StringBuilder sb = new StringBuilder();
        sb.append(from.getLabel());
        sb.append(" " + MESSAGE.unitWFrom() + " ");
        sb.append(to.getLabel());
        sb.append(" " + MESSAGE.unitWTo() + " ");
        sb.append(step.getLabel());
        sb.append(" " + MESSAGE.unitWStep());

        return sb.toString();
    }


    protected String createWString(DataItem single) {
        return single.getLabel();
    }


    protected String createQString(DataItem from, DataItem to, DataItem step) {
        StringBuilder sb = new StringBuilder();
        sb.append(from.getLabel());
        sb.append(" " + MESSAGE.unitQFrom() + " ");
        sb.append(to.getLabel());
        sb.append(" " + MESSAGE.unitQTo() + " ");
        sb.append(step.getLabel());
        sb.append(" " + MESSAGE.unitQStep());

        return sb.toString();
    }


    protected String createQString(DataItem single) {
        return single.getLabel();
    }


    /**
     * This method creates the whole widget. There is a panel on the left, that
     * allows the user to enter values manually by keyboard. On the right, there
     * is a table that allows the user to enter values by mouse click.
     *
     * @param data The data that is displayed in the table on the right.
     *
     * @return the widget.
     */
    protected Canvas createWidget(DataList data) {
        VLayout layout  = new VLayout();
        container       = new HLayout();
        Canvas modeForm = createModePanel();

        container.setMembersMargin(30);
        createWQInputTable();
        createWQInputPanel();
        // the initial panel is the Single-W panel.
        double[] values = getSingleW();
        container.addMember(new DoubleArrayPanel(
            MESSAGE.unitWSingle(), values, this));

        container.addMember(wqTable);
        layout.addMember(modeForm);
        layout.addMember(container);

        return layout;
    }


    /**
     * This method creates the mode panel. It contains two radio button panels
     * that allows the user to switch the input mode between w/q and
     * single/range input.
     *
     * @return a panel.
     */
    protected Canvas createModePanel() {
        RadioGroupItem wq = new RadioGroupItem(FIELD_WQ);
        wq.setShowTitle(false);
        wq.setVertical(false);
        wq.setWidth(WIDTH_LEFT);

        RadioGroupItem mode = new RadioGroupItem(FIELD_MODE);
        mode.setShowTitle(false);
        mode.setVertical(false);
        mode.setWidth(WIDTH_LEFT);

        LinkedHashMap wqValues = new LinkedHashMap();
        wqValues.put(FIELD_WQ_W, MESSAGE.wqW());
        wqValues.put(FIELD_WQ_Q, MESSAGE.wqQ());

        LinkedHashMap modeValues = new LinkedHashMap();
        modeValues.put(FIELD_MODE_SINGLE, MESSAGE.wqSingle());
        modeValues.put(FIELD_MODE_RANGE, MESSAGE.wqRange());

        wq.setValueMap(wqValues);
        mode.setValueMap(modeValues);

        wq.addChangeHandler(this);
        mode.addChangeHandler(this);

        modes = new DynamicForm();
        modes.setFields(wq, mode);
        modes.setWidth(WIDTH_LEFT);
        modes.setNumCols(1);

        LinkedHashMap initial = new LinkedHashMap();
        initial.put(FIELD_WQ, FIELD_WQ_W);
        initial.put(FIELD_MODE, FIELD_MODE_SINGLE);
        modes.setValues(initial);

        return modes;
    }


    /**
     * This method returns the selected data.
     *
     * @return the selected/inserted data.
     */
    public Data[] getData() {
        // XXX If we have entered a value and click right afterwards on the
        // 'next' button, the BlurEvent is not fired, and the values are not
        // saved. So, we gonna save those values explicitly.
        if (!isRangeMode()) {
            Canvas member = container.getMember(0);
            if (member instanceof DoubleArrayPanel) {
                DoubleArrayPanel form = (DoubleArrayPanel) member;
                if (isWMode()) {
                    saveSingleWValues(form);
                }
                else {
                    saveSingleQValues(form);
                }
            }

            return new Data[] {
                getDataMode(),
                getDataSelectionMode(),
                getDataSingle() };
        }
        else {
            Canvas member = container.getMember(0);
            if (member instanceof DoubleRangePanel) {
                DoubleRangePanel form = (DoubleRangePanel) member;

                if (isWMode()) {
                    saveRangeWValues(form);
                }
                else {
                    saveRangeQValues(form);
                }
            }

            return new Data[] {
                getDataMode(),
                getDataSelectionMode(),
                getDataFrom(),
                getDataTo(),
                getDataStep() };
        }
    }


    /**
     * Returns the Data object for the 'mode' attribute.
     *
     * @return the Data object for the 'mode' attribute.
     */
    protected Data getDataMode() {
        String wqMode = modes.getValueAsString(FIELD_WQ);
        DataItem item = new DefaultDataItem("wq_mode", "wq_mode", wqMode);
        return new DefaultData(
            "wq_mode", null, null, new DataItem[] { item });
    }


    /**
     * Returns the Data object for the 'mode' attribute.
     *
     * @return the Data object for the 'mode' attribute.
     */
    protected Data getDataSelectionMode() {
        String wqSelection = modes.getValueAsString(FIELD_MODE);
        DataItem item = new DefaultDataItem(
            "wq_selection", "wq_selection", wqSelection);

        return new DefaultData(
            "wq_selection", null, null, new DataItem[] { item });
    }


    /**
     * Returns the data object for the 'single' attribute.
     *
     * @return the Data object for the 'single' attribute.
     */
    protected Data getDataSingle() {
        double[] values  = getFinalSingle();
        StringBuilder sb = new StringBuilder();
        for (double value: values) {
            sb.append(Double.toString(value));
            sb.append(" ");
        }

        DataItem item = new DefaultDataItem(
            "wq_single", "wq_single", sb.toString());

        return new DefaultData(
            "wq_single", null, null, new DataItem[] { item });
    }


    /**
     * Returns the Data object for the 'from' attribute.
     *
     * @return the Data object for the 'from' attribute.
     */
    protected Data getDataFrom() {
        String value  = Double.valueOf(getFinalFrom()).toString();
        DataItem item = new DefaultDataItem("wq_from", "wq_from", value);
        return new DefaultData(
            "wq_from", null, null, new DataItem[] { item });
    }


    /**
     * Returns the Data object for the 'to' attribute.
     *
     * @return the Data object for the 'to' attribute.
     */
    protected Data getDataTo() {
        String value  = Double.valueOf(getFinalTo()).toString();
        DataItem item = new DefaultDataItem("wq_to", "wq_to", value);
        return new DefaultData(
            "wq_to", null, null, new DataItem[] { item });
    }


    /**
     * Returns the Data object for the 'step' attribute.
     *
     * @return the Data object for the 'step' attribute.
     */
    protected Data getDataStep() {
        String value  = Double.valueOf(getFinalStep()).toString();
        DataItem item = new DefaultDataItem("wq_step","wq_step", value);
        return new DefaultData(
            "wq_step", null, null, new DataItem[] { item });
    }


    protected double[] getFinalSingle() {
        boolean wMode = isWMode();

        return wMode ? getSingleW() : getSingleQ();
    }


    /**
     * Returns the value of 'from' depending on the selected input mode.
     *
     * @return the value of 'from' depending on the selected input mode.
     */
    protected double getFinalFrom() {
        boolean wMode     = isWMode();
        boolean rangeMode = isRangeMode();

        if (rangeMode) {
            return wMode ? getFromW() : getFromQ();

        }
        else {
            double[] values = wMode ? getSingleW() : getSingleQ();
            double   value  = Double.MAX_VALUE;

            for (double v: values) {
                value = value < v ? value : v;
            }

            return value;
        }
    }


    /**
     * Returns the value of 'to' depending on the selected input mode.
     *
     * @return the value of 'to' depending on the selected input mode.
     */
    protected double getFinalTo() {
        boolean wMode     = isWMode();
        boolean rangeMode = isRangeMode();

        if (rangeMode) {
            return wMode ? getToW() : getToQ();

        }
        else {
            double[] values = wMode ? getSingleW() : getSingleQ();
            double   value  = Double.MIN_VALUE;

            for (double v: values) {
                value = value > v ? value : v;
            }

            return value;
        }
    }


    /**
     * Returns the value of 'step' depending on the selected input mode.
     *
     * @return the value of 'step' depending on the selected input mode.
     */
    protected double getFinalStep() {
        boolean wMode     = isWMode();
        boolean rangeMode = isRangeMode();

        if (rangeMode) {
            return wMode ? getStepW() : getStepQ();
        }
        else {
            // we have no field to enter the 'step' attribute in the
            // single mode
            return 0d;
        }
    }


    /**
     * Determines the range/single mode.
     *
     * @return true if the range mode is activated.
     */
    public boolean isRangeMode() {
        String rMode = modes.getValueAsString(FIELD_MODE);

        return rMode.equals(FIELD_MODE_RANGE) ? true : false;
    }


    /**
     * Determines the w/q mode.
     *
     * @return true, if the W mode is activated.
     */
    public boolean isWMode() {
        String wq = modes.getValueAsString(FIELD_WQ);

        return wq.equals(FIELD_WQ_W) ? true : false;
    }


    /**
     * This method changes the lower panel with the input fields depending on
     * the combination of the two radio button panels.
     *
     * @param event The ChangeEvent.
     */
    public void onChange(ChangeEvent event) {
        DynamicForm form = event.getForm();
        FormItem    item = event.getItem();

        String wqMode    = null;
        String inputMode = null;

        if (item.getFieldName().equals(FIELD_MODE)) {
            wqMode    = form.getValueAsString(FIELD_WQ);
            inputMode = (String) event.getValue();
        }
        else {
            wqMode    = (String) event.getValue();
            inputMode = form.getValueAsString(FIELD_MODE);
        }

        container.removeMembers(container.getMembers());

        Canvas newPanel = null;

        if (wqMode.equals(FIELD_WQ_W)) {
            if (inputMode.equals(FIELD_MODE_SINGLE)) {
                // Single W mode
                double[] values = getSingleW();

                newPanel = new DoubleArrayPanel(
                    MESSAGE.unitWSingle(), values, this);

                container.addMember(newPanel);
                container.addMember(wqTable);
            }
            else {
                // Range W mode
                double from = getFromW();
                double to   = getToW();
                double step = getStepW();

                newPanel = new DoubleRangePanel(
                    MESSAGE.unitWFrom(), MESSAGE.unitWTo(), MESSAGE.unitWStep(),
                    from, to, step,
                    250,
                    this);
                container.addMember(newPanel);
                container.addMember(wqRangeTable);
            }
        }
        else {
            if (inputMode.equals(FIELD_MODE_SINGLE)) {
                // Single Q mode
                double[] values = getSingleQ();

                newPanel = new DoubleArrayPanel(
                    MESSAGE.unitQSingle(), values, this);
                container.addMember(newPanel);
                container.addMember(wqTable);
            }
            else {
                // Range Q mode
                double from = getFromQ();
                double to   = getToQ();
                double step = getStepQ();

                newPanel = new DoubleRangePanel(
                    MESSAGE.unitQFrom(), MESSAGE.unitQTo(), MESSAGE.unitQStep(),
                    from, to, step,
                    250,
                    this);
                container.addMember(newPanel);
                container.addMember(wqRangeTable);
            }
        }

    }


    /**
     * This method is called if the value of one of the input fields might have
     * changed. The entered values are validated and stored.
     *
     * @param event The BlurEvent.
     */
    public void onBlur(BlurEvent event) {
        DynamicForm form = event.getForm();
        FormItem    item = event.getItem();

        String wqMode    = (String) modes.getValue(FIELD_WQ);
        String inputMode = (String) modes.getValue(FIELD_MODE);

        if (wqMode.equals(FIELD_WQ_W)) {
            if (inputMode.equals(FIELD_MODE_SINGLE)) {
                DoubleArrayPanel p = (DoubleArrayPanel) form;
                saveSingleWValue(p, item);
            }
            else {
                DoubleRangePanel p = (DoubleRangePanel) form;
                saveRangeWValue(p, item);
            }
        }
        else {
            if (inputMode.equals(FIELD_MODE_SINGLE)) {
                DoubleArrayPanel p = (DoubleArrayPanel) form;
                saveSingleQValue(p, item);
            }
            else {
                DoubleRangePanel p = (DoubleRangePanel) form;
                saveRangeQValue(p, item);
            }
        }
    }


    protected void saveSingleWValues(DoubleArrayPanel p) {
        FormItem[] formItems = p.getFields();

        for (FormItem item: formItems) {
            if (item.getFieldName().equals(DoubleArrayPanel.FIELD_NAME)) {
                saveSingleWValue(p, item);
            }
        }
    }


    protected void saveSingleQValues(DoubleArrayPanel p) {
        FormItem[] formItems = p.getFields();

        for (FormItem item: formItems) {
            if (item.getFieldName().equals(DoubleArrayPanel.FIELD_NAME)) {
                saveSingleQValue(p, item);
            }
        }
    }


    protected void saveSingleWValue(DoubleArrayPanel p, FormItem item) {
        if (p.validateForm(item)) {
            setSingleW(p.getInputValues(item));
        }
    }


    protected void saveSingleQValue(DoubleArrayPanel p, FormItem item) {
        if (p.validateForm(item)) {
            setSingleQ(p.getInputValues(item));
        }
    }


    protected void saveRangeWValues(DoubleRangePanel p) {
        FormItem[] formItems = p.getFields();

        for (FormItem item: formItems) {
            saveRangeWValue(p, item);
        }
    }


    protected void saveRangeQValues(DoubleRangePanel p) {
        FormItem[] formItems = p.getFields();

        for (FormItem item: formItems) {
            saveRangeQValue(p, item);
        }
    }


    protected void saveRangeWValue(DoubleRangePanel p, FormItem item) {
        if (p.validateForm(item)) {
            setFromW(p.getFrom());
            setToW(p.getTo());
            setStepW(p.getStep());
        }
    }


    protected void saveRangeQValue(DoubleRangePanel p, FormItem item) {
        if (p.validateForm(item)) {
            setFromQ(p.getFrom());
            setToQ(p.getTo());
            setStepQ(p.getStep());
        }
    }


    protected double[] getSingleQ() {
        return valuesQ;
    }


    protected void setSingleQ(double[] values) {
        valuesQ = values;
    }


    protected double getFromQ() {
        return fromQ;
    }


    protected void setFromQ(double fromQ) {
        this.fromQ = fromQ;
    }


    protected double getToQ() {
        return toQ;
    }


    protected void setToQ(double toQ) {
        this.toQ = toQ;
    }


    protected double getStepQ() {
        return stepQ;
    }


    protected void setStepQ(double stepQ) {
        this.stepQ = stepQ;
    }


    protected double[] getSingleW() {
        return valuesW;
    }


    protected void setSingleW(double[] values) {
        valuesW = values;
    }


    protected double getFromW() {
        return fromW;
    }


    protected void setFromW(double fromW) {
        this.fromW = fromW;
    }


    protected double getToW() {
        return toW;
    }


    protected void setToW(double toW) {
        this.toW = toW;
    }


    protected double getStepW() {
        return stepW;
    }


    protected void setStepW(double stepW) {
        this.stepW = stepW;
    }


    protected void createWQInputTable() {
        Config config    = Config.getInstance();
        String url       = config.getServerUrl();
        String locale    = config.getLocale ();
        String river     = "";
        String value_min = "";
        String value_max = "";

        ArtifactDescription adescr = artifact.getArtifactDescription();
        DataList[] data = adescr.getOldData();

        //TODO: get the information about old data.
        if (data != null && data.length > 0) {
            for (int i = 0; i < data.length; i++) {
                DataList dl = data[i];
                if (dl.getState().equals("state.winfo.river")) {
                    for (int j = 0; j < dl.size(); j++) {
                        Data d = dl.get(j);
                        DataItem[] di = d.getItems();
                        if (di != null && di.length == 1) {
                           river = d.getItems()[0].getStringValue();
                        }
                    }
                }
                else if (dl.getState().equals("state.winfo.location_distance")){
                    for (int j = 0; j < dl.size(); j++) {
                        Data d = dl.get(j);
                        DataItem[] di = d.getItems();
                        if (di != null && di.length >= 1 && j == 0) {
                            value_max = d.getItems()[0].getStringValue();
                        }
                        else if (di != null &&
                                 di.length >= 1 &&
                                 j == dl.size() - 1) {
                            value_min = d.getItems()[0].getStringValue();
                        }
                    }
                }
            }
        }

        double from = Double.valueOf(value_min);
        double to = Double.valueOf(value_max);
        wqInfoService.getWQInfo(url, locale, river, from, to,
            new AsyncCallback<WQInfoObject[]>() {
                public void onFailure(Throwable caught) {
                    GWT.log("Could not recieve wq informations.");
                    GWT.log(caught.getMessage());
                }

                public void onSuccess(WQInfoObject[] wqi) {
                    int num = wqi != null ? wqi.length :0;
                    GWT.log("Recieved " + num + " wq informations.");

                    if (num == 0) {
                        return;
                    }
                    tableData = wqi;
                    addWQInfo(wqi);
                }
            }
        );
    }


    protected void addWQInfo (WQInfoObject[] wqi) {
        int i = 0;
        for(WQInfoObject wi: wqi) {
            WQInfoRecord rec = new WQInfoRecord (wi);
            wqTable.addData(rec);
            wqRangeTable.addData(rec);
        }
        return;
    }
}



// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :