/**
    * 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.List;
  import java.util.Set;
  
  import org.kuali.student.common.assembly.data.LookupResultMetadata;
  import org.kuali.student.common.search.dto.SearchRequest;
  import org.kuali.student.common.search.dto.SearchResult;
  import org.kuali.student.common.search.dto.SearchResultCell;
  import org.kuali.student.common.search.dto.SearchResultRow;
  import org.kuali.student.common.ui.client.application.KSAsyncCallback;
  import org.kuali.student.common.ui.client.service.CachingSearchService;
  import org.kuali.student.common.ui.client.widgets.pagetable.GenericTableModel;
  import org.kuali.student.common.ui.client.widgets.pagetable.PagingScrollTableBuilder;
  import org.kuali.student.common.ui.client.widgets.searchtable.ResultRow;
  import org.kuali.student.common.ui.client.widgets.searchtable.SearchColumnDefinition;
  
  import com.google.gwt.core.client.GWT;
  import com.google.gwt.gen2.table.client.AbstractColumnDefinition;
  import com.google.gwt.gen2.table.client.PagingScrollTable;
  import com.google.gwt.gen2.table.client.AbstractScrollTable.ResizePolicy;
  import com.google.gwt.gen2.table.event.client.RowSelectionHandler;
  import com.google.gwt.user.client.ui.Composite;
  import com.google.gwt.user.client.ui.Label;
  import com.google.gwt.user.client.ui.VerticalPanel;
  
  public class SearchBackedTable extends Composite
  {
  
  	private List<ResultRow> resultRows = new ArrayList<ResultRow> ();
  	private List<AbstractColumnDefinition<ResultRow, ?>> columnDefs = new ArrayList<AbstractColumnDefinition<ResultRow, ?>> ();
  	private GenericTableModel<ResultRow> tableModel = new GenericTableModel<ResultRow> (resultRows);
  	private PagingScrollTableBuilder<ResultRow> builder = new PagingScrollTableBuilder<ResultRow> ();
  	private String resultIdColumnKey;
  	protected PagingScrollTable<ResultRow> pagingScrollTable;
  	private VerticalPanel layout = new VerticalPanel ();
  
  	private CachingSearchService searchRpcServiceAsync = CachingSearchService.getSearchService();
  
  	public SearchBackedTable ()
  	{
  		super ();
  		redraw ();
  		layout.setWidth ("100%");
  		initWidget (layout);
  	}
  
  	public void clearTable ()
  	{
  		resultRows.clear ();
  		this.redraw ();
  	}
  
  	public void removeSelected ()
  	{
  		for (ResultRow r : getSelectedRows ())
  		{
  			resultRows.remove (r);
  		}
  		this.redraw ();
  	}
  
  	public void performSearch (SearchRequest searchRequest,
  			List<LookupResultMetadata> listResultMetadata,
  			String resultIdKey)
  	{
  
  		initializeTable (listResultMetadata, resultIdKey);
  
  		searchRequest.setNeededTotalResults (false);
  
  		if (pagingScrollTable != null)
  		{
  			pagingScrollTable.setEmptyTableWidget (new Label ("Processing Search..."));
  		}
  
  		//  Window.alert ("About to invoke asynch search...");
  		searchRpcServiceAsync.search (searchRequest, new KSAsyncCallback<SearchResult> (){
  
  			@Override
  			public void onSuccess (SearchResult searchResults)
  			{
  				//    Window.alert ("Got back search results...");
 				resultRows.clear ();
 				if (searchResults != null)
 				{
 					for (SearchResultRow searchResultRow : searchResults.getRows ())
 					{
 						//      Window.alert ("adding row");
 						ResultRow resultRow = new ResultRow ();
 						for (SearchResultCell searchResultCell : searchResultRow.getCells ())
 						{
 							if (searchResultCell.getKey ().equals (resultIdColumnKey))
 							{
 								resultRow.setId (searchResultCell.getValue ());
 							}
 							resultRow.setValue (searchResultCell.getKey (), searchResultCell.getValue ());
 						}
 						resultRows.add (resultRow);
 					}
 				}
 				//    Window.alert ("about to redraw...");
 				redraw ();
 			}
 
 				});
 	}
 
 	private void initializeTable (List<LookupResultMetadata> listResultMetadata,
 			String resultIdKey)
 	{
 		clearTable ();
 
 		this.resultIdColumnKey = resultIdKey;
 		builder = new PagingScrollTableBuilder<ResultRow> ();
 		builder.tablePixelSize (900, 200); // width, height
 
 		columnDefs = new ArrayList<AbstractColumnDefinition<ResultRow, ?>> ();
 		for (LookupResultMetadata r : listResultMetadata)
 		{
 			//TODO: use this as a token to get a message from message service instead
 			String header = r.getName ();
 			String key = r.getKey ();
 			if ( ! r.isHidden ())
 			{
 				columnDefs.add (new SearchColumnDefinition (header, key));
 			}
 		}
 		if (columnDefs.size () == 1)
 		{
 			columnDefs.get (0).setMinimumColumnWidth (370);
 		}
 		builder.columnDefinitions (columnDefs);
 		tableModel.setColumnDefs (columnDefs);
 
 		redraw ();
 	}
 
 	public void redraw ()
 	{
 		tableModel.setRows (resultRows);
 		pagingScrollTable = builder.build (tableModel); 
 		pagingScrollTable.setResizePolicy (ResizePolicy.FILL_WIDTH);
 		layout.clear ();
 		layout.add (pagingScrollTable);
 		pagingScrollTable.fillWidth ();
 		pagingScrollTable.reloadPage();
 	}
 
 	public void addSelectionHandler (RowSelectionHandler selectionHandler)
 	{
 		pagingScrollTable.getDataTable ().addRowSelectionHandler (selectionHandler);
 	}
 
 	public List<ResultRow> getSelectedRows ()
 	{
 		List<ResultRow> rows = new ArrayList<ResultRow> ();
 		Set<Integer> selectedRows =
 			pagingScrollTable.getDataTable ().getSelectedRows ();
 		for (Integer i : selectedRows)
 		{
 			rows.add (pagingScrollTable.getRowValue (i));
 		}
 		return rows;
 	}
 
 	public List<String> getSelectedIds ()
 	{
 		List<String> ids = new ArrayList<String> ();
 		Set<Integer> selectedRows =
 			pagingScrollTable.getDataTable ().getSelectedRows ();
 		for (Integer i : selectedRows)
 		{
 			ids.add (pagingScrollTable.getRowValue (i).getId ());
 		}
 		return ids;
 	}
 
 	public List<String> getAllIds ()
 	{
 		List<String> ids = new ArrayList<String> ();
 		for (ResultRow r : resultRows)
 		{
 			ids.add (r.getId ());
 		}
 		return ids;
 	}
 
 	public List<ResultRow> getAllRows ()
 	{
 		List<ResultRow> rows = new ArrayList<ResultRow> ();
 		for (ResultRow r : resultRows)
 		{
 			rows.add (r);
 		}
 		return rows;
 	}
 
 }