/*******************************************************************************
 * Copyright (c) 2005, 2006 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.tests.commands;

import java.util.Map;

import org.eclipse.core.commands.ParameterizedCommand;
import org.eclipse.core.commands.SerializationException;
import org.eclipse.core.commands.common.CommandException;
import org.eclipse.core.commands.common.NotDefinedException;
import org.eclipse.ui.commands.ICommandService;
import org.eclipse.ui.tests.harness.util.UITestCase;

/**
 * Test serialization and deserialization of ParameterizedCommands. See <a
 * href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=120523">bug 120523</a>.
 * 
 * @since 3.2
 */
public class CommandSerializationTest extends UITestCase {

	/**
	 * Constructs a new instance of <code>CommandSerializationTest</code>.
	 * 
	 * @param name
	 *            The name of the test
	 */
	public CommandSerializationTest(String testName) {
		super(testName);
	}
	
	private final String showPerspectiveCommandId = "org.eclipse.ui.perspectives.showPerspective";
	
	/**
	 * Test a serialization of the show perspective command with no parameters.
	 * 
	 * @throws CommandException
	 */
	public void testSerializeShowPerspective() throws CommandException {

		testDeserializeAndSerialize(showPerspectiveCommandId,
				showPerspectiveCommandId, 0, null, null);

		// test with unnecessary (but valid) trailing "()" characters
		testDeserializeAndSerialize(showPerspectiveCommandId+"()",
				showPerspectiveCommandId, 0, null, null);
	}
	
	
	/**
	 * Test a serialization of the show perspective command with a parameter.
	 * 
	 * @throws CommandException
	 */
	public void testSerializeShowResourcePerspective() throws CommandException {
		
		final String serializedShowResourcePerspectiveCommand = "org.eclipse.ui.perspectives.showPerspective(org.eclipse.ui.perspectives.showPerspective.perspectiveId=org.eclipse.ui.resourcePerspective)";
		final String showPerspectiveParameterId = "org.eclipse.ui.perspectives.showPerspective.perspectiveId";
		final String resourcePerspectiveId = "org.eclipse.ui.resourcePerspective";

		testDeserializeAndSerialize(serializedShowResourcePerspectiveCommand,
				showPerspectiveCommandId, 1,
				new String[] { showPerspectiveParameterId },
				new String[] { resourcePerspectiveId });
		
	}
	
	/**
	 * Test serialization of a command with zero parameters.
	 * 
	 * @throws CommandException
	 */
	public void testZeroParameterCommand() throws CommandException {
		final String zeroParameterCommandId = "org.eclipse.ui.tests.commands.zeroParameterCommand";

		// basic test
		testDeserializeAndSerialize(zeroParameterCommandId,
				zeroParameterCommandId, 0, null, null);
		
		// test with a bogus parameter
		testDeserializeAndSerialize(zeroParameterCommandId
				+ "(bogus.param=hello)", zeroParameterCommandId, 1, null, null);
	}
	
	/**
	 * Test serialization of a command with one parameter.
	 * 
	 * @throws CommandException
	 */
	public void testOneParameterCommand() throws CommandException {
		final String oneParameterCommandId = "org.eclipse.ui.tests.commands.oneParameterCommand";
		final String paramId1 = "param1.1";

		// basic test
		testDeserializeAndSerialize(oneParameterCommandId + "(param1.1=hello)",
				oneParameterCommandId, 1, new String[] { paramId1 },
				new String[] { "hello" });

		// try it with null value param
		testDeserializeAndSerialize(oneParameterCommandId + "(param1.1)",
				oneParameterCommandId, 1, new String[] { paramId1 },
				new String[] { null });

		// try it without the param
		testDeserializeAndSerialize(oneParameterCommandId,
				oneParameterCommandId, 0, null, null);
		
		// test with a bogus parameter
		testDeserializeAndSerialize(oneParameterCommandId
				+ "(bogus.param=hello)", oneParameterCommandId, 1, null, null);
		
		// test with a bogus parameter and the real one
		testDeserializeAndSerialize(oneParameterCommandId
				+ "(bogus.param=hello,param1.1=foo)", oneParameterCommandId, 2,
				new String[] { paramId1 }, new String[] { "foo" });
	}
	
	/**
	 * Test serialization of a command with two parameters.
	 * 
	 * @throws CommandException
	 */
	public void testTwoParameterCommand() throws CommandException {
		final String twoParameterCommandId = "org.eclipse.ui.tests.commands.twoParameterCommand";
		final String paramId1 = "param2.1";
		final String paramId2 = "param2.2";

		// basic test
		testDeserializeAndSerialize(twoParameterCommandId
				+ "(param2.1=hello,param2.2=goodbye)", twoParameterCommandId, 2,
				new String[] { paramId1, paramId2 }, new String[] { "hello",
						"goodbye" });
		
		// re-order parameters
		testDeserializeAndSerialize(twoParameterCommandId
				+ "(param2.2=goodbye,param2.1=hello)", twoParameterCommandId, 2,
				new String[] { paramId1, paramId2 }, new String[] { "hello",
						"goodbye" });
		
		// parameter values that need escaping
		final String value1Escaped = "hello%(%)%%%=%,";
		final String value2Escaped = "%%%=%(%)%,world";
		testDeserializeAndSerialize(twoParameterCommandId + "(param2.1="
				+ value1Escaped + ",param2.2=" + value2Escaped + ")",
				twoParameterCommandId, 2, new String[] { paramId1, paramId2 },
				new String[] { "hello()%=,", "%=(),world" });
	}
	
	/**
	 * Test serialization of a command with three parameters.
	 * 
	 * @throws CommandException
	 */
	public void testThreeParameterCommand() throws CommandException {
		final String threeParameterCommandId = "org.eclipse.ui.tests.commands.threeParameterCommand";
		final String paramId1 = "param3.1";
		final String paramId2 = "param3.2";
		final String paramId3 = "param3.3";

		// basic test
		testDeserializeAndSerialize(threeParameterCommandId
				+ "(param3.1=foo,param3.2=bar,param3.3=baz)",
				threeParameterCommandId, 3, new String[] { paramId1, paramId2,
						paramId3 }, new String[] { "foo", "bar", "baz" });
		
		// test with a null parameter
		testDeserializeAndSerialize(threeParameterCommandId
				+ "(param3.1,param3.2=bar,param3.3=baz)",
				threeParameterCommandId, 3, new String[] { paramId1, paramId2,
						paramId3 }, new String[] { null, "bar", "baz" });
		
		// test with all null parameters
		testDeserializeAndSerialize(threeParameterCommandId
				+ "(param3.1,param3.2,param3.3)",
				threeParameterCommandId, 3, new String[] { paramId1, paramId2,
						paramId3 }, new String[] { null, null, null });
		
		// test with a missing parameter
		testDeserializeAndSerialize(threeParameterCommandId
				+ "(param3.1=foo,param3.3=baz)", threeParameterCommandId, 2,
				new String[] { paramId1, paramId3 }, new String[] { "foo",
						"baz" });
	}

	
	/**
	 * Test serialization of a command with names that need UTF-8 encoding.
	 * 
	 * @throws CommandException
	 */
	public void testFunnyNamesCommand() throws CommandException {
		final String funnyNamesCommandId = "org.eclipse.ui.tests.command.with.f=%)(,unny.name";
		final String funnyNamesCommandIdEncoded = "org.eclipse.ui.tests.command.with.f%=%%%)%(%,unny.name";

		final String funnyNamesParamId = "param.with.F({'><+|.)=,%.name";
		final String funnyNamesParamIdEncoded = "param.with.F%({'><+|.%)%=%,%%.name";

		final String funnyValue = "= %,.&\n\t\r?*[](){}";
		final String funnyValueEncoded = "%= %%%,.&\n\t\r?*[]%(%){}";

		final String serializedFunnyNamesCommand = funnyNamesCommandIdEncoded
				+ "(" + funnyNamesParamIdEncoded + "=" + funnyValueEncoded + ")";

		// basic test
		testDeserializeAndSerialize(serializedFunnyNamesCommand,
				funnyNamesCommandId, 1, new String[] { funnyNamesParamId },
				new String[] { funnyValue });
	}
	
	public void testMalformedSerializationStrings() {
		// try a missing closing ')'
		expectSerializationException(showPerspectiveCommandId + "(");
		
		// try a bad escape sequence
		expectSerializationException("some.command.foo%bar");
	}
	
	public void testUndefinedCommands() {
		expectNotDefinedException("this.command.ain't.defined(i.hope)");
	}
	
	/**
	 * Test deserializing a stored command and then serializing it back into a
	 * string. The <code>serializedParameterizedCommand</code> may contain
	 * some "bogus" parameters (ones not defined in the command registry for the
	 * command). The <code>paramIds</code> and <code>paramValues</code>
	 * arrays represent only the ids and values of the non-bogus serialized
	 * parameters.
	 * 
	 * @param serializedParameterizedCommand
	 *            a command serialization string
	 * @param commandId
	 *            id of the serialized command
	 * @param serializedParamCount
	 *            number of parameters in the serialization (some may be bogus)
	 * @param paramIds
	 *            parameter ids in the serialization that represent real
	 *            parameters in the command
	 * @param paramValues
	 *            parameter values in the serialization (same number and order
	 *            as paramIds)
	 * @throws CommandException
	 */
	private void testDeserializeAndSerialize(
			String serializedParameterizedCommand, String commandId,
			int serializedParamCount, String[] paramIds, String[] paramValues)
			throws CommandException {
		
		ICommandService commandService = getCommandService();
		
		int realParamCount = (paramIds == null) ? 0 : paramIds.length;

		// first convert the serialized string to a ParameterizedCommand and
		// check the parts
		ParameterizedCommand pCommand = commandService
				.deserialize(serializedParameterizedCommand);
		assertNotNull(pCommand);
		assertEquals(commandId, pCommand.getId());

		Map paramMap = pCommand.getParameterMap();
		assertEquals(realParamCount, paramMap.size());

		if (paramIds != null) {
			for (int i = 0; i < realParamCount; i++) {
				assertTrue(paramMap.containsKey(paramIds[i]));
				assertEquals(paramValues[i], paramMap.get(paramIds[i]));
			}
		}

		// now convert the ParameterizedCommand back to a serialized string
		String serialization = pCommand.serialize();
		
		if ((realParamCount == serializedParamCount) && (realParamCount < 2)) {
			if ((realParamCount == 0)
					&& (serializedParameterizedCommand.endsWith("()"))) {
				// empty "()" is ok, but the re-serialization won't have it
				// so add it back for comparison....
				assertEquals(serializedParameterizedCommand, serialization
						+ "()");
			} else {
				assertEquals(serializedParameterizedCommand, serialization);
			}
		} else {
			// params may have been re-ordered so we can't compare
		}
		
		// deserialize again and use .equals() on the ParameterizedCommands
		ParameterizedCommand pCommand2 = commandService.deserialize(serialization);
		assertEquals(pCommand, pCommand2);
	}
	
	private void expectSerializationException(String serializedParameterizedCommand) {
		ICommandService commandService = getCommandService();
		
		try {
			commandService.deserialize(serializedParameterizedCommand);
			fail("expected SerializationException");
		} catch (SerializationException ex) {
			// passed
		} catch (NotDefinedException ex) {
			fail("expected SerializationException");
		}
	}
	
	private void expectNotDefinedException(String serializedParameterizedCommand) {
		ICommandService commandService = getCommandService();
		
		try {
			commandService.deserialize(serializedParameterizedCommand);
			fail("expected NotDefinedException");
		} catch (SerializationException ex) {
			fail("expected NotDefinedException");
		} catch (NotDefinedException ex) {
			// passed
		}
	}
	
	private ICommandService getCommandService() {
		Object serviceObject = getWorkbench().getAdapter(ICommandService.class);
		if (serviceObject != null) {
			ICommandService service = (ICommandService) serviceObject;
			return service;
		}
		return null;
	}
	
}