package net.sourceforge.jparam.conversion.converters;
   
   import java.util.Arrays;
   import java.util.HashSet;
   import java.util.LinkedList;
   import java.util.List;
   import java.util.Set;
   
   import net.sourceforge.jparam.JParamException;
  import net.sourceforge.jparam.conversion.weights.ScalarConversionWeight;
  import net.sourceforge.jparam.typename.TypeNameRegistry;
  import net.sourceforge.jparam.util.Utils;
  
  public class PathConverter extends AbstractConverter {
  	IConverter[] path;
  
  	/***
  	 * @param path
  	 */
  	public PathConverter(IConverter[] path) {
  		setPath(path);
  		conversionWeight = path[0].getWeight();
  
  		for (int i = 1; i < path.length; i++) {
  			conversionWeight = new ScalarConversionWeight(conversionWeight,
  					path[i].getWeight());
  		}
  	}
  
  	private PathConverter(IConverter first, IConverter second) {
  		List localPath = new LinkedList();
  		if (first instanceof PathConverter) {
  			PathConverter firstPath = (PathConverter) first;
  			for (int i = 0; i < firstPath.path.length; i++) {
  				localPath.add(firstPath.path[i]);
  			}
  		} else {
  			localPath.add(first);
  		}
  
  		if (second instanceof PathConverter) {
  			PathConverter secondPath = (PathConverter) second;
  			for (int i = 0; i < secondPath.path.length; i++) {
  				localPath.add(secondPath.path[i]);
  			}
  		} else {
  			localPath.add(second);
  		}
  
  		setPath((IConverter[]) localPath.toArray(new IConverter[localPath
  				.size()]));
  		conversionWeight = new ScalarConversionWeight(first
  				.getWeight(), second.getWeight());
  	}
  
  	private void setPath(IConverter[] path) {
  		this.path = path;
  		this.sourceClass = path[0].getSourceClass();
  		this.targetClass = path[path.length - 1].getTargetClass();
  	}
  
  	public boolean equals(Object o) {
  		if (!o.getClass().equals(PathConverter.class)) {
  			return false;
  		}
  
  		PathConverter other = (PathConverter) o;
  
  		return Arrays.equals(other.path, path)
  				&& conversionWeight.equals(other.conversionWeight);
  	}
  
  	public Object internalConvert(Object o) throws JParamException {
  		for (int i = 0; i < path.length; i++) {
  			o = path[i].convert(o);
  		}
  
  		return o;
  	}
  
  	public static IConverter createConversionPath(IConverter first,
  			IConverter second) {
  		IConverter[] firstConverters;
  		IConverter[] secondConverters;
  
  		if (first instanceof AmbigousConverter) {
  			firstConverters = ((AmbigousConverter) first).getConverters();
  		} else {
  			firstConverters = new IConverter[] { first };
  		}
  
  		if (second instanceof AmbigousConverter) {
  			secondConverters = ((AmbigousConverter) second).getConverters();
  		} else {
  			secondConverters = new IConverter[] { second };
  		}
  
  		if ((firstConverters.length > 1) || (secondConverters.length > 1)) {
  			Set converters = new HashSet();
 			for (int i = 0; i < firstConverters.length; i++) {
 				for (int j = 0; j < secondConverters.length; j++) {
 					converters.add(new PathConverter(firstConverters[i],
 							secondConverters[j]));
 				}
 			}
 			return new AmbigousConverter(converters);
 		}
 
 		return new PathConverter(first, second);
 	}
 
 	protected boolean converterEquals(IConverter o) {
 		PathConverter other = (PathConverter) o;
 
 		return Arrays.equals(path, other.path);
 	}
 
 	public String toConversionString() {
 		StringBuffer result = new StringBuffer();
 
 		try {
 			result.append(TypeNameRegistry.getInstance().getJParamTypeName(
 					sourceClass));
 		} catch (JParamException e) {
 			result.append(sourceClass.getName());
 		}
 
 		for (int i = 0; i < path.length; i++) {
 			result.append(" -> ");
 			try {
 				result.append(TypeNameRegistry.getInstance().getJParamTypeName(
 						path[i].getTargetClass()));
 			} catch (JParamException e) {
 				result.append(path[i].getTargetClass().getName());
 			}
 		}
 
 		return result.toString();
 	}
 
 	public IConverter update(IConverter updatedConverter) {
 		IConverter retConverter = this;
 
 		if (Utils.isDebugEnabled(this)) {
 			System.err.println("Updating " + this + " with: "
 					+ updatedConverter);
 		}
 
 		List prefix = new LinkedList();
 
 		Class updatedSource = updatedConverter.getSourceClass();
 		Class updatedTarget = updatedConverter.getSourceClass();
 
 		int sourceIndex = 0;
 		for (; sourceIndex < path.length; sourceIndex++) {
 			IConverter curStep = path[sourceIndex];
 			if (updatedSource.equals(curStep.getSourceClass())) {
 				break;
 			}
 			prefix.add(curStep);
 		}
 
 		if (sourceIndex < path.length) {
 			List postfix = new LinkedList();
 			int targetIndex = sourceIndex + 1;
 			for (; targetIndex < path.length; targetIndex++) {
 				IConverter curStep = path[targetIndex];
 				if (updatedTarget.equals(curStep.getTargetClass())) {
 					break;
 				}
 				postfix.add(curStep);
 			}
 
 			if (targetIndex < path.length) {
 				IConverter preConverter = null;
 				IConverter postConverter = null;
 
 				if (prefix.size() > 0) {
 					preConverter = new PathConverter((IConverter[]) prefix
 							.toArray(new IConverter[prefix.size()]));
 				}
 
 				if (postfix.size() > 0) {
 					postConverter = new PathConverter((IConverter[]) postfix
 							.toArray(new IConverter[postfix.size()]));
 				}
 
 				IConverter secondHalf;
 				if (postConverter != null) {
 					secondHalf = createConversionPath(updatedConverter,
 							postConverter);
 				} else {
 					secondHalf = updatedConverter;
 				}
 
 				if (preConverter != null) {
 					retConverter = createConversionPath(preConverter,
 							secondHalf);
 				} else {
 					retConverter = createConversionPath(updatedConverter,
 							secondHalf);
 				}
 			}
 		}
 
 		if (Utils.isDebugEnabled(this)) {
 			if (retConverter != this) {
 				System.err.println("Converter updated, new converter: "
 						+ retConverter);
 			} else {
 				System.err.println("No change");
 			}
 		}
 		return this;
 	}
 }