package com.tapina.util;

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.util.Collection;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * A utility class providing transformation routines to convert one type to
 * another using Java 1.5 generics for type safety (unlike <code>ConvertUtils</code>)
 * and brevity.
 * <p>
 * Static methods on this class provide the utilities, and the class itself
 * provides the interface required to perform transformation. Users of the utilities
 * will need to therefore create concrete implementations of the class, which may
 * be anonymous if the transformer is not to be reused. An example follows:
 * <pre>
 *   List&lt;Integer&gt; numbers = (List&lt;Integer&gt;) Arrays.asList(1, 2, 3, 4);
 *   Set&lt;String&gt; strings = new HashSet&lt;String&gt;(numbers.size());
 *   Transformer.transform(numbers, strings, new Transformer<Number,String>() {
 *     public String transform(Number input) {
 *       return input.toString();
 *     }
 *   });
 * </pre>
 * <p>
 * A number of <code>Transformer</code> implementations are provided as constants.
 *
 * @param <I> input object
 * @param <O> output object
 */
public abstract class Transformer<I,O> {
	public final static Transformer<String,Pattern> STRING_TO_LITERAL_PATTERN = new Transformer<String, Pattern>() {
		@Override
		public Pattern transform(String s) {
			return Pattern.compile(s, Pattern.LITERAL);
		}
	};

	public final static Transformer<File,String> FILE_TO_CANONICAL_PATH = new Transformer<File, String>() {
		@Override
		public String transform(File file) {
			try {
				return file.getCanonicalPath();
			} catch (IOException e) {
				return null;
			}
		}
	};

	public final static Transformer<File,URI> FILE_TO_URI = new Transformer<File, URI>() {
		@Override
		public URI transform(File file) {
			return file.toURI();
		}
	};

	public final static Transformer<Object, String> TO_STRING = new Transformer<Object, String>() {
		@Override
		public String transform(Object input) {
			return input.toString();
		}
	};

	public final static Transformer<String, URI> STRING_TO_URI = new Transformer<String, URI>() {
		@Override
		public URI transform(String input) {
			return URI.create(input);
		}
	};

	public final static Transformer<String,File> PATH_TO_FILE = new Transformer<String, File>() {
		@Override
		public File transform(String path) {
			return new File(path);
		}
	};

	/**
	 * Subclasses should implement this method to convert
	 * an object of type I to an object of type O.
	 *
	 * @param input input object, of type I
	 * @return output object, of type O
	 */
	public abstract O transform(I input);

	/**
	 * Appends another transformation to this transformation to produce a single
	 * transformer which combines both operations.
	 *
	 * @param <P> Output type of second transformer
	 * @param chainedTransformer Transformer producing <code>P</code> from this transformer's output.
	 * @return Composite transformer combining both operations.
	 */
	public final <P> Transformer<I,P> followedBy(Transformer<? super O,P> chainedTransformer) {
		return chain(this, chainedTransformer);
	}

	private static <I,O,M> Transformer<I,O> chain(final Transformer<I,M> first,
			final Transformer<? super M,O> second) {
		return new Transformer<I,O>() {
			@Override
			public O transform(I input) {
				return second.transform(first.transform(input));
			}
		};
	}

	/**
	 * Transforms a collection of objects to a collection of a different type. The
	 * input and output collections must be passed to the method.
	 * <p>
	 * The output collection is not cleared before transformed objects are added.
	 *
	 * @param <I> type of object in input collection
	 * @param <O> type of object in output collection
	 * @param <C> type of output collection (a collection capable of holding objects of type O)
	 * @param inputs input collection
	 * @param outputs output collection to be populated
	 * @param transformer instance of this class capable of transforming I to O
	 * @return output collection passed as argument, for convenience.
	 */
	public static <I,O,C extends Collection<? super O>> C transform(Collection<? extends I> inputs, C outputs, Transformer<I,O> transformer) {
		for (I input : inputs) {
			outputs.add(transformer.transform(input));
		}
		return outputs;
	}

	/**
	 * Transforms an array to an array of a different type. The
	 * input and output arrays must be passed to the method.
	 * <p>
	 * If the arrays are different sizes, the array of the shortest length dictates
	 * the number of objects converted.
	 *
	 * @param <I> type of object in input array
	 * @param <O> type of object in output array
	 * @param inputs input array
	 * @param outputs output array to be populated
	 * @param transformer instance of this class capable of transforming I to O
	 * @return output array passed as argument, for convenience.
	 */
	public static <I,O> O[] transform(I[] inputs, O[] outputs, Transformer<I,O> transformer) {
		for (int i = 0; i < outputs.length && i < inputs.length; i++) {
			outputs[i] = transformer.transform(inputs[i]);
		}
		return outputs;
	}

	/**
	 * Transforms a map into an identically-keyed map of different typed values.
	 * The input and output maps must be passed to the method.
	 * <p>
	 * The output map is not cleared before transformed entries are added.
	 *
	 * @param <K> type of key, remains unchanged between input and output map
	 * @param <I>type of value in input map
	 * @param <O> type of value in output map
	 * @param inputs input map
	 * @param outputs output map to be populated
	 * @param transformer instance of this class capable of transforming I to O
	 * @return output array passed as argument, for convenience.
	 */
	public static <K,I,O> Map<K,O> transform(Map<K,I> inputs, Map<K,O> outputs, Transformer<I,O> transformer) {
		for (Map.Entry<K,I> entry : inputs.entrySet()) {
			outputs.put(entry.getKey(), transformer.transform(entry.getValue()));
		}
		return outputs;
	}

}