/* 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.Config;
import org.dive4elements.river.client.client.FLYSConstants;
import org.dive4elements.river.client.client.services.CSVExportService;
import org.dive4elements.river.client.client.services.CSVExportServiceAsync;
import org.dive4elements.river.client.shared.model.DataList;

import com.google.gwt.core.client.GWT;
import com.google.gwt.i18n.client.NumberFormat;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.smartgwt.client.data.Record;
import com.smartgwt.client.types.ListGridFieldType;
import com.smartgwt.client.util.SC;
import com.smartgwt.client.widgets.Canvas;
import com.smartgwt.client.widgets.grid.ListGrid;
import com.smartgwt.client.widgets.grid.ListGridField;
import com.smartgwt.client.widgets.layout.VLayout;
import com.smartgwt.client.widgets.tab.Tab;
import com.smartgwt.client.widgets.tab.TabSet;

/**
 * This UIProvider creates a widget that displays calculated data in a table.
 *
 * @author <a href="mailto:raimund.renkert@intevation.de">Raimund Renkert</a>
 */
public class TableDataPanel {
    /** The message class that provides i18n strings. */
    protected FLYSConstants MESSAGES = GWT.create(FLYSConstants.class);

    protected CSVExportServiceAsync exportService = GWT.create(CSVExportService.class);

    /** A container that will contain the location or the distance panel. */
    protected VLayout container;

    /** The export type. */
    protected String name;

    /** The UUID of the collection. */
    protected String uuid;

    /** The table. */
    protected ListGrid dataTable;

    private final TabSet tabSet;

    /**
     * Creates a new TableDataPanel instance.
     */
    public TableDataPanel() {
        this.container = new VLayout();
        this.dataTable = new ListGrid();
        this.tabSet = new TabSet();
        this.name = "";
    }

    /**
     * This method creates a widget that contains a table.
     *
     * @return a panel.
     */
    public Canvas create() {
        final Config config = Config.getInstance();
        final String locale = config.getLocale();
        this.dataTable.setEmptyMessage(this.MESSAGES.empty_table());
        this.dataTable.setShowHeaderContextMenu(false);
        this.dataTable.setCanDragSelectText(true);

        this.exportService.getCSV(locale, this.uuid, this.name, new AsyncCallback<List<String[]>>() {
            @Override
            public void onFailure(final Throwable caught) {
                GWT.log("Could not receive csv.");
                SC.warn(caught.getMessage());
            }

            @Override
            public void onSuccess(final List<String[]> l) {
                GWT.log("Recieved csv with " + l.size() + " lines.");
                setData(l);
            }
        });
        this.container.addMember(this.dataTable);

        return this.container;
    }

    public void setName(final String name) {
        this.name = name;
    }

    public void setUuid(final String uuid) {
        this.uuid = uuid;
    }

    public Canvas createOld(final DataList dataList) {
        return null;
    }

    protected Canvas createWidget(final DataList data) {
        return null;
    }

    /**
     * This method sets the data to a dynamic table.
     *
     * @param list
     *            List of String[] containing the data.
     */

    public void setData(final List<String[]> list) {
        if (list == null || list.size() < 2) {
            this.dataTable.setEmptyMessage(this.MESSAGES.error_no_calc_result());
            this.dataTable.redraw();
            return;
        }

        final Config config = Config.getInstance();
        final String locale = config.getLocale();

        NumberFormat nf;
        if (locale.equals("de")) {
            nf = NumberFormat.getFormat("#,##");
        } else {
            nf = NumberFormat.getFormat("#.##");
        }
        final List<List<String[]>> tabData = getTabData(list);
        if (tabData.size() == 1) {
            createTable(this.dataTable, tabData.get(0), nf, 0);

        } else if (tabData.size() > 1) {

            for (int i = 0; i < tabData.size(); i++) {
                final List<String[]> items = tabData.get(i);

                final ListGrid table = new ListGrid();

                createTable(table, items, nf, i);
                final Tab tab = new Tab();
                tab.setTitle("Ergebnis: " + i); // TODO: get Title from Server
                tab.setPane(table);
                this.tabSet.addTab(tab);
            }
            this.tabSet.selectTab(0);
            this.container.removeChild(this.dataTable);
            this.container.addChild(this.tabSet);
            this.tabSet.setWidth100();
            this.tabSet.setHeight100();
        }
    }

    private void createTable(final ListGrid dataTableTab, final List<String[]> list, final NumberFormat nf, final int tabNumber) {

        final String[] header = list.get(0);
        final String[] displayField = new String[header.length];

        final ListGridField[] fields = new ListGridField[header.length];

        for (int i = 0; i < header.length; i++) {
            final ListGridField f = new ListGridField(String.valueOf(i));
            fields[i] = f;
            f.setTitle(header[i]);

            try {
                /*
                 * Try to determine the type with the first
                 * non empty element. -> WARUM??! OK, nur Formatierung/Sortierung
                 */
                for (int j = 1; j < list.size(); j++) {
                    if (!list.get(j)[i].isEmpty()) {
                        nf.parse(list.get(j)[i]);
                        f.setType(ListGridFieldType.FLOAT);

                        break;
                    }
                }
            }
            catch (final NumberFormatException nfe) {
                f.setType(ListGridFieldType.TEXT);
            }

            // To keep server-side formatting and i18n also of
            // float values, we will store the value once formatted 'as is'
            // to be displayed and once as e.g. float to allow functions like
            // sorting on it.
            displayField[i] = "$" + i + "_displayField";
            f.setDisplayField(displayField[i]);
            f.setValueField(String.valueOf(i));
            f.setSortByDisplayField(false);

        }
        dataTableTab.setFields(fields);

        for (int i = 1; i < list.size(); i++) { // index bei 1, da erster Eintrag Header ist

            final String[] sItem = list.get(i);
            final Record r = new Record();
            for (int j = 0; j < sItem.length; j++) {
                // See above, display 'as is' from server, but keep value
                // in machine-usable way (float), to allow numeric sorting.
                r.setAttribute(displayField[j], sItem[j]);
                // r.setAttribute(String.valueOf(j), sItem[j]);
                if (fields[j].getType() == ListGridFieldType.TEXT) {
                    r.setAttribute(String.valueOf(j), sItem[j]);
                } else {
                    try {
                        final Float valueFloatSortable = (float) nf.parse(sItem[j]);
                        r.setAttribute(String.valueOf(j), valueFloatSortable);
                    }
                    catch (final NumberFormatException nfe) {
                        r.setAttribute(String.valueOf(j), sItem[j]);
                    }
                }

            }

            dataTableTab.addData(r);
        }
    }

    private List<List<String[]>> getTabData(final List<String[]> raw) {
        final List<List<String[]>> tabs = new ArrayList<List<String[]>>();
        String[] compare = raw.get(0);
        int lastIndex = 0;

        for (int i = 0; i < raw.size(); i++) {
            final String[] row = raw.get(i);
            if (compare.length != row.length) {
                tabs.add(raw.subList(lastIndex, i));
                lastIndex = i;
            }

            if (i == (raw.size() - 1)) {
                tabs.add(raw.subList(lastIndex, i + 1)); // toIndex exclusive, fromIndex inclusive
            }
            compare = row;
        }

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