/*******************************************************************************
 * Copyright (c) 2013 THALES GLOBAL SERVICES 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:
 *     Obeo - initial API and implementation
 *******************************************************************************/
package org.eclipse.emf.ecoretools.design.service;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.ENamedElement;
import org.eclipse.emf.ecore.EOperation;
import org.eclipse.emf.ecore.EParameter;
import org.eclipse.emf.ecore.ETypedElement;
import org.eclipse.emf.ecore.EcoreFactory;

import com.google.common.base.Function;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;

/**
 * Services dealing with EOperations usable from a VSM.
 */
public class EOperationServices {
	private static final String TYPE_SEPARATOR = ":";

	private static final String PARAMETERS_SEPARATOR = ",";

	/**
	 * Computes the label of an EOperation.
	 */
	public String render(EOperation op) {
		StringBuilder sb = new StringBuilder();
		renderName(op, sb);
		renderParameters(op, sb, true);
		renderType(op, sb);
		return sb.toString();
	}

	/**
	 * Computes the tooltip of an EOperation (same as label but excluding the
	 * parameters Types) .
	 * 
	 * @param op
	 *            the operation to be rendered
	 * @return the tooltip of the given EOperation (same as label but excluding
	 *         the parameters Types)
	 */
	public String renderEOperationTooltip(EOperation op) {
		StringBuilder sb = new StringBuilder();
		renderName(op, sb);
		renderParameters(op, sb, false);
		renderType(op, sb);
		return sb.toString();
	}

	/**
	 * Performs a "direct edit" operation on an EOperation.
	 */
	public EOperation performEdit(EOperation op, String editString) {
		editName(op, editString);
		editParameters(op, editString);
		editType(op, editString);
		return op;
	}

	private void renderName(EOperation op, StringBuilder sb) {
		if (op.getName() != null) {
			sb.append(op.getName());
		}
	}

	/**
	 * Renders the parameters of the given EOperation.
	 * 
	 * @param op
	 *            the operation to render
	 * @param sb
	 *            the string builder used to render the eOperation
	 * @param includeParameterType
	 *            indicates whether parameter's Types should be rendered or not
	 */
	private void renderParameters(EOperation op, StringBuilder sb,
			boolean includeParameterType) {
		sb.append("(");
		boolean first = true;
		for (EParameter param : op.getEParameters()) {
			if (!first) {
				sb.append(PARAMETERS_SEPARATOR).append(" ");
			} else {
				first = false;
			}
			sb.append(renderParameter(param, includeParameterType));
		}
		sb.append(")");
	}

	/**
	 * Renders the given Parameter.
	 * 
	 * @param parameter
	 *            the parameter to render
	 * @param includeParameterType
	 *            indicates whether parameter's Type should be rendered or not
	 */
	private String renderParameter(EParameter parameter,
			boolean includeParameterType) {
		String name = parameter.getName();
		String typeName = EGenericsServices.getETypeLabel(parameter);
		if (name != null && typeName != null && includeParameterType) {
			return parameter.getName() + " " + typeName;
		} else if (name != null) {
			return parameter.getName();
		} else {
			return "";
		}
	}

	private void renderType(EOperation op, StringBuilder sb) {
		String typeLabel = EGenericsServices.getETypeLabel(op);
		if (typeLabel != null) {
			sb.append(" ").append(TYPE_SEPARATOR).append(" ");
			sb.append(typeLabel);
		}
	}

	private void editName(EOperation op, String editString) {
		int nameEnd = editString.length();
		int typeStart = editString.indexOf(TYPE_SEPARATOR);
		if (typeStart != -1) {
			nameEnd = Math.min(nameEnd, typeStart);
		}
		int paramStart = editString.indexOf("(");
		if (paramStart != -1) {
			nameEnd = Math.min(nameEnd, paramStart);
		}

		String namePart = editString.substring(0, nameEnd);
		if (namePart.trim().length() > 0) {
			op.setName(namePart.trim());
		} else if (typeStart == -1 && paramStart == -1) {
			// Reset the name only if no other parts have been specified.
			op.setName(null);
		}
	}

	private void editParameters(EOperation op, String editString) {
		int paramStart = editString.indexOf("(");
		int paramEnd = editString.lastIndexOf(")");
		if (paramStart != -1 && paramEnd != -1 && paramStart < paramEnd) {
			List<String[]> spec = parseParameters(editString.substring(
					paramStart + 1, paramEnd));
			int nbParam = spec.size();
			// Remove parameters from the end if we have too many.
			for (int i = op.getEParameters().size() - 1; i >= nbParam; i--) {
				op.getEParameters().remove(i);
			}
			// Update existing parameters with new spec and append additional
			// ones if necessary
			for (int i = 0; i < nbParam; i++) {
				EParameter param = null;
				if (i < op.getEParameters().size()) {
					param = op.getEParameters().get(i);
				} else {
					param = EcoreFactory.eINSTANCE.createEParameter();
					op.getEParameters().add(param);
				}
				updateParameter(op, param, spec.get(i));
			}
		}
	}

	private void updateParameter(EOperation op, EParameter param,
			String[] paramSpec) {
		if (paramSpec[0] != null) {
			param.setName(paramSpec[0]);
		}
		if (paramSpec[1] != null) {
			EClassifier type = new DesignServices().findTypeByName(op,
					paramSpec[1]);
			if (type != null) {
				param.setEType(type);
			}
		}
	}

	private List<String[]> parseParameters(String spec) {
		List<String[]> result = new ArrayList<String[]>();
		if (spec.contains(PARAMETERS_SEPARATOR)) {
			String[] params = spec.split(PARAMETERS_SEPARATOR);
			for (String paramSpec : params) {
				result.add(parseParameter(paramSpec));
			}
		} else if (spec.trim().length() > 0) {
			result.add(parseParameter(spec));
		}
		return result;
	}

	/**
	 * Parses a single parameter specification. Supports the following syntaxes:
	 * 
	 * <pre>
	 * "name"
	 * "name Type"
	 * "name : Type"
	 * " : Type"
	 * </pre>
	 * 
	 * Returns an array of two strings, representing the parameter name and the
	 * type name. Both can be <code>null</code> if the corresponding part is not
	 * specified.
	 * 
	 * Note: this method is public only so that it can be visible from tests.
	 */
	public String[] parseParameter(String paramSpec) {
		String[] type = null;
		// Try ":" as type separator
		int typeStart = paramSpec.indexOf(TYPE_SEPARATOR);
		if (typeStart != -1) {
			type = splitParameterSpec(paramSpec, typeStart);
		} else {
			// If there is no ":", assume whitespace separates the name from the
			// type
			paramSpec = paramSpec.trim();
			typeStart = paramSpec.lastIndexOf(" ");
			if (typeStart != -1) {
				type = splitParameterSpec(paramSpec, typeStart);
			} else {
				typeStart = paramSpec.lastIndexOf("\t");
				if (typeStart != -1) {
					type = splitParameterSpec(paramSpec, typeStart);
				}
			}
		}
		// If there was neither ":" nor space, the spec can specify only the
		// name, or maybe nothing if it is blank.
		if (type == null) {
			String name = paramSpec.trim();
			if (name.length() == 0) {
				name = null;
			}
			type = new String[] { name, null };
		}
		return type;
	}

	public List<ENamedElement> getAllAssociatedElements(EOperation op) {
		// [eParameters->including(self)->asSequence()->sortedBy(name)/]
		List<ENamedElement> result = Lists.newArrayListWithExpectedSize(1 + op
				.getEParameters().size());
		result.add(op);
		result.addAll(op.getEParameters());
		Collections.sort(
				result,
				Ordering.natural().onResultOf(
						new Function<ENamedElement, String>() {
							public String apply(ENamedElement input) {
								return input.getName();
							}
						}));
		return result;
	}

	private String[] splitParameterSpec(String paramSpec, int typeStart) {
		String[] type;
		String name;
		String typeName;
		name = paramSpec.substring(0, typeStart).trim();
		if (typeStart != paramSpec.length() - 1) {
			typeName = paramSpec.substring(typeStart + 1).trim();
		} else {
			typeName = null;
		}
		if (name.length() == 0) {
			name = null;
		}
		if (typeName != null && typeName.length() == 0) {
			typeName = null;
		}
		type = new String[] { name, typeName };
		return type;
	}

	private void editType(EOperation op, String editString) {
		Object value = getSpecifiedType(op, editString);
		if (value != null) {
			EGenericsServices.setETypeWithGenerics(op, value);
		} else {
			// Only reset the type to null if the ":" is explicitly present with
			// no type specified
			int typeStart = editString.lastIndexOf(TYPE_SEPARATOR);
			if (typeStart != -1
					&& !editString.substring(typeStart).contains(")")) {
				op.setEType(null);
			}
		}
	}

	private Object getSpecifiedType(ETypedElement receiver, String editString) {
		int typeStart = editString.lastIndexOf(TYPE_SEPARATOR);
		if (typeStart != -1 && editString.length() > typeStart + 1) {
			String typeName = editString.substring(typeStart + 1).trim();
			if (!typeName.contains(")")) {
				Object value = EGenericsServices.findGenericType(receiver,
						typeName);
				if (value == null) {
					value = new DesignServices().findTypeByName(receiver,
							typeName);
				}
				return value;
			}
		}
		return null;
	}
}