/* Copyright (C) 2011, 2012, 2013 by Bundesanstalt für Gewässerkunde
 * Software engineering by Intevation GmbH
 *
 * 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.FLYS;
import org.dive4elements.river.client.client.FLYSConstants;
import org.dive4elements.river.client.client.event.HasStepBackHandlers;
import org.dive4elements.river.client.client.event.HasStepForwardHandlers;
import org.dive4elements.river.client.client.event.StepBackEvent;
import org.dive4elements.river.client.client.event.StepBackHandler;
import org.dive4elements.river.client.client.event.StepForwardEvent;
import org.dive4elements.river.client.client.event.StepForwardHandler;
import org.dive4elements.river.client.shared.model.Artifact;
import org.dive4elements.river.client.shared.model.ArtifactDescription;
import org.dive4elements.river.client.shared.model.Collection;
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.google.gwt.core.client.GWT;
import com.smartgwt.client.util.SC;
import com.smartgwt.client.widgets.Button;
import com.smartgwt.client.widgets.Canvas;
import com.smartgwt.client.widgets.Img;
import com.smartgwt.client.widgets.events.ClickEvent;
import com.smartgwt.client.widgets.events.ClickHandler;
import com.smartgwt.client.widgets.layout.VLayout;

/**
 * An abstract UIProvider that provides some basic methods.
 *
 * @author <a href="mailto:ingo.weinzierl@intevation.de">Ingo Weinzierl</a>
 */
public abstract class AbstractUIProvider implements UIProvider, HasStepForwardHandlers, ClickHandler, HasStepBackHandlers {
    private static final long serialVersionUID = -1610874613377494184L;

    /** The message class that provides i18n strings. */
    protected FLYSConstants MSG = GWT.create(FLYSConstants.class);

    /** The StepForwardHandlers. */
    protected List<StepForwardHandler> forwardHandlers;

    /** The StepForwardHandlers. */
    protected List<StepBackHandler> backHandlers;

    /** The container that is used to position helper widgets. */
    protected VLayout helperContainer;

    /** The artifact that contains status information. */
    protected Artifact artifact;

    /** The Collection. */
    protected Collection collection;

    /** The ParameterList. */
    protected ParameterList parameterList;

    /**
     * Creates a new UIProvider instance of this class.
     */
    public AbstractUIProvider() {
        this.forwardHandlers = new ArrayList<StepForwardHandler>();
        this.backHandlers = new ArrayList<StepBackHandler>();
    }

    /**
     * Appends a StepBackHandler that wants to listen to StepBackEvents.
     *
     * @param handler
     *            A new StepBackHandler.
     */
    @Override
    public void addStepBackHandler(final StepBackHandler handler) {
        if (handler != null) {
            this.backHandlers.add(handler);
        }
    }

    /**
     * Appends a StepForwardHandler that wants to listen to StepForwardEvents.
     *
     * @param handler
     *            A new StepForwardHandler.
     */
    @Override
    public void addStepForwardHandler(final StepForwardHandler handler) {
        if (handler != null) {
            this.forwardHandlers.add(handler);
        }
    }

    /**
     * This method is called after the user has clicked one of the buttons to
     * step back to a previous state.
     *
     * @param e
     *            The StepBackEvent.
     */
    protected void fireStepBackEvent(final StepBackEvent e) {
        GWT.log("AbstractUIProvider - fireStepBackEvent() handlers: " + this.backHandlers.size());
        for (final StepBackHandler handler : this.backHandlers) {
            handler.onStepBack(e);
        }
    }

    /**
     * This method is called after the user has clicked on the 'next' button to
     * step to the next state.
     *
     * @param e
     *            The StepForwardEvent.
     */
    protected void fireStepForwardEvent(final StepForwardEvent e) {
        GWT.log("AbstractUIProvider - fireStepForwardEvent() handlers: " + this.forwardHandlers.size());
        for (final StepForwardHandler handler : this.forwardHandlers) {
            handler.onStepForward(e);
        }
    }

    /**
     * This method is used to listen to click events on the 'next' button. The
     * fireStepForwardEvent() method is called here.
     *
     * @param e
     *            The click event.
     */
    @Override
    public void onClick(final ClickEvent e) {
        final List<String> errors = validate();
        if (errors == null || errors.isEmpty()) {
            final Data[] data = getData();
            fireStepForwardEvent(new StepForwardEvent(data));
        } else {
            showErrors(errors);
        }
    }

    protected void showErrors(final List<String> errors) {
        final StringBuilder sb = new StringBuilder();

        for (final String error : errors) {
            sb.append(error);
            sb.append("<br>");
        }

        SC.warn(sb.toString());
    }

    /**
     * Creates the 'next' button to step forward to the next state.
     *
     * @return the 'next' button.
     */
    protected Canvas getNextButton() {
        final Button next = new Button(this.MSG.buttonNext());
        next.addClickHandler(this);

        return next;
    }

    @Override
    public Canvas createHelpLink(final DataList dataList, final Data data, final FLYS instance) {
        final String iUrl = GWT.getHostPageBaseURL() + this.MSG.getFeatureInfo();
        final String helpUrl = dataList.getHelpText();

        return new WikiImgLink(iUrl, helpUrl, 30, 30, instance);
    }

    /**
     * Creates the 'back' button to step back to a previous state.
     *
     * @param targetState
     *            The identifier of the target state.
     *
     * @return the 'back' button.
     */
    protected Canvas getBackButton(final String targetState) {
        final String url = GWT.getHostPageBaseURL() + this.MSG.imageBack();
        final Img back = new Img(url, 16, 16);

        back.addClickHandler(new ClickHandler() {
            @Override
            public void onClick(final ClickEvent event) {
                fireStepBackEvent(new StepBackEvent(targetState));
            }
        });

        return back;
    }

    /**
     * This method injects a container that is used to position helper widgets.
     *
     * @param helperContainer
     *            A container that is used to position helper
     *            widgets.
     */
    @Override
    public void setContainer(final VLayout helperContainer) {
        this.helperContainer = helperContainer;
    }

    /**
     * This method injects an artifact that contains the status information.
     *
     * @param art
     *            An artifact containing status information.
     */
    @Override
    public void setArtifact(final Artifact art) {
        this.artifact = art;
    }

    @Override
    public void setCollection(final Collection collection) {
        this.collection = collection;
    }

    @Override
    public void setParameterList(final ParameterList list) {
        this.parameterList = list;
    }

    public Collection getCollection() {
        return this.collection;
    }

    /**
     * This method greps the Data with name <i>name</i> from the list and
     * returns it.
     *
     * @param items
     *            A list of Data.
     * @param name
     *            The name of the Data that we are searching for.
     *
     * @return the Data with the name <i>name</i>.
     */
    protected Data getData(final List<Data> data, final String name) {

        for (final Data d : data) {
            if (name.equals(d.getLabel())) {
                return d;
            }
        }
        return null;
    }

    protected String getDataValue(final String state, final String name) {
        final ArtifactDescription desc = this.artifact.getArtifactDescription();

        final DataList[] old = desc.getOldData();

        for (final DataList list : old) {
            if (list == null) {
                continue;
            }
            final Data d = getData(list.getAll(), name);

            if (d != null) {
                return d.getItems()[0].getStringValue();
            }
        }

        return null;
    }

    /**
     * This method greps the DataItem with name <i>name</i> from the list and
     * returns it.
     *
     * @param items
     *            A list of DataItems.
     * @param name
     *            The name of the DataItem that we are searching for.
     *
     * @return the DataItem with the name <i>name</i>.
     */
    protected DataItem getDataItem(final DataItem[] items, final String name) {
        for (final DataItem item : items) {
            if (name.equals(item.getLabel())) {
                return item;
            }
        }

        return null;
    }

    /**
     * Validates the selection.
     *
     * @return List of internationalized errror messages (if any).
     */
    public List<String> validate() {
        return new ArrayList<String>(); // FIXME: What's this?
    }

    /** Create simple DefaultData with single DataItem inside. */
    public static DefaultData createDataArray(final String name, final String value) {
        final DataItem item = new DefaultDataItem(name, name, value);

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

    /**
     * This method needs to be implemented by concrete subclasses. It should
     * create a new Canvas object with a representation of <i>data</i>.
     *
     * @param data
     *            The data that should be displayed.
     *
     * @return a Canvas object that displays <i>data</i>.
     */
    @Override
    public abstract Canvas create(DataList data);

    /**
     * This method needs to be implemented by concrete subclasses. It should
     * return the selected data.
     *
     * @return the selected data.
     */
    protected abstract Data[] getData();

    protected String getRiverName() {
        final ArtifactDescription adescr = this.artifact.getArtifactDescription();
        return adescr.getRiver();
    }

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