package org.junit.experimental.max;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

import org.junit.runner.Description;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
import org.junit.runner.notification.RunListener;

/**
 * Stores a subset of the history of each test:
 * <ul>
 * <li>Last failure timestamp
 * <li>Duration of last execution
 * </ul>
 */
public class MaxHistory implements Serializable {
	private static final long serialVersionUID= 1L;

	/**
	 * Loads a {@link MaxHistory} from {@code file}, or generates a new one that
	 * will be saved to {@code file}.
	 */
	public static MaxHistory forFolder(File file) {
		if (file.exists())
			try {
				return readHistory(file);
			} catch (CouldNotReadCoreException e) {
				e.printStackTrace();
				file.delete();
			}
		return new MaxHistory(file);
	}

	private static MaxHistory readHistory(File storedResults)
			throws CouldNotReadCoreException {
		try {
			FileInputStream file= new FileInputStream(storedResults);
			try {
				ObjectInputStream stream= new ObjectInputStream(file);
				try {
					return (MaxHistory) stream.readObject();
				} finally {
					stream.close();
				}
			} finally {
				file.close();
			}
		} catch (Exception e) {
			throw new CouldNotReadCoreException(e);
		}
	}

	private final Map<String, Long> fDurations= new HashMap<String, Long>();

	private final Map<String, Long> fFailureTimestamps= new HashMap<String, Long>();

	private final File fHistoryStore;

	private MaxHistory(File storedResults) {
		fHistoryStore= storedResults;
	}

	private void save() throws IOException {
		ObjectOutputStream stream= new ObjectOutputStream(new FileOutputStream(
				fHistoryStore));
		stream.writeObject(this);
		stream.close();
	}

	Long getFailureTimestamp(Description key) {
		return fFailureTimestamps.get(key.toString());
	}

	void putTestFailureTimestamp(Description key, long end) {
		fFailureTimestamps.put(key.toString(), end);
	}

	boolean isNewTest(Description key) {
		return !fDurations.containsKey(key.toString());
	}

	Long getTestDuration(Description key) {
		return fDurations.get(key.toString());
	}

	void putTestDuration(Description description, long duration) {
		fDurations.put(description.toString(), duration);
	}

	private final class RememberingListener extends RunListener {
		private long overallStart= System.currentTimeMillis();

		private Map<Description, Long> starts= new HashMap<Description, Long>();

		@Override
		public void testStarted(Description description) throws Exception {
			starts.put(description, System.nanoTime()); // Get most accurate
			// possible time
		}

		@Override
		public void testFinished(Description description) throws Exception {
			long end= System.nanoTime();
			long start= starts.get(description);
			putTestDuration(description, end - start);
		}

		@Override
		public void testFailure(Failure failure) throws Exception {
			putTestFailureTimestamp(failure.getDescription(), overallStart);
		}

		@Override
		public void testRunFinished(Result result) throws Exception {
			save();
		}
	}

	private class TestComparator implements Comparator<Description> {
		public int compare(Description o1, Description o2) {
			// Always prefer new tests
			if (isNewTest(o1))
				return -1;
			if (isNewTest(o2))
				return 1;
			// Then most recently failed first
			int result= getFailure(o2).compareTo(getFailure(o1));
			return result != 0 ? result
			// Then shorter tests first
					: getTestDuration(o1).compareTo(getTestDuration(o2));
		}

		private Long getFailure(Description key) {
			Long result= getFailureTimestamp(key);
			if (result == null)
				return 0L; // 0 = "never failed (that I know about)"
			return result;
		}
	}

	/**
	 * @return a listener that will update this history based on the test
	 *         results reported.
	 */
	public RunListener listener() {
		return new RememberingListener();
	}

	/**
	 * @return a comparator that ranks tests based on the JUnit Max sorting
	 *         rules, as described in the {@link MaxCore} class comment.
	 */
	public Comparator<Description> testComparator() {
		return new TestComparator();
	}
}