/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.tests.api;

import junit.framework.TestCase;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.ui.IEditorDescriptor;
import org.eclipse.ui.IEditorRegistry;
import org.eclipse.ui.IFileEditorMapping;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.internal.registry.EditorRegistry;
import org.eclipse.ui.internal.registry.FileEditorMapping;
import org.eclipse.ui.tests.TestPlugin;
import org.eclipse.ui.tests.util.ArrayUtil;
import org.eclipse.ui.tests.util.CallHistory;
import org.eclipse.ui.tests.util.FileUtil;

public class IEditorRegistryTest extends TestCase {
	private IEditorRegistry fReg;
	private IProject proj;	

	public IEditorRegistryTest(String testName) {
		super( testName );		
	}
	
	public void setUp() {
		fReg = PlatformUI.getWorkbench().getEditorRegistry();		
	}
	
	public void tearDown() {
		if( proj != null ){
			try{
				FileUtil.deleteProject( proj );
			} catch (CoreException e) {
				TestPlugin.getDefault().getLog().log(e.getStatus());
				fail();
			}
		}
	}

	public void testGetFileEditorMappings() {
		assertTrue( ArrayUtil.checkNotNull( fReg.getFileEditorMappings() ) );
	}
	
	/**
	 *	tests both of the following:
	 *	IEditorDescriptor[] getEditors(IFile file) 
	 *	IEditorDescriptor[] getEditors(String filename)  
	 */
	public void testGetEditors() throws Throwable {
		IEditorDescriptor[] editors, editors2;
		String[][] maps = {
			{"a.mock1", MockEditorPart.ID1 },
			{"b.mock2", MockEditorPart.ID2 }
		};
		
		proj = FileUtil.createProject("testProject");
		
		for( int i = 0; i < maps.length; i ++ ){
			editors = fReg.getEditors( maps[i][0] );
			assertEquals( editors.length, 1 );
			assertEquals( editors[ 0 ].getId(), maps[i][1] );
			editors2 = fReg.getEditors(FileUtil.createFile(maps[i][0], proj).getName());
			assertEquals( ArrayUtil.equals( editors, editors2 ), true );
		}

		//there is no matching editor
		String fileName = IConstants.UnknownFileName[0];
		editors = fReg.getEditors( fileName );
		assertEquals( editors.length, 0 );
		editors = fReg.getEditors(FileUtil.createFile(fileName, proj).getName());
		assertEquals( editors.length, 0 );
	}

	public void testFindEditor() {
		String id = MockEditorPart.ID1;	
		IEditorDescriptor editor = fReg.findEditor( id );		
		assertEquals( editor.getId(), id );		
		
		//editor is not found
		id = IConstants.FakeID;
		editor = fReg.findEditor( id );		
		assertNull( editor );
	}

	/**
	 * getDefaultEditor()
	 */	
	public void testGetDefaultEditor() {
		assertNotNull( fReg.getDefaultEditor() );	
	}	

	/**
	 * getDefaultEditor(String fileName)
	 */
	public void testGetDefaultEditor2() {
		IEditorDescriptor editor = fReg.getDefaultEditor( "a.mock1" );
		assertEquals( editor.getId(), MockEditorPart.ID1 );
		
		// same extension with different name
		IEditorDescriptor editor2 = fReg.getDefaultEditor( "b.mock1" );
		assertEquals( editor, editor2 );
				
		//editor not found		
		assertNull( fReg.getDefaultEditor( IConstants.UnknownFileName[0] ) );
	}

	/**
	 * getDefaultEditor(IFile file)	
	 */
	public void testGetDefaultEditor3() throws Throwable {
		proj = FileUtil.createProject("testProject");
		
		IFile file = FileUtil.createFile("Whats up.bro", proj);
		String id = MockEditorPart.ID1;
		IDE.setDefaultEditor(file, id);
		IEditorDescriptor editor = IDE.getDefaultEditor(file);
		assertEquals( editor.getId(), id );
		
		//attach an IFile object with a registered extension to a different editor
		file = FileUtil.createFile("ambush.mock1", proj);
		id = MockEditorPart.ID2;
		IDE.setDefaultEditor( file, id );
		editor = IDE.getDefaultEditor( file );
		assertEquals( editor.getId(), id );
		
		//a non-registered IFile object with a registered extension
		String name = "what.mock2";
		file = FileUtil.createFile( name, proj);
		editor = IDE.getDefaultEditor( file );
		assertEquals( editor, fReg.getDefaultEditor( name ) );
		
		//a non-registered IFile object with an unregistered extension
		name = IConstants.UnknownFileName[0];
		file = FileUtil.createFile( name, proj);
		assertNull( IDE.getDefaultEditor( file ) );
	}
	
	public void testSetDefaultEditor() throws Throwable {
		proj = FileUtil.createProject("testProject");		
		IFile file = FileUtil.createFile("good.file", proj);

		String id = MockEditorPart.ID1;
		IDE.setDefaultEditor( file, id );	
		IEditorDescriptor editor = IDE.getDefaultEditor( file );
		assertEquals( editor.getId(), id );
		
		//change the default editor
		id = MockEditorPart.ID2;
		IDE.setDefaultEditor( file, id );	
		editor = IDE.getDefaultEditor( file );
		assertEquals( editor.getId(), id );
		
		//register the default editor with an invalid editor id
		IDE.setDefaultEditor( file, IConstants.FakeID );	
		assertNull( IDE.getDefaultEditor( file ) );		
	}
	
	/**
	 *	tests both of the following:
	 *	getImageDescriptor(IFile file)    
	 * 	getImageDescriptor(String filename)  
	 */
	public void testGetImageDescriptor() throws Throwable {
		proj = FileUtil.createProject("testProject");		
		
		
		ImageDescriptor image1, image2; 
		String fileName;
		
		fileName = "a.mock1";
		IFile file = FileUtil.createFile(fileName, proj);
		image1 = fReg.getImageDescriptor( fileName );
		image2 = fReg.getDefaultEditor( fileName).getImageDescriptor();
		assertEquals( image1, image2 );
		//for getImageDescriptor(IFile file)
		assertEquals( image1, fReg.getImageDescriptor( file.getName() ) );
		
		//same extension, different file name
		fileName = "b.mock1";
		file = FileUtil.createFile(fileName, proj);
		assertEquals( image1, fReg.getImageDescriptor( fileName ) );
		assertEquals( image1, fReg.getImageDescriptor( file.getName() ) );
		
		//default image		
		fileName = "a.nullAndVoid";
		file = FileUtil.createFile(fileName, proj);
		image1 = fReg.getImageDescriptor( fileName );
		image2 = fReg.getImageDescriptor( "b.this_is_not_good" );				
		assertNotNull( image1 );
		assertEquals( image1, image2 );
		assertEquals( image2, fReg.getImageDescriptor( file.getName() ) );
	}
	
	public void testAddPropertyListener() throws Throwable {
		final String METHOD = "propertyChanged";
		
		//take out mappings from the registry and put them back right away
		//so that the event gets triggered without making change to the registry
		IFileEditorMapping[] src = fReg.getFileEditorMappings();
		FileEditorMapping[] maps = new FileEditorMapping[src.length];
		System.arraycopy( src, 0, maps, 0, src.length);

		MockPropertyListener listener =
			new MockPropertyListener(fReg, IEditorRegistry.PROP_CONTENTS);
		fReg.addPropertyListener( listener );
		CallHistory callTrace = listener.getCallHistory();

		//multiple listener
		MockPropertyListener listener2 =
			new MockPropertyListener(fReg, IEditorRegistry.PROP_CONTENTS);
		fReg.addPropertyListener( listener2 );
		CallHistory callTrace2 = listener2.getCallHistory();

		//fire!!		
		callTrace.clear();
		callTrace2.clear();
		((EditorRegistry)fReg).setFileEditorMappings( maps );				
		assertEquals( callTrace.contains( METHOD ), true);
		assertEquals( callTrace2.contains( METHOD ), true);
		
		//add the same listener second time
		fReg.addPropertyListener( listener );
		
		//fire!!		
		callTrace.clear();
		((EditorRegistry)fReg).setFileEditorMappings( maps );				
		//make sure the method was called only once
		assertEquals(callTrace.verifyOrder(new String[] { METHOD }), true);
		
		fReg.removePropertyListener( listener );
		fReg.removePropertyListener( listener2 );
	}
	
	public void testRemovePropertyListener() {
		IFileEditorMapping[] src = fReg.getFileEditorMappings();
		FileEditorMapping[] maps = new FileEditorMapping[src.length];
		System.arraycopy( src, 0, maps, 0, src.length);
	
		MockPropertyListener listener =
			new MockPropertyListener(fReg, IEditorRegistry.PROP_CONTENTS);
		fReg.addPropertyListener( listener );
		//remove the listener immediately after adding it
		fReg.removePropertyListener( listener );
		CallHistory callTrace = listener.getCallHistory();
	
		//fire!!		
		callTrace.clear();
		((EditorRegistry)fReg).setFileEditorMappings( maps );				
		assertEquals( callTrace.contains( "propertyChanged" ), false );
		
		//removing the listener that is not registered yet should have no effect
		try{
			fReg.removePropertyListener( listener );	
		} catch (Throwable e) {
			fail();
		}
	}
}