/** Copyright (C) 2017 by Bundesanstalt für Gewässerkunde
 * Software engineering by
 *  Björnsen Beratende Ingenieure GmbH
 *  Dr. Schumacher Ingenieurbüro für Wasser und Umwelt
 *
 * This file is Free Software under the GNU AGPL (>=v3)
 * and comes with ABSOLUTELY NO WARRANTY! Check out the
 * documentation coming with Dive4Elements River for details.
 */
package org.dive4elements.river.client.client.ui;

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

import org.dive4elements.river.client.client.ui.FromToTableHelperPanel.IColumnClickHandler;
import org.dive4elements.river.client.shared.model.Data;
import org.dive4elements.river.client.shared.model.DataItem;
import org.dive4elements.river.client.shared.model.DataList;
import org.dive4elements.river.client.shared.model.DefaultData;
import org.dive4elements.river.client.shared.model.DefaultDataItem;

import com.smartgwt.client.widgets.Canvas;
import com.smartgwt.client.widgets.Label;
import com.smartgwt.client.widgets.form.fields.TextItem;
import com.smartgwt.client.widgets.grid.ListGrid;
import com.smartgwt.client.widgets.grid.ListGridRecord;
import com.smartgwt.client.widgets.layout.HLayout;
import com.smartgwt.client.widgets.layout.VLayout;

/**
 * @author Domenico Nardi Tironi
 *
 */
public abstract class AbstractEpochPanel extends AbstractUIProvider {

    private static final long serialVersionUID = 1L;

    protected enum Type {
        single, multi
        // Type single: nur eine Epoche kann gesetzt werden; minMax vorbelegt aus Datenquelle
        // Type multi: mehrere epochs können eingegeben werden
    }

    private TextItem start;

    private TextItem end;

    private ListGrid elements;

    private List<String> validInputs = new ArrayList<String>();

    private final Type type;

    public AbstractEpochPanel(final Type type) {
        this.type = type;
    }

    protected abstract String getDatakey();

    protected abstract Canvas createWidget(final DataList data);

    protected final TextItem createStartInputItem(final String title) {
        this.start = PanelHelper.createItem(title);
        return this.start;
    }

    protected final TextItem createEndInputItem(final String title) {
        this.end = PanelHelper.createItem(title);
        return this.end;
    }

    protected final ListGrid createListGrid() {
        this.elements = new ListGrid();
        this.elements.setShowHeaderContextMenu(false);
        this.elements.setCanReorderFields(false);
        this.elements.setCanSort(false);
        this.elements.setCanEdit(false);
        return this.elements;
    }

    @Override
    public final Canvas createOld(final DataList dataList) {
        final HLayout layout = new HLayout();
        layout.setWidth("400px");
        final VLayout vLayout = new VLayout();
        vLayout.setWidth(130);
        final Label label = new Label(dataList.getLabel());
        label.setWidth("200px");
        label.setHeight(25);

        final List<Data> items = dataList.getAll();
        final Data str = getData(items, getDatakey());
        final DataItem[] strItems = str.getItems();

        final String[] pairs = strItems[0].getLabel().split(";");
        for (final String pair : pairs) {
            final Label dateLabel = new Label(pair.replace(",", " - "));
            dateLabel.setHeight(20);
            vLayout.addMember(dateLabel);
        }
        final Canvas back = getBackButton(dataList.getState());
        layout.addMember(label);
        layout.addMember(vLayout);
        layout.addMember(back);

        return layout;
    }

    @Override
    public final Canvas create(final DataList data) {
        final VLayout layout = new VLayout();
        final Canvas submit = getNextButton();
        final Canvas widget = createWidget(data);

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

        final IColumnClickHandler fromHandler = createHandler(this.start);
        final IColumnClickHandler toHandler = createHandler(this.end);

        final FromToTableHelperPanel helper = new FromToTableHelperPanel(data, getDatakey(), this.MSG, fromHandler, toHandler);
        this.validInputs = helper.getKeycolEntries();
        final Canvas table = helper.getTable();

        this.helperContainer.addMember(table);

        return layout;
    }

    private final IColumnClickHandler createHandler(final TextItem field) {
        final IColumnClickHandler handler = new IColumnClickHandler() {

            @Override
            public void columnClicked(final String value) {
                field.setValue(value);
            }
        };
        return handler;
    }

    /*
     * Validate the epoch input. We do this here and not in an overridden
     * validate method as we want to validate before an epoch is added
     * to the list of epochs.
     */
    protected final boolean isValidEpoch(final String y1, final String y2) {
        // First check that both are integer
        // int iY1;
        // int iY2;
        final List<String> errors = new ArrayList<String>();
        try {
            // iY1 =
            Integer.parseInt(y1);
        }
        catch (final NumberFormatException e) {
            errors.add(this.MSG.wrongFormat() + ": " + y1);
        }
        try {
            // iY2 =
            Integer.parseInt(y2);
        }
        catch (final NumberFormatException e) {
            errors.add(this.MSG.wrongFormat() + ": " + y2);
        }
        if (!errors.isEmpty()) {
            showErrors(errors);
            return false;
        }
        boolean startIsGood = false;
        boolean endIsGood = false;
        for (final String validYear : this.validInputs) {
            if (startIsGood || y1.equals(validYear)) {
                startIsGood = true;
            }
            if (endIsGood || y2.equals(validYear)) {
                endIsGood = true;
            }
            if (startIsGood && endIsGood) {
                break;
            }
            /*
             * alternative check if data lies in between
             * int aYear = Integer.parseInt(validYear);
             * if (aYear >= iY1 && aYear <= iY2) {
             * isGood = true;
             * break;
             * }
             */
        }
        if (!startIsGood) {
            String tmp = this.MSG.no_data_for_year();
            tmp = tmp.replace("$1", y1);
            errors.add(tmp);
        }
        if (!endIsGood) {
            String tmp = this.MSG.no_data_for_year();
            tmp = tmp.replace("$1", y2);
            errors.add(tmp);
        }
        if (!errors.isEmpty()) {
            showErrors(errors);
            return false;
        }
        return true;
    }

    @Override
    protected final Data[] getData() {
        final List<Data> data = new ArrayList<Data>();
        switch (this.type) {

        case single:
            data.add(buildResult(this.start.getValueAsString(), this.end.getValueAsString()));

            break;
        case multi:
            final ListGridRecord[] lgr = this.elements.getRecords();
            if (lgr.length == 0) {
                return new Data[0];
            }
            for (final ListGridRecord element : lgr) {
                data.add(buildResult(element.getAttribute("from"), element.getAttribute("to")));
            }
            break;
        default:
            throw new IllegalStateException();
        }
        return data.toArray(new Data[data.size()]);
    }

    private final Data buildResult(final String startStr, final String endStr) {
        final StringBuilder builder = new StringBuilder();
        builder.append(startStr);
        builder.append(",");
        builder.append(endStr);
        builder.append(";");
        final DataItem item = new DefaultDataItem(getDatakey(), null, builder.toString());
        return new DefaultData(getDatakey(), null, null, new DataItem[] { item });
    }

}