/*
    * 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.parser.impl;
  
  import java.lang.reflect.Constructor;
  import java.lang.reflect.InvocationTargetException;
  import java.text.DateFormat;
  import java.text.SimpleDateFormat;
  import java.util.Date;
  import java.util.Locale;
  
  import olg.csv.base.UsageInvalideException;
  import olg.csv.bean.Util;
  import olg.csv.bean.parser.AbstractParser;
  import olg.csv.bean.parser.ParseException;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Parser dedicated in parsing String into date.
   * 
   */
  public final class DateParser extends AbstractParser<Date> {
  	/**
  	 * the class Logger.
  	 */
  	private static final Logger LOGGER = LoggerFactory.getLogger(DateParser.class);
  
  	/**
  	 * the date format to use to parse string as date.
  	 */
  	private final DateFormat dateFormat;
  
  	/**
  	 * The concrete class the parser must return.
  	 */
  	private Class<? extends Date> concreteClass = null;
  
  	/**
  	 * the date constructor to invoke on parsing.
  	 */
  	private Constructor<? extends Date> constructor = null;
  
  	@Override
  	public Date parse(String str) {
  		String errorMessage = "Error on parsing ";
  		Date date = null;
  		try {
  			date = dateFormat.parse(str);
  		} catch (java.text.ParseException e) {
  			throw new ParseException(errorMessage + str, e);
  		}
  		if (concreteClass != null) {
  			if (constructor == null) {
  				try {
  					Date date2 = ((Date) concreteClass.newInstance());
  					date2.setTime(date.getTime());
  					date = date2;
  				} catch (InstantiationException e) {
  					// Ne devrait pas arriver
  					LOGGER.error(errorMessage, e);
  					throw new ParseException(errorMessage + str, e);
  				} catch (IllegalAccessException e) {
  					// Ne devrait pas arriver
  					LOGGER.error(errorMessage, e);
  					throw new ParseException(errorMessage + str, e);
  				}
  
  			} else {
  				try {
  					date = (Date) constructor.newInstance(date.getTime());
  				} catch (IllegalArgumentException e) {
  					// Ne devrait pas arriver
  					LOGGER.error(errorMessage, e);
  					throw new ParseException(errorMessage + str, e);
  				} catch (InstantiationException e) {
  					// Ne devrait pas arriver
  					LOGGER.error(errorMessage, e);
  					throw new ParseException(errorMessage + str, e);
  				} catch (IllegalAccessException e) {
  					// Ne devrait pas arriver
  					LOGGER.error(errorMessage, e);
  				} catch (InvocationTargetException e) {
  					// Ne devrait pas arriver
  					LOGGER.error(errorMessage, e);
  					throw new ParseException(errorMessage + str, e);
  				}
 			}
 		}
 		return date;
 
 	}
 
 	/**
 	 * Constructs a date parser.
 	 * 
 	 * @param format
 	 *            the date format.
 	 * @param concreteClass
 	 *            Si <code>null</code>, la classe retournée lors du parsing sera
 	 *            {@link java.util.Date}
 	 * @param locale
 	 *            the locale to apply to this DateParser. May be
 	 *            <code>null</code>
 	 */
 	public DateParser(String format, Class<? extends Date> concreteClass, Locale locale) {
 		super();
 		if (format == null || "".equals(format.trim())) {
 			throw new UsageInvalideException(
 					"DateParser format argument must be conformed to SimpleDateFormat specifications");
 		}
 		try {
 
 			if (locale == null) {
 				this.dateFormat = new SimpleDateFormat(format); // NOPMD by
 																// olivier on
 																// 07/02/12
 																// 01:27
 			} else {
 				this.dateFormat = new SimpleDateFormat(format, locale);
 			}
 
 		} catch (IllegalArgumentException ex) {
 			throw new UsageInvalideException("DateParser argument " + format
 					+ "must be conformed to SimpleDateFormat specifications", ex);
 		}
 		if (concreteClass != null) {
 			if (checkconcreteClass(concreteClass)) {
 				this.concreteClass = concreteClass;
 				try {
 					// Le constructeur prenant un temps en milliseconde en
 					// paramètre
 					constructor = concreteClass.getConstructor(new Class[]{long.class});
 
 				} catch (NoSuchMethodException e) {
 					try {
 						// On vérifie que le constructeur par défaut existe
 						concreteClass.getConstructor(new Class[]{});
 
 					} catch (NoSuchMethodException e1) {
 						throw new UsageInvalideException(
 						// NOPMD by olivier on 28/01/12 15:21
 								"DateParser argument [" + concreteClass + "] must have a constructor with no argument "
 										+ "or a constructor with long parameter", e1);
 					}
 				}
 
 			} else {
 				throw new UsageInvalideException(
 						"DateParser constructor : concreteClass argument must extend java.util.Date"); // should
 																										// not
 																										// happen
 			}
 		}
 
 	}
 
 	/**
 	 * Check if a class is a concrete Date class.
 	 * 
 	 * @param concreteClass
 	 *            the class to check.
 	 * @return true if the class is concrete and is a {@link Date} class or has
 	 *         Date class as a super class.
 	 */
 	public boolean checkconcreteClass(Class<?> concreteClass) {
 		boolean retour = false;
 		if (concreteClass != null && Util.isConcrete(concreteClass) && !concreteClass.isArray()) {
 			if (concreteClass.equals(Date.class)) {
 				retour = true;
 			} else {
 				retour = checkconcreteClass(concreteClass.getSuperclass());
 			}
 
 		}
 		return retour;
 
 	}
 
 }