/*
    * Copyright 2013 Olivier Godineau
    * 
    * 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 olg.csv.bean.annotations.processor;
  
  import java.lang.reflect.Field;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  
  import olg.csv.base.csv.CSVSettings;
  import olg.csv.base.ods.ODSSettings;
  import olg.csv.bean.IBeanProcessor;
  import olg.csv.bean.IPropertyProcessor;
  import olg.csv.bean.IRowProcessor;
  import olg.csv.bean.annotations.CSVProperty;
  import olg.csv.bean.annotations.Column;
  import olg.csv.bean.annotations.Embedded;
  import olg.csv.bean.annotations.ODSProperty;
  import olg.csv.bean.annotations.Param;
  import olg.csv.bean.annotations.RowBean;
  import olg.csv.bean.impl.BeanProcessor;
  import olg.csv.bean.impl.CellProcessor;
  import olg.csv.bean.impl.RowProcessor;
  import olg.csv.bean.parser.AbstractParser;
  import olg.csv.bean.parser.ParseException;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  /**
   * This class is responsible for processing the @RowBean annotation.
   * 
   * @author Olivier Godineau
   * 
   * @param <T>
   *            the type this processor deals with
   */
  public final class RowBeanProcessor<T> {
  	/**
  	 * Class logger.
  	 */
  	private static final Logger LOGGER = LoggerFactory.getLogger(RowBeanProcessor.class);
  
  	/**
  	 * ODSProperties allowed on Reading process.
  	 */
  	private ODSPropertyType[] ODSReadingProperties = ODSPropertyType.values();
  	/**
  	 * ODS Properties allowed on Writing process.
  	 */
  	private ODSPropertyType[] ODSWritingProperties = { ODSPropertyType.SHEETNAME, ODSPropertyType.BEGIN_AT_ROW,
  			ODSPropertyType.BEGIN_AT_COLUMN, ODSPropertyType.HEADERS};
  	/**
  	 * CSV Properties allowed on Reading.
  	 */
  	private CSVPropertyType[] CSVReadingProperties = { CSVPropertyType.DELIMITER, CSVPropertyType.SEPARATOR,
  			CSVPropertyType.CHARSETNAME, CSVPropertyType.HEADERS};
  	/**
  	 * CSV Properties allowed on Writing.
  	 */
  	private CSVPropertyType[] CSVWritingProperties = { CSVPropertyType.DELIMITER, CSVPropertyType.SEPARATOR,
  			CSVPropertyType.CHARSETNAME, CSVPropertyType.LINE_SEPARATOR, CSVPropertyType.HEADERS};
  
  	/**
  	 * 
  	 * ODS Property list.
  	 * 
  	 */
  	private enum ODSPropertyType {
  		/**
  		 * 
  		 */
  		HEADERS(ODSProperty.HEADERS, "withHeaders", new AbstractParser<Boolean>() {
  
  			@Override
  			public Boolean parse(String str) {
  				if (str.equalsIgnoreCase("true") || str.equalsIgnoreCase("false")) {
  					return Boolean.valueOf(str);
  				} else {
  					LOGGER.error("{} ODS Property only supports \"true\" or \"false\" value", ODSProperty.HEADERS);
  					throw new ParseException();
  				}
  			}
  		}),
  		/**
 		 * 
 		 */
 		SHEETNUM(ODSProperty.SHEETNUM, "sheetNum", new AbstractParser<Integer>() {
 
 			@Override
 			public Integer parse(String str) {
 				try {
 					return Integer.valueOf(str);
 				} catch (NumberFormatException ex) {
 					LOGGER.error("{} ODS Property only supports integer value", ODSProperty.SHEETNUM);
 					throw new ParseException();
 				}
 			}
 
 		}),
 		/**
 		 * 
 		 */
 		SHEETNAME(ODSProperty.SHEETNAME, "sheetName", null),
 		/**
 		 * 
 		 */
 		BEGIN_AT_ROW(ODSProperty.BEGIN_AT_ROW, "beginAtRow", new AbstractParser<Integer>() {
 			@Override
 			public Integer parse(String str) {
 				try {
 					return Integer.valueOf(str);
 				} catch (NumberFormatException ex) {
 					LOGGER.error("{} ODS Property only supports integer value", ODSProperty.BEGIN_AT_ROW);
 					throw new ParseException();
 				}
 			}
 		}),
 
 		/**
 		 * 
 		 */
 		END_AT_ROW(ODSProperty.END_AT_ROW, "endAtRow", new AbstractParser<Integer>() {
 			@Override
 			public Integer parse(String str) {
 				try {
 					return Integer.valueOf(str);
 				} catch (NumberFormatException ex) {
 					LOGGER.error("{} ODS Property only supports integer value", ODSProperty.END_AT_ROW);
 					throw new ParseException();
 				}
 			}
 		}),
 
 		/**
 		 * 
 		 */
 		BEGIN_AT_COLUMN(ODSProperty.BEGIN_AT_COLUMN, "beginAtColumn", null),
 		/**
 		 * 
 		 */
 
 		END_AT_COLUMN(ODSProperty.END_AT_COLUMN, "endAtColumn", null);
 
 		/**
 		 * param name.
 		 */
 		private String code;
 		/**
 		 * param value parser.
 		 */
 		private AbstractParser<?> parser;
 		/**
 		 * Method to set the property.
 		 */
 		private Method setter;
 
 		/**
 		 * the property this option sets.
 		 */
 		private String property;
 
 		/**
 		 * 
 		 * @param code
 		 *            param name.
 		 * @param property
 		 *            ODSSettings property to set.
 		 * @param parser
 		 *            parser to convert string to ODSSettings property type.
 		 */
 		private ODSPropertyType(String code, String property, AbstractParser<?> parser) {
 			this.code = code;
 			this.parser = parser;
 			this.property = property;
 			Method[] methods = ODSSettings.class.getMethods();
 
 			String setterName = "set" + property.substring(0, 1).toUpperCase() + (property.substring(1));
 
 			for (Method methode : methods) {
 				if (methode.getName().equals(setterName) && methode.getParameterTypes().length == 1) {
 					this.setter = methode;
 					break;
 				}
 			}
 
 		}
 		/**
 		 * Identify the Property by its code.
 		 * 
 		 * @param code
 		 *            the code
 		 * @return the property
 		 */
 		static ODSPropertyType getByCode(String code) {
 			ODSPropertyType retour = null;
 			for (ODSPropertyType type : ODSPropertyType.values()) {
 				if (type.code.equals(code)) {
 					retour = type;
 					break;
 				}
 			}
 			return retour;
 		}
 
 		/**
 		 * Set the ODSSettings.
 		 * 
 		 * @param settings
 		 *            the settings to set.
 		 * @param value
 		 *            the value.
 		 * @return the ODSSettings setted.
 		 * @throws AnnotationProcessorException
 		 *             if an error occurs during parsing the value.
 		 */
 		ODSSettings setParam(ODSSettings settings, String value) throws AnnotationProcessorException {
 
 			try {
 				setter.invoke(settings, (parser != null ? parser.parse(value) : value));
 			} catch (IllegalAccessException e) {
 				LOGGER.error("Hmm, I thought it couldn't happen", e);
 			} catch (IllegalArgumentException e) {
 				LOGGER.error("Hmm, I thought it couldn't happen", e);
 			} catch (InvocationTargetException e) {
 				LOGGER.error("ODSSettings error on {} setting ", property, e.getTargetException());
 				throw new AnnotationProcessorException();
 			} catch (ParseException e) {
 				throw new AnnotationProcessorException();
 			}
 			return settings;
 		}
 	};
 
 	/**
 	 * 
 	 * CSV Property list.
 	 * 
 	 */
 	private enum CSVPropertyType {
 		/**
 		 * 
 		 */
 		HEADERS(CSVProperty.HEADERS, "withHeaders", new AbstractParser<Boolean>() {
 
 			@Override
 			public Boolean parse(String str) {
 				if (str.equalsIgnoreCase("true") || str.equalsIgnoreCase("false")) {
 					return Boolean.valueOf(str);
 				} else {
 					LOGGER.error("{} CSV Property only supports \"true\" or \"false\" value, not [{}]",
 							CSVProperty.HEADERS, str);
 					throw new ParseException();
 				}
 			}
 		}
 
 		),
 		/**
 		 * 
 		 */
 		SEPARATOR(CSVProperty.SEPARATOR, "separator", new AbstractParser<Character>() {
 			@Override
 			public Character parse(String str) {
 				Character retour = null;
 
 				if (str.trim().length() != 1) {
 					LOGGER.error("{} CSVProperty only supports String as char, not [{}]", CSVProperty.SEPARATOR, str);
 					throw new ParseException();
 				}
 				retour = str.trim().charAt(0);
 
 				return retour;
 			}
 		}),
 
 		/**
 		 * 
 		 */
 		DELIMITER(CSVProperty.DELIMITER, "delimiter", new AbstractParser<Character>() {
 			@Override
 			public Character parse(String str) {
 				Character retour = null;
 
 				if (str.trim().length() != 1) {
 					LOGGER.error("{} CSVProperty only supports String as char, not [{}]", CSVProperty.SEPARATOR, str);
 					throw new ParseException();
 				}
 				retour = str.trim().charAt(0);
 
 				return retour;
 
 			}
 		}),
 		/**
 		 * 
 		 */
 		CHARSETNAME(CSVProperty.CHARSETNAME, "charsetName", null),
 		/**
 				 * 
 				 */
 		LINE_SEPARATOR(CSVProperty.LINE_SEPARATOR, "lineSeparator", null);
 
 		/**
 		 * param name.
 		 */
 		private String code;
 
 		/**
 		 * param value parser.
 		 */
 		private AbstractParser<?> parser;
 		/**
 		 * Method to set property.
 		 */
 		private Method setter;
 		/**
 		 * Property this option sets.
 		 */
 		private String property;
 
 		/**
 		 * 
 		 * @param code
 		 *            param name.
 		 * @param property
 		 *            ODSSettings property to set.
 		 * @param parser
 		 *            parser to convert string to ODSSettings property type.
 		 */
 		private CSVPropertyType(String code, String property, AbstractParser<?> parser) {
 			this.code = code;
 			this.parser = parser;
 			this.property = property;
 
 			Method[] methods = CSVSettings.class.getMethods();
 
 			String setterName = "set" + property.substring(0, 1).toUpperCase() + (property.substring(1));
 
 			for (Method methode : methods) {
 				if (methode.getName().equals(setterName) && methode.getParameterTypes().length == 1) {
 					this.setter = methode;
 					break;
 				}
 			}
 		}
 		/**
 		 * Identify a property by its code.
 		 * 
 		 * @param code
 		 *            the code
 		 * @return the property
 		 */
 		public static CSVPropertyType getByCode(String code) {
 			CSVPropertyType retour = null;
 			for (CSVPropertyType type : CSVPropertyType.values()) {
 				if (type.code.equals(code)) {
 					retour = type;
 					break;
 				}
 			}
 			return retour;
 		}
 
 		/**
 		 * Set the CVSSettings.
 		 * 
 		 * @param settings
 		 *            the settings to set.
 		 * @param value
 		 *            the value.
 		 * @return the CSVSettings setted.
 		 * @throws AnnotationProcessorException
 		 *             on setting the value to the property
 		 */
 		public CSVSettings setParam(CSVSettings settings, String value) throws AnnotationProcessorException {
 
 			try {
 				setter.invoke(settings, (parser != null ? parser.parse(value) : value));
 			} catch (IllegalAccessException e) {
 				LOGGER.error("Hmm, I thought it couldn't happen", e);
 			} catch (IllegalArgumentException e) {
 				LOGGER.error("Hmm, I thought it couldn't happen", e);
 			} catch (InvocationTargetException e) {
 				LOGGER.error("CSVSettings error on {} setting ", property, e.getTargetException());
 				throw new AnnotationProcessorException();
 			} catch (ParseException e) {
 				throw new AnnotationProcessorException();
 			}
 			return settings;
 		}
 	};
 
 	/**
 	 * The class of the type.
 	 */
 	private Class<T> clazz;
 
 	/**
 	 * Processor responsible for processing @Column annotations placed on the fields of the class.
 	 */
 	private ColumnProcessor<T> columnProcessor;
 
 	/**
 	 * Processor responsible for processing @Embedded annotations placed on the fields of the class.
 	 */
 	private EmbeddedProcessor<T> embeddedProcessor;
 
 	/**
 	 * Constructor.
 	 * 
 	 * @param clazz
 	 *            the T class.
 	 */
 	public RowBeanProcessor(Class<T> clazz) {
 		super();
 		this.clazz = clazz;
 		this.columnProcessor = new ColumnProcessor<T>(clazz);
 		this.embeddedProcessor = new EmbeddedProcessor<T>(clazz);
 	}
 
 	/**
 	 * Returns if T has RowBean annotation.
 	 * 
 	 * @return true if the T class has RowBean annotation.
 	 */
 	public boolean hasRowBeanAnnotation() {
 		return clazz.getAnnotation(RowBean.class) != null;
 	}
 	/**
 	 * Returns ODSSettings for reading identified from the RowBean annotation of the class otherwise default Reading ODS
 	 * settings.
 	 * 
 	 * @return the ODSSettings
 	 * @throws AnnotationProcessorException
 	 *             if error occurs during annotation processing.
 	 */
 	public ODSSettings getReadingODSSettings() throws AnnotationProcessorException {
 		RowBean rowBean = clazz.getAnnotation(RowBean.class);
 		Param[] odsReadingParams = rowBean.ODSReadingParams();
 		return getODSSettings(odsReadingParams, ODSReadingProperties, "ODSReadingParam");
 
 	}
 
 	/**
 	 * Returns ODSSettings for writing identified from the RowBean annotation of the class otherwise default writing ODS
 	 * settings.
 	 * 
 	 * @return the ODSSettings
 	 * @throws AnnotationProcessorException
 	 *             if an error occurs during settings identification.
 	 */
 	public ODSSettings getWritingODSSettings() throws AnnotationProcessorException {
 		RowBean rowBean = clazz.getAnnotation(RowBean.class);
 		Param[] odsWritingParams = rowBean.ODSWritingParams();
 		return getODSSettings(odsWritingParams, ODSWritingProperties, "ODSWritingParam");
 
 	}
 
 	/**
 	 * Returns CSVSettings for reading identified from the RowBean annotation of the class otherwise default Reading CSV
 	 * settings.
 	 * 
 	 * @return the CSVSettings
 	 * @throws AnnotationProcessorException
 	 *             if an error occurs during settings identification.
 	 */
 	public CSVSettings getReadingCSVSettings() throws AnnotationProcessorException {
 		RowBean rowBean = clazz.getAnnotation(RowBean.class);
 		Param[] csvReadinggParams = rowBean.CSVReadingParams();
 		return getCSVSettings(csvReadinggParams, CSVReadingProperties, "CSVReadingParam");
 
 	}
 	/**
 	 * Returns CSVSettings for writing identified from the RowBean annotation of the class otherwise default writing CSV
 	 * settings.
 	 * 
 	 * @return the CSVSettings
 	 * @throws AnnotationProcessorException
 	 *             if an error occurs during settings identification.
 	 */
 	public CSVSettings getWritingCSVSettings() throws AnnotationProcessorException {
 		RowBean rowBean = clazz.getAnnotation(RowBean.class);
 		Param[] csvWritingParams = rowBean.CSVWritingParams();
 		return getCSVSettings(csvWritingParams, CSVWritingProperties, "CSVWritingParam");
 	}
 
 	/**
 	 * Build a BeanProcessor from annotations setted on the class this processor deals with.
 	 * 
 	 * @return the beanProcessor
 	 * @throws AnnotationProcessorException
 	 *             if error occurs during annotation processing.
 	 */
 	public IBeanProcessor<T> getBeanProcessor() throws AnnotationProcessorException {
 
 		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
 		List<IPropertyProcessor<T>> propertyProcessors = new ArrayList<IPropertyProcessor<T>>();
 		boolean noError = getReadingProcessor(0, propertyProcessors, map);
 		BeanProcessor<T> beanProcessor = new BeanProcessor<T>(this.clazz);
 
 		for (Entry<Integer, Integer> entry : map.entrySet()) {
 			if (entry.getValue() > 1) {
 				LOGGER.error("For column {}, {} fields match. Only one is supported", entry.getKey(), entry.getValue());
 				noError = false;
 			}
 		}
 
 		if (noError) {
 			beanProcessor.addAll(propertyProcessors);
 			return beanProcessor;
 		} else {
 			throw new AnnotationProcessorException(
 					"Some error occured on BeanProcessor loading. See logs for more details");
 		}
 
 	}
 	/**
 	 * Build a RowProcessor from annotations setted on the class this processor deals with.
 	 * 
 	 * @return the RowProcessor
 	 * @throws AnnotationProcessorException
 	 *             if error occurs during annotation processing.
 	 */
 	public IRowProcessor<T> getRowProcessor() throws AnnotationProcessorException {
 		Map<Integer, List<CellProcessor<T>>> map = new HashMap<Integer, List<CellProcessor<T>>>();
 		boolean noError = getWritingProcessor(map);
 		List<CellProcessor<T>> cellProcessors = new ArrayList<CellProcessor<T>>();
 
 		if (noError) {
 
 			for (Entry<Integer, List<CellProcessor<T>>> entry : map.entrySet()) {
 				// COntrole un processor par num de colonne.
 				if (entry.getValue().size() > 1) {
 					LOGGER.error("For column {}, {} fields match. Only one is supported", entry.getKey(), entry
 							.getValue().size());
 					noError = false;
 				} else {
 					cellProcessors.add(entry.getValue().iterator().next());
 				}
 			}
 		}
 		if (noError) {
 			return new RowProcessor<T>(cellProcessors);
 		} else {
 			throw new AnnotationProcessorException(
 					"Some error occured on RowProcessor loading. See logs for more details");
 		}
 	}
 
 	/**
 	 * Complete a map with the cell Processors identified on the annotated fields of the class (and superclass).
 	 * 
 	 * @param map
 	 *            the map to complete with the CellProcessor built from column annotation setted on the class fields.
 	 *            the keys are the cell num target of the cellProcessor.
 	 * @return true if no error occurs.
 	 */
 	protected boolean getWritingProcessor(Map<Integer, List<CellProcessor<T>>> map) {
 		if (hasRowBeanAnnotation()) {
 			return getWritingProcessor(this.clazz, map);
 		} else {
 			LOGGER.error("@RowBean Annotation not found on {} class", this.clazz.getSimpleName());
 			return false;
 		}
 	}
 
 	/**
 	 * Collect the property processors identified by annotation setted on the fields (@Column and @Embedded) of the
 	 * class and its super class (if annoted with @RowBean).
 	 * 
 	 * @param translate
 	 *            index from which begin the column numerotation
 	 * @param processors
 	 *            the processor list to complete
 	 * @param map
 	 *            the map to complete. this map shows for each cell num the count of the property processors setted on.
 	 * @return true if no error occurs.
 	 */
 	protected boolean getReadingProcessor(int translate, List<IPropertyProcessor<T>> processors,
 			Map<Integer, Integer> map) {
 		if (hasRowBeanAnnotation()) {
 			return getReadingProcessor(this.clazz, translate, processors, map);
 		} else {
 			LOGGER.error("@RowBean Annotation not found on {} class", this.clazz.getSimpleName());
 			return false;
 		}
 	}
 
 	/**
 	 * Collects cell processors from column and embedded annotation setted on a class if annoted with RowBean
 	 * annotation. Collects cell processors from super class if annoted with RowBean annotation.
 	 * 
 	 * @param beanClass
 	 *            the bean class.
 	 * @param map
 	 *            the map to complete with the CellProcessor built from column annotation setted on the field. the keys
 	 *            are the cell num target of the cellProcessor.
 	 * @return true if no error occurs.
 	 */
 	private boolean getWritingProcessor(Class<? super T> beanClass, Map<Integer, List<CellProcessor<T>>> map) {
 		boolean noError = true;
 
 		if (beanClass.getAnnotation(RowBean.class) != null) {
 
 			if (beanClass.getSuperclass() != null) {
 				noError &= getWritingProcessor(beanClass.getSuperclass(), map);
 			}
 
 			Field[] fields = beanClass.getDeclaredFields();
 
 			for (Field field : fields) {
 				if (!checkField(field, beanClass)) {
 					noError = false;
 					continue;
 				}
 
 				noError &= this.columnProcessor.getWritingProcessor(field, map);
 
 				noError &= this.embeddedProcessor.getWritingProcessor(field, map);
 
 			}
 		}
 
 		return noError;
 
 	}
 
 	/**
 	 * Find the property processors identified on a class if annoted with @RowBean and from its super class if annoted
 	 * with @RowBean. The processor are read from the @Column and @Embedded annotation setted on its fields.
 	 * 
 	 * @param beanClass
 	 *            the bean class.
 	 * @param translate
 	 *            index from which begin the column numerotation
 	 * @param processors
 	 *            the list to complete
 	 * @param map
 	 *            the map to complete. this map shows for each cell num the count of the property processors setted on.
 	 * @return true if no error occurs.
 	 */
 	private boolean getReadingProcessor(Class<? super T> beanClass, int translate,
 			List<IPropertyProcessor<T>> processors, Map<Integer, Integer> map) {
 		boolean noError = true;
 
 		if (beanClass.getAnnotation(RowBean.class) != null) {
 			if (beanClass.getSuperclass() != null) {
 
 				noError &= getReadingProcessor(beanClass.getSuperclass(), translate, processors, map);
 			}
 		}
 
 		Field[] fields = beanClass.getDeclaredFields();
 
 		for (Field field : fields) {
 			if (!checkField(field, beanClass)) {
 				noError = false;
 				continue;
 			}
 
 			noError &= this.columnProcessor.getReadingProcessor(translate, field, processors, map);
 			noError &= this.embeddedProcessor.getReadingProcessor(translate, field, processors, map);
 
 		}
 		return noError;
 	}
 
 	/**
 	 * Check if a field hasn't both column annotation and Embedded annotation.
 	 * 
 	 * @param field
 	 *            the field
 	 * @param beanClass
 	 *            the class declaring the field.
 	 * @return true if the field hasn't both column annotation and Embedded annotation.
 	 */
 	private boolean checkField(Field field, Class<? super T> beanClass) {
 		if (field.getAnnotation(Column.class) != null && field.getAnnotation(Embedded.class) != null) {
 			LOGGER.error("{}.{} : A field must not have both the column annotation and the embedded annotation",
 					beanClass.getSimpleName(), field.getName());
 			return false;
 		}
 
 		return true;
 	}
 
 	/**
 	 * Identifies a param as an allowed ODSPropertyType.
 	 * 
 	 * @param param
 	 *            the param.
 	 * @param permittedProperties
 	 *            allowed ODSPropertyTypes.
 	 * @return the ODSPropertyType or null if the param is not identify as a permitted properties.
 	 */
 	private ODSPropertyType identifyPermittedProperty(Param param, ODSPropertyType[] permittedProperties) {
 		ODSPropertyType propertyType = ODSPropertyType.getByCode(param.name());
 		if (propertyType != null) {
 			boolean find = false;
 			for (ODSPropertyType permittedProperty : permittedProperties) {
 				if (propertyType == permittedProperty) {
 					find = true;
 					break;
 				}
 			}
 			propertyType = (find ? propertyType : null);
 		}
 		return propertyType;
 	}
 
 	/**
 	 * Returns ODSSettings corresponding to ODS params of a process.
 	 * 
 	 * @param odsParams
 	 *            the ODS Params
 	 * @param properties
 	 *            the ODS Properties which are allowed for the process
 	 * @param type
 	 *            String identifying the process
 	 * @return the corresonding settings.
 	 * @throws AnnotationProcessorException
 	 *             if errors occur
 	 */
 	private ODSSettings getODSSettings(Param[] odsParams, ODSPropertyType[] properties, String type)
 			throws AnnotationProcessorException {
 
 		ODSSettings settings = new ODSSettings();
 		boolean exceptionOnProcess = false;
 
 		if (odsParams != null && odsParams.length > 0) {
 			for (Param param : odsParams) {
 				ODSPropertyType propertyType = identifyPermittedProperty(param, properties);
 
 				if (propertyType != null) {
 					if ("".equals(param.value())) {
 						LOGGER.warn("{}@RowBean : empty string  is not a legal value for {} {}", new Object[] {
 								this.clazz.getSimpleName(), param.name(), type});
 					} else {
 						try {
 							propertyType.setParam(settings, param.value());
 						} catch (AnnotationProcessorException ex) {
 							exceptionOnProcess = true;
 						}
 					}
 				} else {
 					LOGGER.warn("{}@RowBean : {} is not a legal {}, it will be ignored",
 							new Object[] { this.clazz.getSimpleName(), param.name(), type});
 				}
 			}
 		}
 		if (exceptionOnProcess) {
 			throw new AnnotationProcessorException("See logs for more details");
 		}
 		return settings;
 	}
 
 	/**
 	 * Identifies a param as an allowed CSVPropertyType.
 	 * 
 	 * @param param
 	 *            the param.
 	 * @param permittedProperties
 	 *            allowed CSVPropertyTypes.
 	 * @return the CSVPropertyType or null if the param is not identify as a permitted properties.
 	 */
 	private CSVPropertyType identifyPermittedProperty(final Param param, CSVPropertyType[] permittedProperties) {
 		CSVPropertyType propertyType = CSVPropertyType.getByCode(param.name());
 		if (propertyType != null) {
 			boolean find = false;
 			for (CSVPropertyType permittedProperty : permittedProperties) {
 				if (propertyType == permittedProperty) {
 					find = true;
 					break;
 				}
 			}
 			propertyType = (find ? propertyType : null);
 		}
 		return propertyType;
 	}
 
 	/**
 	 * Products the CSVSettings corresponding to params of a process.
 	 * 
 	 * @param csvParams
 	 *            the params to translate as CSVSettings
 	 * @param properties
 	 *            the CSVProperties which are allowed for the specifig process
 	 * @param type
 	 *            String identifying the process
 	 * @return the CSVSettings corresponding to the param of the process
 	 * @throws AnnotationProcessorException
 	 *             if errors occur.
 	 */
 	private CSVSettings getCSVSettings(final Param[] csvParams, CSVPropertyType[] properties, String type)
 			throws AnnotationProcessorException {
 
 		CSVSettings settings = new CSVSettings();
 		boolean exceptionOnProcess = false;
 
 		if (csvParams != null && csvParams.length > 0) {
 			for (Param param : csvParams) {
 				CSVPropertyType propertyType = identifyPermittedProperty(param, properties);
 
 				if (propertyType != null) {
 					if ("".equals(param.value())) {
 						LOGGER.warn("{}@RowBean : empty string  is not a legal value for {} {}", new Object[] {
 								this.clazz.getSimpleName(), param.name(), type});
 					} else {
 						try {
 							propertyType.setParam(settings, param.value());
 						} catch (AnnotationProcessorException ex) {
 							exceptionOnProcess = true;
 						}
 					}
 				} else {
 					LOGGER.warn("{}@RowBean : {} is not a legal {}, it will be ignored",
 							new Object[] { this.clazz.getSimpleName(), param.name(), type});
 				}
 			}
 		}
 		if (exceptionOnProcess) {
 			throw new AnnotationProcessorException("See logs for more details");
 		}
 		return settings;
 	}
 
 }