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

import java.util.ArrayList;
import java.util.List;

import com.google.gwt.core.client.GWT;
import com.google.gwt.i18n.client.NumberFormat;

import com.smartgwt.client.data.Record;
import com.smartgwt.client.util.SC;
import com.smartgwt.client.widgets.Canvas;
import com.smartgwt.client.widgets.Label;
import com.smartgwt.client.widgets.form.fields.events.BlurHandler;
import com.smartgwt.client.widgets.form.fields.events.BlurEvent;
import com.smartgwt.client.widgets.grid.events.RecordClickHandler;
import com.smartgwt.client.widgets.grid.events.RecordClickEvent;
import com.smartgwt.client.widgets.layout.HLayout;
import com.smartgwt.client.widgets.layout.VLayout;
import com.smartgwt.client.widgets.tab.TabSet;
import com.smartgwt.client.widgets.tab.Tab;

import de.intevation.flys.client.shared.model.ArtifactDescription;
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.client.Config;
import de.intevation.flys.client.client.FLYSConstants;
import de.intevation.flys.client.client.ui.range.DistanceInfoDataSource;
import de.intevation.flys.client.client.ui.range.RangeTable;
import de.intevation.flys.client.client.ui.range.LocationsTable;


public class DistancePanel extends AbstractUIProvider implements BlurHandler {

    public static final int DEFAULT_STEP_WIDTH = 100;

    public static final String FIELD_LOWER = "ld_from";
    public static final String FIELD_UPPER = "ld_to";
    public static final String FIELD_STEP  = "ld_step";


    protected FLYSConstants MSG = GWT.create(FLYSConstants.class);

    protected RangeTable     distancesTable;
    protected LocationsTable locationsTable;

    protected DoubleRangePanel distancePanel;

    protected TabSet tabs;

    protected double min;
    protected double max;


    public DistancePanel() {
        this("right");
    }


    public DistancePanel(String labelOrientation) {
        distancePanel  = new DoubleRangePanel(
            labelFrom(), labelTo(), labelStep(),
            0d, 0d, 0d, 250, this, labelOrientation);
    }


    @Override
    public Canvas create(DataList data) {
        Data d = data.get(0);

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

        Label label = new Label(d.getDescription());

        Canvas submit = getNextButton();

        label.setHeight(25);
        distancePanel.setHeight(50);

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

        initMinMaxValues(data);
        initDefaultValues(data);
        initHelperPanel();

        return layout;
    }


    @Override
    public Canvas createOld(DataList dataList) {
        String s = getOldSelectionString(dataList);
        String l = dataList.getLabel();

        Label label    = new Label(l);
        Label selected = new Label(s);

        HLayout layout = new HLayout();

        layout.setWidth(400);
        label.setWidth(200);
        selected.setWidth(130);

        layout.addMember(label);
        layout.addMember(selected);
        layout.addMember(getBackButton(dataList.getState()));

        return layout;
    }


    protected String getOldSelectionString(DataList dataList) {
        List<Data> items = dataList.getAll();

        Data dFrom = getData(items, getLowerField());
        Data dTo   = getData(items, getUpperField());
        Data dStep = getData(items, getStepField());

        DataItem[] from = dFrom.getItems();
        DataItem[] to   = dTo.getItems();
        DataItem[] step = dStep.getItems();

        StringBuilder sb = new StringBuilder();
        sb.append(from[0].getLabel());
        sb.append(" " + getUnitFrom() + " - ");
        sb.append(to[0].getLabel());
        sb.append(" " + getUnitTo() + " - ");
        sb.append(step[0].getLabel());
        sb.append(" " + getUnitStep());

        return sb.toString();
    }


    protected String labelFrom() {
        return getLabelFrom() + " [" + getUnitFrom() + "]";
    }


    protected String getLabelFrom() {
        return MSG.dpLabelFrom();
    }


    protected String getUnitFrom() {
        return MSG.dpUnitFrom();
    }


    protected String labelTo() {
        return getLabelTo() + " [" + getUnitTo() + "]";
    }


    protected String getLabelTo() {
        return MSG.dpLabelTo();
    }


    protected String getUnitTo() {
        return MSG.dpUnitTo();
    }


    protected String labelStep() {
        return getLabelStep() + " [" + getUnitStep() + "]";
    }


    protected String getLabelStep() {
        return MSG.dpLabelStep();
    }


    protected String getUnitStep() {
        return MSG.dpUnitStep();
    }


    protected String getLowerField() {
        return FIELD_LOWER;
    }


    protected String getUpperField() {
        return FIELD_UPPER;
    }


    protected String getStepField() {
        return FIELD_STEP;
    }


    @Override
    public List<String> validate() {
        List<String> errors = new ArrayList<String>();

        if (!distancePanel.validateForm()) {
            errors.add(MSG.wrongFormat());

            return errors;
        }

        validateFrom(errors);
        validateTo(errors);

        return errors;
    }


    protected void validateFrom(List<String> errors) {
        double from = distancePanel.getFrom();

        if (from < min || from > max) {
            NumberFormat nf = NumberFormat.getDecimalFormat();

            String tmp = MSG.error_validate_lower_range();
            tmp        = tmp.replace("$1", nf.format(from));
            tmp        = tmp.replace("$2", nf.format(min));

            distancePanel.setFrom(min);
            errors.add(tmp);
        }
    }


    protected void validateTo(List<String> errors) {
        double to = distancePanel.getTo();

        if (to < min || to > max) {
            NumberFormat nf = NumberFormat.getDecimalFormat();

            String tmp = MSG.error_validate_upper_range();
            tmp        = tmp.replace("$1", nf.format(to));
            tmp        = tmp.replace("$2", nf.format(max));

            distancePanel.setTo(max);
            errors.add(tmp);
        }
    }


    @Override
    public Data[] getData() {
        Data[] data = new Data[3];

        data[0] = getDataFrom();
        data[1] = getDataTo();
        data[2] = getDataStep();

        return data;
    }


    protected Data getDataFrom() {
        String value = String.valueOf(distancePanel.getFrom());
        String field = getLowerField();

        DataItem item = new DefaultDataItem(field, field, value);
        return new DefaultData(
            field, null, null, new DataItem[] { item });
    }


    protected Data getDataTo() {
        String value = String.valueOf(distancePanel.getTo());
        String field = getUpperField();

        DataItem item = new DefaultDataItem(field, field, value);
        return new DefaultData(
            field, null, null, new DataItem[] { item });
    }


    protected Data getDataStep() {
        String value = String.valueOf(distancePanel.getStep());
        String field = getStepField();

        DataItem item = new DefaultDataItem(field, field, value);
        return new DefaultData(
            field, null, null, new DataItem[] { item });
    }


    @Override
    public void onBlur(BlurEvent event) {
        distancePanel.validateForm();
    }


    protected void initMinMaxValues(DataList data) {
        Data f = getData(data.getAll(), getLowerField());
        Data t = getData(data.getAll(), getUpperField());

        DataItem[] fItems = f.getItems();
        DataItem[] tItems = t.getItems();

        try {
            min = Double.valueOf(fItems[0].getStringValue());
            max = Double.valueOf(tItems[0].getStringValue());
        }
        catch (NumberFormatException nfe) {
            min = -Double.MAX_VALUE;
            max =  Double.MAX_VALUE;
        }
    }


    protected void initDefaultValues(DataList data) {
        initDefaultFrom(data);
        initDefaultTo(data);
        initDefaultStep(data);
    }


    protected void initDefaultFrom(DataList data) {
        Data f = getData(data.getAll(), getLowerField());

        double from = getDefaultFrom();

        try {
            from = getDefaultValue(f);
        }
        catch (NumberFormatException nfe) {
            // do nothing
        }

        distancePanel.setFrom(from);
    }


    protected double getDefaultFrom() {
        return min;
    }


    protected void initDefaultTo(DataList data) {
        Data t = getData(data.getAll(), getUpperField());

        double to = getDefaultTo();

        try {
            to = getDefaultValue(t);
        }
        catch (NumberFormatException nfe) {
            // do nothing
        }

        distancePanel.setTo(to);
    }


    protected double getDefaultTo() {
        return max;
    }


    protected void initDefaultStep(DataList data) {
        Data s = getData(data.getAll(), getStepField());

        double step = getDefaultStep();

        try {
            step = getDefaultValue(s);
        }
        catch (NumberFormatException nfe) {
            // do nothing
        }

        distancePanel.setStep(step);
    }


    protected double getDefaultStep() {
        return (double) DEFAULT_STEP_WIDTH;
    }


    protected double getDefaultValue(Data data)
    throws NumberFormatException
    {
        DataItem def      = data.getDefault();
        String   defValue = def != null ? def.getStringValue() : null;

        return Double.valueOf(defValue);
    }


    protected void initHelperPanel() {
        distancesTable = new RangeTable();
        locationsTable = new LocationsTable();

        Config config = Config.getInstance();
        String url    = config.getServerUrl();
        String river  = getRiverName();

        distancesTable.setAutoFetchData(true);
        locationsTable.setAutoFetchData(true);
        distancesTable.setDataSource(new DistanceInfoDataSource(
            url, river, "distances"));
        locationsTable.setDataSource(new DistanceInfoDataSource(
            url, river, "locations"));

        distancesTable.addRecordClickHandler(new RecordClickHandler() {
            public void onRecordClick(RecordClickEvent e) {
                Record r = e.getRecord();

                String from = r.getAttribute("from");
                String to   = r.getAttribute("to");

                try {
                    distancePanel.setFrom(Double.valueOf(from));
                    distancePanel.setTo(Double.valueOf(to));
                }
                catch (NumberFormatException nfe) {
                    SC.warn(MSG.wrongFormat());
                }
            }
        });

        locationsTable.addRecordClickHandler(new RecordClickHandler() {
            public void onRecordClick(RecordClickEvent e) {
                Record  r = e.getRecord();
                int field = e.getFieldNum();

                try {
                    String value = r.getAttribute("from");

                    switch (field) {
                    case 0:
                        distancePanel.setFrom(Double.valueOf(value));
                        break;
                    case 1:
                        distancePanel.setTo(Double.valueOf(value));
                        break;
                    }
                }
                catch (NumberFormatException nfe) {
                    SC.warn(MSG.wrongFormat());
                }
            }
        });

        tabs = new TabSet();
        tabs.setWidth100();
        tabs.setHeight100();

        Tab locations = new Tab(MSG.locations());
        Tab distances = new Tab(MSG.distance());

        locations.setPane(locationsTable);
        distances.setPane(distancesTable);

        tabs.addTab(locations, 0);
        tabs.addTab(distances, 1);

        helperContainer.addMember(tabs);
    }


    protected String getRiverName() {
        ArtifactDescription adescr = artifact.getArtifactDescription();
        DataList[] data = adescr.getOldData();

        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) {
                           return d.getItems()[0].getStringValue();
                        }
                    }
                }
            }
        }

        return null;
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :