/*******************************************************************************
 * Copyright (c) 2000, 2013 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.tests.api;

import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.jface.preference.PreferenceManager;
import org.eclipse.ui.IEditorRegistry;
import org.eclipse.ui.IPerspectiveRegistry;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.WorkbenchException;
import org.eclipse.ui.tests.harness.util.ArrayUtil;
import org.eclipse.ui.tests.harness.util.EmptyPerspective;
import org.eclipse.ui.tests.harness.util.UITestCase;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/**
 * Tests the IWorkbench interface.
 */
@RunWith(JUnit4.class)
public class IWorkbenchTest extends UITestCase {

	public IWorkbenchTest() {
		super(IWorkbenchTest.class.getSimpleName());
	}

	/**
	 * Tests the activation of two windows.
	 */
	@Test
	@Ignore
	public void XXXtestGetActiveWorkbenchWindow() throws Throwable {
		IWorkbenchWindow win1, win2;

		// Test initial window.
		win1 = fWorkbench.getActiveWorkbenchWindow();
		assertNotNull(win1);

		// Test open window.
		win1 = openTestWindow();
		assertEquals(win1, fWorkbench.getActiveWorkbenchWindow());

		// Test open second window.
		win2 = openTestWindow();
		assertEquals(win2, fWorkbench.getActiveWorkbenchWindow());

		// Test set focus.
		win1.getShell().forceFocus();
		processEvents();
		assertEquals(win1, fWorkbench.getActiveWorkbenchWindow());

		// Test set focus.
		win2.getShell().forceFocus();
		processEvents();
		assertEquals(win2, fWorkbench.getActiveWorkbenchWindow());

		// Cleanup in tearDown.
	}

	@Test
	public void testGetEditorRegistry() throws Throwable {
		IEditorRegistry reg = fWorkbench.getEditorRegistry();
		assertNotNull(reg);
	}

	@Test
	public void testGetPerspectiveRegistry() throws Throwable {
		IPerspectiveRegistry reg = fWorkbench.getPerspectiveRegistry();
		assertNotNull(reg);
	}

	@Test
	public void testGetPrefereneManager() throws Throwable {
		PreferenceManager mgr = fWorkbench.getPreferenceManager();
		assertNotNull(mgr);
	}

	@Test
	public void testGetSharedImages() throws Throwable {
		ISharedImages img = fWorkbench.getSharedImages();
		assertNotNull(img);
	}

	@Test
	public void testGetWorkingSetManager() throws Throwable {
		IWorkingSetManager workingSetManager = fWorkbench
				.getWorkingSetManager();
		IWorkspace workspace = ResourcesPlugin.getWorkspace();

		assertNotNull(workingSetManager);

		IWorkingSet workingSet = workingSetManager.createWorkingSet("ws1",
				new IAdaptable[] { workspace.getRoot() });
		workingSetManager.addWorkingSet(workingSet);
		workingSetManager = fWorkbench.getWorkingSetManager();
		assertEquals(1, workingSetManager.getWorkingSets().length);
		assertEquals(workingSet, workingSetManager.getWorkingSets()[0]);

		workingSetManager.removeWorkingSet(workingSet);
	}

	@Test
	public void testGetWorkbenchWindows() throws Throwable {
		IWorkbenchWindow[] wins = fWorkbench.getWorkbenchWindows();
		assertEquals(ArrayUtil.checkNotNull(wins), true);
		int oldTotal = wins.length;
		int num = 3;

		IWorkbenchWindow[] newWins = new IWorkbenchWindow[num];
		for (int i = 0; i < num; i++) {
			newWins[i] = openTestWindow();
		}

		wins = fWorkbench.getWorkbenchWindows();
		for (int i = 0; i < num; i++) {
			assertTrue(ArrayUtil.contains(wins, newWins[i]));
		}

		assertEquals(wins.length, oldTotal + num);

		closeAllTestWindows();
		wins = fWorkbench.getWorkbenchWindows();
		assertEquals(wins.length, oldTotal);
	}

	/**
	 * openWorkbenchWindow(String, IAdaptable)
	 */
	@Test
	@Ignore
	public void XXXtestOpenWorkbenchWindow() throws Throwable {
		// open a window with valid perspective
		IWorkbenchWindow win = null;
		try {
			win = fWorkbench.openWorkbenchWindow(EmptyPerspective.PERSP_ID, getPageInput());
			assertNotNull(win);
			assertEquals(win, fWorkbench.getActiveWorkbenchWindow());
			assertEquals(EmptyPerspective.PERSP_ID, win.getActivePage()
					.getPerspective().getId());
		} finally {
			if (win != null) {
				win.close();
			}
		}

		// open a window with invalid perspective. WorkbenchException is expected.
		boolean exceptionOccured = false;
		try {
			win = fWorkbench.openWorkbenchWindow("afdasfdasf", getPageInput());
		} catch (WorkbenchException ex) {
			exceptionOccured = true;
		}

		assertEquals(exceptionOccured, true);
	}

	/**
	 * openWorkbenchWindow(IAdaptable)
	 */
	@Test
	@Ignore
	public void XXXtestOpenWorkbenchWindow2() throws Throwable {
		// open a window with valid perspective
		IWorkbenchWindow win = null;

		try {
			win = fWorkbench
					.openWorkbenchWindow(getPageInput());
			assertNotNull(win);
			assertEquals(win, fWorkbench.getActiveWorkbenchWindow());
			String defaultID = fWorkbench.getPerspectiveRegistry()
					.getDefaultPerspective();
			assertEquals(win.getActivePage().getPerspective().getId(),
					defaultID);

		} finally {
			if (win != null) {
				win.close();
			}
		}
	}

	@Test
	@Ignore
	public void testOpenPage1() throws Throwable {
		IWorkbenchWindow win = null;
		//IWorkbenchPage page1, page2;
		try {
			/*
			 * Commented out until test case can be updated to match new
			 * implementation of single page per window
			 *
			 // Open test window.
			 win = fWorkbench.openWorkbenchWindow(ResourcesPlugin.getWorkspace());
			 assertNotNull(win);

			 // Set platform pref for openPage.
			 IPreferenceStore store = WorkbenchPlugin.getDefault().getPreferenceStore();
			 store.setValue(IPreferenceConstants.REUSE_PERSPECTIVES,
			 true);

			 // Call openPage twice with the same input.
			 // Verify that we get the same page back both times.
			 page1 = fWorkbench.openPage(ResourcesPlugin.getWorkspace());
			 assertNotNull(page1);
			 page2 = fWorkbench.openPage(ResourcesPlugin.getWorkspace());
			 assertNotNull(page2);
			 assertEquals("Pages should be equal", page1, page2);

			 // Reset platform pref for openPage.
			 store.setValue(IPreferenceConstants.REUSE_PERSPECTIVES,
			 false);
			 */
			// Call openPage twice with the same input.
			// Verify that we get two different pages back.
			/*
			 * Commented out until Nick has time to update this
			 * test case to match new implementation of openPage
			 * otherwise this test always fails.
			 *
			 page1 = fWorkbench.openPage(ResourcesPlugin.getWorkspace());
			 assertNotNull(page1);
			 page2 = fWorkbench.openPage(ResourcesPlugin.getWorkspace());
			 assertNotNull(page2);
			 assertTrue("Pages should be not equal", page1 != page2);
			 */
		} finally {
			// Close test window.
			if (win != null) {
				win.close();
			}
		}
	}

	@Test
	@Ignore
	public void testOpenPage2() throws Throwable {
		IWorkbenchWindow win = null;
		//IWorkbenchPage page1, page2;
		try {
			/*
			 * Commented out until test case can be updated to match new
			 * implementation of single page per window
			 *
			 // Open test window.
			 win = fWorkbench.openWorkbenchWindow(ResourcesPlugin.getWorkspace());
			 assertNotNull(win);

			 // Set platform pref for openPage.
			 IPreferenceStore store = WorkbenchPlugin.getDefault().getPreferenceStore();
			 store.setValue(IPreferenceConstants.REUSE_PERSPECTIVES,
			 true);

			 // Call openPage twice with the same input.
			 // Verify that we get the same page back both times.
			 page1 = fWorkbench.openPage(EmptyPerspective.PERSP_ID,
			 ResourcesPlugin.getWorkspace(), 0);
			 assertNotNull(page1);
			 page2 = fWorkbench.openPage(IWorkbenchConstants.DEFAULT_LAYOUT_ID,
			 ResourcesPlugin.getWorkspace(), 0);
			 assertNotNull(page2);
			 assertEquals("Pages should be equal", page1, page2);

			 // Reset platform pref for openPage.
			 store.setValue(IPreferenceConstants.REUSE_PERSPECTIVES,
			 false);

			 // Call openPage twice with the same input.
			 // Verify that we get two different pages back.
			 page1 = fWorkbench.openPage(EmptyPerspective.PERSP_ID,
			 ResourcesPlugin.getWorkspace(), 0);
			 assertNotNull(page1);
			 page2 = fWorkbench.openPage(IWorkbenchConstants.DEFAULT_LAYOUT_ID,
			 ResourcesPlugin.getWorkspace(), 0);
			 assertTrue("Pages should be not equal", page1 != page2);
			 */
		} finally {
			// Close test window.
			if (win != null) {
				win.close();
			}
		}
	}

	/**
	 * close() couldn't be tested because calling close() would lead to early termination
	 * to entire test suites
	 */
	@Test
	@Ignore
	public void testClose() {
	}
}
