/*
    * Copyright 2004-2006 the Seasar Foundation and the Others.
    *
    * Licensed under the Apache 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.apache.org/licenses/LICENSE-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.seasar.tuigwaa.database;
  
  import java.lang.reflect.InvocationTargetException;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.TreeSet;
  
  import org.apache.commons.beanutils.PropertyUtils;
  
  import com.isenshi.util.TableMap;
  import com.isenshi.util.functor.BinaryFunction;
  
  public class DataTableImpl extends AbstractDataTable {
  
  	public static final int BEAN_DATA = 0;
  
  	public static final int PRIMITIVE_DATA = 1;
  
  	private Map filterMap_;
  
  	private List data_;
  
  	private DataGetterStrategy strategy_;
  
  	public DataTableImpl(String name, List headers, List data, int strategy) {
  		this(name, headers, headers, data, strategy, null);
  	}
  
  	public void setFilterMap(Map filterMap) {
  		this.filterMap_ = filterMap;
  	}
  
  	public DataTableImpl(String name, List headers, List displayHeaders,
  			List data, int strategy, Map filterMap) {
  		super(name, headers, displayHeaders);
  
  		// this.displayHeaders_ = displayHeaders;
  		this.data_ = data;
  		this.filterMap_ = filterMap;
  		
  		this.setStrategy(strategy);
  	}
  
  	
  	public Collection getDataList() {
  		return data_;
  	}
  
  	public int getRowSize() {
  		return strategy_.getRowSize();
  	}
  
  	public Object getData(int row, int column) {
  		Object data = strategy_.getData(row, column);
  		String header = getHeader(column);
  
  		if (filterMap_ == null) {
  			return data;
  		}
  
  		BinaryFunction function = (BinaryFunction) filterMap_.get(header);
  		if (function != null) {
  			data = function.evaluate(data, data_.get(row));
  		}
  		return data;
  	}
  
  	public Map getDataMap(int row) {
  		Iterator itr = getHeaderIterator();
  		Map map = new HashMap();
  		while (itr.hasNext()) {
  			String header = (String) itr.next();
  			map.put(header, getData(row, header));
  		}
  		return map;
  	}
  
  	public void remove(int row) {
  		data_.remove(row);
 	}
 
 	public void setStrategy(int strategy) {
 		if (BEAN_DATA == strategy) {
 			strategy_ = new BeanDataGetterStrategy();
 		} else if (PRIMITIVE_DATA == strategy) {
 			strategy_ = new PrimitiveDataGetterStrategy();
 		}
 	}
 
 	interface DataGetterStrategy {
 		int getRowSize();
 
 		Object getData(int row, int column);
 	}
 
 	public Object getRowObject(int row) {
 		return data_.get(row);
 	}
 
 	public SpreadSheet createSpreadSheet() {
 		Set rowSet = new TreeSet();
 		Set columnSet = new TreeSet();
 		TableMap map = new TableMap();
 		while (hasNext()) {
 			DataRow dataRow = nextRow();
 			Object rowLabel = dataRow.getCell(0);
 			Object columnLabel = dataRow.getCell(1);
 			if (rowLabel == null) {
 				rowLabel = "";
 			}
 			if (columnLabel == null) {
 				columnLabel = "";
 			}
 			rowSet.add(rowLabel);
 			columnSet.add(columnLabel);
 			map.put(dataRow.getCell(2), rowLabel, columnLabel);
 		}
 		List rowHeaders = new ArrayList();
 		List columnHeaders = new ArrayList();
 		rowHeaders.addAll(rowSet);
 		columnHeaders.addAll(columnSet);
 
 		String rowLabel = (String) getDisplayHeaderMap().get(getHeader(0));
 		String columnLabel = (String) getDisplayHeaderMap().get(getHeader(1));
 		String dataLabel = (String) getDisplayHeaderMap().get(getHeader(2));
 
 		return new SpreadSheetImpl(getName(), dataLabel, rowLabel, rowHeaders,
 				columnLabel, columnHeaders, map);
 	}
 
 	class BeanDataGetterStrategy implements DataGetterStrategy {
 
 		public int getRowSize() {
 			return data_.size();
 		}
 
 		public Object getData(int row, int column) {
 			if (row >= getRowSize()) {
 				return null;
 			}
 			Object rowObject = getRowObject(row);
 			return getProperty(rowObject, column);
 		}
 
 		private Object getProperty(Object obj, int index) {
 			String header = getHeader(index);
 			Object ret = null;
 			try {
 				ret = PropertyUtils.getProperty(obj, header);
 			} catch (IllegalAccessException e) {
 				e.printStackTrace();
 				throw new RuntimeException(e);
 			} catch (InvocationTargetException e) {
 				e.printStackTrace();
 				throw new RuntimeException(e);
 			} catch (NoSuchMethodException e) {
 				e.printStackTrace();
 				throw new RuntimeException(e);
 			}
 			return ret;
 		}
 
 	}
 
 	class PrimitiveDataGetterStrategy implements DataGetterStrategy {
 
 		public int getRowSize() {
 			if (data_ == null || data_.size() == 0) {
 				return 0;
 			}
 
 			Object row = data_.get(0);
 			boolean isArray = false;
 			if (row instanceof Object[]) {
 				isArray = true;
 			}
 			if (isArray) {
 				return data_.size();
 			} else if (!isArray && getColumnSize() == 1) {
 				return data_.size();
 			} else {
 				return 1;
 			}
 		}
 
 		public Object getData(int row, int column) {
 			int columnSize = getColumnSize();
 			int rowSize = getRowSize();
 			if (column >= columnSize || row >= rowSize) {
 				return null;
 			}
 
 			Object ret = null;
 
 			// if (rowSize == 1 && columnSize ==1) {
 			// ret = data_.get(column);
 			// ret = ((Object[])data_.get(0))[column];
 			// } else
 
 			if (columnSize == 1) {
 				ret = data_.get(row);
 			} else {
 				Object[] dataArray = (Object[]) data_.get(row);
 				ret = dataArray[column];
 			}
 			return ret;
 		}
 
 	}
 
 	public String toString() {
 		StringBuffer buf = new StringBuffer();
 
 		while (this.hasNext()) {
 			DataRow dataRow = (DataRow) this.next();
 			while (dataRow.hasNext()) {
 				buf.append(dataRow.next());
 				buf.append("\t");
 			}
 			buf.append("\n");
 		}
 
 		return buf.toString();
 	}
 }