/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package signature.converter.dex;

import static signature.converter.dex.DexUtil.convertAnyWay;
import static signature.converter.dex.DexUtil.declaresExceptions;
import static signature.converter.dex.DexUtil.declaresMemberClasses;
import static signature.converter.dex.DexUtil.findPackageInfo;
import static signature.converter.dex.DexUtil.getClassModifiers;
import static signature.converter.dex.DexUtil.getClassName;
import static signature.converter.dex.DexUtil.getDefaultMappingsAnnotation;
import static signature.converter.dex.DexUtil.getDexName;
import static signature.converter.dex.DexUtil.getEnclosingClassName;
import static signature.converter.dex.DexUtil.getExceptionSignature;
import static signature.converter.dex.DexUtil.getGenericSignature;
import static signature.converter.dex.DexUtil.getKind;
import static signature.converter.dex.DexUtil.getMemberClassNames;
import static signature.converter.dex.DexUtil.getModifier;
import static signature.converter.dex.DexUtil.getPackageName;
import static signature.converter.dex.DexUtil.getQualifiedName;
import static signature.converter.dex.DexUtil.hasAnnotationDefaultSignature;
import static signature.converter.dex.DexUtil.hasGenericSignature;
import static signature.converter.dex.DexUtil.isAnnotation;
import static signature.converter.dex.DexUtil.isConstructor;
import static signature.converter.dex.DexUtil.isEnclosingClass;
import static signature.converter.dex.DexUtil.isEnum;
import static signature.converter.dex.DexUtil.isInternalAnnotation;
import static signature.converter.dex.DexUtil.isJavaLangObject;
import static signature.converter.dex.DexUtil.isMethod;
import static signature.converter.dex.DexUtil.isVisible;
import static signature.converter.dex.DexUtil.splitTypeList;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import signature.converter.Visibility;
import signature.model.IAnnotation;
import signature.model.IAnnotationElement;
import signature.model.IAnnotationField;
import signature.model.IClassDefinition;
import signature.model.IClassReference;
import signature.model.IConstructor;
import signature.model.IEnumConstant;
import signature.model.IField;
import signature.model.IMethod;
import signature.model.IPackage;
import signature.model.IParameter;
import signature.model.ITypeReference;
import signature.model.ITypeVariableDefinition;
import signature.model.Kind;
import signature.model.Modifier;
import signature.model.impl.SigAnnotation;
import signature.model.impl.SigAnnotationElement;
import signature.model.impl.SigAnnotationField;
import signature.model.impl.SigApi;
import signature.model.impl.SigClassDefinition;
import signature.model.impl.SigClassReference;
import signature.model.impl.SigConstructor;
import signature.model.impl.SigEnumConstant;
import signature.model.impl.SigExecutableMember;
import signature.model.impl.SigField;
import signature.model.impl.SigMethod;
import signature.model.impl.SigPackage;
import signature.model.impl.SigParameter;
import signature.model.impl.Uninitialized;
import signature.model.util.TypePool;
import dex.structure.DexAnnotation;
import dex.structure.DexAnnotationAttribute;
import dex.structure.DexClass;
import dex.structure.DexEncodedAnnotation;
import dex.structure.DexEncodedValue;
import dex.structure.DexField;
import dex.structure.DexFile;
import dex.structure.DexMethod;
import dex.structure.DexParameter;

/**
 * Converts a set of dex files to the signature compare api.
 */
public final class DexToSigConverter implements IClassInitializer {

    private final FieldPool elementPool;
    private final TypePool factory;
    private static final Set<IField> EMPTY_FIELDS = Collections.emptySet();
    private static final Set<IEnumConstant> EMPTY_ENUM_CONSTANTS = Collections
            .emptySet();
    private static final Set<IAnnotationField> EMPTY_ANNOTATION_FIELDS =
            Collections.emptySet();
    private static final List<ITypeVariableDefinition> EMPTY_TYPE_VARIABLES =
            Collections.emptyList();
    private static final Set<IClassDefinition> EMPTY_INNER_CLASSES =
            Collections.emptySet();
    private static final Set<ITypeReference> EMPTY_EXCEPTIONS = Collections
            .emptySet();
    private Visibility visibility;
    private Map<String, DexClass> dexNameToDexClass;


    /**
     * Creates a new instance of {@link DexToSigConverter}.
     */
    public DexToSigConverter() {
        factory = new TypePool();
        elementPool = new FieldPool();
    }


    public SigApi convertApi(String apiName, Set<DexFile> dexFiles,
            Visibility visibility) {
        this.visibility = visibility;
        SigApi api = new SigApi(apiName, visibility);
        api.setPackages(convertPackages(dexFiles));
        factory.replaceAllUninitialiezWithNull();
        return api;
    }

    /**
     * Converts the given {@link DexFile}s into the corresponding (packages
     * including their (classes and their members, etc.))E
     * 
     * @param parsedFiles
     *            the dex files to convert
     * @return the converted packages
     */
    /* package */Set<IPackage> convertPackages(Set<DexFile> parsedFiles) {
        Map<String, SigPackage> packageNameToPackage =
                new HashMap<String, SigPackage>();
        Map<SigPackage, Set<DexClass>> packageToDexClasses =
                new HashMap<SigPackage, Set<DexClass>>();

        dexNameToDexClass = new HashMap<String, DexClass>();

        for (DexFile dexFile : parsedFiles) {
            List<DexClass> definedClasses = dexFile.getDefinedClasses();
            for (DexClass dexClass : definedClasses) {

                dexNameToDexClass.put(dexClass.getName(), dexClass);

                String dexName = dexClass.getName();
                String packageName = getPackageName(dexName);
                SigPackage aPackage = packageNameToPackage.get(packageName);
                if (aPackage == null) {
                    aPackage = convertPackage(packageName);
                    packageNameToPackage.put(packageName, aPackage);

                    Set<DexClass> classes = new HashSet<DexClass>();
                    packageToDexClasses.put(aPackage, classes);
                }
                Set<DexClass> classes = packageToDexClasses.get(aPackage);
                classes.add(dexClass);
            }
        }

        Set<SigClassDefinition> allClasses = new HashSet<SigClassDefinition>();

        for (SigPackage aPackage : packageToDexClasses.keySet()) {
            Set<SigClassDefinition> classes = convertClasses(packageToDexClasses
                    .get(aPackage));
            allClasses.addAll(classes);
            aPackage.setClasses(new HashSet<IClassDefinition>(classes));
        }

        // remove package info
        for (SigPackage aPackage : packageToDexClasses.keySet()) {
            IClassDefinition packageInfo = findPackageInfo(aPackage);
            if (packageInfo != null) {
                aPackage.setAnnotations(packageInfo.getAnnotations());
                aPackage.getClasses().remove(packageInfo);
            }
        }

        // link enclosed classes only if they are part of visible api
        for (SigClassDefinition sigClass : allClasses) {
            String dexName = getDexName(sigClass);
            DexClass dexClass = dexNameToDexClass.get(dexName);

            if (declaresMemberClasses(dexClass)) {
                Set<String> enclosedClassesNames =
                        getMemberClassNames(dexClass);
                Set<IClassDefinition> memberClasses =
                        new HashSet<IClassDefinition>();
                for (String enclosedClassName : enclosedClassesNames) {
                    SigClassDefinition memberClass = factory.getClass(
                            getPackageName(enclosedClassName),
                            getClassName(enclosedClassName));
                    // add inner class only if parsed
                    if (allClasses.contains(memberClass)) {
                        memberClasses.add(memberClass);
                    }
                }
                sigClass.setInnerClasses(memberClasses);
            } else {
                sigClass.setInnerClasses(EMPTY_INNER_CLASSES);
            }
        }

        // remove inner classes, is outer class is not visible
        for (SigClassDefinition sigClass : allClasses) {
            if (hasInvisibleParent(sigClass, dexNameToDexClass)) {
                SigPackage sigPackage = packageNameToPackage.get(sigClass
                        .getPackageName());
                sigPackage.getClasses().remove(sigClass);
            }
        }
        return new HashSet<IPackage>(packageToDexClasses.keySet());
    }

    private boolean hasInvisibleParent(IClassDefinition sigClass,
            Map<String, DexClass> dexNameToDexClass) {

        do {
            String dexName = getDexName(sigClass);
            DexClass dexClass = dexNameToDexClass.get(dexName);
            if (isEnclosingClass(dexClass)) {
                IClassDefinition declaringClass = sigClass.getDeclaringClass();
                DexClass declaringDexClass = dexNameToDexClass
                        .get(getDexName(declaringClass));
                if (!isVisible(declaringDexClass, visibility)) {
                    return true;
                }
            }
        } while ((sigClass = sigClass.getDeclaringClass()) != null);
        return false;
    }

    /**
     * Converts a simple string to the corresponding {@link SigPackage}.<br>
     * Format: "a.b.c"
     * 
     * @param packageName
     *            the name of the package
     * @return the package
     */
    protected SigPackage convertPackage(String packageName) {
        SigPackage sigPackage = new SigPackage(packageName);
        return sigPackage;
    }

    /**
     * Converts a set of {@link DexClass} objects to a set of the corresponding
     * {@link SigClassDefinition} objects.
     * 
     * @param dexClasses
     *            the {@link DexClass} objects
     * @return a set of {@link DexClass} objects
     */
    protected Set<SigClassDefinition> convertClasses(Set<DexClass> dexClasses) {
        Set<SigClassDefinition> classes = new HashSet<SigClassDefinition>();
        for (DexClass dexClass : dexClasses) {
            // convert all classes but synthetic, return only initialized
            if (convertAnyWay(dexClass)) {
                SigClassDefinition sigCLass = convertClass(dexClass);
                if (isVisible(dexClass, visibility)) {
                    classes.add(sigCLass);
                }
            }
        }
        return classes;
    }

    /**
     * Converts a {@link DexClass} to the corresponding
     * {@link SigClassDefinition}.
     * 
     * @param dexClass
     *            the {@link DexClass} to convert
     * @return the corresponding {@link SigClassDefinition}
     */
    protected SigClassDefinition convertClass(DexClass dexClass) {
        assert dexClass != null;

        String packageName = getPackageName(dexClass.getName());
        String className = getClassName(dexClass.getName());
        SigClassDefinition sigClass = factory.getClass(packageName, className);
        // Kind
        sigClass.setKind(getKind(dexClass));
        // modifiers
        Set<Modifier> modifiers = getModifier(getClassModifiers(dexClass));
        sigClass.setModifiers(modifiers);

        if (isEnclosingClass(dexClass)) {
            String declaringClassDexName = getEnclosingClassName(dexClass);
            declaringClassDexName = getClassName(declaringClassDexName);
            // declaring class is in same package
            sigClass.setDeclaringClass(factory.getClass(sigClass
                    .getPackageName(), declaringClassDexName));
        } else {
            sigClass.setDeclaringClass(null);
        }

        if (hasGenericSignature(dexClass)) {
            GenericSignatureParser parser = new GenericSignatureParser(factory,
                    this);
            parser.parseForClass(sigClass, getGenericSignature(dexClass));
            sigClass.setTypeParameters(parser.formalTypeParameters);

            if (Kind.INTERFACE.equals(sigClass.getKind())) {
                sigClass.setSuperClass(null);
            } else {
                sigClass.setSuperClass(parser.superclassType);
            }

            sigClass.setInterfaces(new HashSet<ITypeReference>(
                    parser.interfaceTypes));
        } else {

            // Type parameters
            sigClass.setTypeParameters(EMPTY_TYPE_VARIABLES);

            // java.lang.Object has no super class
            if (isJavaLangObject(dexClass)) {
                sigClass.setSuperClass(null);
            } else {

                if (Kind.INTERFACE.equals(sigClass.getKind())
                        || Kind.ANNOTATION.equals(sigClass.getKind())) {
                    sigClass.setSuperClass(null);
                } else {
                    String superClassPackageName = getPackageName(dexClass
                            .getSuperClass());
                    String superClassName = getClassName(dexClass
                            .getSuperClass());
                    sigClass.setSuperClass(factory.getClassReference(
                            superClassPackageName, superClassName));
                }
            }

            List<String> interfaceDexNames = dexClass.getInterfaces();
            Set<ITypeReference> interfaces = new HashSet<ITypeReference>();
            for (String interfaceDexName : interfaceDexNames) {
                String interfacePackageName = getPackageName(interfaceDexName);
                String interfaceName = getClassName(interfaceDexName);
                SigClassDefinition interfaze = factory.getClass(
                        interfacePackageName, interfaceName);
                interfaze.setKind(Kind.INTERFACE);
                interfaces.add(new SigClassReference(interfaze));
            }
            sigClass.setInterfaces(interfaces);
        }

        // constructors
        Set<SigConstructor> constructors = convertConstructors(dexClass
                .getMethods());
        for (SigConstructor constructor : constructors) {
            constructor.setDeclaringClass(sigClass);
        }
        sigClass.setConstructors(new HashSet<IConstructor>(constructors));

        // methods
        Set<SigMethod> methods = Collections.emptySet();


        if (isAnnotation(dexClass)) {
            Map<String, Object> mappings = getDefaultValueMapping(dexClass);
            Set<SigAnnotationField> annotationFields = convertAnnotationFields(
                    dexClass.getMethods(), mappings);
            sigClass.setAnnotationFields(new HashSet<IAnnotationField>(
                    annotationFields));
            addAnnotationsToAnnotationFields(dexClass.getMethods(),
                    annotationFields);

            sigClass.setEnumConstants(EMPTY_ENUM_CONSTANTS);
            sigClass.setFields(EMPTY_FIELDS);

            // sigClass.setAnnotationFields(new
            // HashSet<IAnnotationField>(convertAnnotationFields(dexClass)));
        } else if (isEnum(dexClass)) {
            Set<IField> fields = new HashSet<IField>();
            Set<IEnumConstant> enumConstants = new HashSet<IEnumConstant>();

            for (DexField dexField : dexClass.getFields()) {
                if (isVisible(dexField, visibility)) {
                    if (dexField.isEnumConstant()) {
                        enumConstants.add(convertEnumConstant(dexField));
                    } else {
                        fields.add(convertField(dexField));
                    }
                }
            }

            sigClass.setFields(fields);
            sigClass.setEnumConstants(enumConstants);
            sigClass.setAnnotationFields(EMPTY_ANNOTATION_FIELDS);
            methods = convertMethods(dexClass.getMethods());
        } else {
            // fields
            sigClass.setFields(new HashSet<IField>(convertFields(dexClass
                    .getFields())));
            sigClass.setEnumConstants(EMPTY_ENUM_CONSTANTS);
            sigClass.setAnnotationFields(EMPTY_ANNOTATION_FIELDS);
            methods = convertMethods(dexClass.getMethods());
        }

        for (SigMethod method : methods) {
            method.setDeclaringClass(sigClass);
        }
        sigClass.setMethods(new HashSet<IMethod>(methods));

        // Annotations
        sigClass.setAnnotations(convertAnnotations(dexClass.getAnnotations()));

        return sigClass;
    }

    @SuppressWarnings("unchecked")
    private Map<String, Object> getDefaultValueMapping(DexClass dexClass) {
        HashMap<String, Object> mappings = new HashMap<String, Object>();
        if (hasAnnotationDefaultSignature(dexClass)) {
            // read mapping to defaults from annotation
            DexAnnotation annotation = getDefaultMappingsAnnotation(dexClass);
            DexAnnotationAttribute dexAnnotationAttribute = annotation
                    .getAttributes().get(0);
            if ("value".equals(dexAnnotationAttribute.getName())) {
                DexEncodedValue encodedValue = dexAnnotationAttribute
                        .getEncodedValue();
                DexEncodedValue value = (DexEncodedValue) encodedValue
                        .getValue();
                List<DexAnnotationAttribute> defaults = 
                        (List<DexAnnotationAttribute>) value.getValue();
                for (DexAnnotationAttribute defaultAttribute : defaults) {
                    mappings.put(defaultAttribute.getName(),
                            convertEncodedValue(defaultAttribute
                                    .getEncodedValue()));
                }
            }
        }
        return mappings;
    }


    private void addAnnotationsToAnnotationFields(List<DexMethod> methods,
            Set<SigAnnotationField> annotationFields) {
        Map<String, SigAnnotationField> nameToAnnotationField =
                new HashMap<String, SigAnnotationField>();

        for (SigAnnotationField annotationField : annotationFields) {
            nameToAnnotationField.put(annotationField.getName(),
                    annotationField);
        }

        for (DexMethod method : methods) {
            SigAnnotationField annotationField = nameToAnnotationField
                    .get(method.getName());
            annotationField.setAnnotations(convertAnnotations(method
                    .getAnnotations()));
        }
    }


    private Set<SigAnnotationField> convertAnnotationFields(
            List<DexMethod> list, Map<String, Object> mappings) {
        Set<SigAnnotationField> annotationfields =
                new HashSet<SigAnnotationField>();
        for (DexMethod dexMethod : list) {
            if (isVisible(dexMethod, visibility)) {
                annotationfields.add(convertAnnotationField(dexMethod, mappings
                        .get(dexMethod.getName())));
            }
        }
        return annotationfields;
    }

    private SigAnnotationField convertAnnotationField(DexMethod dexMethod,
            Object defaultValue) {
        SigAnnotationField annotationField = new SigAnnotationField(dexMethod
                .getName());
        annotationField.setDefaultValue(defaultValue);
        annotationField.setModifiers(getModifier(dexMethod.getModifiers()));
        GenericSignatureParser parser = new GenericSignatureParser(factory,
                this);
        annotationField.setType(parser.parseNonGenericType(dexMethod
                .getReturnType()));
        return annotationField;
    }

    private IEnumConstant convertEnumConstant(DexField dexField) {
        String qualifiedTypeName = getQualifiedName(dexField
                .getDeclaringClass().getName());
        SigEnumConstant enumConstant = elementPool.getEnumConstant(
                qualifiedTypeName, dexField.getName());
        Set<Modifier> modifiers = getModifier(dexField.getModifiers());
        modifiers.add(Modifier.STATIC);
        enumConstant.setModifiers(modifiers);

        String typePackageName = getPackageName(dexField.getType());
        String typeName = getClassName(dexField.getType());
        enumConstant.setType(factory.getClassReference(typePackageName,
                typeName));
        enumConstant.setAnnotations(convertAnnotations(dexField
                .getAnnotations()));
        return enumConstant;
    }

    private Set<SigField> convertFields(List<DexField> dexFields) {
        Set<SigField> fields = new HashSet<SigField>();
        for (DexField dexField : dexFields) {
            if (isVisible(dexField, visibility)) {
                fields.add(convertField(dexField));
            }
        }
        return fields;
    }

    private SigField convertField(DexField dexField) {
        String qualTypeName = getQualifiedName(dexField.getDeclaringClass()
                .getName());
        SigField field = elementPool.getField(qualTypeName, dexField.getName());

        field.setModifiers(getModifier(dexField.getModifiers()));

        field.setAnnotations(convertAnnotations(dexField.getAnnotations()));

        if (hasGenericSignature(dexField)) {
            GenericSignatureParser parser = new GenericSignatureParser(factory,
                    this);
            String declaringClassPackageName = getPackageName(dexField
                    .getDeclaringClass().getName());
            String declaringClassName = getClassName(dexField
                    .getDeclaringClass().getName());

            parser.parseForField(factory.getClass(declaringClassPackageName,
                    declaringClassName), getGenericSignature(dexField));
            field.setType(parser.fieldType);
        } else {
            GenericSignatureParser parser = new GenericSignatureParser(factory,
                    this);
            field.setType(parser.parseNonGenericType(dexField.getType()));
        }

        return field;
    }

    /**
     * Converts a set of {@link DexMethod} to a set of corresponding
     * {@link IConstructor}. This method ignores methods which are not
     * constructors.
     * 
     * @param methods
     *            the {@link DexMethod}s to convert
     * @return the corresponding {@link IConstructor}s
     */
    private Set<SigConstructor> convertConstructors(List<DexMethod> methods) {
        Set<SigConstructor> constructors = new HashSet<SigConstructor>();
        for (DexMethod method : methods) {
            if (isConstructor(method) && isVisible(method, visibility)) {
                constructors.add(convertConstructor(method));
            }
        }
        return constructors;
    }

    /**
     * Converts a set of {@link DexMethod} to a set of corresponding
     * {@link DexMethod}. This method ignores methods which are constructors.
     * 
     * @param methods
     *            the {@link DexMethod}s to convert
     * @return the corresponding {@link IConstructor}s
     */
    private Set<SigMethod> convertMethods(List<DexMethod> methods) {
        Set<SigMethod> sigMethods = new HashSet<SigMethod>();
        for (DexMethod method : methods) {
            if (isMethod(method) && isVisible(method, visibility)) {
                sigMethods.add(convertMethod(method));
            }
        }
        return sigMethods;
    }

    /**
     * Converts a dexMethod which must be a constructor to the corresponding
     * {@link SigConstructor} instance.
     * 
     * @param dexMethod
     *            the dex constructor to convert
     * @return the corresponding {@link SigConstructor}
     */
    public SigConstructor convertConstructor(DexMethod dexMethod) {
        String declaringClassName = getClassName(dexMethod.getDeclaringClass()
                .getName());

        SigConstructor constructor = new SigConstructor(declaringClassName);
        constructor.setModifiers(getModifier(dexMethod.getModifiers()));
        String declaringClassPackageName = getPackageName(dexMethod
                .getDeclaringClass().getName());


        SigClassDefinition declaringClass = factory.getClass(
                declaringClassPackageName, declaringClassName);
        constructor.setDeclaringClass(declaringClass);

        // Annotations
        constructor.setAnnotations(convertAnnotations(dexMethod
                .getAnnotations()));

        if (hasGenericSignature(dexMethod)) {
            GenericSignatureParser parser = new GenericSignatureParser(factory,
                    this);
            parser.parseForConstructor(constructor,
                    getGenericSignature(dexMethod));

            // type parameters
            constructor.setTypeParameters(parser.formalTypeParameters);

            // parameters
            // generic parameter types parameters
            List<DexParameter> dexParameters = dexMethod.getParameters();
            List<IParameter> parameters = new ArrayList<IParameter>(
                    parser.parameterTypes.size());
            Iterator<DexParameter> iterator = dexParameters.iterator();
            for (ITypeReference parameterType : parser.parameterTypes) {
                SigParameter parameter = new SigParameter(parameterType);
                iterator.hasNext();
                DexParameter dexParam = iterator.next();
                parameter.setAnnotations(convertAnnotations(dexParam
                        .getAnnotations()));
                parameters.add(parameter);
            }

            constructor.setParameters(parameters);

            // exceptions
            constructor.setExceptions(new HashSet<ITypeReference>(
                    parser.exceptionTypes));

        } else {
            convertNonGenericExecutableMember(constructor, dexMethod);

            // remove first parameter of non static inner class constructors
            // implicit outer.this reference
            if (declaringClass.getDeclaringClass() != null) {
                if (!declaringClass.getModifiers().contains(Modifier.STATIC)) {
                    if (constructor.getParameters().isEmpty()) {
                        throw new IllegalStateException(
                                "Expected at least one parameter!");
                    }
                    IParameter first = constructor.getParameters().remove(0);
                    String enclosingName = declaringClass.getDeclaringClass()
                            .getName();
                    String firstParameterTypeName = ((IClassReference) first
                            .getType()).getClassDefinition().getName();
                    if (!enclosingName.equals(firstParameterTypeName))
                        throw new IllegalStateException(
                                "Expected first constructor parameter of type "
                                        + enclosingName);
                }
            }
        }

        addExceptions(constructor, dexMethod);
        return constructor;
    }

    public SigMethod convertMethod(DexMethod dexMethod) {
        SigMethod method = new SigMethod(dexMethod.getName());
        method.setModifiers(getModifier(dexMethod.getModifiers()));

        String declaringClassPackageName = getPackageName(dexMethod
                .getDeclaringClass().getName());
        String declaringClassName = getClassName(dexMethod.getDeclaringClass()
                .getName());

        method.setDeclaringClass(factory.getClass(declaringClassPackageName,
                declaringClassName));

        // Annotations
        method.setAnnotations(convertAnnotations(dexMethod.getAnnotations()));

        if (hasGenericSignature(dexMethod)) {
            GenericSignatureParser parser = new GenericSignatureParser(factory,
                    this);
            parser.parseForMethod(method, getGenericSignature(dexMethod));

            // type parameters
            method.setTypeParameters(parser.formalTypeParameters);

            // generic parameter types parameters
            List<DexParameter> dexParameters = dexMethod.getParameters();
            List<IParameter> parameters = new ArrayList<IParameter>(
                    parser.parameterTypes.size());
            Iterator<DexParameter> iterator = dexParameters.iterator();
            for (ITypeReference parameterType : parser.parameterTypes) {
                SigParameter parameter = new SigParameter(parameterType);
                iterator.hasNext();
                DexParameter dexParam = iterator.next();
                parameter.setAnnotations(convertAnnotations(dexParam
                        .getAnnotations()));
                parameters.add(parameter);
            }
            method.setParameters(parameters);

            // exceptions
            method.setExceptions(new HashSet<ITypeReference>(
                    parser.exceptionTypes));
            method.setReturnType(parser.returnType);

        } else {
            convertNonGenericExecutableMember(method, dexMethod);
            GenericSignatureParser parser = new GenericSignatureParser(factory,
                    this);
            ITypeReference type = parser.parseNonGenericReturnType(dexMethod
                    .getReturnType());
            method.setReturnType(type);
        }
        addExceptions(method, dexMethod);
        return method;
    }

    private void addExceptions(SigExecutableMember member,
            DexMethod dexMethod) {
        if (declaresExceptions(dexMethod)) {
            String exceptionSignature = getExceptionSignature(dexMethod);
            Set<String> exceptionTypeNames = splitTypeList(exceptionSignature);
            Set<ITypeReference> exceptions = new HashSet<ITypeReference>();

            for (String exTypeName : exceptionTypeNames) {
                String packageName = getPackageName(exTypeName);
                String className = getClassName(exTypeName);
                exceptions.add(factory
                        .getClassReference(packageName, className));
            }
            member.setExceptions(exceptions);
        } else {
            member.setExceptions(EMPTY_EXCEPTIONS);
        }
    }

    private void convertNonGenericExecutableMember(SigExecutableMember member,
            DexMethod dexMethod) {
        List<DexParameter> dexParameters = dexMethod.getParameters();
        List<IParameter> parameters = new ArrayList<IParameter>(dexParameters
                .size());

        for (DexParameter dexParameter : dexParameters) {
            GenericSignatureParser parser = new GenericSignatureParser(factory,
                    this);
            ITypeReference type = parser.parseNonGenericType(dexParameter
                    .getTypeName());
            SigParameter parameter = new SigParameter(type);
            parameters.add(parameter);
            // Annotations
            parameter.setAnnotations(convertAnnotations(dexParameter
                    .getAnnotations()));
        }
        member.setParameters(parameters);

        member.setTypeParameters(EMPTY_TYPE_VARIABLES);

        // if (declaresExceptions(dexMethod)) {
        // String exceptionSignature = getExceptionSignature(dexMethod);
        // Set<String> exceptionTypeNames = splitTypeList(exceptionSignature);
        // Set<IType> exceptions = new HashSet<IType>();
        //
        // for (String exTypeName : exceptionTypeNames) {
        // String packageName = getPackageName(exTypeName);
        // String className = getClassName(exTypeName);
        // exceptions.add(factory.getClass(packageName, className));
        // }
        // member.setExceptions(exceptions);
        // } else {
        // member.setExceptions(EMPTY_EXCEPTIONS);
        // }
    }

    /**
     * Converts a set of {@link DexAnnotation} to a set of corresponding
     * {@link SigAnnotation}.
     * 
     * @param dexAnnotations
     *            the {@link DexAnnotation}s to convert
     * @return the corresponding {@link SigAnnotation}s
     */
    private Set<IAnnotation> convertAnnotations(
            Set<DexAnnotation> dexAnnotations) {
        Set<IAnnotation> annotations = new HashSet<IAnnotation>();
        for (DexAnnotation dexAnnotation : dexAnnotations) {
            if (!isInternalAnnotation(dexAnnotation)) {
                annotations.add(convertAnnotation(dexAnnotation));
            }
        }
        return annotations;
    }

    /**
     * Converts a {@link DexAnnotation} to the corresponding
     * {@link SigAnnotation}.
     * 
     * @param dexAnnotation
     *            the {@link DexAnnotation} to convert
     * @return the corresponding {@link SigAnnotation}
     */
    protected SigAnnotation convertAnnotation(DexAnnotation dexAnnotation) {
        SigAnnotation sigAnnotation = new SigAnnotation();
        String packageName = getPackageName(dexAnnotation.getTypeName());
        String className = getClassName(dexAnnotation.getTypeName());
        sigAnnotation
                .setType(factory.getClassReference(packageName, className));
        sigAnnotation.setElements(convertAnnotationElements(dexAnnotation
                .getAttributes()));
        return sigAnnotation;
    }

    private Set<IAnnotationElement> convertAnnotationElements(
            List<DexAnnotationAttribute> attributes) {
        Set<IAnnotationElement> annotationAttributes =
                new HashSet<IAnnotationElement>();
        for (DexAnnotationAttribute dexAnnotationAttribute : attributes) {
            annotationAttributes
                    .add(convertAnnotationAttribute(dexAnnotationAttribute));
        }
        return annotationAttributes;
    }

    private IAnnotationElement convertAnnotationAttribute(
            DexAnnotationAttribute dexAnnotationAttribute) {

        SigAnnotationElement sigElement = new SigAnnotationElement();
        String nameOfField = dexAnnotationAttribute.getName();


        String typeName = dexAnnotationAttribute.getAnnotation().getTypeName();
        SigClassDefinition annotationClass = factory.getClass(
                getPackageName(typeName), getClassName(typeName));
        if (!Uninitialized.isInitialized(
                annotationClass.getAnnotationFields())) {
            initializeClass(getPackageName(typeName), getClassName(typeName));
        }
        for (IAnnotationField field : annotationClass.getAnnotationFields()) {
            if (nameOfField.equals(field.getName())) {
                sigElement.setDeclaringField(field);
            }
        }

        sigElement.setValue(convertEncodedValue(dexAnnotationAttribute
                .getEncodedValue()));
        return sigElement;
    }

    @SuppressWarnings("unchecked")
    private Object convertEncodedValue(DexEncodedValue dexEnodedValue) {
        Object value = null;
        switch (dexEnodedValue.getType()) {
        case VALUE_INT:
        case VALUE_BOOLEAN:
        case VALUE_BYTE:
        case VALUE_CHAR:
        case VALUE_DOUBLE:
        case VALUE_FLOAT:
        case VALUE_LONG:
        case VALUE_NULL:
        case VALUE_STRING:
        case VALUE_SHORT:
            value = dexEnodedValue.getValue();
            break;
        case VALUE_ARRAY: {
            List<DexEncodedValue> dexValues =
                    (List<DexEncodedValue>) dexEnodedValue.getValue();
            Object[] arrayValues = new Object[dexValues.size()];
            int i = 0;
            for (DexEncodedValue dexValue : dexValues) {
                arrayValues[i++] = convertEncodedValue(dexValue);
            }
            value = arrayValues;
            break;
        }
        case VALUE_ANNOTATION: {
            DexEncodedAnnotation annotation =
                    (DexEncodedAnnotation) dexEnodedValue.getValue();
            SigAnnotation sigAnnotation = new SigAnnotation();
            String packageName = getPackageName(annotation.getTypeName());
            String className = getClassName(annotation.getTypeName());
            sigAnnotation.setType(factory.getClassReference(packageName,
                    className));

            sigAnnotation.setElements(convertAnnotationElements(annotation
                    .getValue()));
            value = sigAnnotation;
            break;
        }
        case VALUE_FIELD: {
            String fieldDesc = (String) dexEnodedValue.getValue();
            // FORMAT La/b/E;!CONSTANT
            String[] typeAndFieldName = fieldDesc.split("!");
            String typeName = typeAndFieldName[0];
            String fieldName = typeAndFieldName[1];
            value = elementPool.getField(getQualifiedName(typeName), fieldName);
            break;
        }
        case VALUE_ENUM: {
            String fieldDesc = (String) dexEnodedValue.getValue();
            // FORMAT La/b/E;!CONSTANT
            String[] typeAndFieldName = fieldDesc.split("!");
            String typeName = typeAndFieldName[0];
            String fieldName = typeAndFieldName[1];
            value = elementPool.getEnumConstant(getQualifiedName(typeName),
                    fieldName);
            break;
        }
        case VALUE_TYPE: {
            String typeName = (String) dexEnodedValue.getValue();
            GenericSignatureParser parser = new GenericSignatureParser(factory,
                    this);
            value = parser.parseNonGenericReturnType(typeName);
            break;
        }
        default:
            throw new IllegalStateException();
        }
        return value;
    }

    public IClassDefinition initializeClass(String packageName,
            String className) {
        String dexName = getDexName(packageName, className);
        DexClass dexClass = dexNameToDexClass.get(dexName);
        return convertClass(dexClass);
    }
}