/*******************************************************************************
 * Copyright (c) 2007, 2009 IBM Corporation and Others
 * 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:
 *    Kentarou FUKUDA - initial API and implementation
 *******************************************************************************/

package org.eclipse.actf.model.ui.util;

import org.eclipse.actf.model.internal.ui.WebBrowserUtilForACTF;
import org.eclipse.actf.model.ui.IModelService;
import org.eclipse.actf.model.ui.IModelServiceHolder;
import org.eclipse.actf.model.ui.editor.DummyEditorInput;
import org.eclipse.actf.model.ui.editor.browser.IWebBrowserACTF;
import org.eclipse.actf.ui.util.PlatformUIUtil;
import org.eclipse.actf.util.logging.DebugPrintUtil;
import org.eclipse.ui.IEditorDescriptor;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IEditorRegistry;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;

/**
 * Utility class to manage ACTF model services (implementation of
 * {@link IModelService})
 */
public class ModelServiceUtils {

	private static class EditorNotFoundException extends Exception {
		private static final long serialVersionUID = -5760127077107164112L;

	}

	/**
	 * Find and launch an Editor associated with the target URL
	 * 
	 * @param targetUrl
	 *            target URL
	 * @return {@link IEditorPart} implements {@link IModelServiceHolder}, or
	 *         null if not available
	 */
	public static IEditorPart launch(String targetUrl) {
		IWorkbenchPage activePage = PlatformUIUtil.getActivePage();
		if (activePage == null) {
			return null;
		}

		if (targetUrl != null && targetUrl.length() != 0) {
			targetUrl = targetUrl.trim();

			IEditorReference[] editorRefs = activePage.getEditorReferences();
			for (int i = 0; i < editorRefs.length; i++) {
				IEditorPart part = editorRefs[i].getEditor(false);
				if (part instanceof IModelServiceHolder) {
					IModelService modelService = ((IModelServiceHolder) part)
							.getModelService();
					if (targetUrl.equals(modelService.getURL())) {
						activePage.activate(part);
						modelService.open(targetUrl);
						return part;
					}
				}
			}

			try {
				return (launch(targetUrl, getEditorId(targetUrl)));
			} catch (EditorNotFoundException e) {
				System.err.println("Editor not found: " + targetUrl); //$NON-NLS-1$
			}
		}
		return null;
	}

	private static boolean isModelService(IEditorDescriptor desc) {
		if (desc == null) {
			return false;
		}
		return desc.getId().indexOf("actf.model.ui") >= 0; //$NON-NLS-1$
	}

	private static String getEditorId(String targetUrl)
			throws EditorNotFoundException {
		// TODO support multiple editor, dialog, preference
		IEditorRegistry editors = PlatformUI.getWorkbench().getEditorRegistry();
		IEditorDescriptor[] candidates;
		IEditorDescriptor editor;

		if (!targetUrl.startsWith("http://") //$NON-NLS-1$
				&& !targetUrl.startsWith("https://")) { //$NON-NLS-1$
			editor = editors.getDefaultEditor(targetUrl);
			if (isModelService(editor)) {
				return editor.getId();
			} else {
				candidates = editors.getEditors(targetUrl);
				for (IEditorDescriptor desc : candidates) {
					if (isModelService(desc)) {
						return desc.getId();
					}
				}
			}
		}
		editor = editors.getDefaultEditor("default.html"); //$NON-NLS-1$
		if (isModelService(editor)) {
			return editor.getId();
		} else {
			candidates = editors.getEditors("default.html"); //$NON-NLS-1$
			for (IEditorDescriptor desc : candidates) {
				if (isModelService(desc)) {
					return desc.getId();
				}
			}
		}
		throw new EditorNotFoundException();
	}

	/**
	 * Launch an Editor
	 * 
	 * @param targetUrl
	 *            target URL
	 * @param id
	 *            ID of target Editor
	 * @return {@link IEditorPart}, or null if not available
	 */
	public static IEditorPart launch(String targetUrl, String id) {

		IWorkbenchPage activePage = PlatformUIUtil.getActivePage();
		if (activePage == null) {
			return null;
		}
		if (targetUrl != null) {
			targetUrl = targetUrl.trim();
		} else {
			targetUrl = ""; //$NON-NLS-1$
		}

		IEditorPart blankEditorPart = getBlankBrowserEditorPart(id);
		if (blankEditorPart != null) {
			activePage.activate(blankEditorPart);
			if (targetUrl != null) {
				((IModelServiceHolder) blankEditorPart).getModelService().open(
						targetUrl);
				return blankEditorPart;
			}
		} else {
			IEditorReference[] editorRefs = activePage.getEditorReferences();
			for (int i = 0; i < editorRefs.length; i++) {
				if (editorRefs[i].getId().equals(id)) {
					IWorkbenchPart part = editorRefs[i].getPart(false);
					if (part instanceof IModelServiceHolder) {
						IModelService modelService = ((IModelServiceHolder) part)
								.getModelService();
						if (targetUrl.equals(modelService.getURL())) {
							activePage.activate(part);
							return (IEditorPart) part;
						}
					}
				}
			}

			try {
				String editorName = ""; //$NON-NLS-1$
				IEditorRegistry editors = PlatformUI.getWorkbench()
						.getEditorRegistry();
				IEditorDescriptor editorDesc = editors.findEditor(id);
				if (editorDesc != null) {
					editorName = editorDesc.getLabel();
					return activePage.openEditor(new DummyEditorInput(
							targetUrl, editorName), id);
				} else {
					System.err.println("Editor not found: " + id); //$NON-NLS-1$
				}
			} catch (PartInitException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	private static IEditorPart getBlankBrowserEditorPart(String id) {
		IEditorReference[] editors = PlatformUIUtil.getActivePage()
				.getEditorReferences();
		for (int i = 0; i < editors.length; i++) {
			if (editors[i].getId().equals(id)) {
				IWorkbenchPart part = editors[i].getPart(false);
				if (part instanceof IModelServiceHolder) {
					IModelService modelService = ((IModelServiceHolder) part)
							.getModelService();
					// System.out.println(modelService.getURL());
					if (modelService.getURL() == null)
						return (IEditorPart) part;
					if (modelService instanceof IWebBrowserACTF
							&& ("about:blank".equals(modelService.getURL()) || ("" //$NON-NLS-1$ //$NON-NLS-2$
							.equals(modelService.getURL()))))
						return (IEditorPart) part;
				}
			}
		}
		return null;
	}

	/**
	 * Try to open the target URL in existing {@link IEditorPart}. If
	 * appropriate Editor is not available, launch new {@link IEditorPart}.
	 * 
	 * @param targetUrl
	 *            target URL
	 */
	public static void openInExistingEditor(String targetUrl) {
		if (targetUrl == null) {
			return;
		}

		targetUrl = targetUrl.trim();
		String editorId;

		IWorkbenchPage activePage = PlatformUIUtil.getActivePage();
		if (activePage == null) {
			return;
		}
		try {
			editorId = getEditorId(targetUrl);
		} catch (EditorNotFoundException e) {
			System.err.println("Editor not found: " + targetUrl); //$NON-NLS-1$
			return;
		}
		if (activateEditorPart(editorId)) {
			IEditorPart editor = activePage.getActiveEditor();
			if (editor instanceof IModelServiceHolder) {
				((IModelServiceHolder) editor).getModelService()
						.open(targetUrl);
			} else {
				launch(targetUrl);
			}
		} else {
			launch(targetUrl);
		}

	}

	/**
	 * Activate {@link IEditorPart}
	 * 
	 * @param id
	 *            ID of target {@link IEditorPart}
	 * @return true if activation is successfully finished
	 */
	public static boolean activateEditorPart(String id) {
		if (id != null) {
			IWorkbenchPage activePage = PlatformUIUtil.getActivePage();
			if (activePage == null) {
				return false;
			}
			IEditorPart editor = activePage.getActiveEditor();
			if (editor != null && editor.getSite().getId().equals(id)) {
				return true;
			}

			IEditorReference[] editors = activePage.getEditorReferences();
			for (int i = 0; i < editors.length; i++) {
				DebugPrintUtil.devOrDebugPrintln(editors[i].getId());
				if (editors[i].getId().equals(id)) {
					editor = editors[i].getEditor(false);
					if (editor != null) {
						activePage.activate(editor);
						return true;
					}
				}
			}
		}

		return false;
	}

	/**
	 * Get {@link IModelServiceHolder} from the current active
	 * {@link IEditorPart}
	 * 
	 * @return active {@link IModelServiceHolder}
	 */
	public static IModelServiceHolder getActiveModelServiceHolder() {
		IEditorPart editor = PlatformUIUtil.getActiveEditor();
		if (editor != null && editor instanceof IModelServiceHolder) {
			return (IModelServiceHolder) editor;
		}

		if (editor != null) {
			DebugPrintUtil.devOrDebugPrintln("ModelServiceUtils: " + editor //$NON-NLS-1$
					+ " isn't IModelServiceHolder"); //$NON-NLS-1$
		}

		return null;
	}

	/**
	 * Get {@link IModelService} from the current active {@link IEditorPart}
	 * 
	 * @return active {@link IModelService}
	 */
	public static IModelService getActiveModelService() {
		IModelServiceHolder holder = getActiveModelServiceHolder();
		if (holder != null) {
			return (holder.getModelService());
		}
		return null;
	}

	/**
	 * Try to open the same URL of the current active WebBrowserEditor by the
	 * ACTF Browser.
	 * 
	 * @return {@link IEditorPart} implements {@link IModelServiceHolder}, or
	 *         null if not available
	 */
	public static IEditorPart reopenInACTFBrowser() {
		String url = WebBrowserUtilForACTF.getUrl(PlatformUIUtil
				.getActiveEditor());
		if (url != null) {
			return ModelServiceUtils.launch(url);
		}
		return null;
	}

}