/*******************************************************************************
 *  Copyright (c) 2012 Google, Inc.
 *  All rights reserved. This program and the accompanying materials
 *  are made available under the terms of the Eclipse Public License v1.0
 *  which accompanies this distribution, and is available at
 *  http://www.eclipse.org/legal/epl-v10.html
 *  
 *  Contributors:
 *  Google, Inc. - initial API and implementation
 *******************************************************************************/
package com.windowtester.runtime.swt.condition.eclipse;

import java.lang.reflect.Method;

import junit.framework.TestCase;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;

import com.windowtester.internal.runtime.IDiagnostic;
import com.windowtester.internal.runtime.IDiagnosticParticipant;
import com.windowtester.runtime.condition.ICondition;
import com.windowtester.runtime.util.StringComparator;

/**
 * Tests the active editor to see if it contains a given file.
 * <p>
 * Example use:
 * <pre>
 * //wait for "MyFile.java" to be in the active editor
 * ui.wait(ActiveEditorCondition.forName("MyFile.java"));
 * </pre>
 *
 */
public abstract class ActiveEditorCondition implements ICondition, IDiagnosticParticipant {

	protected final boolean isActive;
	
	private static class ByPath extends ActiveEditorCondition {
		private final IPath expectedPath;
		private IPath actualPath;

		public ByPath(IPath path, boolean isActive) {
			super(isActive);
			if (path == null)
				throw new IllegalArgumentException("file path must not be null");
			this.expectedPath = ResourcesPlugin.getWorkspace().getRoot().getLocation().append(path);
		}
		
		/* (non-Javadoc)
		 * @see com.windowtester.swt.condition.ICondition#test()
		 */
		public boolean test() {
			IFile file = getActiveFile();
			if (file == null)
				return false;
			actualPath = file.getLocation();
			return actualPath.equals(actualPath) == isActive;
		}
		
		private IFile getFile(IEditorInput input) {
			/*
			 * We'd like to cast to an IFileEditorInput but that would introduce an
			 * unwanted dependency on eclipse.ui.ide.
			 */

			if (input == null)
				return null;

			Class<? extends IEditorInput> cls = input.getClass();
			try {
				Method m = cls.getMethod("getFile", (Class[]) null);
				IFile file = (IFile) m.invoke(input, (Object[]) null);
				return file;
			} catch (Exception e) {
				//really, do nothing
			}
			return null;
		}
		
		/**
		 * Return the IFile for the active editor 
		 */
		IFile getActiveFile() {
			// get the file from the active workbench editor
			IEditorPart activeEditor = getActiveEditor();
			if (activeEditor == null)
				return null;
			IEditorInput input = activeEditor.getEditorInput();
			return getFile(input);
		}
		
		/* (non-Javadoc)
		 * @see java.lang.Object#toString()
		 */
		public String toString() {
			return " for path [" + expectedPath + "] to be in the active editor: "
				+ isActive;
		}
		
//		public ICondition not() {
//			return new ByPath(expectedPath, false);
//		}
		
		////////////////////////////////////////////////////////////////////////////
		//
		// IDiagnosticParticipant
		//
		////////////////////////////////////////////////////////////////////////////

		public void diagnose(IDiagnostic diagnostic) {
			diagnostic.attribute("class", ActiveEditorCondition.class.getName());
			diagnostic.attribute("expected", safeToString(expectedPath));
			diagnostic.attribute("actual", safeToString(actualPath));
		}

		
		protected String safeToString(Object object) {
			return object == null ? "null" : object.toString();
		}

			
	}
	
	private static class ByName extends ActiveEditorCondition {
		private final String expectedTitle;
		private String actualTitle;
		ByName(String name, boolean isActive) {
			super(isActive);
			this.expectedTitle = name;
		}
		
		/* (non-Javadoc)
		 * @see com.windowtester.swt.condition.ICondition#test()
		 */
		public boolean test() {
			IEditorPart activeEditor = getActiveEditor();
			if (activeEditor == null)
				return false;
			actualTitle = activeEditor.getTitle();
			return StringComparator.matches(actualTitle, expectedTitle);
		}
		
		/* (non-Javadoc)
		 * @see java.lang.Object#toString()
		 */
		public String toString() {
			return " for name [" + expectedTitle + "] to be in the active editor: " + isActive;
		}
		
//		public ICondition not() {
//			return new ByName(expectedTitle, false);
//		}
		
		////////////////////////////////////////////////////////////////////////////
		//
		// IDiagnosticParticipant
		//
		////////////////////////////////////////////////////////////////////////////

		public void diagnose(IDiagnostic diagnostic) {
			diagnostic.attribute("class", ActiveEditorCondition.class.getName());
			diagnostic.attribute("expected", expectedTitle);
			diagnostic.attribute("actual", actualTitle);
		}
		
	}
	
	/**
	 * Create a condition that matches by path.
	 */
	public static ActiveEditorCondition forPath(IPath path) {
		return new ByPath(path, true);
	}
	
	/**
	 * Create a condition that matches by name.
	 */
	public static ActiveEditorCondition forName(String name) {
		return new ByName(name, true);
	}

	
	public ActiveEditorCondition(boolean isActive) {
		this.isActive = isActive;
	}

	

	IEditorPart getActiveEditor() {
		final IWorkbenchPage page = getActivePage();
		final IEditorPart[] activeEditor = new IEditorPart[1];
		Display.getDefault().syncExec(new Runnable() {
			public void run() {
				activeEditor[0] = page.getActiveEditor();
			}
		});
		return activeEditor[0];
	}

	IWorkbenchPage getActivePage() {
		final IWorkbenchWindow window = getActiveWorkbenchWindow();
		final IWorkbenchPage[] page = new IWorkbenchPage[1];
		Display.getDefault().syncExec(new Runnable() {
			public void run() {
				page[0] = window.getActivePage();
			}
		});
		TestCase.assertNotNull(page[0]);
		return page[0];
	}

	IWorkbenchWindow getActiveWorkbenchWindow() {
		final IWorkbench workbench = getWorkbench();
		final IWorkbenchWindow[] window = new IWorkbenchWindow[1];
		Display.getDefault().syncExec(new Runnable() {
			public void run() {
				window[0] = workbench.getActiveWorkbenchWindow();
			}
		});
		TestCase.assertNotNull(window[0]);
		return window[0];
	}

	IWorkbench getWorkbench() {
		final IWorkbench[] workbench = new IWorkbench[1];
		Display.getDefault().syncExec(new Runnable() {
			public void run() {
				workbench[0] = PlatformUI.getWorkbench();
			}
		});
		TestCase.assertNotNull(workbench[0]);
		return workbench[0];
	}
	

}