/*
    * Copyright 2012 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.impl;
  
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.util.List;
  
  import olg.csv.bean.PropertyException;
  import olg.csv.bean.filter.AbstractStringFilter;
  import olg.csv.bean.formatter.Formatter;
  
  /**
   * In writing Bean, allows to represent a field of an object as a String. This
   * class seems to be the same as {@link Formatter} class. But its motivation is
   * different : We want to product a string which represents a characteristic of
   * an object not the object itself.
   * 
   * @author Olivier Godineau
   * 
   */
  public abstract class PropertyFormatter { // NOPMD by olivier on 05/01/12 00:36
  	/**
  	 * Name of the property on which to apply the conversion.
  	 */
  	protected String name;
  
  	/**
  	 * Returns a string representation of the property.
  	 * <p>
  	 * Throws a PropertyException when errors occurs during the formatting.
  	 * </p>
  	 * 
  	 * @param object
  	 *            Object from which product a string representation of its
  	 *            property
  	 * @return the string representation.
  	 * 
  	 */
  	public abstract String toString(Object object);
  
  	/**
  	 * Returns the name of the property.
  	 * 
  	 * @return the property name.
  	 */
  	public String getName() {
  		return name;
  	}
  
  	/**
  	 * Return the full name of the property. In case property is itself a
  	 * property of a field, must indicate the field name followed by the
  	 * property name like "field.property".
  	 * 
  	 * @return the full name.
  	 */
  	public String getFullName() {
  		return name;
  	}
  
  	/**
  	 * Returns a PropertyFormatter which concates strings the given
  	 * propertyformatters returns.
  	 * 
  	 * @param formatters
  	 *            list of PropertyFormatter to concate. Must be not
  	 *            <code>null</code> and not empty.
  	 * @param filtre
  	 *            it's possible to filtre the string rendered by the given
  	 *            propertyFormatters before to be returned
  	 * @return a new instance of PropertyFormatter
  	 */
  	public static PropertyFormatter getConcatePropertyReader(List<PropertyFormatter> formatters,
  			AbstractStringFilter filtre) {
  		if (formatters == null || formatters.isEmpty()) {
  			throw new IllegalArgumentException("PropertyFormatter#getConcatePropertyReader  "
  					+ "propertiyFormatters argument must be not null and not empty");
  		}
  
  		return new ConcatePropertyReader(formatters, filtre);
  
  	}
  
  	@Override
  	public int hashCode() {
  		final int prime = 31;
  		int result = 1;
 		result = prime * result + (getFullName() == null ? 0 : getFullName().hashCode());
 		return result;
 	}
 	@Override
 	public boolean equals(Object obj) {
 		if (this == obj) {
 			return true;
 		}
 		if (obj == null) {
 			return false;
 		}
 		if (getClass() != obj.getClass()) {
 			return false;
 		}
 		PropertyFormatter other = (PropertyFormatter) obj;
 		if (getFullName() == null) {
 			if (other.getFullName() != null) {
 				return false;
 			}
 		} else if (!getFullName().equals(other.getFullName())) {
 			return false;
 		}
 		return true;
 	}
 
 	/**
 	 * Returns a PropertyFormatter which extracts as a string a characteristic
 	 * of a field.
 	 * 
 	 * @param getter
 	 *            the method to extract the field from its object. Must be not
 	 *            <code>null</code>.
 	 * @param name
 	 *            the field name
 	 * @param propertyFormatter
 	 *            the formatter to apply to the field, not to the owner object.
 	 *            May be obtained from getPropertyReader or get
 	 *            delegatePropertyReader methods.Must be not <code>null</code>.
 	 * @return a new instance of PropertyFormatter
 	 */
 	public static PropertyFormatter getDelegatePropertyReader(Method getter, String name,
 			PropertyFormatter propertyFormatter) {
 
 		if (getter == null) {
 			throw new IllegalArgumentException(
 					"PropertyFormatter#getDelegatePropertyReader  getter argument must ne not null");
 		}
 		if (propertyFormatter == null) {
 			throw new IllegalArgumentException(
 					"PropertyFormatter#getDelegatePropertyReader  propertyFormatter argument must be not null");
 		}
 
 		return new DelegatePropertyReader(getter, name, propertyFormatter);
 
 	}
 
 	/**
 	 * Returns a basic PropertyFormatter.
 	 * 
 	 * @param getter
 	 *            the method to extract the field from the object. Must not be
 	 *            <code>null</code>.
 	 * @param name
 	 *            the property name
 	 * @param formatter
 	 *            this formatter allows to transform the field into a string. if
 	 *            the given argument is <code>null</code> a default formatter is
 	 *            define which use the toString method of the field.
 	 * @param filtre
 	 *            it's possible to filtre the string rendered by the formatter
 	 *            before to be returned
 	 * @param <T>
 	 *            the type of the property
 	 * @return a new instance of PropertyFormatter
 	 */
 	public static <T> PropertyFormatter getPropertyReader(Method getter, String name, Formatter<T> formatter,
 			AbstractStringFilter filtre) {
 		if (getter == null) {
 			throw new IllegalArgumentException("PropertyFormatter#getPropertyReader getter argument must be not null");
 		}
 
 		return new PropertyReader(getter, name, (formatter == null ? new Formatter<T>() : formatter), filtre);
 	}
 
 	/**
 	 * 
 	 * Allows to concate severals characteristics of an object into a single
 	 * string.
 	 * 
 	 */
 	private static final class ConcatePropertyReader extends PropertyFormatter {
 
 		/**
 		 * 
 		 * @param properties
 		 *            The list of PropertyFormatter used to concate their
 		 *            results.
 		 * @param filtre
 		 *            The filtre used to filter the concated strings.
 		 */
 		ConcatePropertyReader(List<PropertyFormatter> properties, AbstractStringFilter filtre) {
 			super();
 			this.properties = properties;
 			this.filtre = filtre;
 		}
 
 		/**
 		 * The list of PropertyFormatter used to concate their results.
 		 */
 		private final List<PropertyFormatter> properties;
 
 		/**
 		 * The filtre used to filter the concated strings.
 		 */
 		private final AbstractStringFilter filtre;
 		@Override
 		public String toString(Object object) {
 			String retour = null;
 			if (object != null) {
 
 				StringBuffer buf = new StringBuffer();
 				for (PropertyFormatter property : properties) {
 					String toBuf = property.toString(object);
 					buf.append(toBuf == null ? "" : toBuf);
 				}
 				retour = (filtre == null ? buf.toString() : filtre.filtre(buf.toString()));
 			}
 			return retour;
 		}
 
 		/**
 		 * {@inheritDoc} Throws UnsupportedOperationException.
 		 */
 		@Override
 		public String getName() {
 			throw new UnsupportedOperationException();
 		}
 
 		@Override
 		public String getFullName() {
 			StringBuilder builder = new StringBuilder();
 
 			for (PropertyFormatter property : properties) {
 				builder.append(property.getFullName()).append(";");
 			}
 			return builder.toString();
 		}
 
 	}
 
 	/**
 	 * 
 	 * PropertyFormatter to use to represent a characterstic of a field as a
 	 * string.
 	 * 
 	 */
 	private static final class DelegatePropertyReader extends PropertyFormatter {
 
 		/**
 		 * 
 		 * 
 		 * @param getter
 		 *            the method to invoke to get the property value.
 		 * @param name
 		 *            the property name.
 		 * @param propertyFormatter
 		 *            the formatter. format the property value as a string.
 		 */
 		DelegatePropertyReader(Method getter, String name, PropertyFormatter propertyFormatter) {
 			super();
 			this.getter = getter;
 			this.name = name;
 			this.propertyFormatter = propertyFormatter;
 
 		}
 
 		@Override
 		public String getFullName() {
 
 			return name + "." + propertyFormatter.getFullName();
 		}
 
 		@Override
 		public String getName() {
 
 			return propertyFormatter.getName();
 		}
 
 		/**
 		 * The method to extract the field.
 		 */
 		private final Method getter;
 		/**
 		 * The propertyFormatter used to represents the field.
 		 */
 		private final PropertyFormatter propertyFormatter;
 		@Override
 		public String toString(Object object) {
 			String retour = null;
 			if (object != null) {
 
 				try {
 					Object property = getter.invoke(object, (Object[]) null);
 					retour = propertyFormatter.toString(property);
 				} catch (IllegalArgumentException e) {
 					throw new PropertyException("Error on method invocation  " + getter.getName(), e); // NOPMD
 																										// by
 																										// olivier
 																										// on
 																										// 01/02/12
 																										// 00:34
 				} catch (IllegalAccessException e) {
 					throw new PropertyException("Error on method invocation  " + getter.getName(), e);
 				} catch (InvocationTargetException e) {
 					throw new PropertyException("Error on method invocation  " + getter.getName(), // NOPMD
 																									// by
 																									// olivier
 																									// on
 																									// 28/01/12
 																									// 14:05
 							e.getTargetException());
 				}
 			}
 			return retour;
 		}
 
 	}
 
 	/**
 	 * 
 	 * Basic PropertyFormatter. Allow to represent a field as a string.
 	 * 
 	 */
 	private static final class PropertyReader extends PropertyFormatter {
 
 		/**
 		 * 
 		 * @param name
 		 *            the name of the field
 		 * @param getter
 		 *            the method to use to extract field of the object
 		 * @param formatter
 		 *            the formatter to use to transform the field into a string
 		 * @param filtre
 		 *            it's possible to use a filter after the field has bean
 		 *            formatted
 		 */
 
 		PropertyReader(Method getter, String name, @SuppressWarnings("rawtypes") Formatter formatter,
 				AbstractStringFilter filtre) {
 			super();
 			this.name = name;
 			this.getter = getter;
 			this.formatter = formatter;
 			this.filtre = filtre;
 
 		}
 
 		/**
 		 * the method to use to extract property of the object.
 		 */
 		private final Method getter;
 
 		/**
 		 * the formatter to use to transform the field into a string.
 		 */
 		@SuppressWarnings("rawtypes")
 		private final Formatter formatter;
 		/**
 		 * The filter to use to filter the string the formatter returns.
 		 */
 		private final AbstractStringFilter filtre;
 
 		@SuppressWarnings("unchecked")
 		@Override
 		public String toString(Object object) {
 			String retour = null;
 			if (object != null) {
 				try {
 					Object property = getter.invoke(object, (Object[]) null);
 					String rendered = formatter.toString(property);
 					retour = (filtre == null ? rendered : filtre.filtre(rendered));
 
 				} catch (IllegalArgumentException e) {
 					throw new PropertyException("Error on method invocation  " + getter.getName(), e);
 				} catch (IllegalAccessException e) {
 					throw new PropertyException("Error on method invocation  " + getter.getName(), e);
 				} catch (InvocationTargetException e) {
 					throw new PropertyException("Error on method invocation  " + getter.getName(), // NOPMD
 																									// by
 																									// olivier
 																									// on
 																									// 28/01/12
 																									// 14:05
 							e.getTargetException());
 				}
 			}
 			return retour;
 		}
 
 	}
 
 }