/**

  * Copyright 2010 The Kuali Foundation Licensed under the

  * Educational Community License, Version 2.0 (the "License"); you may

  * not use this file except in compliance with the License. You may

  * obtain a copy of the License at

  *

  * http://www.osedu.org/licenses/ECL-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an "AS IS"

  * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express

  * or implied. See the License for the specific language governing

  * permissions and limitations under the License.

  */

 package org.kuali.student.lum.lu.ui.tools.client.widgets;

 import java.util.ArrayList;

 import java.util.HashSet;

 import java.util.LinkedHashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Map.Entry;

 import org.kuali.student.common.assembly.data.LookupMetadata;

 import org.kuali.student.common.assembly.data.LookupParamMetadata;

 import org.kuali.student.common.search.dto.SearchParam;

 import org.kuali.student.common.search.dto.SearchRequest;

 import org.kuali.student.common.ui.client.mvc.Callback;

 import org.kuali.student.common.ui.client.widgets.KSButton;

 import org.kuali.student.common.ui.client.widgets.search.SelectedResults;

 import org.kuali.student.common.ui.client.widgets.searchtable.ResultRow;

 import com.google.gwt.event.dom.client.ClickEvent;

 import com.google.gwt.event.dom.client.ClickHandler;

 import com.google.gwt.user.client.ui.Composite;

 import com.google.gwt.user.client.ui.FlowPanel;

 public class BrowsePanel extends Composite {

         // Layout configuration

         private FlowPanel layout;

         private FlowPanel tablePanel;

         private LookupMetadata lookupMetadata = null;

         private SearchBackedTable searchBackedTable = null;

         private boolean multiSelect = false;

         public Map<String, Object> parameters;

         private int tableHeight = 200;;

         public interface OnSelectedCallback {

                 public void selected(List<String> selectedIds);

         }

         private OnSelectedCallback onSelectectedCallback;

         public BrowsePanel(LookupMetadata lookupMetadata) {

                 this.lookupMetadata = lookupMetadata;

                 layout = new FlowPanel();

                 layout.addStyleName("KS-Picker-Border");

                 layout.addStyleName("KS-Advanced-Search-Panel");

                 tablePanel = new FlowPanel();

                 this.initWidget(layout);

         }

         public BrowsePanel(LookupMetadata lookupMetadata, int tableHeight) {

                 this(lookupMetadata);

                 this.tableHeight = tableHeight;

         }

         public Map<String, Object> getParameters() {

                 if (parameters == null) {

                         parameters = new LinkedHashMap<String, Object>();

                 }

                 return parameters;

         }

         public void setParameters(Map<String, Object> parameters) {

                 this.parameters = parameters;

         }

         private Map<String, Object> getDefaultParameters() {

                 Map<String, Object> defParms = new LinkedHashMap<String, Object>();

                 for (LookupParamMetadata paramMeta : lookupMetadata.getParams()) {

                         if (paramMeta.getDefaultValueString() != null) {

                                 defParms.put(paramMeta.getKey(),

                                                 paramMeta.getDefaultValueString());

                                 continue;

                         }

                         if (paramMeta.getDefaultValueList() != null) {

                                 defParms.put(paramMeta.getKey(),

                                                 paramMeta.getDefaultValueList());

                         }

                 }

                 return defParms;

         }

         public OnSelectedCallback getOnSelectectedCallback() {

                 return onSelectectedCallback;

         }

         public void setOnSelectectedCallback(

                         OnSelectedCallback onSelectectedCallback) {

                 this.onSelectectedCallback = onSelectectedCallback;

         }

         private class SelectButtonClickHandler implements ClickHandler {

                 private OnSelectedCallback callback;

                 private SearchBackedTable searchBackedTable;

                 public SelectButtonClickHandler(OnSelectedCallback callback,

                                 SearchBackedTable searchBackedTable) {

                         this.callback = callback;

                         this.searchBackedTable = searchBackedTable;

                 }

                 @Override

                 public void onClick(ClickEvent event) {

                         this.callback.selected(this.searchBackedTable.getSelectedIds());

                 }

         }

         @SuppressWarnings("unchecked")

         public void executeSearch(Callback<Boolean> callback) {

                 tablePanel.clear();

                 layout.clear();

                 tablePanel.setVisible(false);

                 layout.add(tablePanel);

                 // layout.addStyleName ("KS-Picker-Border");

                 // layout.addStyleName (Style.BROWSE.getStyle ());

                 searchBackedTable = new SearchBackedTable(tableHeight);

                 searchBackedTable.addStyleName("KS-Advanced-Search-Results-Table");

                 KSButton selectButton = new KSButton("Select",

                                 new SelectButtonClickHandler(this.onSelectectedCallback,

                                                 this.searchBackedTable));

                 tablePanel.add(searchBackedTable);

                 tablePanel.add(selectButton);

                 tablePanel.setVisible(false);

                 SearchRequest searchRequest = new SearchRequest();

                 List<SearchParam> searchParams = new ArrayList<SearchParam>();

                 Map<String, Object> parms = getDefaultParameters();

                 parms.putAll(getParameters());

                 for (Entry<String, Object> entry : parms.entrySet()) {

                         Object value = entry.getValue();

                         SearchParam searchParam = new SearchParam();

                         searchParam.setKey(entry.getKey());

                         if (value instanceof String) {

                                 searchParam.setValue((String) value);

                         } else {

                                 searchParam.setValue((List<String>) value);

                         }

                         searchParams.add(searchParam);

                 }

                 searchRequest.setParams(searchParams);

                 searchRequest.setSearchKey(lookupMetadata.getSearchTypeId());

                 // StringBuilder builder = new StringBuilder ();

                 // builder.append ("About to invoke search: type=");

                 // builder.append (lookupMetadata.getSearchTypeId ());

                 // builder.append (" with ");

                 // builder.append (searchParams.size ());

                 // builder.append (" parametrs.");

                 // String comma = "\n";

                 // for (SearchParam param : searchParams)

                 // {

                 // builder.append (comma);

                 // builder.append (param.getKey ());

                 // builder.append ("=");

                 // builder.append (param.getValue ());

                 // }

                 // Window.alert (builder.toString ());

                 searchBackedTable.performSearch(searchRequest,

                                 lookupMetadata.getResults(),

                                 lookupMetadata.getResultReturnKey(), callback);

                 tablePanel.setVisible(true);

                 layout.setVisible(true);

         }

         public List<String> getSelectedIds() {

                 List<String> ids = new ArrayList<String>();

                 if (searchBackedTable != null) {

                         ids = searchBackedTable.getSelectedIds();

                 }

                 return ids;

         }

         public List<SelectedResults> getSelectedValues() {

                 List<SelectedResults> selectedValues = new ArrayList<SelectedResults>();

                 if (searchBackedTable != null) {

                         List<ResultRow> selectedRows = searchBackedTable.getSelectedRows();

                         for (ResultRow row : selectedRows) {

                                 String displayKey = row.getValue(lookupMetadata

                                                 .getResultDisplayKey());

                                 String returnKey = row.getValue(lookupMetadata

                                                 .getResultReturnKey());

                                 selectedValues.add(new SelectedResults(displayKey, returnKey));

                                 if (multiSelect == false) {

                                         break;

                                 }

                         }

                 }

                 return selectedValues;

         }

         public void showAllRows() {

                 searchBackedTable.getResultRows().clear();

                 searchBackedTable.getResultRows().addAll(

                                 searchBackedTable.getAllResults());

                 searchBackedTable.redraw();

         }

         public void showOnlyRows(HashSet<String> rowKeys) {

                 searchBackedTable.getResultRows().clear();

                 for (ResultRow resultRow : searchBackedTable.getAllResults()) {

                         if (rowKeys.contains(resultRow.getId())) {

                                 searchBackedTable.getResultRows().add(resultRow);

                         }

                 }

                 searchBackedTable.redraw();

         }

         public List<ResultRow> getAllResultRows() {

                 return searchBackedTable.getAllResults();

         }

         public boolean isMultiSelect() {

                 return multiSelect;

         }

         public void setMultiSelect(boolean multiSelect) {

                 this.multiSelect = multiSelect;

         }

 }