/**
    * Copyright 2007 Björn Voß
    *
    * 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 net.sf.oxclient.mappings.xml;
  
  import java.io.IOException;
  import java.lang.reflect.Modifier;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import net.sf.oval.constraint.NotNull;
  import net.sf.oval.guard.Guarded;
  import net.sf.oxclient.mappings.IMappingManager;
  
  import org.apache.commons.collections.MapUtils;
  import org.apache.commons.lang.ClassUtils;
  import org.springframework.beans.factory.InitializingBean;
  import org.springframework.core.io.Resource;
  
  import com.thoughtworks.xstream.XStream;
  
  /**
   * @author Björn Voß
   *
   */
  @Guarded
  public class XMLMappingManager implements IMappingManager, InitializingBean {
  
  	private Resource mappingFile;
  	private List<Mapping> mappings;
  
  	/* (non-Javadoc)
  	 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
  	 */
  	public void afterPropertiesSet() throws Exception {
  		if ((this.mappingFile == null) && (this.mappings == null) ) {
  			throw new IllegalStateException("mapping file or mappings must be set");
  		}
  		if (this.mappings == null ) {
  			readMappingsFromXML();
  		}
  	}
  
  	/**
  	 * @throws IOException
  	 */
  	private void readMappingsFromXML() throws IOException {
  		final XStream xStream = new XStream();
  		xStream.alias("classmapping", Classmappings.class);
  		xStream.alias("mapping", Mapping.class);
  		xStream.alias("property", Property.class);
  		xStream.useAttributeFor(Property.class, "name");
  		xStream.useAttributeFor(Property.class, "oxcolumnid");
  		xStream.useAttributeFor(Mapping.class, "clazz");
  		xStream.aliasAttribute(Mapping.class, "clazz", "beanclass");
  		xStream.addImplicitCollection(Classmappings.class, "mappings");
  		xStream.addImplicitCollection(Mapping.class, "properties");
  		final Classmappings classmappings =
  			(Classmappings) xStream.fromXML(this.mappingFile.getInputStream());
  		this.mappings = classmappings.getMappings();
  	}
  
  	/**
  	 * @return the mappingFile
  	 */
  	public Resource getMappingFile() {
  		return this.mappingFile;
  	}
  
  	/* (non-Javadoc)
  	 * @see net.sf.oxclient.mappings.IMappingManager#getMappingForClass(java.lang.Class)
  	 */
  	@SuppressWarnings("unchecked")
  	public Map<Integer, String> getMappingForClass(@NotNull final Class<?> clazz) {
  		if (Modifier.isAbstract(clazz.getModifiers())) {
  			throw new IllegalArgumentException("not allowed for abstract class " + clazz.getName());
  		}
  		final Mapping mapping = findMapping(clazz);
  		if (mapping == null) {
  			throw new IllegalArgumentException("unkowen class " + clazz.getName());
  		}
  		final Map<Integer, String> result = new SingelKeyMap<Integer, String>();
  		addProperties(mapping.getProperties(), result);
  		addPropertiesFromSuperClasses(result, clazz);
  		return MapUtils.unmodifiableMap(result);
 	}
 
 	/**
 	 * @param result
 	 * @param clazz
 	 */
 	@SuppressWarnings("unchecked")
 	private void addPropertiesFromSuperClasses(
 			final Map<Integer, String> result,
 			final Class<?> clazz) {
 		final List<Class<?>> superClasses = ClassUtils.getAllSuperclasses(clazz);
 		for (final Class<?> superClass : superClasses) {
 			final Mapping supperMapping = findMapping(superClass);
 			if (supperMapping != null) {
 				addProperties(supperMapping.getProperties(), result);
 			}
 		}
 	}
 
 	/**
 	 * @param properties
 	 * @param result
 	 */
 	private void addProperties(
 			final Set<Property> properties,
 			final Map<Integer, String> result) {
 		for (final Property property : properties) {
 			result.put(property.getOxcolumnid(), property.getName());
 		}
 	}
 
 	/**
 	 * @param clazz
 	 */
 	private Mapping findMapping(final Class<?> clazz) {
 		for (final Mapping mapping : this.mappings) {
 			if (clazz.equals(mapping.getClazz())) {
 				return mapping;
 			}
 		}
 		return null;
 	}
 
 	/**
 	 * @return the mappings
 	 */
 	public List<Mapping> getMappings() {
 		return this.mappings;
 	}
 
 	/**
 	 * @param mappingFile the mappingFile to set
 	 */
 	public void setMappingFile(@NotNull final Resource mappingFile) {
 		this.mappingFile = mappingFile;
 	}
 
 	/**
 	 * @param mappings the mappings to set
 	 */
 	public void setMappings(@NotNull final List<Mapping> mappings) {
 		this.mappings = mappings;
 	}
 
 	private class SingelKeyMap<K, V> extends HashMap<K, V> {
 
 		private static final long serialVersionUID = 1814634918815348649L;
 
 		SingelKeyMap() {
 			super();
 		}
 
 		/* (non-Javadoc)
 		 * @see java.util.HashMap#put(java.lang.Object, java.lang.Object)
 		 */
 		@Override
 		public V put(final K key, final V value) {
 			if (containsKey(key)) {
 				throw new IllegalArgumentException("already set key " + key);
 			}
 			return super.put(key, value);
 		}
 	}
 
 }