/*
    * 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.controller;
  
  import java.util.Calendar;
  import java.util.Collections;
  import java.util.Date;
  import java.util.GregorianCalendar;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  import org.apache.commons.lang.StringUtils;
  import org.seasar.tuigwaa.database.CriteriaFunctionFactory;
  import org.seasar.tuigwaa.database.function.criteria.CriteriaFunction;
  import org.seasar.tuigwaa.database.function.criteria.DateFuncCriteriaFunction;
  import org.seasar.tuigwaa.database.function.criteria.LikeCriteriaFunction;
  import org.seasar.tuigwaa.database.function.criteria.SubcriteriaFunction;
  import org.seasar.tuigwaa.model.core.TgwAttribute;
  import org.seasar.tuigwaa.model.core.TgwEntity;
  import org.seasar.tuigwaa.model.core.impl.BooleanAttribute;
  import org.seasar.tuigwaa.model.core.impl.DateAttribute;
  import org.seasar.tuigwaa.model.core.impl.DoubleAttribute;
  import org.seasar.tuigwaa.model.core.impl.FileAttribute;
  import org.seasar.tuigwaa.model.core.impl.FloatAttribute;
  import org.seasar.tuigwaa.model.core.impl.IntegerAttribute;
  import org.seasar.tuigwaa.model.core.impl.LinkAttribute;
  import org.seasar.tuigwaa.model.core.impl.LongAttribute;
  import org.seasar.tuigwaa.model.core.impl.SecurityAttribute;
  import org.seasar.tuigwaa.model.core.impl.StringAttribute;
  import org.seasar.tuigwaa.model.core.impl.TimestampAttribute;
  import org.seasar.tuigwaa.system.Constants;
  import org.seasar.tuigwaa.util.TgwResource;
  import org.seasar.tuigwaa.util.ajax.AbstractRowSetForm;
  import org.seasar.tuigwaa.view.AttributeFormGenerateVisitor;
  
  import com.isenshi.util.HtmlBuffer;
  
  public abstract class AbstractFieldFilterForm extends AbstractRowSetForm {
  
  	protected static final Map FIELD_FORM_MAP;
  
  	private TgwEntity entity;
  
  	private boolean disjunction = false;
  
  	private String name;
  
  	static {
  		Map basics = new HashMap();
  		basics.put(IntegerAttribute.class, IntegerFieldForm.class);
  		basics.put(LongAttribute.class, LongFieldForm.class);
  		basics.put(FloatAttribute.class, FloatFieldForm.class);
  		basics.put(DoubleAttribute.class, DoubleFieldForm.class);
  		basics.put(BooleanAttribute.class, BooleanFieldForm.class);
  		basics.put(StringAttribute.class, StringFieldForm.class);
  		basics.put(DateAttribute.class, DateFieldForm.class);
  		basics.put(TimestampAttribute.class, TimestampForm.class);
  		basics.put(SecurityAttribute.class, StringFieldForm.class);
  		FIELD_FORM_MAP = Collections.unmodifiableMap(basics);
  	}
  
  	// [Start] ----- Setter Getter Method -----
  
  	public void setEntity(TgwEntity entity) {
  		this.entity = entity;
  	}
  
  	public final TgwEntity getEntity() {
  		return entity;
  	}
  
  	public void setDisjunction(boolean disjunction) {
  		this.disjunction = disjunction;
  	}
  
  	public boolean isDisjunction() {
  		return disjunction;
  	}
  
  	public void setName(String name) {
  		this.name = name;
  	}
  
  	public String getName() {
  		return name;
 	}
 
 	// [End] ----- Setter Getter Method -----
 
 	protected final FieldForm createFieldForm(TgwAttribute field,
 			String fieldName) {
 		return createFieldForm(field, fieldName, true);
 	}
 
 	protected final FieldForm createFieldForm(TgwAttribute field,
 			String fieldName, boolean needValue) {
 		Class clazz = (Class) FIELD_FORM_MAP.get(field.getClass());
 		FieldForm form = null;
 		try {
 			form = (FieldForm) clazz.newInstance();
 		} catch (InstantiationException e) {
 			// Do Nothing
 			e.printStackTrace();
 		} catch (IllegalAccessException e) {
 			// Do Nothing
 			e.printStackTrace();
 		}
 		form.setFieldName(fieldName);
 		form.setEntity(getEntity());
 		form.setNeedValue(needValue);
 		return form;
 	}
 
 	protected final String getHtmlCell(int rowIndex, int columnIndex,
 			String restriction) {
 		FieldForm fieldForm = (FieldForm) getRow(rowIndex);
 		if (fieldForm.isNeedValue()) {
 			return fieldForm.updateValueHtml(rowIndex, restriction);
 		} else {
 			return fieldForm.createRemoveButton(rowIndex);
 		}
 	}
 
 	protected CriteriaFunction getFunction(String type, TgwEntity entity,
 			String field) {
 		return getFunction(type, entity, field, null);
 	}
 
 	protected CriteriaFunction getFunction(String type, TgwEntity entity,
 			String field, Object value) {
 
 		CriteriaFunction function = null;
 
 		int index = field.indexOf(".");
 		if (index < 0) {
 			String option = null;
 			int optionIndex = type.indexOf("?");
 			if (optionIndex > 0) {
 				option = type.substring(optionIndex + 1, type.length());
 				type = type.substring(0, optionIndex);
 			}
 			function = CriteriaFunctionFactory.getFunction(type);
 			function.setField(field);
 			function.setValue(value);
 			function.setOption(option);
 		} else {
 			String thisField = field.substring(0, index);
 			String nestedField = field.substring(index + 1, field.length());
 			TgwEntity refEntity = ((LinkAttribute) entity.getField(thisField))
 					.getRefEntity();
 			CriteriaFunction sequentialFunction = getFunction(type, refEntity,
 					nestedField, value);
 			function = new SubcriteriaFunction(thisField, sequentialFunction);
 		}
 		return function;
 	}
 
 	public static abstract class FieldForm {
 
 		private static final int FORM_FIELD = 0;
 
 		private static final int FORM_TYPE = 1;
 
 		private static final int FORM_VALUE = 2;
 
 		private static final int FORM_ACTION = 3;
 
 		private static final int LENGTH_FORM = 4;
 
 		protected static final String EQ = "eq";
 
 		protected static final String NE = "ne";
 
 		protected static final String LE = "le";
 
 		protected static final String LT = "lt";
 
 		protected static final String GE = "ge";
 
 		protected static final String GT = "gt";
 
 		protected static final String ISNULL = "isNull";
 
 		protected static final String ISNOTNULL = "isNotNull";
 
 		protected static final String BETWEEN = "between";
 
 		protected static final String DATEFUNC = "dateFunc";
 
 		protected static final String SECURITY = "security";
 
 		protected static final String LIKE_HEAD = "like?"
 				+ LikeCriteriaFunction.TYPE_HEAD;
 
 		protected static final String LIKE_TAIL = "like?"
 				+ LikeCriteriaFunction.TYPE_TAIL;
 
 		protected static final String LIKE_IN = "like?"
 				+ LikeCriteriaFunction.TYPE_IN;
 
 		private boolean needValue = true; // default is true
 
 		private String type_;
 
 		private String fieldName_;
 
 		private Object value_;
 
 		private TgwEntity entity_;
 
 		private String displayName;
 
 		private AttributeFormGenerateVisitor visitor_ = AttributeFormGenerateVisitor.SEARCHFORM_INSTANCE;
 
 		public void setDisplayName(String displayName) {
 			this.displayName = displayName;
 		}
 
 		public String getDisplayName() {
 			return displayName;
 		}
 
 		public void setNeedValue(boolean needValue) {
 			this.needValue = needValue;
 		}
 
 		public void setEntity(TgwEntity entity) {
 			this.entity_ = entity;
 		}
 
 		public void setType(String type) {
 			this.type_ = type;
 		}
 
 		public String getType() {
 			return this.type_;
 		}
 
 		public void setFieldName(String fieldName) {
 			this.fieldName_ = fieldName;
 		}
 
 		public String getFieldName() {
 			return this.fieldName_;
 		}
 
 		public TgwAttribute getField() {
 			return getEntity().getField(getFieldName());
 		}
 
 		public boolean isNeedValue() {
 			return needValue;
 		}
 
 		public void setValue(Object value) {
 			this.value_ = value;
 		}
 
 		public Object getValue() {
 			return value_;
 		}
 
 		protected TgwEntity getEntity() {
 			return entity_;
 		}
 
 		public String[] getHtmlData(int index) {
 			String fieldName = getFieldName();
 			String[] data = null;
 
 			if (needValue) {
 				data = new String[LENGTH_FORM];
 				data[FORM_VALUE] = getValueHtml(index, fieldName);
 				data[FORM_ACTION] = createRemoveButton(index);
 			} else {
 				data = new String[LENGTH_FORM - 1];
 				data[FORM_ACTION - 1] = createRemoveButton(index);
 			}
 			data[FORM_TYPE] = getTypeHtml(index);
 			data[FORM_FIELD] = getFieldHtml(index, fieldName);
 			return data;
 
 		}
 
 		protected String createRemoveButton(int index) {
 			return createRemoveButtonHtml(index, TgwResource
 					.getMessage("button.remove"));
 		}
 
 		private final String getFieldHtml(int index, String selectedFieldName) {
 			HtmlBuffer buf = new HtmlBuffer();
 
 			buf.appendStartTag("select");
 			buf.appendAttribute("name", getPrefix(index) + "fieldName");
 			bindTypeEvent(buf);
 
 			Iterator itr = entity_.getAllFieldList().iterator();
 
 			while (itr.hasNext()) {
 				TgwAttribute field = (TgwAttribute) itr.next();
 				if (field instanceof FileAttribute) {
 					continue;
 				}
 				buf.appendOption(field.getDisplayName(), field.getName(),
 						selectedFieldName);
 			}
 
 			buf.appendOption(getEntity().getPrimaryKeyDisplayName(),
 					Constants.ENTITY_BUILTIN_ID, selectedFieldName);
 			buf.endTag();
 			return buf.toString();
 		}
 
 		private final String getTypeHtml(int index) {
 			HtmlBuffer buf = new HtmlBuffer();
 			buf.appendStartTag("select");
 			buf.appendAttribute("name", getPrefix(index) + "type");
 			bindTypeEvent(buf, "onChangeRestriction(this);");
 
 			String[] pickTypes = getPickTypes();
 
 			for (int i = 0; i < pickTypes.length; i++) {
 				String value = pickTypes[i];
 
 				String key = null;
 				if (needValue) {
 					key = "filter.label." + value;
 				} else {
 					if (value.equals("between") || value.equals("dateFunc")
 							|| value.equals("security")) {
 						continue;
 					}
 					key = "search.label." + value;
 				}
 
 				String label = TgwResource.getMessage(key);
 
 				buf.appendOption(label, value, type_);
 			}
 			buf.endTag();
 			return buf.toString();
 		}
 
 		// this method is called at changing field name;
 		protected String getValueHtml(int index, String fieldName) {
 			// return createTextField(getPrefix(index) + "valueField");
 			return (String) getField().accept(getVisitor(),
 					getPrefix(index) + "valueField");
 		}
 
 		// this method is called at changeing restriction;
 		protected String updateValueHtml(int index, String restriction) {
 			if (isNullablePickType(restriction)) {
 				return "";
 			}
 			return getValueHtml(index, getFieldName());
 		}
 
 		abstract String[] getPickTypes();
 
 		private AttributeFormGenerateVisitor getVisitor() {
 			return visitor_;
 		}
 
 		public void setVisitor(AttributeFormGenerateVisitor visitor) {
 			this.visitor_ = visitor;
 		}
 
 		protected boolean isNullablePickType(String restriction) {
 			if (restriction == null)
 				return false; // should throw Exception
 			return ISNULL.equals(restriction) || ISNOTNULL.equals(restriction);
 		}
 
 	}
 
 	public static class IntegerFieldForm extends FieldForm {
 
 		private static final String[] pickValues = { EQ, NE, LE, LT, GE, GT,
 				ISNULL, ISNOTNULL };
 
 		public String[] getPickTypes() {
 			return pickValues;
 		}
 
 		public void setValueField(Integer value) {
 			setValue(value);
 		}
 	}
 
 	public static class LongFieldForm extends FieldForm {
 
 		private static final String[] pickValues = { EQ, NE, LE, LT, GE, GT,
 				ISNULL, ISNOTNULL };
 
 		public String[] getPickTypes() {
 			return pickValues;
 		}
 
 		public void setValueField(Long value) {
 			setValue(value);
 		}			
 	}
 
 	public static class DoubleFieldForm extends FieldForm {
 
 		private static final String[] pickValues = { EQ, NE, LE, LT, GE, GT,
 				ISNULL, ISNOTNULL };
 
 		public String[] getPickTypes() {
 			return pickValues;
 		}
 
 		public void setValueField(Double value) {
 			setValue(value);
 		}
 	}
 
 	public static class FloatFieldForm extends FieldForm {
 
 		private static final String[] pickValues = { EQ, NE, LE, LT, GE, GT,
 				ISNULL, ISNOTNULL };
 
 		public String[] getPickTypes() {
 			return pickValues;
 		}
 
 		public void setValueField(Float value) {
 			setValue(value);
 		}
 	}
 
 	public static class StringFieldForm extends FieldForm {
 
 		private static final String[] pickTypes = { EQ, NE, LIKE_HEAD,
 				LIKE_TAIL, LIKE_IN, SECURITY, ISNULL, ISNOTNULL };
 
 		public String[] getPickTypes() {
 			String attrName = getFieldName();
 			// TgwEntity entity = getEntity();
 			if (attrName.indexOf('.') > 0) {
 				String[] newpicktypes = new String[pickTypes.length + 1];
 				for (int i = 0; i < pickTypes.length; i++) {
 					newpicktypes[i] = pickTypes[i];
 				}
 				newpicktypes[newpicktypes.length - 1] = "eq?list";
 				return newpicktypes;
 			} else {
 				return pickTypes;
 			}
 		}
 
 		public void setValueField(String value) {
 			setValue(value);
 		}
 
 		protected String updateValueHtml(int index, String restriction) {
 			if (SECURITY.equals(restriction) || isNullablePickType(restriction)) {
 				return "";
 			} else {
 				StringAttribute attr = (StringAttribute) getField();
 				String html = (String) attr.accept(
 						AttributeFormGenerateVisitor.DEFAULT_INSTANCE,
 						getPrefix(index) + "valueField");
 				// return super.updateValueHtml(index, restriction);
 				return html;
 			}
 		}
 	}
 
 	public static class BooleanFieldForm extends FieldForm {
 
 		private static final String[] pickTypes = { EQ, NE, ISNULL, ISNOTNULL };
 
 		public String[] getPickTypes() {
 			return pickTypes;
 		}
 
 		public void setValueField(Boolean value) {
 			setValue(value);
 		}
 
 		public Object getValue() {
 			if (ISNULL.equals(getType())) {
 				return null;
 			}
 			return super.getValue();
 		}
 
 		// override
 		protected String getValueHtml(int index, String fieldName) {
 			HtmlBuffer buf = new HtmlBuffer();
 			buf.appendStartTag("select");
 			buf.appendAttribute("name", getPrefix(index) + "valueField");
 
 			BooleanAttribute bField = (BooleanAttribute) getEntity().getField(
 					fieldName);
 
 			String value = null;
 			if (getValue() != null) {
 				value = getValue().toString();
 			}
 
 			buf.appendOption(bField.getTrueStr(), "true", value);
 			buf.appendOption(bField.getFalseStr(), "false", value);
 
 			buf.endTag();
 
 			return buf.toString();
 		}
 	}
 
 	public static class TimestampForm extends DateFieldForm {
 		private static final String[] pickTypes = { LE, GE, BETWEEN, DATEFUNC };
 
 		public String[] getPickTypes() {
 			return pickTypes;
 		}
 	}
 
 	public static class DateFieldForm extends FieldForm {
 
 		private static final String[] pickTypes = { EQ, LE, GE, NE, BETWEEN,
 				DATEFUNC, ISNULL, ISNOTNULL };
 
 		public String[] getPickTypes() {
 			return pickTypes;
 		}
 
 		private int year_;
 
 		private int month_;
 
 		private int date_;
 
 		private int year2;
 
 		private int month2;
 
 		private int date2;
 
 		private String selectType;
 
 		public String getSelectType() {
 			return selectType;
 		}
 
 		public void setSelectType(String selectType) {
 			this.selectType = selectType;
 		}
 
 		public int getYear() {
 			return year_;
 		}
 
 		public void setYear(int year) {
 			this.year_ = year;
 		}
 
 		public int getMonth() {
 			return month_;
 		}
 
 		public void setMonth(int month) {
 			this.month_ = month;
 		}
 
 		public int getDate() {
 			return date_;
 		}
 
 		public void setDate(int date) {
 			this.date_ = date;
 		}
 
 		public int getDate2() {
 			return date2;
 		}
 
 		public void setDate2(int date2) {
 			this.date2 = date2;
 		}
 
 		public int getMonth2() {
 			return month2;
 		}
 
 		public void setMonth2(int month2) {
 			this.month2 = month2;
 		}
 
 		public int getYear2() {
 			return year2;
 		}
 
 		public void setYear2(int year2) {
 			this.year2 = year2;
 		}
 
 		public Object getValue() {
 			String type = getType();
 			if (DATEFUNC.equals(type)) {
 				return getSelectType();
 			} else if (BETWEEN.equals(type)) {
 				Date[] dates = new Date[2];
 				dates[0] = getDate(getYear(), getMonth(), getDate());
 				dates[1] = getDate(getYear2(), getMonth2(), getDate2());
 				return dates;
 			} else {
 				return getDate(getYear(), getMonth(), getDate());
 			}
 		}
 
 		private Object getValueFromValueObject() {
 			String type = getType();
 			if (DATEFUNC.equals(type)) {
 				return getSelectType();
 			} else {
 				return super.getValue();
 			}
 		}
 
 		private Date getDate(int year, int month, int date) {
 			Calendar cal = new GregorianCalendar(year, month - 1, date);
 			return cal.getTime();
 		}
 
 		protected String getValueHtml(int index, String fieldName) {
 			if (StringUtils.isNotEmpty(getType())) {
 				return updateValueHtml(index, getType());
 			}
 			return updateValueHtml(index, getPickTypes()[0]);
 		}
 
 		public void setValue(Object value) {
 			if (DATEFUNC.equals(getType())) {
 				setSelectType((String) value);
 			}
 			super.setValue(value);
 		}
 
 		protected String updateValueHtml(int index, String restriction) {
 			if (DATEFUNC.equals(restriction)) {
 				return getSelectTypeField(index);
 			} else if (BETWEEN.equals(restriction)) {
 				return getValueHtml(index, false) + "-"
 						+ getValueHtml(index, true);
 			} else if (isNullablePickType(restriction)) {
 				return "";
 			} else {
 				return getValueHtml(index);
 			}
 		}
 
 		private String getSelectTypeField(int index) {
 			HtmlBuffer buf = new HtmlBuffer();
 
 			buf.appendStartTag("select");
 			buf.appendAttribute("name", getPrefix(index) + "selectType");
 
 			for (int i = 0; i < DateFuncCriteriaFunction.DATE_TYPE.length; i++) {
 				String type = DateFuncCriteriaFunction.DATE_TYPE[i];
 				String label = TgwResource.getMessage("datefield." + type);
 				buf.appendOption(label, type, getSelectType());
 			}
 
 			buf.endTag();
 			return buf.toString();
 		}
 
 		protected String getValueHtml(int index) {
 			return getValueHtml(index, false);
 		}
 
 		protected String getValueHtml(int index, boolean isSuffix) {
 			String suffix = "";
 			if (isSuffix) {
 				suffix = "2";
 			}
 
 			int startYear = Calendar.getInstance().get(Calendar.YEAR) - 10;
 			int endYear = Calendar.getInstance().get(Calendar.YEAR) + 10;
 
 			if (getField() instanceof DateAttribute) {
 				DateAttribute dField = (DateAttribute) getField();
 				startYear = dField.getStartValue();
 				endYear = dField.getEndValue();
 			}
 
 			String yearLabel = getPrefix(index) + "year" + suffix;
 			String monthLabel = getPrefix(index) + "month" + suffix;
 			String dateLabel = getPrefix(index) + "date" + suffix;
 
 			String onchange = null;
 
 			HtmlBuffer buf = new HtmlBuffer();
 
 			String values[] = getDateValues(suffix);
 
 			buf.appendSelect(yearLabel, startYear, endYear, values[0],
 					onchange, false);
 			buf.appendSelect(monthLabel, 1, 12, values[1], onchange, false);
 			buf.appendSelect(dateLabel, 1, 31, values[2], onchange, false);
 
 			return buf.toString();
 		}
 
 		private String[] getDateValues(String suffix) {
 			String[] str = new String[3];
 			Date d = null;
 			if (getValueFromValueObject() == null) {
 				return str;
 			} else if (getValueFromValueObject() instanceof Date) {
 				d = (Date) getValueFromValueObject();
 			} else if (BETWEEN.equals(getType())) {
 				Date[] date = (Date[]) getValueFromValueObject();
 				if ("".equals(suffix)) {
 					d = date[0];
 				} else if ("2".equals(suffix)) {
 					d = date[1];
 				}
 			}
 
 			Calendar cal = GregorianCalendar.getInstance();
 			cal.setTime(d);
 			str[0] = String.valueOf(cal.get(Calendar.YEAR));
 			str[1] = String.valueOf(cal.get(Calendar.MONTH) + 1);
 			str[2] = String.valueOf(cal.get(Calendar.DAY_OF_MONTH));
 			return str;
 		}
 	}
 }