/*******************************************************************************
 * Copyright (c) 2000, 2015 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.jdi.internal;

import com.sun.jdi.ClassLoaderReference;
import com.sun.jdi.ClassNotLoadedException;
import com.sun.jdi.ClassNotPreparedException;
import com.sun.jdi.Type;
import com.sun.jdi.Value;

/**
 * this class implements the corresponding interfaces declared by the JDI
 * specification. See the com.sun.jdi package for more information.
 *
 */
public abstract class TypeImpl extends AccessibleImpl implements Type {
	/** Text representation of this type. */
	protected String fName = null;
	/** JNI-style signature for this type. */
	protected String fSignature = null;

	/**
	 * Creates new instance, used for REFERENCE types.
	 */
	protected TypeImpl(String description, VirtualMachineImpl vmImpl) {
		super(description, vmImpl);
	}

	/**
	 * Creates new instance, used for PRIMITIVE types or VOID.
	 */
	protected TypeImpl(String description, VirtualMachineImpl vmImpl,
			String name, String signature) {
		super(description, vmImpl);
		setName(name);
		setSignature(signature);
	}

	/**
	 * @return Returns new instance based on signature and (if it is a
	 *         ReferenceType) classLoader.
	 * @throws ClassNotLoadedException
	 *             when type is a ReferenceType and it has not been loaded by
	 *             the specified class loader.
	 */
	public static TypeImpl create(VirtualMachineImpl vmImpl, String signature,
			ClassLoaderReference classLoader) throws ClassNotLoadedException {
		// For void values, a VoidType is always returned.
		if (isVoidSignature(signature))
			return new VoidTypeImpl(vmImpl);

		// For primitive variables, an appropriate PrimitiveType is always
		// returned.
		if (isPrimitiveSignature(signature))
			return PrimitiveTypeImpl.create(vmImpl, signature);

		// For object variables, the appropriate ReferenceType is returned if it
		// has
		// been loaded through the enclosing type's class loader.
		return ReferenceTypeImpl.create(vmImpl, signature, classLoader);
	}

	/**
	 * Assigns name.
	 */
	public void setName(String name) {
		fName = name;
	}

	/**
	 * Assigns signature.
	 */
	public void setSignature(String signature) {
		fSignature = signature;
	}

	/**
	 * @return Returns description of Mirror object.
	 */
	@Override
	public String toString() {
		try {
			return name();
		} catch (ClassNotPreparedException e) {
			return JDIMessages.TypeImpl__Unloaded_Type__1;
		} catch (Exception e) {
			return fDescription;
		}
	}

	/**
	 * @return Create a null value instance of the type.
	 */
	public abstract Value createNullValue();

	/**
	 * @return Returns text representation of this type.
	 */
	@Override
	public String name() {
		return fName;
	}

	/**
	 * @return JNI-style signature for this type.
	 */
	@Override
	public String signature() {
		return fSignature;
	}

	/**
	 * @return Returns modifier bits.
	 */
	@Override
	public abstract int modifiers();

	/**
	 * Converts a class name to a JNI signature.
	 */
	public static String classNameToSignature(String qualifiedName) {
		// L<classname>; : fully-qualified-class
		/*
		 * JNI signature examples: int[][] -> [[I long[] -> [J java.lang.String
		 * -> Ljava/lang/String; java.lang.String[] -> [Ljava/lang/String;
		 */
		StringBuffer signature = new StringBuffer();

		int firstBrace = qualifiedName.indexOf('[');
		if (firstBrace < 0) {
			// Not an array type. Must be class type.
			signature.append('L');
			signature.append(qualifiedName.replace('.', '/'));
			signature.append(';');
			return signature.toString();
		}

		int index = 0;
		while ((index = (qualifiedName.indexOf('[', index) + 1)) > 0) {
			signature.append('[');
		}

		String name = qualifiedName.substring(0, firstBrace);
		switch (name.charAt(0)) {
		// Check for primitive array type
		case 'b':
			if (name.equals("byte")) { //$NON-NLS-1$
				signature.append('B');
				return signature.toString();
			} else if (name.equals("boolean")) { //$NON-NLS-1$
				signature.append('Z');
				return signature.toString();
			}
			break;
		case 'i':
			if (name.equals("int")) { //$NON-NLS-1$
				signature.append('I');
				return signature.toString();
			}
			break;
		case 'd':
			if (name.equals("double")) { //$NON-NLS-1$
				signature.append('D');
				return signature.toString();
			}
			break;
		case 's':
			if (name.equals("short")) { //$NON-NLS-1$
				signature.append('S');
				return signature.toString();
			}
			break;
		case 'c':
			if (name.equals("char")) { //$NON-NLS-1$
				signature.append('C');
				return signature.toString();
			}
			break;
		case 'l':
			if (name.equals("long")) { //$NON-NLS-1$
				signature.append('J');
				return signature.toString();
			}
			break;
		case 'f':
			if (name.equals("float")) { //$NON-NLS-1$
				signature.append('F');
				return signature.toString();
			}
			break;
		}
		// Class type array
		signature.append('L');
		signature.append(name.replace('.', '/'));
		signature.append(';');
		return signature.toString();
	}

	/**
	 * Converts a JNI class signature to a name.
	 */
	public static String classSignatureToName(String signature) {
		// L<classname>; : fully-qualified-class
		return signature.substring(1, signature.length() - 1).replace('/', '.');
	}

	/**
	 * Converts a JNI array signature to a name.
	 */
	public static String arraySignatureToName(String signature) {
		// [<type> : array of type <type>
		if (signature.indexOf('[') < 0) {
			return signature;
		}
		StringBuffer name = new StringBuffer();
		String type = signature.substring(signature.lastIndexOf('[') + 1);
		if (type.length() == 1 && isPrimitiveSignature(type)) {
			name.append(getPrimitiveSignatureToName(type.charAt(0)));
		} else {
			name.append(classSignatureToName(type));
		}
		int index = 0;
		while ((index = (signature.indexOf('[', index) + 1)) > 0) {
			name.append('[').append(']');
		}
		return signatureToName(signature.substring(1)) + "[]"; //$NON-NLS-1$
	}

	/**
	 * @returns Returns Type Name, converted from a JNI signature.
	 */
	public static String signatureToName(String signature) {
		// See JNI 1.1 Specification, Table 3-2 Java VM Type Signatures.
		String primitive = getPrimitiveSignatureToName(signature.charAt(0));
		if (primitive != null) {
			return primitive;
		}
		switch (signature.charAt(0)) {
		case 'V':
			return "void"; //$NON-NLS-1$
		case 'L':
			return classSignatureToName(signature);
		case '[':
			return arraySignatureToName(signature);
		case '(':
			throw new InternalError(
					JDIMessages.TypeImpl_Can__t_convert_method_signature_to_name_2);
		}
		throw new InternalError(JDIMessages.TypeImpl_Invalid_signature____10
				+ signature + JDIMessages.TypeImpl___11); //
	}

	private static String getPrimitiveSignatureToName(char signature) {
		switch (signature) {
		case 'Z':
			return "boolean"; //$NON-NLS-1$
		case 'B':
			return "byte"; //$NON-NLS-1$
		case 'C':
			return "char"; //$NON-NLS-1$
		case 'S':
			return "short"; //$NON-NLS-1$
		case 'I':
			return "int"; //$NON-NLS-1$
		case 'J':
			return "long"; //$NON-NLS-1$
		case 'F':
			return "float"; //$NON-NLS-1$
		case 'D':
			return "double"; //$NON-NLS-1$
		default:
			return null;
		}
	}

	/**
	 * @returns Returns Jdwp Tag, converted from a JNI signature.
	 */
	public static byte signatureToTag(String signature) {
		switch (signature.charAt(0)) {
		case 'Z':
			return BooleanValueImpl.tag;
		case 'B':
			return ByteValueImpl.tag;
		case 'C':
			return CharValueImpl.tag;
		case 'S':
			return ShortValueImpl.tag;
		case 'I':
			return IntegerValueImpl.tag;
		case 'J':
			return LongValueImpl.tag;
		case 'F':
			return FloatValueImpl.tag;
		case 'D':
			return DoubleValueImpl.tag;
		case 'V':
			return VoidValueImpl.tag;
		case 'L':
			return ObjectReferenceImpl.tag;
		case '[':
			return ArrayReferenceImpl.tag;
		case '(':
			throw new InternalError(
					JDIMessages.TypeImpl_Can__t_covert_method_signature_to_tag___9
							+ signature);
		}
		throw new InternalError(JDIMessages.TypeImpl_Invalid_signature____10
				+ signature + JDIMessages.TypeImpl___11); //
	}

	/**
	 * @returns Returns true if signature is an primitive signature.
	 */
	public static boolean isPrimitiveSignature(String signature) {
		switch (signature.charAt(0)) {
		case 'Z':
		case 'B':
		case 'C':
		case 'S':
		case 'I':
		case 'J':
		case 'F':
		case 'D':
			return true;
		}
		return false;
	}

	/**
	 * @returns Returns true if signature is void signature.
	 */
	public static boolean isVoidSignature(String signature) {
		return (signature.charAt(0) == 'V');
	}

}