/*
 * Copyright (C) 2012, 2017 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 static com.android.SdkConstants.ANDROID_URI;
import static com.android.SdkConstants.ATTR_DRAWABLE_END;
import static com.android.SdkConstants.ATTR_DRAWABLE_LEFT;
import static com.android.SdkConstants.ATTR_DRAWABLE_RIGHT;
import static com.android.SdkConstants.ATTR_DRAWABLE_START;
import static com.android.SdkConstants.ATTR_GRAVITY;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_END;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_LEFT;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_PARENT_END;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_PARENT_LEFT;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_PARENT_RIGHT;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_PARENT_START;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_RIGHT;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_START;
import static com.android.SdkConstants.ATTR_LAYOUT_GRAVITY;
import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN;
import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN_END;
import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN_LEFT;
import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN_RIGHT;
import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN_START;
import static com.android.SdkConstants.ATTR_LAYOUT_TO_END_OF;
import static com.android.SdkConstants.ATTR_LAYOUT_TO_LEFT_OF;
import static com.android.SdkConstants.ATTR_LAYOUT_TO_RIGHT_OF;
import static com.android.SdkConstants.ATTR_LAYOUT_TO_START_OF;
import static com.android.SdkConstants.ATTR_LIST_PREFERRED_ITEM_PADDING_END;
import static com.android.SdkConstants.ATTR_LIST_PREFERRED_ITEM_PADDING_LEFT;
import static com.android.SdkConstants.ATTR_LIST_PREFERRED_ITEM_PADDING_RIGHT;
import static com.android.SdkConstants.ATTR_LIST_PREFERRED_ITEM_PADDING_START;
import static com.android.SdkConstants.ATTR_PADDING;
import static com.android.SdkConstants.ATTR_PADDING_END;
import static com.android.SdkConstants.ATTR_PADDING_LEFT;
import static com.android.SdkConstants.ATTR_PADDING_RIGHT;
import static com.android.SdkConstants.ATTR_PADDING_START;
import static com.android.SdkConstants.ATTR_TEXT_ALIGNMENT;
import static com.android.SdkConstants.GRAVITY_VALUE_CENTER;
import static com.android.SdkConstants.GRAVITY_VALUE_CENTER_HORIZONTAL;
import static com.android.SdkConstants.GRAVITY_VALUE_CENTER_VERTICAL;
import static com.android.SdkConstants.GRAVITY_VALUE_END;
import static com.android.SdkConstants.GRAVITY_VALUE_FILL;
import static com.android.SdkConstants.GRAVITY_VALUE_FILL_HORIZONTAL;
import static com.android.SdkConstants.GRAVITY_VALUE_FILL_VERTICAL;
import static com.android.SdkConstants.GRAVITY_VALUE_LEFT;
import static com.android.SdkConstants.GRAVITY_VALUE_RIGHT;
import static com.android.SdkConstants.GRAVITY_VALUE_START;
import static com.android.SdkConstants.TAG_APPLICATION;
import static com.android.SdkConstants.TextAlignment;
import static com.android.SdkConstants.VALUE_FALSE;
import static com.android.utils.XmlUtils.getFirstSubTagByName;

import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.ide.common.resources.configuration.FolderConfiguration;
import com.android.ide.common.resources.configuration.VersionQualifier;
import com.android.tools.lint.client.api.UElementHandler;
import com.android.tools.lint.detector.api.Category;
import com.android.tools.lint.detector.api.Context;
import com.android.tools.lint.detector.api.Implementation;
import com.android.tools.lint.detector.api.Incident;
import com.android.tools.lint.detector.api.Issue;
import com.android.tools.lint.detector.api.JavaContext;
import com.android.tools.lint.detector.api.LayoutDetector;
import com.android.tools.lint.detector.api.Lint;
import com.android.tools.lint.detector.api.LintFix;
import com.android.tools.lint.detector.api.LintMap;
import com.android.tools.lint.detector.api.Location;
import com.android.tools.lint.detector.api.Project;
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.android.tools.lint.detector.api.XmlContext;
import com.google.common.annotations.VisibleForTesting;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiField;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.List;
import java.util.Locale;
import org.jetbrains.uast.UElement;
import org.jetbrains.uast.USimpleNameReferenceExpression;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/** Check which looks for RTL issues (right-to-left support) in layouts */
public class RtlDetector extends LayoutDetector implements SourceCodeScanner {

    private static final Implementation IMPLEMENTATION =
            new Implementation(
                    RtlDetector.class,
                    EnumSet.of(Scope.RESOURCE_FILE, Scope.JAVA_FILE, Scope.MANIFEST),
                    Scope.RESOURCE_FILE_SCOPE,
                    Scope.JAVA_FILE_SCOPE,
                    Scope.MANIFEST_SCOPE);

    public static final Issue USE_START =
            Issue.create(
                    "RtlHardcoded",
                    "Using left/right instead of start/end attributes",
                    "Using `Gravity#LEFT` and `Gravity#RIGHT` can lead to problems when a layout is "
                            + "rendered in locales where text flows from right to left. Use `Gravity#START` "
                            + "and `Gravity#END` instead. Similarly, in XML `gravity` and `layout_gravity` "
                            + "attributes, use `start` rather than `left`.\n"
                            + "\n"
                            + "For XML attributes such as paddingLeft and `layout_marginLeft`, use `paddingStart` "
                            + "and `layout_marginStart`. **NOTE**: If your `minSdkVersion` is less than 17, you should "
                            + "add **both** the older left/right attributes **as well as** the new start/end "
                            + "attributes. On older platforms, where RTL is not supported and the start/end "
                            + "attributes are unknown and therefore ignored, you need the older left/right "
                            + "attributes. There is a separate lint check which catches that type of error.\n"
                            + "\n"
                            + "(Note: For `Gravity#LEFT` and `Gravity#START`, you can use these constants even "
                            + "when targeting older platforms, because the `start` bitmask is a superset of the "
                            + "`left` bitmask. Therefore, you can use `gravity=\"start\"` rather than "
                            + "`gravity=\"left|start\"`.)",
                    Category.RTL,
                    5,
                    Severity.WARNING,
                    IMPLEMENTATION);

    public static final Issue COMPAT =
            Issue.create(
                    "RtlCompat",
                    "Right-to-left text compatibility issues",
                    "API 17 adds a `textAlignment` attribute to specify text alignment. However, "
                            + "if you are supporting older versions than API 17, you must **also** specify a "
                            + "gravity or layout_gravity attribute, since older platforms will ignore the "
                            + "`textAlignment` attribute.",
                    Category.RTL,
                    6,
                    Severity.ERROR,
                    IMPLEMENTATION);

    public static final Issue SYMMETRY =
            Issue.create(
                    "RtlSymmetry",
                    "Padding and margin symmetry",
                    "If you specify padding or margin on the left side of a layout, you should "
                            + "probably also specify padding on the right side (and vice versa) for "
                            + "right-to-left layout symmetry.",
                    Category.RTL,
                    6,
                    Severity.WARNING,
                    IMPLEMENTATION);

    public static final Issue ENABLED =
            Issue.create(
                    "RtlEnabled",
                    "Using RTL attributes without enabling RTL support",
                    "To enable right-to-left support, when running on API 17 and higher, you must "
                            + "set the `android:supportsRtl` attribute in the manifest `<application>` element.\n"
                            + "\n"
                            + "If you have started adding RTL attributes, but have not yet finished the "
                            + "migration, you can set the attribute to false to satisfy this lint check.",
                    Category.RTL,
                    3,
                    Severity.WARNING,
                    IMPLEMENTATION);

    /* TODO:
    public static final Issue FIELD = Issue.create(
        "RtlFieldAccess",
        "Accessing margin and padding fields directly",

        "Modifying the padding and margin constants in view objects directly is " +
        "problematic when using RTL support, since it can lead to inconsistent states. You " +
        "**must** use the corresponding setter methods instead (`View#setPadding` etc).",

        Category.RTL, 3, Severity.WARNING, IMPLEMENTATION).setEnabledByDefault(false);

    public static final Issue AWARE = Issue.create(
        "RtlAware",
        "View code not aware of RTL APIs",

        "When manipulating views, and especially when implementing custom layouts, " +
        "the code may need to be aware of RTL APIs. This lint check looks for usages of " +
        "APIs that frequently require adjustments for right-to-left text, and warns if it " +
        "does not also see text direction look-ups indicating that the code has already " +
        "been updated to handle RTL layouts.",

        Category.RTL, 3, Severity.WARNING, IMPLEMENTATION).setEnabledByDefault(false);
    */

    private static final String RIGHT_FIELD = "RIGHT";
    private static final String LEFT_FIELD = "LEFT";
    private static final String FQCN_GRAVITY = "android.view.Gravity";
    static final String ATTR_SUPPORTS_RTL = "supportsRtl";

    /** API version in which RTL support was added */
    private static final int RTL_API = 17;

    private static final String LEFT = "Left";
    private static final String START = "Start";
    private static final String RIGHT = "Right";
    private static final String END = "End";

    private Boolean mEnabledRtlSupport;
    private boolean mUsesRtlAttributes;
    private boolean mSpecifiesRtlMode;

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

    private boolean rtlApplies(@NonNull Context context) {
        Project project = context.getMainProject();
        if (project.getTargetSdk() < RTL_API) {
            return false;
        }

        if (mEnabledRtlSupport != null && !mEnabledRtlSupport) {
            return false;
        }

        // Enabled RTL support not set? Look for it in the merged manifest
        if (mEnabledRtlSupport == null) {
            mEnabledRtlSupport = getMergedManifestRtlSetting(context);
            if (mEnabledRtlSupport == null) {
                mEnabledRtlSupport = false;
            }

            return mEnabledRtlSupport;
        }

        return true;
    }

    @Nullable
    private static Boolean getMergedManifestRtlSetting(@NonNull Context context) {
        Project mainProject = context.getMainProject();
        Document mergedManifest = mainProject.getMergedManifest();
        if (mergedManifest == null) {
            return null;
        }
        Element root = mergedManifest.getDocumentElement();
        if (root == null) {
            return null;
        }
        Element application = getFirstSubTagByName(root, TAG_APPLICATION);
        if (application == null) {
            return null;
        }
        String rtlSupported = application.getAttributeNS(ANDROID_URI, ATTR_SUPPORTS_RTL);
        return !VALUE_FALSE.equals(rtlSupported);
    }

    @Override
    public boolean filterIncident(
            @NonNull Context context, @NonNull Incident incident, @NonNull LintMap map) {
        int flags = map.getInt(KEY_APPLIES, 0);
        if (applies(context, flags, incident.getLocation().getFile())) {
            String message = incident.getMessage();
            if (message.contains("%s")) {
                // Patch in the actual minSdkVersion
                String minApi = context.getMainProject().getMinSdkVersion().getApiString();
                incident.setMessage(String.format(message, minApi));
            }
            return true;
        }
        return false;
    }

    private boolean applies(@NonNull Context context, int flags, @NonNull File location) {
        // Access merged manifest from main project to see if RTL is on/off
        if ((flags & APPLIES_REQUIRES_RTL) != 0 && !rtlApplies(context)) {
            return false;
        }

        // targetSdkVersion constraints
        if ((flags & APPLIES_TARGET_PRE_17) != 0
                && context.getMainProject().getTargetSdk() >= RTL_API) {
            return false;
        }

        // folder and minSdkVersion checks.
        if ((flags & APPLIES_FOLDER_OR_MIN_17) != 0) {
            return context.getProject().getMinSdk() >= RTL_API
                    || getFolderVersion(location) >= RTL_API;
        } else if ((flags & APPLIES_MIN_17) != 0) {
            return context.getMainProject().getMinSdk() >= RTL_API;
        } else if ((flags & APPLIES_MIN_PRE_17) != 0) {
            return context.getMainProject().getMinSdk() < RTL_API;
        } else {
            return true;
        }
    }

    /** For a resource folder config like */
    static int getFolderVersion(@NonNull File resourceFile) {
        String path = resourceFile.getPath();
        int i = path.length() - 1;
        for (; i >= 0; i--) {
            char c = path.charAt(i);
            if (c == '/' || c == '\\') {
                i--;
                break;
            }
        }
        if (i != 0) {
            boolean haveDash = false;
            int j = i;
            for (; j >= 0; j--) {
                char c = path.charAt(j);
                if (c == '/' || c == '\\') {
                    j++;
                    break;
                } else if (c == '-') {
                    haveDash = true;
                }
            }
            if (haveDash) {
                String folderName = path.substring(Math.max(j, 0), i + 1);
                FolderConfiguration config = FolderConfiguration.getConfigForFolder(folderName);
                if (config != null) {
                    VersionQualifier qualifier = config.getVersionQualifier();
                    if (qualifier != null) {
                        return qualifier.getVersion();
                    }
                }
            }
        }
        return -1;
    }

    @Override
    public void afterCheckRootProject(@NonNull Context context) {
        if (mUsesRtlAttributes && !mSpecifiesRtlMode) {
            List<File> manifestFile = context.getProject().getManifestFiles();
            if (!manifestFile.isEmpty()) {
                Location location = Location.create(manifestFile.get(0));
                context.report(
                        new Incident(
                                ENABLED,
                                location,
                                "The project references RTL attributes, but does not explicitly enable "
                                        + "or disable RTL support with `android:supportsRtl` in the manifest"),
                        map().put(KEY_APPLIES, APPLIES_REQUIRES_RTL));
            }
        }
    }

    // ---- Implements XmlDetector ----

    @VisibleForTesting
    static final String[] ATTRIBUTES =
            new String[] {
                // Pairs, from left/right constants to corresponding start/end constants
                ATTR_LAYOUT_ALIGN_PARENT_LEFT, ATTR_LAYOUT_ALIGN_PARENT_START,
                ATTR_LAYOUT_ALIGN_PARENT_RIGHT, ATTR_LAYOUT_ALIGN_PARENT_END,
                ATTR_LAYOUT_MARGIN_LEFT, ATTR_LAYOUT_MARGIN_START,
                ATTR_LAYOUT_MARGIN_RIGHT, ATTR_LAYOUT_MARGIN_END,
                ATTR_PADDING_LEFT, ATTR_PADDING_START,
                ATTR_PADDING_RIGHT, ATTR_PADDING_END,
                ATTR_DRAWABLE_LEFT, ATTR_DRAWABLE_START,
                ATTR_DRAWABLE_RIGHT, ATTR_DRAWABLE_END,
                ATTR_LIST_PREFERRED_ITEM_PADDING_LEFT, ATTR_LIST_PREFERRED_ITEM_PADDING_START,
                ATTR_LIST_PREFERRED_ITEM_PADDING_RIGHT, ATTR_LIST_PREFERRED_ITEM_PADDING_END,

                // RelativeLayout
                ATTR_LAYOUT_TO_LEFT_OF, ATTR_LAYOUT_TO_START_OF,
                ATTR_LAYOUT_TO_RIGHT_OF, ATTR_LAYOUT_TO_END_OF,
                ATTR_LAYOUT_ALIGN_LEFT, ATTR_LAYOUT_ALIGN_START,
                ATTR_LAYOUT_ALIGN_RIGHT, ATTR_LAYOUT_ALIGN_END,
            };

    static {
        if (Lint.assertionsEnabled()) {
            for (int i = 0; i < ATTRIBUTES.length; i += 2) {
                String replace = ATTRIBUTES[i];
                String with = ATTRIBUTES[i + 1];
                assert with.equals(convertOldToNew(replace));
                assert replace.equals(convertNewToOld(with));
            }
        }
    }

    public static boolean isRtlAttributeName(@NonNull String attribute) {
        for (int i = 1; i < ATTRIBUTES.length; i += 2) {
            if (attribute.equals(ATTRIBUTES[i])) {
                return true;
            }
        }
        return false;
    }

    @VisibleForTesting
    static String convertOldToNew(String attribute) {
        if (attribute.contains(LEFT)) {
            return attribute.replace(LEFT, START);
        } else {
            return attribute.replace(RIGHT, END);
        }
    }

    static String convertNewToOld(String attribute) {
        if (attribute.contains(START)) {
            return attribute.replace(START, LEFT);
        } else {
            return attribute.replace(END, RIGHT);
        }
    }

    @VisibleForTesting
    static String convertToOppositeDirection(String attribute) {
        if (attribute.contains(LEFT)) {
            return attribute.replace(LEFT, RIGHT);
        } else if (attribute.contains(RIGHT)) {
            return attribute.replace(RIGHT, LEFT);
        } else if (attribute.contains(START)) {
            return attribute.replace(START, END);
        } else {
            return attribute.replace(END, START);
        }
    }

    @Nullable
    static String getTextAlignmentToGravity(String attribute) {
        if (attribute.equals(TextAlignment.CENTER)) {
            return GRAVITY_VALUE_CENTER_HORIZONTAL;
        } else if (attribute.endsWith(START)) { // textStart, viewStart, ...
            return GRAVITY_VALUE_START;
        } else if (attribute.endsWith(END)) { // textEnd, viewEnd, ...
            return GRAVITY_VALUE_END;
        } else {
            return null; // inherit, others
        }
    }

    @Override
    public Collection<String> getApplicableAttributes() {
        int size = ATTRIBUTES.length + 4;
        List<String> attributes = new ArrayList<>(size);

        // For detecting whether RTL support is enabled
        attributes.add(ATTR_SUPPORTS_RTL);

        // For detecting left/right attributes which should probably be
        // migrated to start/end
        attributes.add(ATTR_GRAVITY);
        attributes.add(ATTR_LAYOUT_GRAVITY);

        // For detecting existing attributes which indicate an attempt to
        // use RTL
        attributes.add(ATTR_TEXT_ALIGNMENT);

        // Add conversion attributes: left/right attributes to nominate
        // attributes that should be added as start/end, and start/end
        // attributes to use to look up elements that should have compatibility
        // left/right ones as well
        Collections.addAll(attributes, ATTRIBUTES);

        assert attributes.size() == size : attributes.size();

        return attributes;
    }

    @Override
    public void visitAttribute(@NonNull XmlContext context, @NonNull Attr attribute) {
        String value = attribute.getValue();

        if (!ANDROID_URI.equals(attribute.getNamespaceURI())) {
            // Layout attribute not in the Android namespace (or a custom namespace).
            // This is likely an application error (which should get caught by
            // the MissingPrefixDetector)
            return;
        }

        String name = attribute.getLocalName();
        assert name != null : attribute.getName();

        if (name.equals(ATTR_SUPPORTS_RTL)) {
            mSpecifiesRtlMode = true;
            mEnabledRtlSupport = Boolean.valueOf(value);
            if (!attribute.getOwnerElement().getTagName().equals(TAG_APPLICATION)) {
                context.report(
                        new Incident(
                                ENABLED,
                                attribute,
                                context.getLocation(attribute),
                                String.format(
                                        "Wrong declaration: `%1$s` should be defined on the `<application>` element",
                                        attribute.getName())));
            }
            if (mEnabledRtlSupport && context.getProject().getMinSdk() < RTL_API) {
                String message =
                        String.format(
                                Locale.getDefault(),
                                "You must set `android:targetSdkVersion` to at least %1$d when "
                                        + "enabling RTL support",
                                RTL_API);
                reportRtl(
                        context,
                        ENABLED,
                        attribute,
                        context.getValueLocation(attribute),
                        message,
                        null,
                        APPLIES_TARGET_PRE_17);
            }
            return;
        }

        if (name.equals(ATTR_TEXT_ALIGNMENT)) {
            if (context.getProject().getReportIssues()) {
                mUsesRtlAttributes = true;
            }

            Element element = attribute.getOwnerElement();
            final String gravitySpec;
            final Attr gravityNode;
            if (element.hasAttributeNS(ANDROID_URI, ATTR_GRAVITY)) {
                gravityNode = element.getAttributeNodeNS(ANDROID_URI, ATTR_GRAVITY);
                gravitySpec = gravityNode.getValue();
            } else if (element.hasAttributeNS(ANDROID_URI, ATTR_LAYOUT_GRAVITY)) {
                gravityNode = element.getAttributeNodeNS(ANDROID_URI, ATTR_LAYOUT_GRAVITY);
                gravitySpec = gravityNode.getValue();
            } else if (context.getProject().getMinSdk() < RTL_API) {
                int folderVersion = context.getFolderVersion();
                if (folderVersion < RTL_API && context.isEnabled(COMPAT)) {
                    String expectedGravity = getTextAlignmentToGravity(value);
                    if (expectedGravity != null) {
                        String message =
                                String.format(
                                        Locale.getDefault(),
                                        // %%: place holder; will be replaced when reporting
                                        "To support older versions than API 17 (project specifies %%s) "
                                                + "you must **also** specify `gravity` or `layout_gravity=\"%1$s\"`",
                                        expectedGravity);

                        LintFix fix1 =
                                fix().set(ANDROID_URI, ATTR_GRAVITY, expectedGravity).build();
                        LintFix fix2 =
                                fix().set(ANDROID_URI, ATTR_LAYOUT_GRAVITY, expectedGravity)
                                        .build();
                        LintFix fix = fix().alternatives(fix1, fix2);
                        reportRtl(
                                context,
                                COMPAT,
                                attribute,
                                context.getNameLocation(attribute),
                                message,
                                fix,
                                APPLIES_MIN_PRE_17 | APPLIES_REQUIRES_RTL);
                    }
                }
                return;
            } else {
                return;
            }

            String expectedGravity = getTextAlignmentToGravity(value);
            if (expectedGravity != null && context.isEnabled(COMPAT)) {
                List<String> gravities = new ArrayList<>();
                for (String g : gravitySpec.split("\\|")) {
                    g = g.trim();
                    gravities.add(g);
                    if (g.equals(GRAVITY_VALUE_CENTER)) {
                        gravities.add(GRAVITY_VALUE_CENTER_HORIZONTAL);
                        gravities.add(GRAVITY_VALUE_CENTER_VERTICAL);
                    }
                    if (g.equals(GRAVITY_VALUE_FILL)) {
                        gravities.add(GRAVITY_VALUE_FILL_HORIZONTAL);
                        gravities.add(GRAVITY_VALUE_FILL_VERTICAL);
                    }
                }
                if (gravities.stream().noneMatch(g -> g.equals(expectedGravity))) {
                    String message =
                            String.format(
                                    "Inconsistent alignment specification between `textAlignment` and "
                                            + "`gravity` attributes: was `%1$s`, expected `%2$s`",
                                    gravitySpec, expectedGravity);
                    Location location = context.getValueLocation(attribute);
                    Location secondary = context.getValueLocation(gravityNode);
                    secondary.setMessage("Incompatible direction here");
                    location.setSecondary(secondary);
                    reportRtl(
                            context,
                            COMPAT,
                            attribute,
                            location,
                            message,
                            null,
                            APPLIES_REQUIRES_RTL);
                }
            }
        }

        if (name.equals(ATTR_GRAVITY) || name.equals(ATTR_LAYOUT_GRAVITY)) {
            boolean isLeft = value.contains(GRAVITY_VALUE_LEFT);
            boolean isRight = value.contains(GRAVITY_VALUE_RIGHT);
            if (!isLeft && !isRight) {
                if ((value.contains(GRAVITY_VALUE_START) || value.contains(GRAVITY_VALUE_END))
                        && context.getProject().getReportIssues()) {
                    mUsesRtlAttributes = true;
                }
                return;
            }
            String message =
                    String.format(
                            "Use \"`%1$s`\" instead of \"`%2$s`\" to ensure correct behavior in "
                                    + "right-to-left locales",
                            isLeft ? GRAVITY_VALUE_START : GRAVITY_VALUE_END,
                            isLeft ? GRAVITY_VALUE_LEFT : GRAVITY_VALUE_RIGHT);
            if (context.isEnabled(USE_START)) {
                reportRtl(
                        context,
                        USE_START,
                        attribute,
                        context.getValueLocation(attribute),
                        message,
                        null,
                        APPLIES_REQUIRES_RTL);
            }

            return;
        }

        // Some other left/right/start/end attribute

        // TODO: If attribute is drawableLeft or drawableRight, add note that you might
        // want to consider adding a specialized image in the -ldrtl folder as well

        Element element = attribute.getOwnerElement();
        boolean isPaddingAttribute = isPaddingAttribute(name);
        if (isPaddingAttribute || isMarginAttribute(name)) {
            String opposite = convertToOppositeDirection(name);
            if (element.hasAttributeNS(ANDROID_URI, opposite)) {
                String oldValue = element.getAttributeNS(ANDROID_URI, opposite);
                if (value.equals(oldValue)) {
                    return;
                }
            } else if (isPaddingAttribute
                    && !element.hasAttributeNS(
                            ANDROID_URI,
                            isOldAttribute(opposite)
                                    ? convertOldToNew(opposite)
                                    : convertNewToOld(opposite))
                    && context.isEnabled(SYMMETRY)) {
                String message =
                        String.format(
                                "When you define `%1$s` you should probably also define `%2$s` for "
                                        + "right-to-left symmetry",
                                name, opposite);
                reportRtl(
                        context,
                        SYMMETRY,
                        attribute,
                        context.getNameLocation(attribute),
                        message,
                        null,
                        APPLIES_REQUIRES_RTL);
            }
        }

        boolean isOld = isOldAttribute(name);
        if (isOld) {
            if (!context.isEnabled(USE_START)) {
                return;
            }
            String rtl = convertOldToNew(name);
            if (element.hasAttributeNS(ANDROID_URI, rtl)) {
                // Warn that left/right isn't needed (provisionally; can't just look
                // at current minSdkVersion since it can be higher in the app report
                String message =
                        String.format(
                                "Redundant attribute `%1$s`; already defining `%2$s` with "
                                        + "`targetSdkVersion` %3$s",
                                name, rtl, context.getProject().getTargetSdk());
                LintFix fix = fix().unset(ANDROID_URI, name).autoFix().build();
                reportRtl(
                        context,
                        USE_START,
                        attribute,
                        context.getNameLocation(attribute),
                        message,
                        fix,
                        APPLIES_FOLDER_OR_MIN_17 | APPLIES_REQUIRES_RTL);
            } else {
                // No need to check these levels in the main app; the main app's
                // minSdkVersion is always at least as high, and the folder version
                // is constant
                if (context.getProject().getMinSdk() < RTL_API
                        && context.getFolderVersion() < RTL_API) {
                    String message =
                            String.format(
                                    "Consider adding `%1$s:%2$s=\"%3$s\"` to better support "
                                            + "right-to-left layouts",
                                    attribute.getPrefix(), rtl, value);
                    LintFix lintFix =
                            fix().name(
                                            String.format(
                                                    "Add %1$s:%2$s=\"%3$s\"",
                                                    attribute.getPrefix(), rtl, value))
                                    .set(attribute.getNamespaceURI(), rtl, attribute.getValue())
                                    .build();
                    reportRtl(
                            context,
                            USE_START,
                            attribute,
                            context.getNameLocation(attribute),
                            message,
                            lintFix,
                            APPLIES_MIN_PRE_17);
                }
                String message =
                        String.format(
                                "Consider replacing `%1$s` with `%2$s:%3$s=\"%4$s\"` to better support "
                                        + "right-to-left layouts",
                                attribute.getName(), attribute.getPrefix(), rtl, value);

                LintFix lintFix =
                        fix().replace()
                                .name(
                                        String.format(
                                                "Replace with %1$s:%2$s=\"%3$s\"",
                                                attribute.getPrefix(), rtl, value))
                                .text(name)
                                .with(rtl)
                                .build();
                reportRtl(
                        context,
                        USE_START,
                        attribute,
                        context.getNameLocation(attribute),
                        message,
                        lintFix,
                        APPLIES_MIN_17 | APPLIES_REQUIRES_RTL);
            }
        } else {
            if (context.getProject().getMinSdk() >= RTL_API || !context.isEnabled(COMPAT)) {
                // Only supporting 17+: no need to define older attributes
                return;
            }
            int folderVersion = context.getFolderVersion();
            if (folderVersion >= RTL_API) {
                // In a -v17 folder or higher: no need to define older attributes
                return;
            }
            String old = convertNewToOld(name);
            if (element.hasAttributeNS(ANDROID_URI, old)) {
                return;
            }
            String oldValue = convertNewToOld(value);
            String message =
                    String.format(
                            Locale.getDefault(),
                            "To support older versions than API 17 (project specifies %%s) "
                                    + "you should **also** add `%1$s:%2$s=\"%3$s\"`",
                            attribute.getPrefix(),
                            old,
                            oldValue);
            LintFix fix = fix().set(attribute.getNamespaceURI(), old, oldValue).build();
            reportRtl(
                    context,
                    COMPAT,
                    attribute,
                    context.getNameLocation(attribute),
                    message,
                    fix,
                    APPLIES_MIN_PRE_17 | APPLIES_REQUIRES_RTL);
        }
    }

    /** The targetSdkVersion must be less than 17 */
    @SuppressWarnings("PointlessBitwiseExpression") // for symmetry
    private static final int APPLIES_TARGET_PRE_17 = 1 << 0; // does not require rtl
    /** The application must specify that it requires RTL */
    private static final int APPLIES_REQUIRES_RTL = 1 << 1;
    /** The minSdkVersion must be less than 17 */
    private static final int APPLIES_MIN_PRE_17 = 1 << 2; // also requires rtl
    /** The minSdkVersion must be at least 17 */
    private static final int APPLIES_MIN_17 = 1 << 3; // also requires rtl
    /** Either minSdkVersion of resource folder version >= 17 */
    private static final int APPLIES_FOLDER_OR_MIN_17 = 1 << 4; // aso requires minSdk >= 17

    private static final String KEY_APPLIES = "applies";

    private void reportRtl(
            @NonNull XmlContext context,
            @NonNull Issue issue,
            @NonNull Node scope,
            @NonNull Location nameLocation,
            @NonNull String message,
            @Nullable LintFix fix,
            int constraint) {
        Incident incident = new Incident(issue, scope, nameLocation, message, fix);
        context.report(incident, map().put(KEY_APPLIES, constraint));
    }

    private static boolean isOldAttribute(String name) {
        return name.contains(LEFT) || name.contains(RIGHT);
    }

    private static boolean isMarginAttribute(@NonNull String name) {
        return name.startsWith(ATTR_LAYOUT_MARGIN);
    }

    private static boolean isPaddingAttribute(@NonNull String name) {
        return name.startsWith(ATTR_PADDING);
    }

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

    @Override
    public List<Class<? extends UElement>> getApplicableUastTypes() {
        return Collections.singletonList(USimpleNameReferenceExpression.class);
    }

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

    private static class IdentifierChecker extends UElementHandler {
        private final JavaContext context;

        public IdentifierChecker(JavaContext context) {
            this.context = context;
        }

        @Override
        public void visitSimpleNameReferenceExpression(
                @NonNull USimpleNameReferenceExpression element) {
            String identifier = element.getIdentifier();
            boolean isLeft = LEFT_FIELD.equals(identifier);
            boolean isRight = RIGHT_FIELD.equals(identifier);
            if (!isLeft && !isRight) {
                return;
            }

            PsiElement resolved = element.resolve();
            if (!(resolved instanceof PsiField)) {
                return;
            } else {
                PsiField field = (PsiField) resolved;
                if (!context.getEvaluator().isMemberInClass(field, FQCN_GRAVITY)) {
                    return;
                }
            }

            String message =
                    String.format(
                            "Use \"`Gravity.%1$s`\" instead of \"`Gravity.%2$s`\" to ensure correct "
                                    + "behavior in right-to-left locales",
                            (isLeft ? GRAVITY_VALUE_START : GRAVITY_VALUE_END)
                                    .toUpperCase(Locale.US),
                            (isLeft ? GRAVITY_VALUE_LEFT : GRAVITY_VALUE_RIGHT)
                                    .toUpperCase(Locale.US));
            Location location = context.getLocation(element);
            Incident incident = new Incident(USE_START, element, location, message);
            context.report(incident, new LintMap().put(KEY_APPLIES, APPLIES_REQUIRES_RTL));
        }
    }
}