package com.temp.client.foundation.widget.table;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import com.temp.shared.utils.ComparatorSource;
import com.temp.shared.utils.StringUtils;
import com.temp.shared.LoadingProgressListener;
import com.temp.client.foundation.widget.table.CustomDataTable.SortDirection;
import com.temp.client.foundation.widget.table.CustomDataTable.DataTableUpdater;

import com.google.gwt.dom.client.Style.Unit;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.user.cellview.client.Column;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.Widget;
import com.google.gwt.view.client.SelectionModel;

/**
 *
 * @author paule
 * To use CachedDataTable:
 * <pre>
 * 1) instantiate:
 *          table = new CachedDataTable&lt;RowType&gt;(...)
 *
 *  2) add Columns:
 *          table.addColumn(...)
 *
 *  3) set data of type List&lt;RowType&gt;
 *          table.setData(...)
 *
 *  And you're done!
 *</pre>
 * @param <R> the row type
 */
@SuppressWarnings("rawtypes")
public class CachedDataTable<R extends DataRow<F>,F> extends Composite implements LoadingProgressListener {
    public static final String DEFAULT_HEIGHT = "350px";
    public static final String DEFAULT_WIDTH = "100%";

    private static class SortFieldComparatorDirection {
        String sortByField;
        Comparator comparator;
        SortDirection sortDirection;
        SortFieldComparatorDirection(String _sortByField, Comparator _comparator, SortDirection _sortDirection) {
            sortByField = _sortByField;
            comparator = _comparator;
            sortDirection = _sortDirection;
        }

        String getSortByField() { return sortByField; }
        Comparator getComparator() { return comparator; }
        SortDirection getSortDirection() { return sortDirection; }

        void setSortDirection(SortDirection _sortDirection) { sortDirection = _sortDirection; }
    }

    // table
    CustomDataTable<R,F> dataTable;
    Map<String, Column<R, ?>> fieldColumns = new HashMap<String, Column<R, ?>>();
    Map<String, Comparator> fieldComparators = new HashMap<String, Comparator>();

    // data
    List<R> fullDataList = new ArrayList<R>();
    LinkedHashMap<String, List<R>> pageMarkerDataList = new LinkedHashMap<String, List<R>>();
    Map<String, String> nextPageMarkerMap = new HashMap<String, String>();
    LinkedList<SortFieldComparatorDirection> sortQueue = new LinkedList<SortFieldComparatorDirection>();

    public CachedDataTable() {
        this(CustomDataTable.DEFAULT_RESULTS_PER_PAGE, true, null, false, null, null, null, DEFAULT_WIDTH, DEFAULT_HEIGHT);
    }

    public CachedDataTable(String title) {
        this(CustomDataTable.DEFAULT_RESULTS_PER_PAGE, true, title, true, null, null, null, DEFAULT_WIDTH, DEFAULT_HEIGHT);
    }

    public CachedDataTable(String title, ClickHandler downloadCSVButtonClickHandler) {
        this(CustomDataTable.DEFAULT_RESULTS_PER_PAGE, true, title, true, null, null, downloadCSVButtonClickHandler, DEFAULT_WIDTH, DEFAULT_HEIGHT);
    }

    public CachedDataTable(int pageSize, boolean supportPaging, String width, String height) {
        this( pageSize, supportPaging, null, false, null, null, null, width, height);
    }

    public CachedDataTable(String title, int pageSize, boolean supportPaging, String width, String height) {
        this( pageSize, supportPaging, title, true, null, null, null, width, height);
    }

    public CachedDataTable(String title, int pageSize, boolean supportPaging, boolean includeRowNumber, String width, String height) {
        this( pageSize, supportPaging, title, true, null, null, null, includeRowNumber, width, height);
    }

    public CachedDataTable(int pageSize, boolean supportPaging, String title, boolean includeTitleBar,  Widget topWidget,
            Widget bottomWidget, final ClickHandler downloadCSVButtonClickHandler, String width, String height) {
        this(pageSize, supportPaging, title, includeTitleBar,  topWidget,
            bottomWidget,  downloadCSVButtonClickHandler, true, width, height);
    }

    private CachedDataTable(int pageSize, boolean supportPaging, String title, boolean includeTitleBar,  Widget topWidget,
            Widget bottomWidget, final ClickHandler downloadCSVButtonClickHandler, boolean includeRowNumber, String width, String height) {

        boolean includeDownloadCSVButton = (downloadCSVButtonClickHandler != null);
        dataTable = new CustomDataTable<R,F>(
                pageSize, supportPaging, title,
                new DataTableUpdater() {
                    public void updateDataTable() {
                        String pageMarker = dataTable.getPageMarker();
                        List<R> dataList = new ArrayList<R>();
                        for (List<R> pagedDataList : pageMarkerDataList.values()) {
                            dataList.addAll(pagedDataList);
                        }
                        sort(dataList);
                        refreshData(dataList);
                        List<R> dataListPage = pageMarkerDataList.get(pageMarker);
                        String nextPageMarker = nextPageMarkerMap.get(pageMarker);
                        dataTable.setData(dataListPage, nextPageMarker);
                    }
                    public void onDataTableDownloadCSVButtonClick(ClickEvent event) {
                        downloadCSVButtonClickHandler.onClick(event);
                    }
                },
                topWidget, bottomWidget,
                includeTitleBar, includeDownloadCSVButton, includeRowNumber,
                width, height);
        initWidget(dataTable);
    }

    public void setTitle(String title) {
        dataTable.setTitle(title);
    }

    public void setSelectionModel(SelectionModel<R> selectionModel) {
        dataTable.setSelectionModel(selectionModel);
    }

    public SelectionModel<? super R> getSelectionModel() {
        return dataTable.getSelectionModel();
    }

    @Override
    public void loadingReset() {
        dataTable.loadingReset();
    }

    @Override
    public void loadingStarted() {
        dataTable.loadingStarted();
    }

    @Override
    public void loadingCompleted(boolean successfully) {
        dataTable.loadingCompleted(successfully);
    }

    /**
     * Adds a column
     *
     * @param fields
     *            - the column / "field" definitions
     */
    public <FIELD extends DataRowField> void addColumns(FIELD... fields) {
        if (fields != null) {
            for (FIELD field : fields) {
                addColumn(field);
            }
        }
    }

    /**
     * Adds a column
     *
     * @param field
     *            - the column or "field" definition
     */
    public <FIELD extends DataRowField> void addColumn(FIELD field) {
        if (show(field)) {
            addComparator( dataTable.addColumn(field), field, getComparator( field ) );
        }
    }

    /**
     * Adds a column
     *
     * @param column
     *            - the column
     * @param field
     *            - the column definition "field"
     */
    public <FIELD extends DataRowField> void addColumn(Column<R, ?> column, FIELD field) {
        if (show(field)) {
            addComparator(dataTable.addColumn(column, field), field, getComparator(field));
        }
    }

    /**
     * Adds a column
     *
     * @param field
     *            - the column or "field" definition
     * @param comparator - the comparator
     */
    public <FIELD extends DataRowField> void addColumn(FIELD field, Comparator comparator) {
        if (show(field)) {
            addComparator(dataTable.addColumn(field), field, comparator);
        }
    }

    /**
     * Adds a column
     *
     * @param column
     *            - the column
     * @param field
     *            - the column definition "field"
     * @param comparator - the comparator
     */
    public <FIELD extends DataRowField> void addColumn(Column<R, ?> column, FIELD field, Comparator comparator) {
        if (show(field)) {
            addComparator(dataTable.addColumn(column, field), field, comparator);
        }
    }

    private <FIELD extends DataRowField> boolean show(FIELD field) {
        if (field == null) {
            return false;
        }
        return (field instanceof ColumnHidable) ? !((ColumnHidable)field).hideColumn() : true;
    }

    /**
     * Adds a column with a comparator.
     * @param column - the column
     * @param columnHeader - the column header that appears at the top of the table
     * @param fieldName - must be unique among columns (used as key for columns for sorting)
     * @param comparator - the comparator
     */
    public void addColumn(Column<R, ?> column, String columnHeader, String fieldName, Comparator comparator) {
        dataTable.addColumn(column, columnHeader, fieldName);
        addComparator(column, fieldName, comparator);
    }

    /**
     * Adds a column
     * @param column - the column
     * @param columnHeader - the column header to be displayed
     */
    public void addColumn(Column<R, ?> column, String columnHeader, String fieldName) {
        dataTable.addColumn(column, columnHeader, fieldName);
    }

    public void addColumn(Column<R, ?> column, String columnHeader, String fieldName, int width, Unit widthUnit) {
        dataTable.addColumn(column, columnHeader, fieldName, width, widthUnit);
    }

    public void addColumn(Column<R, ?> column, String columnHeader, String fieldName, Comparator comparator, int width, Unit widthUnit) {
        dataTable.addColumn(column, columnHeader, fieldName, width, widthUnit);
        addComparator(column, fieldName, comparator);
    }

    private <FIELD extends DataRowField> Comparator<?> getComparator(FIELD field) {
        if (field instanceof Comparator) {
            return (Comparator)field;
        }
        if (field instanceof ComparatorSource) {
            return ((ComparatorSource)field).getComparator();
        }
        return null;
    }

    private <FIELD extends DataRowField> void addComparator(Column<R, ?> column, FIELD field, Comparator comparator) {
        addComparator(column, field.name(), comparator);
    }

    private void addComparator(Column<R, ?> column, String fieldName, Comparator comparator) {
        if (comparator != null) {
            fieldComparators.put(fieldName, comparator);
            fieldColumns.put(fieldName, column);
        }
    }

    private void addToSortQueue(String sortByField, SortDirection sortDirection) {
        if (StringUtils.isBlank(sortByField)) {
            return;
        }
        Comparator comparator = fieldComparators.get(sortByField);
        if (comparator == null) {
            return;
        }
        SortFieldComparatorDirection sortParams = !sortQueue.isEmpty() ? sortQueue.getLast() : null;
        if (sortParams != null && sortParams.getSortByField().equals(sortByField))  {
            sortParams.setSortDirection(sortDirection);
        } else {
            if (sortQueue.size() == fieldComparators.size() && !sortQueue.isEmpty()) {
                // remove the head of the list;
                sortQueue.remove();
            }
            sortQueue.add(new SortFieldComparatorDirection(sortByField, comparator, sortDirection));
        }

    }

    /**
     * Sort the dataList
     * @param dataList - the unsorted data
     */
    @SuppressWarnings("unchecked")
    public void sort(List<R> dataList) {
        if (dataList == null || dataList.isEmpty()) {
            return;
        }

        String sortByField = dataTable.getSortByField();
        SortDirection sortDirection = dataTable.getSortDirection();
        addToSortQueue(sortByField, sortDirection);

        List<R> sortedDataList = new ArrayList<R>(dataList);
        for (SortFieldComparatorDirection sortParams : sortQueue) {
            final Comparator comparator = sortParams.getComparator();
            final Column<R, ?> column = fieldColumns.get(sortParams.getSortByField());
            //Window.alert("sort by " + sortParams.getSortByField() + ", " + sortParams.getSortDirection().name());
            Collections.sort(sortedDataList, new Comparator<R>(){
                public int compare(R data1, R data2) {
                    Object key1 = column.getValue(data1);
                    Object key2 = column.getValue(data2);
                    //Window.alert("" + key1 + " (" + comparator.compare(key1, key2) + ") " + key2);
                    return comparator.compare(key1, key2);
                }
            });
            dataList.clear();
            dataList.addAll(sortedDataList);

            if (sortParams.getSortDirection() == SortDirection.DESC) {
                Collections.reverse(dataList);
            }
        }
    }

    private void refreshData(List<R> dataList) {
        int numResultsPerPage = dataTable.getResultsPerPage();
        // break up the data list into page chunks
        pageMarkerDataList.clear();
        nextPageMarkerMap.clear();

        int pagedDataCounter = 0;
        String pageMarker = null;
        int pageMarkerCounter = 0;
        int dataCounter = 0;
        for (R data : dataList) {
            List<R> pagedDataList = pageMarkerDataList.get(pageMarker);
            if (pagedDataList == null) {
                pagedDataList = new ArrayList<R>(numResultsPerPage);
                pageMarkerDataList.put(pageMarker, pagedDataList);
            }
            pagedDataList.add(data);

            pagedDataCounter++;
            dataCounter++;
            if (pagedDataCounter == numResultsPerPage) {
                if (dataCounter < dataList.size()) {
                    String nextPageMarker = "" + (++pageMarkerCounter);
                    nextPageMarkerMap.put(pageMarker, nextPageMarker);
                    pageMarker = nextPageMarker;
                    pagedDataCounter = 0;
                } else {
                    nextPageMarkerMap.put(pageMarker, null);
                }
            }
        }
    }

    public void setData(List<R> dataList) {
    	List<R> newList = (dataList != null && !dataList.isEmpty()) ? new ArrayList<R>(dataList) : new ArrayList<R>();
        clear();
        fullDataList = newList;
        refreshData(fullDataList);
        dataTable.setData(pageMarkerDataList.get(null), nextPageMarkerMap.get(null));
    }

    public List<R> getData() {
        return fullDataList;
    }

    public void clear() {
        dataTable.reset();
        fullDataList.clear();
        sortQueue.clear();
        pageMarkerDataList.clear();
        nextPageMarkerMap.clear();
    }

    public void redraw(){
        dataTable.redraw();
    }

    public void addRow(R row) {
        fullDataList.add(row);
        setData(fullDataList);
    }
}