package autotest.common.table;

import autotest.common.Utils;
import autotest.common.table.DataTable.TableWidgetFactory;
import autotest.common.table.TableClickWidget.TableWidgetClickListener;
import autotest.common.ui.TableSelectionPanel.SelectionPanelListener;

import com.google.gwt.json.client.JSONObject;
import com.google.gwt.user.client.ui.CheckBox;
import com.google.gwt.user.client.ui.Widget;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;

/**
 * This class manages a selection of rows on a DataTable.  It keeps track of selected objects and
 * takes care of highlighting rows.  It can also be used for a DynamicTable, with support for paging
 * etc., if you use DynamicTableSelectionManager.
 * 
 * For convenience, it can also act as a TableWidgetFactory to supply checkboxes for selecting rows 
 * in a table, and as a SelectionPanelListener.
 *
 */
public class SelectionManager implements TableWidgetFactory, TableWidgetClickListener,
                                         SelectionPanelListener {
    private Set<JSONObject> selectedObjects = new JSONObjectSet<JSONObject>();
    private boolean selectOnlyOne = false;
    private DataTable attachedTable;
    private List<SelectionListener> listeners = new ArrayList<SelectionListener>();
    private SelectableRowFilter selectableRowFilter;
    
    public interface SelectionListener {
        public void onAdd(Collection<JSONObject> objects);
        public void onRemove(Collection<JSONObject> objects);
    }
    
    public interface SelectableRowFilter {
        public boolean isRowSelectable(JSONObject row);
    }
    
    public SelectionManager(DataTable table, boolean selectOnlyOne) {
        attachedTable = table;
        this.selectOnlyOne = selectOnlyOne;
    }
    
    public void setSelectableRowFilter(SelectableRowFilter filter) {
        selectableRowFilter = filter;
    }
    
    public void refreshSelection() {
        for (int i = 0; i < attachedTable.getRowCount(); i++) {
            JSONObject row = attachedTable.getRow(i);
            if (!isSelectable(row)) {
                continue;
            }
            if (selectedObjects.contains(row)) { 
                attachedTable.highlightRow(i);
            } else {
                attachedTable.unhighlightRow(i);
            }
        }
        attachedTable.refreshWidgets();
    }
    
    private boolean isSelectable(JSONObject row) {
        if (selectableRowFilter != null) {
            return selectableRowFilter.isRowSelectable(row);
        }
        return true;
    }

    public void selectObject(JSONObject object) {
        selectObjects(Utils.wrapObjectWithList(object));
    }
    
    public void selectObjects(Collection<? extends JSONObject> objects) {
        if (selectOnlyOne) {
            assert objects.size() == 1;
            deselectAll();
        }
        addOrRemoveObjects(objects, true);
    }
    
    public void deselectObject(JSONObject object) {
        deselectObjects(Utils.wrapObjectWithList(object));
    }
    
    public void deselectObjects(Collection<JSONObject> objects) {
        addOrRemoveObjects(objects, false);
    }
    
    protected void addOrRemoveObjects(Collection<? extends JSONObject> objects,
                                      boolean add) {
        List<JSONObject> actuallyUsed = new ArrayList<JSONObject>();
        for (JSONObject object : objects) {
            if (!isSelectable(object)) {
                continue;
            }
            boolean used = false;
            if (add) {
                used = selectedObjects.add(object);
            } else {
                used = selectedObjects.remove(object);
            }
            if (used) {
                actuallyUsed.add(object);
            }
        }
        notifyListeners(actuallyUsed, add);
    }
    
    /*
     * Select all objects in the table.
     */
    public void selectAll() {
        selectVisible();
    }
    
    public void deselectAll() {
        List<JSONObject> removed = new ArrayList<JSONObject>(selectedObjects);
        selectedObjects.clear();
        notifyListeners(removed, false);
    }
    
    public void selectVisible() {
        selectObjects(attachedTable.getAllRows());
    }
    
    public void toggleSelected(JSONObject object) {
        if (selectedObjects.contains(object))
            deselectObject(object);
        else
            selectObject(object);
    }
    
    public JSONObject getSelectedOne() {
        assert selectOnlyOne;
        if (selectedObjects.isEmpty())
            return null;
        return selectedObjects.iterator().next();
    }
    
    public Set<JSONObject> getSelectedObjects() {
        return Collections.unmodifiableSet(selectedObjects);
    }
    
    public boolean isEmpty() {
        return selectedObjects.isEmpty();
    }
    
    public void addListener(SelectionListener listener) {
        listeners.add(listener);
    }
    
    public void removeListener(SelectionListener listener) {
        listeners.remove(listener);
    }
    
    protected void notifyListeners(Collection<JSONObject> objects,
                                   boolean add) {
        refreshSelection();
        for (SelectionListener listener : listeners) {
            if (add)
                listener.onAdd(objects);
            else
                listener.onRemove(objects);
        }
    }

    // code for acting as a TableWidgetFactory/TableWidgetClickListener
    
    public Widget createWidget(int row, int cell, JSONObject rowObject) {
        if (!isSelectable(rowObject)) {
            return null;
        }

        CheckBox checkBox = new CheckBox();
        if(selectedObjects.contains(rowObject)) {
            checkBox.setValue(true);
        }
        return new TableClickWidget(checkBox, this, row, cell);
    }

    public void onClick(TableClickWidget widget) {
        toggleSelected(attachedTable.getRow(widget.getRow()));
        refreshSelection();
    }
    
    // code for acting as a SelectionPanelListener

    public void onSelectAll(boolean visibleOnly) {
        if (visibleOnly) {
            selectVisible();
        } else {
            selectAll();
        }
    }

    public void onSelectNone() {
        deselectAll();
    }
}