/** 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.util.SC;
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.layout.HLayout;
import com.smartgwt.client.widgets.layout.VLayout;

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

    private static final long serialVersionUID = 1L;

    public enum Type {
        single, multi, limit5 // "SingleItem" (Klassenname) meint, dass es nur ein einziges Eingabefeld gibt (nicht from-to; epoch)
        // Type multi: append (year): es können mehrere Werte eingegeben werden; Leerzeichen-getrennt
        // Type single: append (year, sohlhöhendifferenz): nur ein Wert ist zulässig
        // Type limit5 TODO: generalize, if needed
    }

    private final Type type;

    private TextItem inputItem;

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

    protected abstract String getDatakey();

    protected abstract Canvas createWidget(final DataList data);

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

    @Override
    public final Canvas create(final DataList data) {
        final VLayout layout = new VLayout();
        final IColumnClickHandler fromHandler = new IColumnClickHandler() { // add to external class

            @Override
            public void columnClicked(final String value) {
                appendValue(value);
            }
        };

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

        this.helperContainer.addMember(table);

        final Canvas submit = getNextButton();
        final Canvas widget = createWidget(data);

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

        return layout;
    }

    @Override
    public final Canvas createOld(final DataList dataList) {
        final List<Data> items = dataList.getAll();
        final Data years = getData(items, getDatakey());
        final DataItem[] yearsItems = years.getItems();

        final String v1 = yearsItems[0].getStringValue().replace(" ", ", ");

        final Label old = new Label(v1);
        final HLayout layout = new HLayout();
        layout.setWidth("400px");

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

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

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

        return layout;
    }

    @Override
    protected final Data[] getData() {
        final List<String> errors = this.validate();
        if (errors.size() > 0) {
            showErrors(errors); // TODO: do not allow advance state
            // return null;
        }
        if (this.inputItem != null && !this.inputItem.getValueAsString().isEmpty()) {
            final List<Data> data = new ArrayList<Data>();

            final DataItem yearsdata = new DefaultDataItem(getDatakey(), getDatakey(), this.inputItem.getValueAsString().trim());
            data.add(new DefaultData(getDatakey(), null, null, new DataItem[] { yearsdata }));

            return data.toArray(new Data[data.size()]);
        }
        return new Data[0];
    }

    protected final TextItem createInputItem(final String title) {
        this.inputItem = PanelHelper.createItem(title);// new TextItem(title);
        return this.inputItem;
    }

    private final List<String> checkForEmpty() {
        final List<String> errors = new ArrayList<String>();

        if (this.inputItem.getValueAsString() == null || this.inputItem.getValueAsString().trim().isEmpty()) {
            errors.add(this.MSG.empty_filter());
            return errors;
        }
        return errors;
    }

    private final List<String> validateSingleInput(final String sValue) {
        final List<String> errors = new ArrayList<String>();
        // String filtered = "";
        // int goodValues = 0;
        errors.addAll(validateNumber(sValue));
        boolean isGood = false;
        for (final String validYear : this.validInputs) {
            /* No list contains for strings? */
            if (sValue.equals(validYear)) {
                isGood = true;
                break;
            }
        }
        if (!isGood) {
            String tmp = errorForItemMsg();
            tmp = tmp.replace("$1", sValue);
            errors.add(tmp);
            // continue;
        }

        return errors;
    }

    private final List<String> validateNumber(final String sValue) {
        final List<String> errors = new ArrayList<String>();

        try {
            Integer.parseInt(sValue);
        }
        catch (final NumberFormatException e) {
            errors.add(this.MSG.wrongFormat() + ": " + sValue);

        }
        return errors;
    }

    protected abstract String errorForItemMsg();

    protected final void appendValue(final String value) {

        switch (this.type) {
        case multi:
            // APPEND = ADD to existing -> MULTI YEAR
            final String oldYears = this.inputItem.getValueAsString();
            if (oldYears != null && !oldYears.isEmpty())
                this.inputItem.setValue(oldYears.trim() + " " + value);
            else
                this.inputItem.setValue(value);

            break;

        case limit5:
            // APPEND = ADD to existing -> MULTI YEAR
            final String oldValues = this.inputItem.getValueAsString();
            if (oldValues != null && !oldValues.isEmpty()) {
                final String[] oldVals = oldValues.split(" ");
                if (oldVals.length < 5)// TODO: generalize, if needed
                    this.inputItem.setValue(oldValues.trim() + " " + value);
                else {
                    // msg TODO: generalize, if needed
                    SC.warn(this.MSG.error_limit_exceeded_salix());
                }
            }

            else
                this.inputItem.setValue(value);

            break;

        case single:
            this.inputItem.setValue(value);
            break;

        default:
            throw new IllegalStateException();
        }
    }

    @Override
    public final List<String> validate() {

        final List<String> errors = new ArrayList<String>();
        errors.addAll(this.checkForEmpty());

        final String sValue = this.inputItem.getValueAsString();

        switch (this.type) {
        case multi:

            final String[] sValues = sValue.trim().split(" ");
            for (final String value : sValues) {
                errors.addAll(this.validateSingleInput(value));
            }
            break;
        case limit5:
            final String[] values = sValue.trim().split(" ");
            if (values.length > 5) {
                errors.add(this.MSG.error_limit_exceeded_salix());// TODO generalize if needed
            }
            for (int i = 0; i < values.length; i++) {
                if (i < 5)
                    errors.addAll(this.validateNumber(values[i]));
            }
            break;
        case single:
            errors.addAll(this.validateSingleInput(sValue));
            break;

        default:
            throw new IllegalStateException();
        }

        return errors;
    }
}