package org.cateproject.controller.flow.action.upload;
   
   import java.io.Serializable;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.Map;
   
   import org.apache.log4j.Logger;
   import org.springframework.beans.BeanWrapperImpl;
  import org.springframework.beans.InvalidPropertyException;
  import org.springframework.beans.NullValueInNestedPathException;
  import org.springframework.core.convert.ConversionService;
  import org.springframework.util.ReflectionUtils;
  
  import eu.etaxonomy.cdm.api.service.ITermService;
  import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
  import eu.etaxonomy.cdm.persistence.query.OrderHint;
  import eu.etaxonomy.cdm.persistence.query.OrderHint.SortOrder;
  
  public class AbstractMatrixHeader<T extends IdentifiableEntity> implements Serializable, Comparable<AbstractMatrixHeader<T>> {
  	/**
  	 * 
  	 */
  	private static final long serialVersionUID = 1L;
  
  	protected static Logger logger = Logger.getLogger(AbstractMatrixHeader.class);
  	
  	private int index;
  	private String fullPath;
  	private String path;
  	
  	private String label;
  	private AbstractMatrixHeaderType type;
  	private Class<T> clazz;
      private List<Class> classes;
      private List<HeaderPath> paths = new ArrayList<HeaderPath>();
      private List<DefinedTermBase> terms = new ArrayList<DefinedTermBase>();
  
  	private boolean set = false;
  
  	public AbstractMatrixHeader(String path, int index, Class<T> clazz, Map<Class,List<Class>> classes, ITermService termService) {;
  		this.label = path;
  		this.index = index;
  		this.clazz = clazz;
  
  		this.fullPath = path;
  		
  		if(path.endsWith(".class")) {
  			this.path = path.substring(0, path.lastIndexOf(".class"));
  			this.type = AbstractMatrixHeaderType.CLASS;
  		} else if(path.equals("class")) {
  			this.path = "";
  			this.type = AbstractMatrixHeaderType.ROOT_CLASS;
  		}else {
  			this.type = AbstractMatrixHeaderType.PROPERTY;
  			this.path = path;
  		}
  		logger.info("Constructing header for " + path + " " + clazz + " " + classes.get(clazz)); 
  		HeaderPath p = new HeaderPath(clazz, classes.get(clazz), path);
  		this.paths.add(p);
  		while(!p.isTerminating()) {
  			if(classes.containsKey(p.getPropertyType())) {
  				p = new HeaderPath(p.getPropertyType(),classes.get(p.getPropertyType()),p.getRemainingPath());
  			} else { 
  				p = new HeaderPath(p.getPropertyType(),p.getRemainingPath());
  			}
  			this.paths.add(p);
  		}
  		
  		Class terminalPropertyType = this.paths.get(this.paths.size() - 1).getPropertyType();
  		
  		if(terminalPropertyType != null && DefinedTermBase.class.isAssignableFrom(terminalPropertyType)) {
  			List<OrderHint> orderHints = new ArrayList<OrderHint>();
  			orderHints.add(new OrderHint("titleCache",SortOrder.ASCENDING));
  		    this.terms = termService.list(terminalPropertyType, null, null, orderHints, null);		
  		}
  		
  	}
  	
  	public boolean isNested() {
  		return this.paths.get(0).isTerminating();
  	}
  	
  	public HeaderPath[] getPaths() {
  		return this.paths.toArray(new HeaderPath[this.paths.size()]);
  	}
  	
  
  	public MatrixHeader<T> getHeaderForObject(T o, ConversionService conversionService) {
  		if(this.isApplicable(o,conversionService)) {
  			if(this.getType().equals(AbstractMatrixHeaderType.ROOT_CLASS)) {
  				return new RootClassMatrixHeader<T>(clazz);
  			} else if(this.getType().equals(AbstractMatrixHeaderType.CLASS)) {
  				return new ClassMatrixHeader<T>(this.path,this.paths,o);
  			} else {
  		        return new PropertyMatrixHeader<T>(this.path,this.paths,o,terms);
  			}
  		} else {
 			return null;
 		}
 	}
 
 	public boolean isApplicable(Object o, ConversionService conversionService) {
 		if(this.type.equals(AbstractMatrixHeaderType.ROOT_CLASS)) {
 			return true;
 		} else if(this.type.equals(AbstractMatrixHeaderType.CLASS) && this.paths.get(0).isCollection()) { 
 			if(ReflectionUtils.findField(o.getClass(), this.paths.get(0).getProperty()) != null) {			
 			    return true;
 			} else {
 				return false;
 			}
 		} else {
 		  BeanWrapperImpl beanWrapperImpl = new BeanWrapperImpl(o);
 		  beanWrapperImpl.setAutoGrowNestedPaths(true);
 		  beanWrapperImpl.setConversionService(conversionService);
 		  try {
 				beanWrapperImpl.getPropertyDescriptor(this.path);
 				return true; // this property can be found in the current object;
 		  } catch(IllegalArgumentException iae) { 
 			  logger.info(iae.getMessage());
 			  return false; // the property is null;
 		  } catch(NullValueInNestedPathException nvinpe) {
 			  logger.info(nvinpe.getMessage());
 			  return false;
 		  } catch(InvalidPropertyException ipe) {
 			  logger.info(ipe.getMessage());
 			  return false;
 		  }
 		}
 	}
 
 	public boolean isClassType() {
 		return type.equals(AbstractMatrixHeaderType.CLASS);
 	}
 	
 	public boolean isObjectType() {
 		return type.equals(AbstractMatrixHeaderType.PROPERTY);
 	}
 
 	public int getIndex() {
 		return index;
 	}
 	
 	public String getLabel() {
 		return this.label;
 	}
 
 	public String getPath(String prefix) {
 		if(path == "") {
 			return prefix;
 		}
 		return prefix + "." + path;
 	}
 	
 	protected String getPath() {
 		return path;
 	}
 
 	public int compareTo(AbstractMatrixHeader o) {
 		if(this.path.contains(".")) {
 			if(!o.getPath().contains(".")) {
 				return -1;
 			} else{
 			  String path1 = this.path.substring(0,this.path.lastIndexOf("."));
 			  String path2 = o.getPath().substring(0, o.getPath().lastIndexOf("."));
 			  if(path1.equals(path2)) {
 				  String property1 = this.path.substring(this.path.lastIndexOf(".") + 1);
 				  String property2 = o.getPath().substring(o.getPath().lastIndexOf(".") + 1);
 				  if(property1.equals("class") && property2.contains("class")) {
 						return 0;
 					  } else if(property1.equals("class")) { 
 						return 1;				
 					  } else if(property2.equals("class")) {
 						return -1;
 					  } else {
 						return property1.compareTo(property2);
 					  }
 			  } else{
 				  return path1.compareTo(path2);
 			  }
 			}
 		} else {
 			if(o.getPath().contains(".")) {
 				return 1;
 			} else {
 			  if(this.path.equals("class") && o.getPath().contains("class")) {
 				return 0;
 			  } else if(this.path.equals("class")) { 
 				return 1;				
 			  } else if(o.getPath().equals("class")) {
 				return -1;
 			  } else {
 				return this.path.compareTo(o.getPath());
 			  }
 			}
 		}
 	}
 
 	public AbstractMatrixHeaderType getType() {
 		return type;
 	}
 
 	public List<DefinedTermBase> getTerms() {
 		return terms;
 	}
 
 	public Class<T> getClazz() {
 		return clazz;
 	}
 
 	public Class getFieldType() {
 		return this.paths.get(this.paths.size() - 1).getPropertyType();
 	}
 
 	public boolean isSet() {
 		if(this.paths.size() == 1) {
 			return false;
 		} else {
     		return this.paths.get(this.paths.size() - 2).isSet();
 		}
 	}
 
 	public boolean isMap() {
 		if(this.paths.size() == 1) {
 			return false;
 		} else {
     		return this.paths.get(this.paths.size() - 2).isMap();
 		}
 	}
 }