/*
    * 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/07/30
   */
  package org.seasar.tuigwaa.model;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import org.seasar.tuigwaa.database.CriteriaFunctionFactory;
  import org.seasar.tuigwaa.database.function.CriteriaExeFunction;
  import org.seasar.tuigwaa.database.function.DaoMethod;
  import org.seasar.tuigwaa.database.function.SearchExeFunction;
  import org.seasar.tuigwaa.database.function.UpdateExeFunction;
  import org.seasar.tuigwaa.database.function.aggregation.AggregationFunction;
  import org.seasar.tuigwaa.database.function.aggregation.AvgProjectionFunction;
  import org.seasar.tuigwaa.database.function.aggregation.GroupProjectionFunction;
  import org.seasar.tuigwaa.database.function.aggregation.ProjectionFunction;
  import org.seasar.tuigwaa.database.function.criteria.CriteriaListFunction;
  import org.seasar.tuigwaa.database.function.criteria.UnaryCriteriaFunction;
  import org.seasar.tuigwaa.model.common.EntityDAO;
  import org.seasar.tuigwaa.model.common.EntityDAOImpl;
  import org.seasar.tuigwaa.model.common.EntityUtils;
  import org.seasar.tuigwaa.model.core.TgwAttribute;
  import org.seasar.tuigwaa.model.core.TgwEntity;
  import org.seasar.tuigwaa.model.core.impl.DoubleAttribute;
  import org.seasar.tuigwaa.model.core.impl.IntegerAttribute;
  import org.seasar.tuigwaa.model.core.impl.TgwEntityImpl;
  import org.seasar.tuigwaa.util.TgwPathResolver;
  
  import com.isenshi.util.extlib.DiconResource;
  
  /***
   * @author nishioka
   */
  public class DAOServiceImpl implements DAOService {
  
  	private static final String[][] BASIC_FUNC_NAMES = {
  			{ "orderListExe", EntityDAO.ORDERED_LIST },
  			{ "loadExe", EntityDAO.LOAD }, { "listExe", EntityDAO.LIST },
  			{ "deleteExe", EntityDAO.DELETE },
  			{ "saveOrUpdateExe", EntityDAO.SAVEUPDATE },
  			{ "injectCriteriaExe", EntityDAO.INJECT_CRITERIA },
  			{ "deleteAllExe", EntityDAO.DELETEALL } };
  
  	private Map functionMap_ = new HashMap();
  
  	public DAOServiceImpl() {
  	}
  
  	public void registerDaoMethod(TgwEntity entity, DaoMethod daoMethod) {
  		FunctionSet set = getFunctionSet(entity);
  		registerDaoMethod(entity.getDomainName(), set, daoMethod);
  	}
  
  	public DaoMethod deregisterDaoMethod(TgwEntity entity, String funcName) {
  		FunctionSet set = getFunctionSet(entity);
  		return set.remove(funcName);
  	}
  
  	public CriteriaExeFunction injectDataFilter(TgwEntity entity,
  			String aggregationName, UnaryCriteriaFunction function) {
  		Map map = getAggregationFunctionMap(entity);
  		CriteriaExeFunction exe = (CriteriaExeFunction) map
  				.get(aggregationName);
  		List projectionList = exe.getProjectionList();
  		CriteriaExeFunction newExe = CriteriaFunctionFactory
  				.createCriteriaExeFunction(entity, "", exe
  						.getUnaryCriteriaFunction());
  		for (Iterator i = projectionList.iterator(); i.hasNext();) {
  			newExe.addProjection((String) i.next());
  		}
  		newExe.setDataTableFilter(function);
  		return newExe;
  	}
  
  	public TgwEntity createProjectionEntity(TgwEntity orgEntity,
  			String aggregationName) {
  		Map aggMap = getAggregationFunctionMap(orgEntity);
  		Map valueAggMap = getValueFunctionMap(orgEntity);
 
 		CriteriaExeFunction exe = (CriteriaExeFunction) aggMap
 				.get(aggregationName);
 		if (exe == null) {
 			exe = (CriteriaExeFunction) valueAggMap.get(aggregationName);
 		}
 		return doCreateProjectionEntity(orgEntity, exe, aggregationName);
 	}
 
 	public void loadFunctions(TgwEntity entity) {
 		String path = TgwPathResolver.getDaoFilePath(entity.getDomainName(),
 				entity.getName());
 		DiconResource resource = loadDiconResource(path);
 		if (resource == null) {
 			return;
 		}
 
 		FunctionSet functionSet = new FunctionSet();
 
 		Object[] daoMethods = resource.findComponents(DaoMethod.class);
 		for (int i = 0; i < daoMethods.length; i++) {
 			registerDaoMethod(entity.getDomainName(), functionSet,
 					(DaoMethod) daoMethods[i]);
 		}
 
 		synchronized (functionMap_) {
 			functionMap_.put(EntityUtils.getKeys(entity), functionSet);
 		}
 	}
 
 	public void saveFunction(TgwEntity entity) {
 		FunctionSet set = getFunctionSet(entity);
 		saveFunction(entity.getDomainName(), entity.getName(), set);
 	}
 
 	public void saveAllFunctions() {
 		synchronized (functionMap_) {
 			Iterator itr = functionMap_.keySet().iterator();
 			while (itr.hasNext()) {
 				String key = (String) itr.next();
 				FunctionSet set = (FunctionSet) functionMap_.get(key);
 				int index = key.indexOf(".");
 				String domain = key.substring(0, index);
 				String entityName = key.substring(index + 1, key.length());
 				saveFunction(domain, entityName, set);
 			}
 		}
 	}
 
 	public void resetAllFunctions() {
 		functionMap_ = new HashMap();
 	}
 
 	public Map getDataFilterFunctionMap(TgwEntity entity) {
 		FunctionSet set = getFunctionSet(entity);
 		return Collections.unmodifiableMap(set.getDataFilterFunctionMap());
 	}
 
 	public Map getAggregationFunctionMap(TgwEntity entity) {
 		FunctionSet set = getFunctionSet(entity);
 		return Collections.unmodifiableMap(set.getAggregationExeFunctionMap());
 	}
 
 	public Map getSearchFunctionMap(TgwEntity entity) {
 		FunctionSet set = getFunctionSet(entity);
 		return Collections.unmodifiableMap(set.getSearchExeFunctionMap());
 	}
 
 	public Map getCustomFormFunctionMap(TgwEntity entity) {
 		FunctionSet set = getFunctionSet(entity);
 		return Collections.unmodifiableMap(set.getCustomFormFunctionMap());
 	}
 
 	public Map getValueFunctionMap(TgwEntity entity) {
 		FunctionSet set = getFunctionSet(entity);
 		return Collections.unmodifiableMap(set.getValueExeFunctionMap());
 	}
 
 	public EntityDAO getDAO(TgwEntity entity) {
 		FunctionSet set = getFunctionSet(entity);
 		Map funcMap = new HashMap();
 		funcMap.putAll(set.getAllFunctionMap());
 		for (int i = 0; i < BASIC_FUNC_NAMES.length; i++) {
 			DaoMethod basicDao = CriteriaFunctionFactory.createBasicDaoMethod(
 					entity, BASIC_FUNC_NAMES[i][0]);
 			basicDao.setDomainName(entity.getDomainName());
 			funcMap.put(BASIC_FUNC_NAMES[i][1], basicDao);
 		}
 		EntityDAO dao = new EntityDAOImpl(funcMap);
 		return dao;
 	}
 
 	public FunctionSet getFunctionSet(TgwEntity entity) {
 		String fullPath = EntityUtils.getKeys(entity);
 		FunctionSet set = null;
 		synchronized (functionMap_) {
 			set = (FunctionSet) functionMap_.get(fullPath);
 			if (set == null) {
 				set = new FunctionSet();
 				functionMap_.put(fullPath, set);
 			}
 		}
 		return set;
 	}
 
 	// [Start] ------ Private Method ------
 
 	private TgwEntity doCreateProjectionEntity(TgwEntity entity,
 			CriteriaExeFunction exe, String aggregationName) {
 		TgwEntity newEntity = new TgwEntityImpl(entity.getDomainName(), entity
 				.getName());
 		newEntity.setAggregation(true);
 		newEntity.setDisplayName(aggregationName);
 
 		UnaryCriteriaFunction topFunction = exe.getUnaryCriteriaFunction();
 
 		AggregationFunction aggFunction = getAggregationFunction(topFunction);
 
 		Iterator itr = aggFunction.getFunctionList().iterator();
 
 		for (int i = 0; itr.hasNext(); i++) {
 			ProjectionFunction projection = (ProjectionFunction) itr.next();
 			if (projection instanceof GroupProjectionFunction) {
 				String fieldName = projection.getAlias();
 				TgwAttribute field = entity.getField(fieldName);
 				newEntity.addField(field);
 			} else {
 				// Virtual Number Field
 				TgwAttribute iField = null;
 				if (projection instanceof AvgProjectionFunction) {
 					iField = new DoubleAttribute();
 				} else {
 					iField = new IntegerAttribute();
 				}
 				iField.setName(projection.getAlias());
 				iField.setDisplayName((String) exe.getProjectionList().get(i));
 				newEntity.addField(iField);
 			}
 		}
 		return newEntity;
 	}
 
 	private AggregationFunction getAggregationFunction(
 			UnaryCriteriaFunction function) {
 		if (function instanceof CriteriaListFunction) {
 			List list = ((CriteriaListFunction) function).getFunctionList();
 			for (Iterator i = list.iterator(); i.hasNext();) {
 				UnaryCriteriaFunction aFunction = (UnaryCriteriaFunction) i
 						.next();
 				AggregationFunction aggFunction = getAggregationFunction(aFunction);
 				if (aggFunction != null) {
 					return aggFunction;
 				}
 			}
 		} else if (function instanceof AggregationFunction) {
 			return (AggregationFunction) function;
 		}
 		return null;
 	}
 
 	private DiconResource loadDiconResource(String path) {
 		DiconResource resource = new DiconResource();
 		resource.setPath(path);
 		resource.load();
 		if (!resource.hasContainer()) {
 			return null;
 		}
 		resource.bindRoot();
 		resource.include("dicon/basedb.dicon");
 		resource.include("dicon/logic.dicon");
 		return resource;
 	}
 
 	private void saveFunction(String domain, String entityName, FunctionSet set) {
 		DiconResource resource = new DiconResource();
 		Map options = new HashMap();
 		Map aspects = new HashMap();
 		aspects.put("evaluate", "basedb.requiredTx");
 		options.put(DiconResource.OPTION_ASPECTS, aspects);
 		resource.addComponentAll(set.getAllFunctionsExcludeCustomForm(),
 				options);
 
 		Map options2 = new HashMap();
 		Map aspects2 = new HashMap();
 		List list = new ArrayList();
 		list.add("tlogic.dataSave");
 		list.add("basedb.requiredTx");
 		aspects2.put("evaluate", list);
 		options2.put(DiconResource.OPTION_ASPECTS, aspects2);
 		resource.addComponentAll(set.getCustomFormFunctionMap().values(),
 				options2);
 
 		resource.setPath(TgwPathResolver.getDaoFilePath(domain, entityName));
 		resource.save();
 	}
 
 	private void registerDaoMethod(String domainName, FunctionSet set,
 			DaoMethod daoMethod) {
 		if (daoMethod instanceof CriteriaExeFunction) {
 			CriteriaExeFunction exe = (CriteriaExeFunction) daoMethod;
 			if (exe.isValueFlag()) {
 				set.addValueExeFunction(exe);
 			} else if (exe.isProjection()) {
 				set.addAggregationExeFunction(exe);
 			} else {
 				set.addDataFilterFunction(exe);
 			}
 		} else if (daoMethod instanceof SearchExeFunction) {
 			SearchExeFunction exe = (SearchExeFunction) daoMethod;
 			set.addSearchExeFunction(exe);
 		} else if (daoMethod instanceof UpdateExeFunction) {
 			UpdateExeFunction exe = (UpdateExeFunction) daoMethod;
 			if (exe.getDtoFieldList() != null
 					&& exe.getDtoFieldList().size() != 0) {
 				set.addCustomForm(exe);
 			} else {
 				set.addCustomUpdateFunction(exe);
 			}
 		}
 		daoMethod.setDomainName(domainName);
 	}
 
 	// [Start] ------ Inner Class FunctionSet ------
 
 	public class FunctionSet {
 
 		private Map dataFilterFunctionMap_ = new HashMap();
 
 		private Map aggregationExeFunctionMap_ = new HashMap();
 
 		private Map searchExeFunctionMap = new HashMap();
 
 		private Map valueExeFunctionMap = new HashMap();
 
 		private Map customFormFunctionMap = new HashMap();
 
 		private Map customUpdateFunctionMap = new HashMap();
 
 		public DaoMethod remove(String funcName) {
 			Object obj = null;
 			if (obj == null) {
 				obj = dataFilterFunctionMap_.remove(funcName);
 			}
 			if (obj == null) {
 				obj = aggregationExeFunctionMap_.remove(funcName);
 			}
 			if (obj == null) {
 				obj = searchExeFunctionMap.remove(funcName);
 			}
 			if (obj == null) {
 				obj = valueExeFunctionMap.remove(funcName);
 			}
 			if (obj == null) {
 				obj = customFormFunctionMap.remove(funcName);
 			}
 			if (obj == null) {
 				obj = customUpdateFunctionMap.remove(funcName);
 			}
 			return (DaoMethod) obj;
 		}
 
 		// data filter
 
 		public void addDataFilterFunction(CriteriaExeFunction function) {
 			dataFilterFunctionMap_.put(function.getName(), function);
 		}
 
 		public CriteriaExeFunction getDataFilterFunction(String name) {
 			return (CriteriaExeFunction) dataFilterFunctionMap_.get(name);
 		}
 
 		public Map getDataFilterFunctionMap() {
 			return dataFilterFunctionMap_;
 		}
 
 		// aggregation
 
 		public void addAggregationExeFunction(CriteriaExeFunction function) {
 			aggregationExeFunctionMap_.put(function.getName(), function);
 		}
 
 		public CriteriaExeFunction getAggregationExeFunction(String name) {
 			return (CriteriaExeFunction) aggregationExeFunctionMap_.get(name);
 		}
 
 		public Map getAggregationExeFunctionMap() {
 			return aggregationExeFunctionMap_;
 		}
 
 		// value exe
 
 		public void addValueExeFunction(CriteriaExeFunction function) {
 			valueExeFunctionMap.put(function.getName(), function);
 		}
 
 		public CriteriaExeFunction getValueExeFunction(String name) {
 			return (CriteriaExeFunction) valueExeFunctionMap.get(name);
 		}
 
 		public Map getValueExeFunctionMap() {
 			return valueExeFunctionMap;
 		}
 
 		// search exe
 
 		public void addSearchExeFunction(SearchExeFunction function) {
 			searchExeFunctionMap.put(function.getName(), function);
 		}
 
 		public Map getSearchExeFunctionMap() {
 			return searchExeFunctionMap;
 		}
 
 		// custom form
 
 		public void addCustomForm(UpdateExeFunction updateExe) {
 			customFormFunctionMap.put(updateExe.getName(), updateExe);
 		}
 
 		public Map getCustomFormFunctionMap() {
 			return customFormFunctionMap;
 		}
 
 		// custom update
 
 		public void addCustomUpdateFunction(UpdateExeFunction updateExe) {
 			customUpdateFunctionMap.put(updateExe.getName(), updateExe);
 		}
 
 		public Map getCustomUpdateFunctionMap() {
 			return customUpdateFunctionMap;
 		}
 
 		public Map getAllFunctionMap() {
 			Map map = new HashMap();
 			map.putAll(getDataFilterFunctionMap());
 			map.putAll(getAggregationExeFunctionMap());
 			map.putAll(getSearchExeFunctionMap());
 			map.putAll(getValueExeFunctionMap());
 			map.putAll(getCustomFormFunctionMap());
 			map.putAll(getCustomUpdateFunctionMap());
 			return map;
 		}
 
 		public Map getAllFunctionMapExcludeCustomForm() {
 			Map map = new HashMap();
 			map.putAll(getDataFilterFunctionMap());
 			map.putAll(getAggregationExeFunctionMap());
 			map.putAll(getSearchExeFunctionMap());
 			map.putAll(getValueExeFunctionMap());
 			// map.putAll(getCustomFormFunctionMap());
 			map.putAll(getCustomUpdateFunctionMap());
 			return map;
 		}
 
 		public Collection getAllFunctions() {
 			return getAllFunctionMap().values();
 		}
 
 		public Collection getAllFunctionsExcludeCustomForm() {
 			return getAllFunctionMapExcludeCustomForm().values();
 		}
 	}
 }