/*
    * 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.
   */
  /*
   * Created on 2005/08/23
   */
  package org.seasar.tuigwaa.controller;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.List;
  
  import javax.servlet.http.HttpServletRequest;
  
  import org.apache.commons.collections.Factory;
  import org.apache.commons.collections.ListUtils;
  import org.apache.struts.action.ActionErrors;
  import org.apache.struts.action.ActionMapping;
  import org.seasar.tuigwaa.database.CriteriaFunctionFactory;
  import org.seasar.tuigwaa.database.function.CriteriaExeFunction;
  import org.seasar.tuigwaa.database.function.criteria.CriteriaFunction;
  import org.seasar.tuigwaa.database.function.criteria.CriteriaListFunction;
  import org.seasar.tuigwaa.database.function.criteria.FirstResultCriteriaFunction;
  import org.seasar.tuigwaa.database.function.criteria.MaxResultCriteriaFunction;
  import org.seasar.tuigwaa.database.function.criteria.OrderCriteriaFunction;
  import org.seasar.tuigwaa.database.function.criteria.SubcriteriaFunction;
  import org.seasar.tuigwaa.database.function.criteria.UnaryCriteriaFunction;
  import org.seasar.tuigwaa.model.common.EntityUtils;
  import org.seasar.tuigwaa.model.core.RelationAttribute;
  import org.seasar.tuigwaa.model.core.TgwAttribute;
  import org.seasar.tuigwaa.model.core.TgwElement;
  import org.seasar.tuigwaa.model.core.TgwEntity;
  import org.seasar.tuigwaa.model.core.impl.FkAttribute;
  import org.seasar.tuigwaa.view.AttributeFormGenerateVisitor;
  
  /***
   * フィルタを作成するフォームに対応
   * 
   * @author nishioka
   */
  public class DataFilterForm extends AbstractFieldFilterForm {
  
  	private static final long serialVersionUID = -6374715710236762455L;
  
  	private String aggregationName_;
  
  	private boolean columnSelected = false;
  
  	private String[] selectedColumns;
  
  	private List dataFilterFormOrderRows = ListUtils.lazyList(new ArrayList(),
  			new DataFilterFormOrderRowFactory());
  
  	private List orderedFormNameList = new ArrayList();
  
  	private Integer maxResult;// = -1;
  
  	private Integer firstResult;
  
  	private void init(TgwEntity entity) {
  		setEntity(entity);
  		initSelectedColumns();
  	}
  
  	public DataFilterForm(TgwEntity entity) {
  		init(entity);
  	}
  
  	public DataFilterForm(TgwEntity entity, String aggregationName) {
  		init(entity);
  		this.aggregationName_ = aggregationName;
  
  	}
  
  	public DataFilterForm(TgwEntity entity, CriteriaExeFunction function) {
  		init(entity);
  		this.dataFilterFormOrderRows = ListUtils.lazyList(new ArrayList(),
  				new DataFilterFormOrderRowFactory());
  		setName(function.getName());
  		setSelectedHeaders(function.getSelectedHeaders());
  		setFormDatasFromFunction((CriteriaListFunction) function
  				.getUnaryCriteriaFunction());
  	}
  
  	private void setFormDatasFromFunction(CriteriaListFunction listFunction) {
  
 		setDisjunction(listFunction.isDisjunction());
 
 		Iterator itr = listFunction.getFunctionList().iterator();
 		List orderCriteriaFunctions = ListUtils.lazyList(new ArrayList(),
 				new DataFilterFormOrderRowFactory());
 		while (itr.hasNext()) {
 			CriteriaFunction criteriaFunction = (CriteriaFunction) itr.next();
 			if (criteriaFunction instanceof OrderCriteriaFunction) {
 				orderCriteriaFunctions.add(criteriaFunction);
 			} else if (criteriaFunction instanceof FirstResultCriteriaFunction) {
 				chargeFirstResultCriteriaFunction((FirstResultCriteriaFunction) criteriaFunction);
 			} else if (criteriaFunction instanceof MaxResultCriteriaFunction) {
 				chargeMaxResultCriteriaFunction((MaxResultCriteriaFunction) criteriaFunction);
 			} else {
 				chargeCriteriaFunction(criteriaFunction);
 			}
 
 		}
 		chargeOrderCriteriaFunction(orderCriteriaFunctions);
 	}
 
 	private void chargeCriteriaFunction(CriteriaFunction function) {
 		String fieldName = null;
 
 		if (function instanceof SubcriteriaFunction) {
 			fieldName = ((SubcriteriaFunction) function).getNestedAttrName();
 		} else {
 			fieldName = function.getField();
 		}
 
 		TgwAttribute attribute = getEntity().getField(fieldName);
 		FieldForm form = createFieldForm(attribute, fieldName);
 
 		CriteriaFunction nestedFunc = CriteriaFunctionFactory
 				.getFunction(function);
 
 		// form.setType(CriteriaFunctionFactory.getType(function));
 		form.setType(CriteriaFunctionFactory.getType(nestedFunc));
 		form.setValue(nestedFunc.getValue());
 
 		setEntityProperty(form);
 		addRow(form);
 	}
 
 	private void setEntityProperty(FieldForm form) {
 		if (form instanceof AbstractFieldFilterForm.BooleanFieldForm
 				|| form instanceof AbstractFieldFilterForm.DateFieldForm) {
 			return; // BooleanFieldForm と DateFieldForm では Visitor を使わないため
 		}
 
 		Object obj = null;
 		String propName = form.getFieldName();
 		int lastIndex = propName.lastIndexOf(".");
 
 		if (lastIndex >= 0) {
 			String parentAttrName = propName.substring(0, lastIndex);
 			propName = propName.substring(lastIndex + 1);
 			RelationAttribute fk = (RelationAttribute) getEntity().getField(
 					parentAttrName);
 			obj = fk.getRefEntity().newInstance();
 		} else {
 			obj = getEntity().newInstance();
 		}
 		EntityUtils.setProperty(obj, propName, form.getValue());
 		form.setVisitor(AttributeFormGenerateVisitor.createTableForm(obj));
 	}
 
 	private void chargeOrderCriteriaFunction(List orderCriteriaFunctions) {
 		Iterator itr = orderCriteriaFunctions.iterator();
 		while (itr.hasNext()) {
 			OrderCriteriaFunction function = (OrderCriteriaFunction) itr.next();
 			DataFilterFormOrderRow row = new DataFilterFormOrderRow();
 			row.setOrderSelected(true);
 			row.setSelectedOrder(function.getField());
 			row.setAscendant(!function.isDesc());
 			row.setDisplayName(getEntity().getField(function.getField())
 					.getDisplayName());
 
 			this.dataFilterFormOrderRows.add(row);
 			this.orderedFormNameList.add(row.getSelectedOrder());
 
 		}
 	}
 
 	private void chargeFirstResultCriteriaFunction(
 			FirstResultCriteriaFunction function) {
 		setFirstResult((Integer) ((FirstResultCriteriaFunction) function)
 				.getValue());
 	}
 
 	private void chargeMaxResultCriteriaFunction(
 			MaxResultCriteriaFunction function) {
 		setMaxResult((Integer) ((MaxResultCriteriaFunction) function)
 				.getValue());
 	}
 
 	private void setSelectedHeaders(List selectedHeaders) {
 		if (selectedHeaders != null && selectedHeaders.size() > 0) {
 			setColumnSelected(true);
 
 			Iterator fieldIterator = getEntity().getFieldIterator();
 			int n = 0;
 			while (fieldIterator.hasNext()) {
 				String fieldName = ((TgwElement) fieldIterator.next())
 						.getName();
 				if (selectedHeaders.contains(fieldName)) {
 					setSelectedColumn(n, fieldName);
 				}
 				n++;
 			}
 		}
 	} // [Start] ----- Getter Setter Methods -----
 
 	public Integer getFirstResult() {
 		return firstResult;
 	}
 
 	public void setFirstResult(Integer firstResult) {
 		this.firstResult = firstResult;
 	}
 
 	public Integer getMaxResult() {
 		return maxResult;
 	}
 
 	public void setMaxResult(Integer maxResult) {
 		this.maxResult = maxResult;
 	}
 
 	public boolean isColumnSelected() {
 		return columnSelected;
 	}
 
 	public void setColumnSelected(boolean columnSelected) {
 		this.columnSelected = columnSelected;
 	}
 
 	public String[] getSelectedColumns() {
 		return selectedColumns;
 	}
 
 	private void initSelectedColumns() {
 		Collection fields = getEntity().getFieldList();
 		if (fields != null) {
 			selectedColumns = new String[fields.size()];
 		}
 	}
 
 	public void setSelectedColumns(String[] selectedColumns) {
 		this.selectedColumns = selectedColumns;
 	}
 
 	private void setSelectedColumn(int index, String str) {
 		this.selectedColumns[index] = str;
 	}
 
 	public String getAggregationName() {
 		return aggregationName_;
 	}
 
 	public Collection getFieldList() {
 		return getEntity().getFieldList();
 	}
 
 	protected void removeRow(int index, Object row) {
 	}
 
 	protected String[] getHtmlData(int index, Object row) {
 		FieldForm fieldForm = (FieldForm) row;
 		return fieldForm.getHtmlData(index);
 	}
 
 	protected Object createRow(int index, String value) {
 		TgwAttribute field = getEntity().getField(value);
 		return createFieldForm(field, value);
 	}
 
 	protected Object createNewRow() {
 		TgwAttribute field = getEntity().getFirstNotFkField();
 		String fieldName = getEntity().getFirstNotFkFieldName();
 		return createFieldForm(field, fieldName);
 	}
 
 	// [End] ----- Ajax Methods -----
 
 	/***
 	 * This method is called by DatgaFilterAction. User input data is converted
 	 * to DataFilterFunction Object.
 	 */
 	public CriteriaExeFunction getDataFilterFunction() {
 		UnaryCriteriaFunction function = getUnaryCriteriaFunction();
 		CriteriaExeFunction exe = CriteriaFunctionFactory
 				.createCriteriaExeFunction(getEntity(), getName(), function);
 		if (selectedColumns != null && selectedColumns.length > 0) {
 			for (int i = 0; i < selectedColumns.length; i++) {
 				exe.addSelectedHeader(selectedColumns[i]);
 			}
 		}
 		return exe;
 	}
 
 	public UnaryCriteriaFunction getUnaryCriteriaFunction() {
 		CriteriaListFunction function = new CriteriaListFunction();
 		function.setDisjunction(isDisjunction());
 		for (Iterator itr = getRowSet().iterator(); itr.hasNext();) {
 			FieldForm form = (FieldForm) itr.next();
 			CriteriaFunction critariFunction = getFunction(form.getType(),
 					getEntity(), form.getFieldName(), form.getValue());
 			function.addFunction(critariFunction);
 		}
 
 		if (getMaxResult() != null && getMaxResult().intValue() > 0) {
 			function.addFunction(new MaxResultCriteriaFunction(getMaxResult()));
 		}
 
 		if (getFirstResult() != null && getFirstResult().intValue() > 0) {
 			function.addFunction(new FirstResultCriteriaFunction(
 					getFirstResult()));
 		}
 
 		Iterator itr = this.dataFilterFormOrderRows.iterator();
 		while (itr.hasNext()) {
 			DataFilterFormOrderRow row = (DataFilterFormOrderRow) itr.next();
 			OrderCriteriaFunction func = row.getUnaryCriteriaFunction();
 			if (func != null) {
 				function.addFunction(func);
 			}
 		}
 
 		return function;
 	}
 
 	public void reset(ActionMapping arg0, HttpServletRequest arg1) {
 
 		if (getSelectedColumns() != null) {
 			String str[] = new String[getSelectedColumns().length];
 			setSelectedColumns(str);
 		}
 		Iterator itr = this.dataFilterFormOrderRows.iterator();
 		while (itr.hasNext()) {
 			((DataFilterFormOrderRow) itr.next()).reset();
 		}
 
 		super.reset(arg0, arg1);
 	}
 
 	public ActionErrors validate(ActionMapping arg0, HttpServletRequest arg1) {
 		if (!isColumnSelected()) {
 			initSelectedColumns();
 		}
 		return super.validate(arg0, arg1);
 	}
 
 	public DataFilterFormOrderRow getDataFilterFormOrderRow(int index) {
 		return (DataFilterFormOrderRow) dataFilterFormOrderRows.get(index);
 	}
 
 	public void setDataFilterFormOrderRow(DataFilterFormOrderRow orderRow) {
 		this.dataFilterFormOrderRows.add(orderRow);
 	}
 
 	public void setDataFilterFormOrderRows(List dataFilterFormOrderRows) {
 		this.dataFilterFormOrderRows = dataFilterFormOrderRows;
 	}
 
 	public Collection getDataFilterFormOrderRows() {
 		return dataFilterFormOrderRows;
 	}
 
 	public Collection getNotOrderFields() {
 		List list = new ArrayList();
 		Collection fields = getFieldList();
 		Iterator itr = fields.iterator();
 		while (itr.hasNext()) {
 			TgwAttribute field = (TgwAttribute) itr.next();
 			if (!orderedFormNameList.contains(field.getName())) {
 				list.add(field);
 			}
 		}
 		return list;
 	}
 
 	public class DataFilterFormOrderRow {
 		private boolean ascendant = false;
 
 		private String selectedOrder = null;
 
 		private boolean orderSelected = false;
 
 		private String displayName = null;
 
 		public boolean isAscendant() {
 			return ascendant;
 		}
 
 		public void setAscendant(boolean ascendant) {
 			this.ascendant = ascendant;
 		}
 
 		public boolean isOrderSelected() {
 			return orderSelected;
 		}
 
 		public void setOrderSelected(boolean orderSelected) {
 			this.orderSelected = orderSelected;
 		}
 
 		public String getSelectedOrder() {
 			return selectedOrder;
 		}
 
 		public void setSelectedOrder(String selectedOrder) {
 			this.selectedOrder = selectedOrder;
 		}
 
 		private OrderCriteriaFunction getUnaryCriteriaFunction() {
 			if (this.orderSelected && this.selectedOrder != null) {
 				boolean descFlag = !isAscendant();
 				return new OrderCriteriaFunction(getSelectedOrder(), null,
 						descFlag);
 			}
 			return null;
 		}
 
 		public void reset() {
 			this.setOrderSelected(false);
 		}
 
 		public String getDisplayName() {
 			return displayName;
 		}
 
 		public void setDisplayName(String displayName) {
 			this.displayName = displayName;
 		}
 
 		public String getAscendantChecked() {
 			if (ascendant) {
 				return "checked";
 			}
 			return "";
 		}
 
 		public String getDescendantChecked() {
 			if (!ascendant) {
 				return "checked";
 			}
 			return "";
 		}
 
 	}
 
 	public class DataFilterFormOrderRowFactory implements Factory {
 		public Object create() {
 			return new DataFilterFormOrderRow();
 		}
 	}
 
 }