/*********************************************************************
 * Copyright (c) 2009, 2012 SpringSource, a division of VMware, Inc.
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
**********************************************************************/

package org.eclipse.virgo.ide.bundlor.jdt.core;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;

import org.apache.commons.lang.StringUtils;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
import org.eclipse.jdt.core.dom.CastExpression;
import org.eclipse.jdt.core.dom.CatchClause;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.EnumDeclaration;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.IBinding;
import org.eclipse.jdt.core.dom.IMethodBinding;
import org.eclipse.jdt.core.dom.IPackageBinding;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.IVariableBinding;
import org.eclipse.jdt.core.dom.ImportDeclaration;
import org.eclipse.jdt.core.dom.InstanceofExpression;
import org.eclipse.jdt.core.dom.MarkerAnnotation;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.NormalAnnotation;
import org.eclipse.jdt.core.dom.QualifiedName;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.SimpleType;
import org.eclipse.jdt.core.dom.SingleMemberAnnotation;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.virgo.bundlor.support.partialmanifest.PartialManifest;

/**
 * {@link MethodVisitor} that is based on JDT's AST
 * </p>
 * <strong>Concurrent Semantics</strong><br />
 * Not thread safe.
 *
 * @author Christian Dupuis
 * @author Glyn Normington
 */
public class ArtifactAnalyserTypeVisitor extends ASTVisitor {

    private final PartialManifest partialManifest;

    private final Set<String> referencedTypes = new HashSet<String>();

    private String typePackage;

    public ArtifactAnalyserTypeVisitor(PartialManifest model) {
        this.partialManifest = model;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(CastExpression node) {
        recordTypeBinding(node.resolveTypeBinding());
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(CatchClause node) {
        recordTypeBinding(node.getException().getType().resolveBinding());
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(ClassInstanceCreation node) {
        recordTypeBinding(node.resolveTypeBinding());
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(FieldDeclaration node) {
        recordTypeBinding(node.getType().resolveBinding());
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(ImportDeclaration node) {
        if (node.resolveBinding() != null && !node.resolveBinding().isRecovered()) {
            IBinding binding = node.resolveBinding();
            if (binding instanceof IPackageBinding) {
                this.partialManifest.recordReferencedPackage(((IPackageBinding) binding).getName());
            } else if (binding instanceof ITypeBinding) {
                recordTypeBinding((ITypeBinding) binding);
            }
        } else {
            if (!node.isOnDemand() && !node.isStatic()) {
                Name importElementName = node.getName();
                recordFullyQualifiedName(importElementName.getFullyQualifiedName());
            } else if (node.isOnDemand() && !node.isStatic()) {
                Name importElementName = node.getName();
                this.partialManifest.recordReferencedPackage(importElementName.getFullyQualifiedName());
            } else if (!node.isOnDemand() && node.isStatic()) {
                Name importElementName = node.getName();
                String fqn = importElementName.getFullyQualifiedName().substring(0, importElementName.getFullyQualifiedName().lastIndexOf('.'));
                recordFullyQualifiedName(fqn);
            }
        }
        return false;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(InstanceofExpression node) {
        recordTypeBinding(node.getRightOperand().resolveBinding());
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(MarkerAnnotation node) {
        ITypeBinding binding = node.resolveTypeBinding();
        recordTypeBinding(binding);
        this.partialManifest.recordUsesPackage(this.typePackage, getPackageBinding(binding).getName());
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(MethodDeclaration node) {
        IMethodBinding binding = node.resolveBinding();
        if (binding == null) {
            return true;
        }
        // return value
        if (binding.getReturnType() != null) {
            String fqn = binding.getReturnType().getQualifiedName();
            if (!"void".equals(fqn)) {
                recordTypeBinding(binding.getReturnType());
                if (!Modifier.isPrivate(node.getModifiers())) {
                    IPackageBinding packageBinding = getPackageBinding(binding.getReturnType());
                    if (packageBinding != null) {
                        this.partialManifest.recordUsesPackage(this.typePackage, packageBinding.getName());
                    }
                }
            }
        }
        // throws clause
        if (binding.getExceptionTypes() != null) {
            for (ITypeBinding exceptionBinding : binding.getExceptionTypes()) {
                recordTypeBinding(exceptionBinding);
                if (!Modifier.isPrivate(node.getModifiers())) {
                    IPackageBinding packageBinding = getPackageBinding(exceptionBinding);
                    if (packageBinding != null) {
                        this.partialManifest.recordUsesPackage(this.typePackage, packageBinding.getName());
                    }
                }
            }
        }
        // parameter
        if (binding.getParameterTypes() != null) {
            for (ITypeBinding parameterBinding : binding.getParameterTypes()) {
                recordTypeBinding(parameterBinding);
                if (!Modifier.isPrivate(node.getModifiers())) {
                    IPackageBinding packageBinding = getPackageBinding(parameterBinding);
                    if (packageBinding != null) {
                        this.partialManifest.recordUsesPackage(this.typePackage, packageBinding.getName());
                    }
                }
            }
        }

        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(MethodInvocation node) {
        IMethodBinding binding = node.resolveMethodBinding();
        if (binding != null) {
            recordTypeBinding(binding.getDeclaringClass());

            // return value
            if (binding.getReturnType() != null) {
                recordTypeBinding(binding.getReturnType());
            }
            // parameter
            if (binding.getParameterTypes() != null) {
                for (ITypeBinding parameterBinding : binding.getParameterTypes()) {
                    recordTypeBinding(parameterBinding);
                }
            }
        } else {

        }
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(NormalAnnotation node) {
        ITypeBinding binding = node.resolveTypeBinding();
        recordTypeBinding(binding);
        this.partialManifest.recordUsesPackage(this.typePackage, getPackageBinding(binding).getName());
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(QualifiedName node) {
        IBinding binding = node.resolveBinding();

        if (isValid(binding)) {
            // Record the declared type.
            recordTypeBinding(node.resolveTypeBinding());

            // Record the declaring type.
            if (binding.getKind() == IBinding.VARIABLE) {
                recordTypeBinding(((IVariableBinding) binding).getDeclaringClass());
            }
        }
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(SimpleName node) {
        String fqn = node.getFullyQualifiedName();
        recordFullyQualifiedName(fqn);
        return true;
    }

    /**
     * It is important to record the type binding only if it is not recovered. Recovered bindings occur for invalid
     * source code and incomplete class paths.
     *
     * @param binding the binding which may be recorded
     * @return <code>true</code> if and only if the binding should be recorded
     */
    private boolean isValid(IBinding binding) {
        return binding != null && !binding.isRecovered();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(SimpleType node) {
        if (isValid(node.resolveBinding())) {
            recordTypeBinding(node.resolveBinding());
        } else {
            Name simpleName = node.getName();
            String fqn = simpleName.getFullyQualifiedName();
            recordFullyQualifiedName(fqn);
        }
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(SingleMemberAnnotation node) {
        ITypeBinding binding = node.resolveTypeBinding();
        recordTypeBinding(binding);
        this.partialManifest.recordUsesPackage(this.typePackage, getPackageBinding(binding).getName());
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(TypeDeclaration node) {
        ITypeBinding binding = node.resolveBinding();
        if (binding == null) {
            return false;
        }
        String name = binding.getBinaryName();
        this.typePackage = getPackageBinding(binding).getName();

        if (!node.isLocalTypeDeclaration()) {
            this.partialManifest.recordType(name);
        }

        for (String referencedType : this.referencedTypes) {
            recordFullyQualifiedName(referencedType);
        }

        if (node.getSuperclassType() != null) {
            ITypeBinding superClassBinding = node.getSuperclassType().resolveBinding();
            recordTypeBinding(superClassBinding);
            this.partialManifest.recordUsesPackage(this.typePackage, getPackageBinding(superClassBinding).getName());
        }

        for (int i = 0; i < node.superInterfaceTypes().size(); i++) {
            org.eclipse.jdt.core.dom.Type interfaceType = (org.eclipse.jdt.core.dom.Type) node.superInterfaceTypes().get(i);
            ITypeBinding interfaceBinding = interfaceType.resolveBinding();
            recordTypeBinding(interfaceBinding);
            this.partialManifest.recordUsesPackage(this.typePackage, getPackageBinding(interfaceBinding).getName());
        }

        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(AnonymousClassDeclaration node) {
        ITypeBinding binding = node.resolveBinding();
        if (binding == null) {
            return false;
        }
        this.partialManifest.recordType(binding.getBinaryName());

        ITypeBinding superClassBinding = binding.getSuperclass();
        if (superClassBinding != null) {
            recordTypeBinding(superClassBinding);
            this.partialManifest.recordUsesPackage(this.typePackage, getPackageBinding(superClassBinding).getName());
        }

        ITypeBinding[] interfaceBindings = binding.getInterfaces();
        if (interfaceBindings != null) {
            for (ITypeBinding interfaceBinding : interfaceBindings) {
                recordTypeBinding(interfaceBinding);
                this.partialManifest.recordUsesPackage(this.typePackage, getPackageBinding(interfaceBinding).getName());
            }
        }

        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(AnnotationTypeDeclaration node) {
        ITypeBinding binding = node.resolveBinding();
        if (binding == null) {
            return false;
        }

        String name = binding.getBinaryName();
        this.typePackage = getPackageBinding(binding).getName();

        this.partialManifest.recordType(name);
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean visit(EnumDeclaration node) {
        ITypeBinding binding = node.resolveBinding();
        if (binding == null) {
            return false;
        }

        String name = binding.getBinaryName();
        this.typePackage = getPackageBinding(binding).getName();

        this.partialManifest.recordType(name);
        return true;
    }

    private IPackageBinding getPackageBinding(ITypeBinding binding) {
        if (binding != null) {
            if (binding.isArray()) {
                return getPackageBinding(binding.getComponentType());
            } else {
                return binding.getPackage();
            }
        }
        return null;
    }

    private String recordFullyQualifiedName(String fqn) {
        if (!"void".equals(fqn)) {
            if (this.typePackage == null) {
                this.referencedTypes.add(fqn);
                return fqn;
            } else if (fqn != null && !this.typePackage.equals(getPackageName(fqn))) {
                // This is required to get FQCNs of the form
                // org.springframework.util.ReflectionUtils.MethodCallback correctly detected
                StringTokenizer segments = new StringTokenizer(fqn, ".");
                if (segments.countTokens() > 1) {
                    List<String> newSegments = new ArrayList<String>();
                    while (segments.hasMoreTokens()) {
                        String segment = segments.nextToken();
                        newSegments.add(segment);
                        if (!Character.isLowerCase(segment.charAt(0))) {
                            break;
                        }
                    }
                    fqn = StringUtils.join(newSegments, ".");
                }

                this.partialManifest.recordReferencedType(fqn);
                return fqn;
            }
        }
        return "";
    }

    private String getPackageName(String fullyQualifiedTypeName) {
        if (fullyQualifiedTypeName == null) {
            return "";
        }
        int index = fullyQualifiedTypeName.lastIndexOf('.');

        if (index > -1) {
            return fullyQualifiedTypeName.substring(0, index);
        }

        return "";
    }

    private String recordTypeBinding(ITypeBinding binding) {
        if (binding != null) {
            if (binding.isArray()) {
                return recordTypeBinding(binding.getComponentType());
            } else {
                String fqn = binding.getBinaryName();
                return recordFullyQualifiedName(fqn);
            }
        }
        return "";
    }

}