/*
 * Copyright (C) 2016 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 com.android.tools.lint.checks;

import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.tools.lint.client.api.UElementHandler;
import com.android.tools.lint.detector.api.Category;
import com.android.tools.lint.detector.api.Detector;
import com.android.tools.lint.detector.api.Implementation;
import com.android.tools.lint.detector.api.Issue;
import com.android.tools.lint.detector.api.JavaContext;
import com.android.tools.lint.detector.api.Location;
import com.android.tools.lint.detector.api.Scope;
import com.android.tools.lint.detector.api.Severity;
import com.android.tools.lint.detector.api.SourceCodeScanner;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiField;
import com.intellij.psi.PsiJavaCodeReferenceElement;
import com.intellij.psi.PsiMember;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.PsiTypeElement;
import java.util.ArrayList;
import java.util.List;
import org.jetbrains.uast.UElement;
import org.jetbrains.uast.UImportStatement;
import org.jetbrains.uast.UQualifiedReferenceExpression;
import org.jetbrains.uast.UReferenceExpression;
import org.jetbrains.uast.USimpleNameReferenceExpression;
import org.jetbrains.uast.UVariable;

/** Checks for errors related to the Exif Interface */
public class ExifInterfaceDetector extends Detector implements SourceCodeScanner {

    public static final String EXIF_INTERFACE = "ExifInterface";
    public static final String OLD_EXIF_INTERFACE = "android.media.ExifInterface";

    private static final Implementation IMPLEMENTATION =
            new Implementation(ExifInterfaceDetector.class, Scope.JAVA_FILE_SCOPE);

    /** Using android.media.ExifInterface */
    public static final Issue ISSUE =
            Issue.create(
                            "ExifInterface",
                            "Using `android.media.ExifInterface`",
                            "The `android.media.ExifInterface` implementation has some known security "
                                    + "bugs in older versions of Android. There is a new implementation available "
                                    + "of this library in the support library, which is preferable.",
                            Category.CORRECTNESS,
                            6,
                            Severity.WARNING,
                            IMPLEMENTATION)
                    .setAndroidSpecific(true);

    /** Constructs a new {@link ExifInterfaceDetector} */
    public ExifInterfaceDetector() {}

    // ---- implements SourceCodeScanner ----

    private static void fix(
            @NonNull JavaContext context,
            @NonNull UElement reference,
            @NonNull PsiElement referenced) {
        // Can't just check for PsiMember, because we explicitly don't want to include PsiClass
        // (which is also a PsiMember)
        if (referenced instanceof PsiMethod || referenced instanceof PsiField) {
            referenced = ((PsiMember) referenced).getContainingClass();
        }
        if (referenced instanceof PsiClass) {
            String qualifiedName = ((PsiClass) referenced).getQualifiedName();
            if (qualifiedName != null && OLD_EXIF_INTERFACE.equals(qualifiedName)) {
                replace(context, reference);
            }
        }
    }

    private static void replace(@NonNull JavaContext context, @NonNull UElement reference) {
        UElement locationNode = reference;
        //noinspection ConstantConditions
        while (locationNode.getUastParent() instanceof UReferenceExpression) {
            locationNode = locationNode.getUastParent();
        }

        Location location = context.getLocation(locationNode);
        String message = getErrorMessage();
        context.report(ISSUE, reference, location, message);
    }

    private static void replace(@NonNull JavaContext context, @NonNull PsiElement reference) {
        Location location = context.getLocation(reference);
        String message = getErrorMessage();
        context.report(ISSUE, reference, location, message);
    }

    @NonNull
    private static String getErrorMessage() {
        return "Avoid using `android.media.ExifInterface`; use "
                + "`android.support.media.ExifInterface` from the support library instead";
    }

    @Override
    public List<Class<? extends UElement>> getApplicableUastTypes() {
        List<Class<? extends UElement>> types = new ArrayList<>(3);
        types.add(UQualifiedReferenceExpression.class);
        types.add(UImportStatement.class);
        types.add(UVariable.class);
        return types;
    }

    @Nullable
    @Override
    public UElementHandler createUastHandler(@NonNull JavaContext context) {
        return new MyVisitor(context);
    }

    private static final class MyVisitor extends UElementHandler {

        private final JavaContext context;

        private MyVisitor(JavaContext context) {
            this.context = context;
        }

        @Override
        public void visitQualifiedReferenceExpression(@NonNull UQualifiedReferenceExpression node) {
            UElement selector = node.getSelector();
            if (selector instanceof USimpleNameReferenceExpression) {
                USimpleNameReferenceExpression name = (USimpleNameReferenceExpression) selector;
                if (EXIF_INTERFACE.equals(name.getIdentifier())) {
                    PsiElement resolved = node.resolve();
                    if (resolved != null) {
                        fix(context, node, resolved);
                    }
                }
            }
        }

        @Override
        public void visitImportStatement(@NonNull UImportStatement node) {
            // We don't get UQualifiedReferenceExpressions for import statements so
            // visit these separately
            UElement importReference = node.getImportReference();
            if (importReference != null) {
                PsiElement resolved = node.resolve();
                // Can't just check PsiMember because we don't want to include PsiClass which
                // is also a PsiMember
                if (resolved instanceof PsiField) {
                    resolved = ((PsiField) resolved).getContainingClass();
                } else if (resolved instanceof PsiMethod) {
                    resolved = ((PsiMethod) resolved).getContainingClass();
                }
                if (resolved instanceof PsiClass) {
                    PsiClass cls = (PsiClass) resolved;
                    if (EXIF_INTERFACE.equals(cls.getName())
                            && OLD_EXIF_INTERFACE.equals(cls.getQualifiedName())) {
                        fix(context, importReference, resolved);
                    }
                }
            }
        }

        @Override
        public void visitVariable(@NonNull UVariable node) {
            // We don't get UQualifiedReferenceExpressions for fully qualified type
            // references in variable declarations, so visit these separately

            // PSI workaround: node.getTypeReference just returns null. Operate on PSI
            // type element instead for now since UVariable has a PSI getTypeElement
            // accessor.
            PsiTypeElement typeElement = node.getTypeElement();
            if (typeElement != null) {
                PsiJavaCodeReferenceElement referenceElement =
                        typeElement.getInnermostComponentReferenceElement();
                if (referenceElement != null
                        && EXIF_INTERFACE.equals(referenceElement.getReferenceName())
                        && OLD_EXIF_INTERFACE.equals(referenceElement.getText())) {
                    replace(context, referenceElement);
                }
            }
        }
    }
}