/*
    * 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.loader;
  
  import java.io.File;
  import java.io.IOException;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.xpath.XPathConstants;
  import javax.xml.xpath.XPathExpressionException;
  
  import olg.csv.base.Cell;
  import olg.csv.bean.filter.AbstractStringFilter;
  import olg.csv.bean.formatter.Formatter;
  import olg.csv.bean.impl.CellProcessor;
  import olg.csv.bean.impl.PropertyFormatter;
  import olg.csv.bean.loader.filter.AbstractFiltreLoader;
  
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.NodeList;
  import org.xml.sax.SAXException;
  
  /**
   * Class dedicated to load List of ColumnFormatter from an XML file.
   * 
   * @param <B>
   *            the entity type the cellProcessor deals with.
   * 
   * @see CellProcessor
   * 
   */
  public class CellProcessorLoader<B> {
  	/**
  	 * column name attribute name.
  	 */
  	protected static final String ATTR_NAME = "name";
  	/**
  	 * class attribute name.
  	 */
  	protected static final String ATTR_CLASS = "class";
  	/**
  	 * rang atribute name.
  	 */
  	protected static final String ATTR_RANG = "rang";
  	/**
  	 * Column node name.
  	 */
  	protected static final String EL_COLUMN = "column";
  	/**
  	 * Formatter node name.
  	 */
  	protected static final String EL_FORMATTER = "formatter";
  	/**
  	 * Filter node name.
  	 */
  	protected static final String EL_FILTER = "filter";
  	/**
  	 * Property node name.
  	 */
  	protected static final String EL_PROPERTY = "property";
  	/**
  	 * Properties node name.
  	 */
  	protected static final String EL_PROPERTIES = "properties";
  
  	/**
  	 * Returns the ColumnFormatter list described in the given XML file.
  	 * 
  	 * <p>
  	 * XML root of the given file must be one of the followings :
  	 * <ul>
  	 * <li>bean-writer conform to BeanWriterType</li>
  	 * <li>row-bean and conform to RowBeanType.</li>
  	 * </ul>
  	 * </p>
  	 * 
  	 * @param file
  	 *            the XML File.
  	 * @return a new ColumnFormatter list
  	 * @throws LoadException
  	 *             if an error occurs during loading
  	 * @see CellProcessor
  	 * 
 	 */
 	public List<CellProcessor<B>> load(File file) throws LoadException {
 		if (file == null) {
 			throw new IllegalArgumentException("file argument must be not null");
 		}
 		List<CellProcessor<B>> retour = null;
 		Document doc;
 		try {
 			Util.validate(file);
 			doc = Util.openDocument(file);
 			Element element = (Element) Util.evaluerDOM(doc, "/bean-writer", XPathConstants.NODE);
 
 			if (element != null) { // NOPMD by olivier on 07/02/12 01:34
 				@SuppressWarnings("unchecked")
 				Class<B> beanClass = (Class<B>) Class.forName(element.getAttribute(ATTR_CLASS));
 				if (!Util.checkBean(beanClass)) {
 					throw new LoadException(beanClass + " should be a bean class");
 				}
 				retour = load(element, EL_COLUMN, beanClass);
 
 			} else {
 				element = (Element) Util.evaluerDOM(doc, "/bean-row", XPathConstants.NODE);
 				if (element == null) {
 					throw new LoadException("Root XML Element must be bean-writer or row-bean to create a Bean Writer");
 
 				} else {
 					@SuppressWarnings("unchecked")
 					Class<B> beanClass = (Class<B>) Class.forName(element.getAttribute(ATTR_CLASS));
 					if (!Util.checkBean(beanClass)) {
 						throw new LoadException(beanClass + " should be a bean class");
 					}
 					retour = new RowBeanPropertyFormatterLoader<B>().load(element, EL_PROPERTY, beanClass);
 				}
 
 			}
 
 		} catch (ParserConfigurationException e) {
 			throw new LoadException(e);
 		} catch (SAXException e) {
 			throw new LoadException(e);
 		} catch (IOException e) {
 			throw new LoadException(e);
 		} catch (XPathExpressionException e) {
 			throw new LoadException(e);
 		} catch (ClassNotFoundException e) {
 			throw new LoadException(e);
 		}
 		return retour;
 
 	}
 
 	// /**
 	// * load a CellProcessor list from an xml node
 	// *
 	// * @param element
 	// * xml element conformed to XML Schema bean-writerType or beanRowType
 	// * specification.
 	// * @param xmlListNodeName
 	// * node name identifying columnFormatter description as expectected in the
 	// XML schema type of the given element
 	// * @return a new ColumnFormatter list
 	// * @throws ClassNotFoundException
 	// * @throws LoadException
 	// * @throws XPathExpressionException
 	// */
 	// protected List<CellProcessor<?>> load(Element element, String
 	// xmlListNodeName) throws ClassNotFoundException,
 	// LoadException, XPathExpressionException {
 	// Class<?> beanClass = Class.forName(element.getAttribute(ATTR_CLASS));
 	// if (!Util.checkBean(beanClass)) {
 	// throw new LoadException(beanClass + " should be a bean class");
 	// }
 	//
 	// NodeList liste = (NodeList) Util.evaluerDOM(element, xmlListNodeName,
 	// XPathConstants.NODESET);
 	// List<CellProcessor<?>> formatters = new ArrayList<CellProcessor<?>>();
 	//
 	// for (int i = 0; i < liste.getLength(); i++) {
 	// formatters.addAll(extractColumnType((Element) liste.item(i), beanClass));
 	// }
 	// Collections.sort(formatters);
 	// return formatters;
 	// }
 
 	/**
 	 * load a CellProcessor list from an xml node.
 	 * 
 	 * @param element
 	 *            xml element conformed to XML Schema bean-writerType or
 	 *            beanRowType specification.
 	 * @param xmlListNodeName
 	 *            node name identifying columnFormatter description as
 	 *            expectected in the XML schema type of the given element
 	 * @param beanClass
 	 *            the bean class from which identify the properties targeted by
 	 *            the cell processors.. May be the B class or the class of a B
 	 *            property.
 	 * @param <E>
 	 *            the type on which identify the properties target of the cell
 	 *            processors.
 	 * @return a new ColumnFormatter list
 	 * 
 	 * @throws ClassNotFoundException
 	 *             if class not found when an attribute ("class") is identified
 	 *             as a class
 	 * @throws LoadException
 	 *             if an error occurs during loading
 	 * @throws XPathExpressionException
 	 *             on invalid XPathExpression
 	 */
 	protected <E> List<CellProcessor<B>> load(Element element, String xmlListNodeName, Class<E> beanClass)
 			throws ClassNotFoundException, LoadException, XPathExpressionException {
 
 		NodeList liste = (NodeList) Util.evaluerDOM(element, xmlListNodeName, XPathConstants.NODESET);
 		List<CellProcessor<B>> cellProcessors = new ArrayList<CellProcessor<B>>();
 
 		for (int i = 0; i < liste.getLength(); i++) {
 			cellProcessors.addAll(extractColumnType((Element) liste.item(i), beanClass));
 		}
 		Collections.sort(cellProcessors);
 		return cellProcessors;
 	}
 	/**
 	 * Identifies from an XML Element a CellProcessor list.
 	 * 
 	 * @param element
 	 *            the XML Element (ColumnType Element)
 	 * @param beanClass
 	 *            the bean class from which identify the properties targeted by
 	 *            the cell processors. May be the B class or the class of a B
 	 *            property.
 	 * @param <E>
 	 *            the type on which identify the properties target of the cell
 	 *            processors.
 	 * @return a list
 	 * @throws XPathExpressionException
 	 *             on invalid XPathExpression
 	 * @throws LoadException
 	 *             if an error occurs during loading
 	 * @throws XPathExpressionException
 	 *             on invalid XPathExpression
 	 * @throws ClassNotFoundException
 	 *             if class not found when an attribute ("class") is identified
 	 *             as a class
 	 */
 	protected <E> List<CellProcessor<B>> extractColumnType(Element element, Class<E> beanClass) throws LoadException,
 			XPathExpressionException, ClassNotFoundException {
 		List<CellProcessor<B>> formatters = new ArrayList<CellProcessor<B>>(1);
 		String name = Util.emptyToNull(element.getAttribute(ATTR_NAME));
 		String rang = element.getAttribute(ATTR_RANG);
 
 		name = (name == null ? Cell.defaultCellName(rang) : name); // NOPMD by
 																	// olivier
 																	// on
 		// 07/02/12 01:29
 		formatters.add(new CellProcessor<B>(rang, name, extractConcateReadPropertyType(
 				(Element) Util.evaluerDOM(element, EL_PROPERTIES, XPathConstants.NODE), beanClass)));
 		return formatters;
 	}
 
 	/**
 	 * Returns a PropertyFormatter which assembles severals properties of the
 	 * given bean as a string.
 	 * 
 	 * @param element
 	 *            XML node supposed to be conformed to ConcateReadPropertyType
 	 *            xsd declaration
 	 * @param beanClass
 	 *            class of the bean which has the propeties the
 	 *            propertyFormatter assembles.
 	 * @return the property formatter loaded from the XML node.
 	 * @throws LoadException
 	 *             if an error occurs during loading
 	 * @throws XPathExpressionException
 	 *             on invalid XPathExpression
 	 * @throws ClassNotFoundException
 	 *             if class not found when an attribute ("class") is identified
 	 *             as a class
 	 */
 
 	private static PropertyFormatter extractConcateReadPropertyType(Element element, Class<?> beanClass)
 			throws LoadException, XPathExpressionException, ClassNotFoundException {
 
 		NodeList liste = (NodeList) Util.evaluerDOM(element, EL_PROPERTY, XPathConstants.NODESET);
 		List<PropertyFormatter> formatters = new ArrayList<PropertyFormatter>();
 		for (int i = 0; i < liste.getLength(); i++) {
 			formatters.add(extractReadPropertyType((Element) liste.item(i), beanClass));
 		}
 
 		AbstractStringFilter filtre = AbstractFiltreLoader.getInstance().getFilter(
 				(Element) Util.evaluerDOM(element, EL_FILTER, XPathConstants.NODE));
 
 		return PropertyFormatter.getConcatePropertyReader(formatters, filtre);
 
 	}
 
 	/**
 	 * Returns PropertyFormatter from the given XML element.
 	 * 
 	 * @param element
 	 *            corresponding to ReadPropertyType xsd declaration
 	 * @param classBean
 	 *            bean parent class the bean class from which the returned
 	 *            propertyFormatter must format a property as a string
 	 * @return the property formatter loaded from the xml node.
 	 * @throws LoadException
 	 *             if an error occurs during loading
 	 * @throws XPathExpressionException
 	 *             on invalid XPathExpression
 	 * @throws ClassNotFoundException
 	 *             if class not found when an attribute ("class") is identified
 	 *             as a class
 	 */
 
 	private static PropertyFormatter extractReadPropertyType(Element element, Class<?> classBean) throws LoadException,
 			XPathExpressionException, ClassNotFoundException {
 		PropertyFormatter retour = null;
 		String name = element.getAttribute(ATTR_NAME); // Property name
 		Element delegateElement = (Element) Util.evaluerDOM(element, EL_PROPERTIES, XPathConstants.NODE);
 		Method method = olg.csv.bean.Util.identifyGetter(classBean, name);
 		if (method == null) {
 			throw new LoadException("Unrecognized property " + name + " from " + classBean);
 		}
 
 		if (delegateElement != null) {
 			String className = Util.emptyToNull(element.getAttribute(ATTR_CLASS));
 			Class<?> propertyClass = (className != null ? Class.forName(className) : method.getReturnType()); // NOPMD
 																												// by
 																												// olivier
 																												// on
 																												// 07/02/12
 																												// 01:34
 			// TODO vérifier conformitée propertyClass avec method.getReturnType
 			PropertyFormatter propertyFormatter = extractConcateReadPropertyType(delegateElement, propertyClass);
 			retour = PropertyFormatter.getDelegatePropertyReader(method, name, propertyFormatter);
 
 		} else {
 			AbstractStringFilter filtre = AbstractFiltreLoader.getInstance().getFilter(
 					(Element) Util.evaluerDOM(element, EL_FILTER, XPathConstants.NODE));
 			Formatter<?> formatter = AbstractFormatterLoader.getInstance().getFormatter(
 					(Element) Util.evaluerDOM(element, EL_FORMATTER, XPathConstants.NODE));
 			retour = PropertyFormatter.getPropertyReader(method, name, formatter, filtre);
 		}
 		return retour;
 
 	}
 
 	/**
 	 * PropertyFormatterLoader adaptation in order to manage with beanRowType
 	 * elements.
 	 * 
 	 */
 	protected static final class RowBeanPropertyFormatterLoader<B> extends CellProcessorLoader<B> {
 
 		/**
 		 * Checking the order of columns.
 		 * 
 		 * @param columnFormatters
 		 *            CellProcessor list to check.
 		 * @param <E>
 		 *            the type the cell processors deals with
 		 * @throws LoadException
 		 *             if the columns do not follow the "rang" order
 		 */
 		protected <E> void checkLoading(List<CellProcessor<E>> columnFormatters) throws LoadException {
 			int previousRank = -1;
 			int expectedRank = 0;
 			List<String> propertyNames = new ArrayList<String>();
 			for (CellProcessor<E> columnFormatter : columnFormatters) {
 				if (propertyNames.contains(columnFormatter.getPropertyFormatter().getFullName())) {
 					throw new LoadException("the property " + columnFormatter.getPropertyFormatter().getFullName()
 							+ " is still mapped");
 				} else {
 					propertyNames.add(columnFormatter.getPropertyFormatter().getFullName());
 				}
 				if (columnFormatter.getRang() == expectedRank) {
 					previousRank = expectedRank++;
 				} else {
 					if (previousRank == -1) {
 						throw new LoadException("The first column is missing at rank 0");
 
 					} else {
 						throw new LoadException("A column is missing after column at rank " + previousRank);
 					}
 				}
 			}
 		}
 
 		@Override
 		protected <E> List<CellProcessor<B>> load(Element element, String xmlListNodeName, Class<E> beanClass)
 				throws ClassNotFoundException, LoadException, XPathExpressionException {
 
 			List<CellProcessor<B>> columnFormatters = super.load(element, xmlListNodeName, beanClass);
 			checkLoading(columnFormatters);
 			return columnFormatters;
 
 		}
 
 		/**
 		 * @param element
 		 *            corresponding to BeanRowPropertyType xsd declaration
 		 *            {@inheritDoc}
 		 */
 		@Override
 		protected <T> List<CellProcessor<B>> extractColumnType(Element element, Class<T> classBean)
 				throws LoadException, XPathExpressionException, ClassNotFoundException {
 			List<CellProcessor<B>> cellProcessors = new ArrayList<CellProcessor<B>>();
 			String name = element.getAttribute(ATTR_NAME); // Property name
 
 			Method method = olg.csv.bean.Util.identifyGetter(classBean, name);
 			if (method == null) {
 				throw new LoadException("No recognized property " + name + " of " + classBean);
 			}
 
 			NodeList liste = (NodeList) Util.evaluerDOM(element, EL_PROPERTY, XPathConstants.NODESET);
 
 			if (liste.getLength() > 0) {
 				String className = Util.emptyToNull(element.getAttribute(ATTR_CLASS));
 				Class<?> propertyClass = (Class<?>) (className != null ? Class.forName(className) : method
 						.getReturnType()); // NOPMD
 				// by
 				// olivier
 				// on
 				// 07/02/12
 				// 01:33
 
 				for (int i = 0; i < liste.getLength(); i++) {
 					List<CellProcessor<B>> delegatedProcessors = extractColumnType((Element) liste.item(i),
 							propertyClass);
 
 					for (CellProcessor<B> delegatedProcessor : delegatedProcessors) {
 						delegatedProcessor.setPropertyFormatter(PropertyFormatter.getDelegatePropertyReader(method,
 								name, delegatedProcessor.getPropertyFormatter()));
 
 						cellProcessors.add(delegatedProcessor);
 					}
 
 				}
 
 			} else {
 				Formatter<?> formatter = AbstractFormatterLoader.getInstance().getFormatter(
 						(Element) Util.evaluerDOM(element, EL_FORMATTER, XPathConstants.NODE));
 
 				String rang = ((Element) Util.evaluerDOM(element, EL_COLUMN, XPathConstants.NODE))
 						.getAttribute(ATTR_RANG);
 				String columnName = Util.emptyToNull(((Element) Util
 						.evaluerDOM(element, EL_COLUMN, XPathConstants.NODE)).getAttribute(ATTR_NAME));
 				CellProcessor<B> columnFormatter = new CellProcessor<B>(rang, columnName == null ? name : columnName,
 						PropertyFormatter.getPropertyReader(method, name, formatter, null));
 
 				cellProcessors.add(columnFormatter);
 			}
 			return cellProcessors;
 
 		}
 
 	}
 
 }