/*
 * Copyright (C) 2011 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.ATTR_NAME;
import static com.android.SdkConstants.CLASS_CONTEXT;
import static com.android.SdkConstants.CLASS_FRAGMENT;
import static com.android.SdkConstants.CLASS_RESOURCES;
import static com.android.SdkConstants.CLASS_V4_FRAGMENT;
import static com.android.SdkConstants.FORMAT_METHOD;
import static com.android.SdkConstants.GET_STRING_METHOD;
import static com.android.SdkConstants.TAG_STRING;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_BOOLEAN_WRAPPER;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_BYTE_WRAPPER;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_CHARACTER_WRAPPER;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_DOUBLE_WRAPPER;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_FLOAT_WRAPPER;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_INTEGER_WRAPPER;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_LONG_WRAPPER;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_OBJECT;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_SHORT_WRAPPER;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_STRING;
import static com.android.utils.CharSequences.indexOf;

import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.ide.common.rendering.api.ResourceNamespace;
import com.android.ide.common.rendering.api.ResourceValue;
import com.android.ide.common.resources.ResourceItem;
import com.android.ide.common.resources.ResourceRepository;
import com.android.resources.ResourceFolderType;
import com.android.resources.ResourceType;
import com.android.resources.ResourceUrl;
import com.android.tools.lint.client.api.JavaEvaluator;
import com.android.tools.lint.client.api.LintClient;
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.Issue;
import com.android.tools.lint.detector.api.JavaContext;
import com.android.tools.lint.detector.api.Lint;
import com.android.tools.lint.detector.api.Location;
import com.android.tools.lint.detector.api.Location.Handle;
import com.android.tools.lint.detector.api.Position;
import com.android.tools.lint.detector.api.ResourceEvaluator;
import com.android.tools.lint.detector.api.ResourceXmlDetector;
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.android.utils.Pair;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.intellij.psi.PsiClassType;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.PsiParameterList;
import com.intellij.psi.PsiType;
import com.intellij.psi.PsiVariable;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.jetbrains.uast.UCallExpression;
import org.jetbrains.uast.UExpression;
import org.jetbrains.uast.ULiteralExpression;
import org.jetbrains.uast.UReferenceExpression;
import org.jetbrains.uast.UastFacade;
import org.jetbrains.uast.util.UastExpressionUtils;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * Check which looks for problems with formatting strings such as inconsistencies between
 * translations or between string declaration and string usage in Java.
 *
 * <p>TODO: Handle Resources.getQuantityString as well
 */
public class StringFormatDetector extends ResourceXmlDetector implements SourceCodeScanner {
    private static final Implementation IMPLEMENTATION_XML =
            new Implementation(StringFormatDetector.class, Scope.ALL_RESOURCES_SCOPE);

    @SuppressWarnings("unchecked")
    private static final Implementation IMPLEMENTATION_XML_AND_JAVA =
            new Implementation(
                    StringFormatDetector.class,
                    EnumSet.of(Scope.ALL_RESOURCE_FILES, Scope.JAVA_FILE),
                    Scope.JAVA_FILE_SCOPE);

    /** Whether formatting strings are invalid */
    public static final Issue INVALID =
            Issue.create(
                    "StringFormatInvalid",
                    "Invalid format string",
                    "If a string contains a '%' character, then the string may be a formatting string "
                            + "which will be passed to `String.format` from Java code to replace each '%' "
                            + "occurrence with specific values.\n"
                            + "\n"
                            + "This lint warning checks for two related problems:\n"
                            + "(1) Formatting strings that are invalid, meaning that `String.format` will throw "
                            + "exceptions at runtime when attempting to use the format string.\n"
                            + "(2) Strings containing '%' that are not formatting strings getting passed to "
                            + "a `String.format` call. In this case the '%' will need to be escaped as '%%'.\n"
                            + "\n"
                            + "NOTE: Not all Strings which look like formatting strings are intended for "
                            + "use by `String.format`; for example, they may contain date formats intended "
                            + "for `android.text.format.Time#format()`. Lint cannot always figure out that "
                            + "a String is a date format, so you may get false warnings in those scenarios. "
                            + "See the suppress help topic for information on how to suppress errors in "
                            + "that case.",
                    Category.MESSAGES,
                    9,
                    Severity.ERROR,
                    IMPLEMENTATION_XML);

    /** Whether formatting argument types are consistent across translations */
    public static final Issue ARG_COUNT =
            Issue.create(
                    "StringFormatCount",
                    "Formatting argument types incomplete or inconsistent",
                    "When a formatted string takes arguments, it usually needs to reference the "
                            + "same arguments in all translations (or all arguments if there are no "
                            + "translations.\n"
                            + "\n"
                            + "There are cases where this is not the case, so this issue is a warning rather "
                            + "than an error by default. However, this usually happens when a language is not "
                            + "translated or updated correctly.",
                    Category.MESSAGES,
                    5,
                    Severity.WARNING,
                    IMPLEMENTATION_XML);

    /** Whether the string format supplied in a call to String.format matches the format string */
    public static final Issue ARG_TYPES =
            Issue.create(
                    "StringFormatMatches",
                    "`String.format` string doesn't match the XML format string",
                    "This lint check ensures the following:\n"
                            + "(1) If there are multiple translations of the format string, then all translations "
                            + "use the same type for the same numbered arguments\n"
                            + "(2) The usage of the format string in Java is consistent with the format string, "
                            + "meaning that the parameter types passed to String.format matches those in the "
                            + "format string.",
                    Category.MESSAGES,
                    9,
                    Severity.ERROR,
                    IMPLEMENTATION_XML_AND_JAVA);

    /** This plural does not use the quantity value */
    public static final Issue POTENTIAL_PLURAL =
            Issue.create(
                            "PluralsCandidate",
                            "Potential Plurals",
                            "This lint check looks for potential errors in internationalization where you have "
                                    + "translated a message which involves a quantity and it looks like other parts of "
                                    + "the string may need grammatical changes.\n"
                                    + "\n"
                                    + "For example, rather than something like this:\n"
                                    + "```xml\n"
                                    + "  <string name=\"try_again\">Try again in %d seconds.</string>\n"
                                    + "```\n"
                                    + "you should be using a plural:\n"
                                    + "```xml\n"
                                    + "   <plurals name=\"try_again\">\n"
                                    + "        <item quantity=\"one\">Try again in %d second</item>\n"
                                    + "        <item quantity=\"other\">Try again in %d seconds</item>\n"
                                    + "    </plurals>\n"
                                    + "```\n"
                                    + "This will ensure that in other languages the right set of translations are "
                                    + "provided for the different quantity classes.\n"
                                    + "\n"
                                    + "(This check depends on some heuristics, so it may not accurately determine whether "
                                    + "a string really should be a quantity. You can use tools:ignore to filter out false "
                                    + "positives.",
                            Category.MESSAGES,
                            5,
                            Severity.WARNING,
                            IMPLEMENTATION_XML)
                    .addMoreInfo(
                            "https://developer.android.com/guide/topics/resources/string-resource.html#Plurals");

    /**
     * Map from a format string name to a list of declaration file and actual formatting string
     * content. We're using a list since a format string can be defined multiple times, usually for
     * different translations.
     */
    private Map<String, List<Pair<Handle, String>>> mFormatStrings;

    /** Map of strings that do not contain any formatting. */
    private final Map<String, Handle> mNotFormatStrings = new HashMap<>();

    /**
     * Set of strings that have an unknown format such as date formatting; we should not flag these
     * as invalid when used from a String#format call
     */
    private Set<String> mIgnoreStrings;

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

    @Override
    public boolean appliesTo(@NonNull ResourceFolderType folderType) {
        return folderType == ResourceFolderType.VALUES;
    }

    @Override
    public Collection<String> getApplicableElements() {
        return Collections.singletonList(TAG_STRING);
    }

    @Override
    public void visitElement(@NonNull XmlContext context, @NonNull Element element) {
        NodeList childNodes = element.getChildNodes();
        if (childNodes.getLength() > 0) {
            if (childNodes.getLength() == 1) {
                Node child = childNodes.item(0);
                if (child.getNodeType() == Node.TEXT_NODE) {
                    checkTextNode(context, element, stripQuotes(child.getNodeValue()));
                }
            } else {
                // Concatenate children and build up a plain string.
                // This is needed to handle xliff localization documents,
                // but this needs more work so ignore compound XML documents as
                // string values for now:
                StringBuilder sb = new StringBuilder();
                addText(sb, element);
                if (sb.length() > 0) {
                    checkTextNode(context, element, sb.toString());
                }
            }
        }
    }

    static void addText(StringBuilder sb, Node node) {
        short nodeType = node.getNodeType();
        if (nodeType == Node.TEXT_NODE || nodeType == Node.CDATA_SECTION_NODE) {
            sb.append(stripQuotes(node.getNodeValue().trim()));
        } else {
            NodeList childNodes = node.getChildNodes();
            for (int i = 0, n = childNodes.getLength(); i < n; i++) {
                addText(sb, childNodes.item(i));
            }
        }
    }

    /**
     * Removes all the unescaped quotes. See <a
     * href="http://developer.android.com/guide/topics/resources/string-resource.html#FormattingAndStyling">Escaping
     * apostrophes and quotes</a>
     */
    static String stripQuotes(String s) {
        StringBuilder sb = new StringBuilder();
        boolean isEscaped = false;
        boolean isQuotedBlock = false;
        for (int i = 0, len = s.length(); i < len; i++) {
            char current = s.charAt(i);
            if (isEscaped) {
                sb.append(current);
                isEscaped = false;
            } else {
                isEscaped = current == '\\'; // Next char will be escaped so we will just copy it
                if (current == '"') {
                    isQuotedBlock = !isQuotedBlock;
                } else if (current == '\'') {
                    if (isQuotedBlock) {
                        // We only add single quotes when they are within a quoted block
                        sb.append(current);
                    }
                } else {
                    sb.append(current);
                }
            }
        }

        return sb.toString();
    }

    private void checkTextNode(XmlContext context, Element element, String text) {
        String name = element.getAttribute(ATTR_NAME);
        boolean found = false;
        boolean foundPlural = false;

        // Look at the String and see if it's a format string (contains
        // positional %'s)
        for (int j = 0, m = text.length(); j < m; j++) {
            char c = text.charAt(j);
            if (c == '\\') {
                j++;
            }
            if (c == '%') {
                // Also make sure this String isn't an unformatted String
                String formatted = element.getAttribute("formatted");
                if (!formatted.isEmpty() && !Boolean.parseBoolean(formatted)) {
                    if (!mNotFormatStrings.containsKey(name)) {
                        Handle handle = context.createLocationHandle(element);
                        handle.setClientData(element);
                        mNotFormatStrings.put(name, handle);
                    }
                    return;
                }

                // See if it's not a format string, e.g. "Battery charge is 100%!".
                // If so we want to record this name in a special list such that we can
                // make sure you don't attempt to reference this string from a String.format
                // call.
                Matcher matcher = FORMAT.matcher(text);
                if (!matcher.find(j)) {
                    if (!mNotFormatStrings.containsKey(name)) {
                        Handle handle = context.createLocationHandle(element);
                        handle.setClientData(element);
                        mNotFormatStrings.put(name, handle);
                    }
                    return;
                }

                String conversion = matcher.group(6);
                int conversionClass = getConversionClass(conversion.charAt(0));
                if (conversionClass == CONVERSION_CLASS_UNKNOWN || matcher.group(5) != null) {
                    if (mIgnoreStrings == null) {
                        mIgnoreStrings = new HashSet<>();
                    }
                    mIgnoreStrings.add(name);

                    // Don't process any other strings here; some of them could
                    // accidentally look like a string, e.g. "%H" is a hash code conversion
                    // in String.format (and hour in Time formatting).
                    return;
                }

                if (conversionClass == CONVERSION_CLASS_INTEGER && !foundPlural) {
                    // See if there appears to be further text content here.
                    // Look for whitespace followed by a letter, with no punctuation in between
                    for (int k = matcher.end(); k < m; k++) {
                        char nc = text.charAt(k);
                        if (!Character.isWhitespace(nc)) {
                            if (Character.isLetter(nc)) {
                                foundPlural = checkPotentialPlural(context, element, text, k);
                            }
                            break;
                        }
                    }
                }

                found = true;
                j++; // Ensure that when we process a "%%" we don't separately check the second %
            }
        }

        if (!context.getProject().getReportIssues()) {
            // If this is a library project not being analyzed, ignore it
            return;
        }

        if (name != null) {
            Handle handle = context.createLocationHandle(element);
            handle.setClientData(element);
            if (found) {
                // Record it for analysis when seen in Java code
                if (mFormatStrings == null) {
                    mFormatStrings = new HashMap<>();
                }

                List<Pair<Handle, String>> list = mFormatStrings.get(name);
                if (list == null) {
                    list = new ArrayList<>();
                    mFormatStrings.put(name, list);
                }
                list.add(Pair.of(handle, text));
            } else {
                if (!isReference(text)) {
                    mNotFormatStrings.put(name, handle);
                }
            }
        }
    }

    private static boolean isReference(@NonNull String text) {
        for (int i = 0, n = text.length(); i < n; i++) {
            char c = text.charAt(i);
            if (!Character.isWhitespace(c)) {
                return c == '@' || c == '?';
            }
        }
        return false;
    }

    /**
     * Checks whether the text begins with a non-unit word, pointing to a string that should
     * probably be a plural instead. This
     */
    private static boolean checkPotentialPlural(
            XmlContext context, Element element, String text, int wordBegin) {
        // This method should only be called if the text is known to start with a word
        assert Character.isLetter(text.charAt(wordBegin));

        int wordEnd = wordBegin;
        while (wordEnd < text.length()) {
            if (!Character.isLetter(text.charAt(wordEnd))) {
                break;
            }
            wordEnd++;
        }

        // Eliminate units, since those are not sentences you need to use plurals for, e.g.
        //   "Elevation gain: %1$d m (%2$d ft)"
        // We'll determine whether something is a unit by looking for
        // (1) Multiple uppercase characters (e.g. KB, or MiB), or better yet, uppercase characters
        //     anywhere but as the first letter
        // (2) No vowels (e.g. ft)
        // (3) Adjacent consonants (e.g. ft); this one can eliminate some legitimate
        //     English words as well (e.g. "the") so we should really limit this to
        //     letter pairs that are not common in English. This is probably overkill
        //     so not handled yet. Instead we use a simpler heuristic:
        // (4) Very short "words" (1-2 letters)
        if (wordEnd - wordBegin <= 2) {
            // Very short word (1-2 chars): possible unit, e.g. "m", "ft", "kb", etc
            return false;
        }
        boolean hasVowel = false;
        for (int i = wordBegin; i < wordEnd; i++) {
            // Uppercase character anywhere but first character: probably a unit (e.g. KB)
            char c = text.charAt(i);
            if (i > wordBegin && Character.isUpperCase(c)) {
                return false;
            }
            if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y') {
                hasVowel = true;
            }
        }
        if (!hasVowel) {
            // No vowels: likely unit
            return false;
        }

        String word = text.substring(wordBegin, wordEnd);

        // Some other known abbreviations that we don't want to count:
        if (word.equals("min")) {
            return false;
        }

        // This heuristic only works in English!
        if (Lint.isEnglishResource(context, true)) {
            String message =
                    String.format(
                            "Formatting %%d followed by words (\"%1$s\"): "
                                    + "This should probably be a plural rather than a string",
                            word);
            context.report(POTENTIAL_PLURAL, element, context.getLocation(element), message);
            // Avoid reporting multiple errors on the same string
            // (if it contains more than one %d)
            return true;
        }

        return false;
    }

    @Override
    public void afterCheckRootProject(@NonNull Context context) {
        if (mFormatStrings != null) {
            boolean checkCount = context.isEnabled(ARG_COUNT);
            boolean checkValid = context.isEnabled(INVALID);
            boolean checkTypes = context.isEnabled(ARG_TYPES);

            // Ensure that all the format strings are consistent with respect to each other;
            // e.g. they all have the same number of arguments, they all use all the
            // arguments, and they all use the same types for all the numbered arguments
            for (Map.Entry<String, List<Pair<Handle, String>>> entry : mFormatStrings.entrySet()) {
                String name = entry.getKey();
                List<Pair<Handle, String>> list = entry.getValue();

                // Check argument counts
                if (checkCount) {
                    Handle notFormatted = mNotFormatStrings.get(name);
                    if (notFormatted != null) {
                        list =
                                ImmutableList.<Pair<Handle, String>>builder()
                                        .add(Pair.of(notFormatted, name))
                                        .addAll(list)
                                        .build();
                    }
                    checkArity(context, name, list);
                }

                // Check argument types (and also make sure that the formatting strings are valid)
                if (checkValid || checkTypes) {
                    checkTypes(context, checkValid, checkTypes, name, list);
                }
            }
        }
    }

    private static void checkTypes(
            Context context,
            boolean checkValid,
            boolean checkTypes,
            String name,
            List<Pair<Handle, String>> list) {
        Map<Integer, String> types = new HashMap<>();
        Map<Integer, Handle> typeDefinition = new HashMap<>();
        for (Pair<Handle, String> pair : list) {
            Handle handle = pair.getFirst();
            String formatString = pair.getSecond();

            //boolean warned = false;
            Matcher matcher = FORMAT.matcher(formatString);
            int index = 0;
            int prevIndex = 0;
            int nextNumber = 1;
            while (true) {
                if (matcher.find(index)) {
                    int matchStart = matcher.start();
                    // Make sure this is not an escaped '%'
                    for (; prevIndex < matchStart; prevIndex++) {
                        char c = formatString.charAt(prevIndex);
                        if (c == '\\') {
                            prevIndex++;
                        }
                    }
                    if (prevIndex > matchStart) {
                        // We're in an escape, ignore this result
                        index = prevIndex;
                        continue;
                    }

                    index = matcher.end(); // Ensure loop proceeds
                    String str = formatString.substring(matchStart, matcher.end());
                    if (str.equals("%%") || str.equals("%n")) {
                        // Just an escaped %
                        continue;
                    }

                    if (checkValid) {
                        // Make sure it's a valid format string
                        if (str.length() > 2 && str.charAt(str.length() - 2) == ' ') {
                            char last = str.charAt(str.length() - 1);
                            // If you forget to include the conversion character, e.g.
                            //   "Weight=%1$ g" instead of "Weight=%1$d g", then
                            // you're going to end up with a format string interpreted as
                            // "%1$ g". This means that the space character is interpreted
                            // as a flag character, but it can only be a flag character
                            // when used in conjunction with the numeric conversion
                            // formats (d, o, x, X). If that's not the case, make a
                            // dedicated error message
                            if (last != 'd' && last != 'o' && last != 'x' && last != 'X') {
                                Object clientData = handle.getClientData();
                                if (clientData instanceof Node) {
                                    if (context.getDriver()
                                            .isSuppressed(null, INVALID, (Node) clientData)) {
                                        return;
                                    }
                                }

                                Location location = handle.resolve();
                                String message =
                                        String.format(
                                                "Incorrect formatting string `%1$s`; missing conversion "
                                                        + "character in '`%2$s`' ?",
                                                name, str);
                                context.report(INVALID, location, message);
                                //warned = true;
                                continue;
                            }
                        }
                    }

                    if (!checkTypes) {
                        continue;
                    }

                    // Shouldn't throw a number format exception since we've already
                    // matched the pattern in the regexp
                    int number;
                    String numberString = matcher.group(1);
                    if (numberString != null) {
                        // Strip off trailing $
                        numberString = numberString.substring(0, numberString.length() - 1);
                        number = Integer.parseInt(numberString);
                        nextNumber = number + 1;
                    } else {
                        number = nextNumber++;
                    }
                    String format = matcher.group(6);
                    String currentFormat = types.get(number);
                    if (currentFormat == null) {
                        types.put(number, format);
                        typeDefinition.put(number, handle);
                    } else if (!currentFormat.equals(format)
                            && isIncompatible(currentFormat.charAt(0), format.charAt(0))) {

                        Object clientData = handle.getClientData();
                        if (clientData instanceof Node) {
                            if (context.getDriver()
                                    .isSuppressed(null, ARG_TYPES, (Node) clientData)) {
                                return;
                            }
                        }

                        Location location = handle.resolve();
                        // Attempt to limit the location range to just the formatting
                        // string in question
                        location =
                                refineLocation(
                                        context,
                                        location,
                                        formatString,
                                        matcher.start(),
                                        matcher.end());
                        Location otherLocation = typeDefinition.get(number).resolve();
                        otherLocation.setMessage("Conflicting argument type here");
                        location.setSecondary(otherLocation);
                        File f = otherLocation.getFile();
                        String message =
                                String.format(
                                        "Inconsistent formatting types for argument #%1$d in "
                                                + "format string `%2$s` ('%3$s'): Found both '`%4$s`' and '`%5$s`' "
                                                + "(in %6$s)",
                                        number,
                                        name,
                                        str,
                                        currentFormat,
                                        format,
                                        Lint.getFileNameWithParent(context.getClient(), f));
                        //warned = true;
                        context.report(ARG_TYPES, location, message);
                        break;
                    }
                } else {
                    break;
                }
            }

            // Check that the format string is valid by actually attempting to instantiate
            // it. We only do this if we haven't already complained about this string
            // for other reasons.
            /* Check disabled for now: it had many false reports due to conversion
             * errors (which is expected since we just pass in strings), but once those
             * are eliminated there aren't really any other valid error messages returned
             * (for example, calling the formatter with bogus formatting flags always just
             * returns a "conversion" error. It looks like we'd need to actually pass compatible
             * arguments to trigger other types of formatting errors such as precision errors.
            if (!warned && checkValid) {
                try {
                    formatter.format(formatString, "", "", "", "", "", "", "",
                            "", "", "", "", "", "", "");

                } catch (IllegalFormatException t) { // TODO: UnknownFormatConversionException
                    if (!t.getLocalizedMessage().contains(" != ")
                            && !t.getLocalizedMessage().contains("Conversion")) {
                        Location location = handle.resolve();
                        context.report(INVALID, location,
                                String.format("Wrong format for %1$s: %2$s",
                                        name, t.getLocalizedMessage()), null);
                    }
                }
            }
            */
        }
    }

    /**
     * Returns true if two String.format conversions are "incompatible" (meaning that using these
     * two for the same argument across different translations is more likely an error than
     * intentional. Some conversions are incompatible, e.g. "d" and "s" where one is a number and
     * string, whereas others may work (e.g. float versus integer) but are probably not intentional.
     */
    private static boolean isIncompatible(char conversion1, char conversion2) {
        int class1 = getConversionClass(conversion1);
        int class2 = getConversionClass(conversion2);
        return class1 != class2
                && class1 != CONVERSION_CLASS_UNKNOWN
                && class2 != CONVERSION_CLASS_UNKNOWN;
    }

    private static final int CONVERSION_CLASS_UNKNOWN = 0;
    private static final int CONVERSION_CLASS_STRING = 1;
    private static final int CONVERSION_CLASS_CHARACTER = 2;
    private static final int CONVERSION_CLASS_INTEGER = 3;
    private static final int CONVERSION_CLASS_FLOAT = 4;
    private static final int CONVERSION_CLASS_BOOLEAN = 5;
    private static final int CONVERSION_CLASS_HASHCODE = 6;
    private static final int CONVERSION_CLASS_PERCENT = 7;
    private static final int CONVERSION_CLASS_NEWLINE = 8;
    private static final int CONVERSION_CLASS_DATETIME = 9;

    private static int getConversionClass(char conversion) {
        // See http://developer.android.com/reference/java/util/Formatter.html
        switch (conversion) {
            case 't': // Time/date conversion
            case 'T':
                return CONVERSION_CLASS_DATETIME;
            case 's': // string
            case 'S': // Uppercase string
                return CONVERSION_CLASS_STRING;
            case 'c': // character
            case 'C': // Uppercase character
                return CONVERSION_CLASS_CHARACTER;
            case 'd': // decimal
            case 'o': // octal
            case 'x': // hex
            case 'X':
                return CONVERSION_CLASS_INTEGER;
            case 'f': // decimal float
            case 'e': // exponential float
            case 'E':
            case 'g': // decimal or exponential depending on size
            case 'G':
            case 'a': // hex float
            case 'A':
                return CONVERSION_CLASS_FLOAT;
            case 'b': // boolean
            case 'B':
                return CONVERSION_CLASS_BOOLEAN;
            case 'h': // boolean
            case 'H':
                return CONVERSION_CLASS_HASHCODE;
            case '%': // literal
                return CONVERSION_CLASS_PERCENT;
            case 'n': // literal
                return CONVERSION_CLASS_NEWLINE;
        }

        return CONVERSION_CLASS_UNKNOWN;
    }

    private static Location refineLocation(
            Context context,
            Location location,
            String formatString,
            int substringStart,
            int substringEnd) {
        Position startLocation = location.getStart();
        Position endLocation = location.getEnd();
        if (startLocation != null && endLocation != null) {
            int startOffset = startLocation.getOffset();
            int endOffset = endLocation.getOffset();
            if (startOffset >= 0) {
                CharSequence contents = context.getClient().readFile(location.getFile());
                if (endOffset <= contents.length() && startOffset < endOffset) {
                    int formatOffset = indexOf(contents, formatString, startOffset);
                    if (formatOffset != -1 && formatOffset <= endOffset) {
                        return Location.create(
                                location.getFile(),
                                contents,
                                formatOffset + substringStart,
                                formatOffset + substringEnd);
                    }
                }
            }
        }

        return location;
    }

    /**
     * Check that the number of arguments in the format string is consistent across translations,
     * and that all arguments are used
     */
    private static void checkArity(Context context, String name, List<Pair<Handle, String>> list) {
        // Check to make sure that the argument counts and types are consistent
        int prevCount = -1;
        for (Pair<Handle, String> pair : list) {
            Set<Integer> indices = new HashSet<>();
            int count = getFormatArgumentCount(pair.getSecond(), indices);
            Handle handle = pair.getFirst();
            if (prevCount != -1 && prevCount != count) {
                Object clientData = handle.getClientData();
                if (clientData instanceof Node) {
                    if (context.getDriver().isSuppressed(null, ARG_COUNT, (Node) clientData)) {
                        return;
                    }
                }
                Location location = handle.resolve();
                Location secondary = list.get(0).getFirst().resolve();
                secondary.setMessage("Conflicting number of arguments here");
                location.setSecondary(secondary);
                String message =
                        String.format(
                                "Inconsistent number of arguments in formatting string `%1$s`; "
                                        + "found both %2$d and %3$d",
                                name, prevCount, count);
                context.report(ARG_COUNT, location, message);
                break;
            }

            for (int i = 1; i <= count; i++) {
                if (!indices.contains(i)) {
                    Object clientData = handle.getClientData();
                    if (clientData instanceof Node) {
                        if (context.getDriver().isSuppressed(null, ARG_COUNT, (Node) clientData)) {
                            return;
                        }
                    }

                    Set<Integer> all = new HashSet<>();
                    for (int j = 1; j < count; j++) {
                        all.add(j);
                    }
                    all.removeAll(indices);
                    List<Integer> sorted = new ArrayList<>(all);
                    Collections.sort(sorted);
                    Location location = handle.resolve();
                    String message =
                            String.format(
                                    "Formatting string '`%1$s`' is not referencing numbered arguments %2$s",
                                    name, sorted);
                    context.report(ARG_COUNT, location, message);
                    break;
                }
            }

            prevCount = count;
        }
    }

    // See java.util.Formatter docs
    public static final Pattern FORMAT =
            Pattern.compile(
                    // Generic format:
                    //   %[argument_index$][flags][width][.precision]conversion
                    //
                    "%"
                            +
                            // Argument Index
                            "(\\d+\\$)?"
                            +
                            // Flags
                            "([-+#, 0(<]*)?"
                            +
                            // Width
                            "(\\d+)?"
                            +
                            // Precision
                            "(\\.\\d+)?"
                            +
                            // Conversion. These are all a single character, except date/time conversions
                            // which take a prefix of t/T:
                            "([tT])?"
                            +
                            // The current set of conversion characters are
                            // b,h,s,c,d,o,x,e,f,g,a,t (as well as all those as upper-case characters), plus
                            // n for newlines and % as a literal %. And then there are all the time/date
                            // characters: HIKLm etc. Just match on all characters here since there should
                            // be at least one.
                            "([a-zA-Z%])");

    /** Given a format string returns the format type of the given argument */
    @VisibleForTesting
    @Nullable
    static String getFormatArgumentType(String s, int argument) {
        Matcher matcher = FORMAT.matcher(s);
        int index = 0;
        int prevIndex = 0;
        int nextNumber = 1;
        while (true) {
            if (matcher.find(index)) {
                String value = matcher.group(6);
                if ("%".equals(value) || "n".equals(value)) {
                    index = matcher.end();
                    continue;
                }
                int matchStart = matcher.start();
                // Make sure this is not an escaped '%'
                for (; prevIndex < matchStart; prevIndex++) {
                    char c = s.charAt(prevIndex);
                    if (c == '\\') {
                        prevIndex++;
                    }
                }
                if (prevIndex > matchStart) {
                    // We're in an escape, ignore this result
                    index = prevIndex;
                    continue;
                }

                // Shouldn't throw a number format exception since we've already
                // matched the pattern in the regexp
                int number;
                String numberString = matcher.group(1);
                if (numberString != null) {
                    // Strip off trailing $
                    numberString = numberString.substring(0, numberString.length() - 1);
                    number = Integer.parseInt(numberString);
                    nextNumber = number + 1;
                } else {
                    number = nextNumber++;
                }

                if (number == argument) {
                    return matcher.group(6);
                }
                index = matcher.end();
            } else {
                break;
            }
        }

        return null;
    }

    /**
     * Given a format string returns the number of required arguments. If the {@code seenArguments}
     * parameter is not null, put the indices of any observed arguments into it.
     */
    static int getFormatArgumentCount(@NonNull String s, @Nullable Set<Integer> seenArguments) {
        Matcher matcher = FORMAT.matcher(s);
        int index = 0;
        int prevIndex = 0;
        int nextNumber = 1;
        int max = 0;
        while (true) {
            if (matcher.find(index)) {
                String value = matcher.group(6);
                if ("%".equals(value) || "n".equals(value)) {
                    index = matcher.end();
                    continue;
                }
                int matchStart = matcher.start();
                // Make sure this is not an escaped '%'
                for (; prevIndex < matchStart; prevIndex++) {
                    char c = s.charAt(prevIndex);
                    if (c == '\\') {
                        prevIndex++;
                    }
                }
                if (prevIndex > matchStart) {
                    // We're in an escape, ignore this result
                    index = prevIndex;
                    continue;
                }

                // Shouldn't throw a number format exception since we've already
                // matched the pattern in the regexp
                int number;
                String numberString = matcher.group(1);
                if (numberString != null) {
                    // Strip off trailing $
                    numberString = numberString.substring(0, numberString.length() - 1);
                    number = Integer.parseInt(numberString);
                    nextNumber = number + 1;
                } else {
                    number = nextNumber++;
                }

                if (number > max) {
                    max = number;
                }
                if (seenArguments != null) {
                    seenArguments.add(number);
                }

                index = matcher.end();
            } else {
                break;
            }
        }

        return max;
    }

    /**
     * Determines whether the given {@link String#format(String, Object...)} formatting string is
     * "locale dependent", meaning that its output depends on the locale. This is the case if it for
     * example references decimal numbers of dates and times.
     *
     * @param format the format string
     * @return true if the format is locale sensitive, false otherwise
     */
    public static boolean isLocaleSpecific(@NonNull String format) {
        if (format.indexOf('%') == -1) {
            return false;
        }

        Matcher matcher = FORMAT.matcher(format);
        int index = 0;
        int prevIndex = 0;
        while (true) {
            if (matcher.find(index)) {
                int matchStart = matcher.start();
                // Make sure this is not an escaped '%'
                for (; prevIndex < matchStart; prevIndex++) {
                    char c = format.charAt(prevIndex);
                    if (c == '\\') {
                        prevIndex++;
                    }
                }
                if (prevIndex > matchStart) {
                    // We're in an escape, ignore this result
                    index = prevIndex;
                    continue;
                }

                String type = matcher.group(6);
                if (!type.isEmpty()) {
                    char t = type.charAt(0);

                    // The following formatting characters are locale sensitive:
                    switch (t) {
                        case 'd': // decimal integer
                        case 'e': // scientific
                        case 'E':
                        case 'f': // decimal float
                        case 'g': // general
                        case 'G':
                        case 't': // date/time
                        case 'T':
                            return true;
                    }
                }
                index = matcher.end();
            } else {
                break;
            }
        }

        return false;
    }

    @Override
    public List<String> getApplicableMethodNames() {
        return Arrays.asList(FORMAT_METHOD, GET_STRING_METHOD);
    }

    @Override
    public void visitMethodCall(
            @NonNull JavaContext context,
            @NonNull UCallExpression node,
            @NonNull PsiMethod method) {
        if (mFormatStrings == null && !context.getClient().supportsProjectResources()) {
            return;
        }

        JavaEvaluator evaluator = context.getEvaluator();
        String methodName = method.getName();
        if (methodName.equals(FORMAT_METHOD)) {
            if (evaluator.isMemberInClass(method, TYPE_STRING)) {
                // Check formatting parameters for
                //   java.lang.String#format(String format, Object... formatArgs)
                //   java.lang.String#format(Locale locale, String format, Object... formatArgs)
                checkStringFormatCall(
                        context, method, node, method.getParameterList().getParametersCount() == 3);

                // TODO: Consider also enforcing
                // java.util.Formatter#format(String string, Object... formatArgs)
            }
        } else {
            // Look up any of these string formatting methods:
            // android.content.res.Resources#getString(@StringRes int resId, Object... formatArgs)
            // android.content.Context#getString(@StringRes int resId, Object... formatArgs)
            // android.app.Fragment#getString(@StringRes int resId, Object... formatArgs)
            // android.support.v4.app.Fragment#getString(@StringRes int resId, Object... formatArgs)

            // Many of these also define a plain getString method:
            // android.content.res.Resources#getString(@StringRes int resId)
            // However, while it's possible that these contain formatting strings) it's
            // also possible that they're looking up strings that are not intended to be used
            // for formatting so while we may want to warn about this it's not necessarily
            // an error.
            if (method.getParameterList().getParametersCount() < 2) {
                return;
            }

            if (evaluator.isMemberInSubClassOf(method, CLASS_RESOURCES, false)
                    || evaluator.isMemberInSubClassOf(method, CLASS_CONTEXT, false)
                    || evaluator.isMemberInSubClassOf(method, CLASS_FRAGMENT, false)
                    || evaluator.isMemberInSubClassOf(method, CLASS_V4_FRAGMENT.oldName(), false)
                    || evaluator.isMemberInSubClassOf(method, CLASS_V4_FRAGMENT.newName(), false)) {
                checkStringFormatCall(context, method, node, false);
            }

            // TODO: Consider also looking up
            // android.content.res.Resources#getQuantityString(@PluralsRes int id, int quantity,
            //              Object... formatArgs)
            // though this will require being smarter about cross referencing formatting
            // strings since we'll need to go via the quantity string definitions
        }
    }

    /**
     * Checks a String.format call that is using a string that doesn't contain format placeholders.
     *
     * @param context the context to report errors to
     * @param call the AST node for the {@link String#format}
     * @param name the string name
     * @param handle the string location
     */
    private static void checkNotFormattedHandle(
            JavaContext context, UCallExpression call, String name, Handle handle) {
        Object clientData = handle.getClientData();
        if (clientData instanceof Node) {
            if (context.getDriver().isSuppressed(null, INVALID, (Node) clientData)) {
                return;
            }
        }
        Location location = context.getLocation(call);
        Location secondary = handle.resolve();
        secondary.setMessage("This definition does not require arguments");
        location.setSecondary(secondary);
        String message =
                String.format(
                        "Format string '`%1$s`' is not a valid format string so it should not be "
                                + "passed to `String.format`",
                        name);
        context.report(INVALID, call, location, message);
    }

    /**
     * Check the given String.format call (with the given arguments) to see if the string format is
     * being used correctly
     *
     * @param context the context to report errors to
     * @param calledMethod the method being called
     * @param call the AST node for the {@link String#format}
     * @param specifiesLocale whether the first parameter is a locale string, shifting the
     */
    private void checkStringFormatCall(
            JavaContext context,
            PsiMethod calledMethod,
            UCallExpression call,
            boolean specifiesLocale) {

        int argIndex = specifiesLocale ? 1 : 0;
        List<UExpression> args = call.getValueArguments();

        if (args.size() <= argIndex) {
            return;
        }

        UExpression argument = args.get(argIndex);
        ResourceUrl resource = ResourceEvaluator.getResource(context.getEvaluator(), argument);
        if (resource == null || resource.isFramework() || resource.type != ResourceType.STRING) {
            return;
        }

        String name = resource.name;
        if (mIgnoreStrings != null && mIgnoreStrings.contains(name)) {
            return;
        }

        boolean passingVarArgsArray = false;
        int callCount = args.size() - 1 - argIndex;

        if (callCount == 1) {
            // If instead of a varargs call like
            //    getString(R.string.foo, arg1, arg2, arg3)
            // the code is calling the varargs method with a packed Object array, as in
            //    getString(R.string.foo, new Object[] { arg1, arg2, arg3 })
            // we'll need to handle that such that we don't think this is a single
            // argument

            UExpression lastArg = args.get(args.size() - 1);
            PsiParameterList parameterList = calledMethod.getParameterList();
            int parameterCount = parameterList.getParametersCount();
            if (parameterCount > 0
                    && parameterList.getParameters()[parameterCount - 1].isVarArgs()) {
                boolean knownArity = false;

                boolean argWasReference = false;
                if (lastArg instanceof UReferenceExpression) {
                    PsiElement resolved = ((UReferenceExpression) lastArg).resolve();
                    if (resolved instanceof PsiVariable) {
                        UExpression initializer =
                                UastFacade.INSTANCE.getInitializerBody((PsiVariable) resolved);
                        if (initializer != null
                                && (UastExpressionUtils.isNewArray(initializer)
                                        || UastExpressionUtils.isArrayInitializer(initializer))) {
                            argWasReference = true;
                            // Now handled by check below
                            lastArg = initializer;
                        }
                    }
                }

                if (UastExpressionUtils.isNewArray(lastArg)
                        || UastExpressionUtils.isArrayInitializer(lastArg)) {
                    UCallExpression arrayInitializer = (UCallExpression) lastArg;

                    if (UastExpressionUtils.isNewArrayWithInitializer(lastArg)
                            || UastExpressionUtils.isArrayInitializer(lastArg)) {
                        callCount = arrayInitializer.getValueArgumentCount();
                        knownArity = true;
                    } else if (UastExpressionUtils.isNewArrayWithDimensions(lastArg)) {
                        List<UExpression> arrayDimensions = arrayInitializer.getValueArguments();
                        if (arrayDimensions.size() == 1) {
                            UExpression first = arrayDimensions.get(0);
                            if (first instanceof ULiteralExpression) {
                                Object o = ((ULiteralExpression) first).getValue();
                                if (o instanceof Integer) {
                                    callCount = (Integer) o;
                                    knownArity = true;
                                }
                            }
                        }
                    }
                    if (!knownArity) {
                        if (!argWasReference) {
                            return;
                        }
                    } else {
                        passingVarArgsArray = true;
                    }
                }
            }
        }

        if (callCount > 0 && mNotFormatStrings.containsKey(name)) {
            checkNotFormattedHandle(context, call, name, mNotFormatStrings.get(name));
            return;
        }

        List<Pair<Handle, String>> list = mFormatStrings != null ? mFormatStrings.get(name) : null;
        if (list == null) {
            LintClient client = context.getClient();
            if (client.supportsProjectResources()
                    && !context.getScope().contains(Scope.RESOURCE_FILE)) {
                ResourceRepository resources =
                        client.getResourceRepository(context.getMainProject(), true, false);
                List<ResourceItem> items;
                if (resources != null) {
                    items =
                            resources.getResources(
                                    ResourceNamespace.TODO(), ResourceType.STRING, name);
                } else {
                    // Must be a non-Android module
                    items = null;
                }
                if (items != null) {
                    for (final ResourceItem item : items) {
                        ResourceValue v = item.getResourceValue();
                        if (v != null) {
                            String value = v.getRawXmlValue();
                            // Attempt to resolve indirection
                            if (value == null) {
                                continue;
                            }
                            if (isReference(value)) {
                                // Only resolve a few indirections
                                for (int i = 0; i < 3; i++) {
                                    ResourceUrl url = ResourceUrl.parse(value);
                                    if (url == null || url.isFramework()) {
                                        break;
                                    }
                                    List<ResourceItem> l =
                                            resources.getResources(
                                                    ResourceNamespace.TODO(), url.type, url.name);
                                    if (l != null && !l.isEmpty()) {
                                        v = l.get(0).getResourceValue();
                                        if (v != null) {
                                            value = v.getValue();
                                            if (value == null || !isReference(value)) {
                                                break;
                                            }
                                        } else {
                                            break;
                                        }
                                    } else {
                                        break;
                                    }
                                }
                            }

                            if (value != null && !isReference(value)) {
                                // Make sure it's really a formatting string,
                                // not for example "Battery remaining: 90%"
                                boolean isFormattingString = value.indexOf('%') != -1;
                                for (int j = 0, m = value.length();
                                        j < m && isFormattingString;
                                        j++) {
                                    char c = value.charAt(j);
                                    if (c == '\\') {
                                        j++;
                                    } else if (c == '%') {
                                        Matcher matcher = FORMAT.matcher(value);
                                        if (!matcher.find(j)) {
                                            isFormattingString = false;
                                        } else {
                                            String conversion = matcher.group(6);
                                            int conversionClass =
                                                    getConversionClass(conversion.charAt(0));
                                            if (conversionClass == CONVERSION_CLASS_UNKNOWN
                                                    || matcher.group(5) != null) {
                                                // Some date format etc - don't process
                                                return;
                                            }
                                        }
                                        j++; // Don't process second % in a %%
                                    }
                                    // If the user marked the string with
                                }

                                Handle handle = client.createResourceItemHandle(item);
                                if (isFormattingString) {
                                    if (list == null) {
                                        list = Lists.newArrayList();
                                        if (mFormatStrings == null) {
                                            mFormatStrings = Maps.newHashMap();
                                        }
                                        mFormatStrings.put(name, list);
                                    }
                                    list.add(Pair.of(handle, value));
                                } else if (callCount > 0) {
                                    checkNotFormattedHandle(context, call, name, handle);
                                }
                            }
                        }
                    }
                }
            } else {
                return;
            }
        }

        if (list != null) {
            Set<String> reported = null;
            for (Pair<Handle, String> pair : list) {
                String s = pair.getSecond();
                if (reported != null && reported.contains(s)) {
                    continue;
                }
                int count = getFormatArgumentCount(s, null);
                Handle handle = pair.getFirst();
                if (count != callCount) {
                    Location location = context.getLocation(call);
                    Location secondary = handle.resolve();
                    secondary.setMessage(
                            String.format("This definition requires %1$d arguments", count));
                    location.setSecondary(secondary);
                    String message =
                            String.format(
                                    "Wrong argument count, format string `%1$s` requires `%2$d` but format "
                                            + "call supplies `%3$d`",
                                    name, count, callCount);
                    context.report(ARG_TYPES, call, location, message);
                    if (reported == null) {
                        reported = Sets.newHashSet();
                    }
                    reported.add(s);
                } else {
                    if (passingVarArgsArray) {
                        // Can't currently check these: make sure we don't incorrectly
                        // flag parameters on the Object[] instead of the wrapped parameters
                        return;
                    }
                    for (int i = 1; i <= count; i++) {
                        int argumentIndex = i + argIndex;
                        PsiType type = args.get(argumentIndex).getExpressionType();
                        if (type != null) {
                            boolean valid = true;
                            String formatType = getFormatArgumentType(s, i);
                            if (formatType == null) {
                                continue;
                            }
                            char last = formatType.charAt(formatType.length() - 1);
                            if (formatType.length() >= 2
                                    && Character.toLowerCase(
                                                    formatType.charAt(formatType.length() - 2))
                                            == 't') {
                                // Date time conversion.
                                // TODO
                                continue;
                            }
                            switch (last) {
                                    // Booleans. It's okay to pass objects to these;
                                    // it will print "true" if non-null, but it's
                                    // unusual and probably not intended.
                                case 'b':
                                case 'B':
                                    valid = isBooleanType(type);
                                    break;

                                    // Numeric: integer and floats in various formats
                                case 'x':
                                case 'X':
                                case 'd':
                                case 'o':
                                case 'e':
                                case 'E':
                                case 'f':
                                case 'g':
                                case 'G':
                                case 'a':
                                case 'A':
                                    valid = isNumericType(type, true);
                                    break;
                                case 'c':
                                case 'C':
                                    // Unicode character
                                    valid = isCharacterType(type);
                                    break;
                                case 'h':
                                case 'H': // Hex print of hash code of objects
                                    // From https://developer.android.com/reference/java/util/Formatter.html
                                    // """The following general conversions may be applied to any
                                    // argument type: 'b', 'B', 'h', 'H', 's', 'S' """
                                    // We'll still warn about %s since you may have intended
                                    // numeric formatting, but hex printing seems pretty well
                                    // intended.
                                    continue;
                                case 's':
                                case 'S':
                                    // String. Can pass anything, but warn about
                                    // numbers since you may have meant more
                                    // specific formatting. Use special issue
                                    // explanation for this?
                                    valid = !isBooleanType(type) && !isNumericType(type, false);
                                    break;
                            }

                            if (!valid) {
                                Location location = context.getLocation(args.get(argumentIndex));
                                Location secondary = handle.resolve();
                                secondary.setMessage("Conflicting argument declaration here");
                                location.setSecondary(secondary);
                                String suggestion = null;
                                if (isBooleanType(type)) {
                                    suggestion = "`b`";
                                } else if (isCharacterType(type)) {
                                    suggestion = "'c'";
                                } else if (PsiType.INT.equals(type)
                                        || PsiType.LONG.equals(type)
                                        || PsiType.BYTE.equals(type)
                                        || PsiType.SHORT.equals(type)) {
                                    suggestion = "`d`, 'o' or `x`";
                                } else if (PsiType.FLOAT.equals(type)
                                        || PsiType.DOUBLE.equals(type)) {
                                    suggestion = "`e`, 'f', 'g' or `a`";
                                } else if (type instanceof PsiClassType) {
                                    String fqn = type.getCanonicalText();
                                    if (TYPE_INTEGER_WRAPPER.equals(fqn)
                                            || TYPE_LONG_WRAPPER.equals(fqn)
                                            || TYPE_BYTE_WRAPPER.equals(fqn)
                                            || TYPE_SHORT_WRAPPER.equals(fqn)) {
                                        suggestion = "`d`, 'o' or `x`";
                                    } else if (TYPE_FLOAT_WRAPPER.equals(fqn)
                                            || TYPE_DOUBLE_WRAPPER.equals(fqn)) {
                                        suggestion = "`d`, 'o' or `x`";
                                    } else if (TYPE_OBJECT.equals(fqn)) {
                                        suggestion = "'s' or 'h'";
                                    }
                                }

                                if (suggestion != null) {
                                    suggestion =
                                            " (Did you mean formatting character "
                                                    + suggestion
                                                    + "?)";
                                } else {
                                    suggestion = "";
                                }

                                String canonicalText = type.getCanonicalText();
                                canonicalText =
                                        canonicalText.substring(canonicalText.lastIndexOf('.') + 1);

                                String message =
                                        String.format(
                                                "Wrong argument type for formatting argument '#%1$d' "
                                                        + "in `%2$s`: conversion is '`%3$s`', received `%4$s` "
                                                        + "(argument #%5$d in method call)%6$s",
                                                i,
                                                name,
                                                formatType,
                                                canonicalText,
                                                argumentIndex + 1,
                                                suggestion);

                                if ((last == 's' || last == 'S') && isNumericType(type, false)) {
                                    message =
                                            String.format(
                                                    "Suspicious argument type for formatting argument #%1$d "
                                                            + "in `%2$s`: conversion is `%3$s`, received `%4$s` "
                                                            + "(argument #%5$d in method call)%6$s",
                                                    i,
                                                    name,
                                                    formatType,
                                                    canonicalText,
                                                    argumentIndex + 1,
                                                    suggestion);
                                }

                                context.report(ARG_TYPES, call, location, message);
                                if (reported == null) {
                                    reported = Sets.newHashSet();
                                }
                                reported.add(s);
                            }
                        }
                    }
                }
            }
        }
    }

    private static boolean isCharacterType(PsiType type) {
        //return PsiType.CHAR.isAssignableFrom(type);
        if (type == PsiType.CHAR) {
            return true;
        }
        if (type instanceof PsiClassType) {
            String fqn = type.getCanonicalText();
            return TYPE_CHARACTER_WRAPPER.equals(fqn);
        }

        return false;
    }

    private static boolean isBooleanType(PsiType type) {
        //return PsiType.BOOLEAN.isAssignableFrom(type);
        if (type == PsiType.BOOLEAN) {
            return true;
        }
        if (type instanceof PsiClassType) {
            String fqn = type.getCanonicalText();
            return TYPE_BOOLEAN_WRAPPER.equals(fqn);
        }

        return false;
    }

    //PsiType:java.lang.Boolean
    private static boolean isNumericType(@NonNull PsiType type, boolean allowBigNumbers) {
        if (PsiType.INT.equals(type)
                || PsiType.FLOAT.equals(type)
                || PsiType.DOUBLE.equals(type)
                || PsiType.LONG.equals(type)
                || PsiType.BYTE.equals(type)
                || PsiType.SHORT.equals(type)) {
            return true;
        }

        if (type instanceof PsiClassType) {
            String fqn = type.getCanonicalText();
            if (TYPE_INTEGER_WRAPPER.equals(fqn)
                    || TYPE_FLOAT_WRAPPER.equals(fqn)
                    || TYPE_DOUBLE_WRAPPER.equals(fqn)
                    || TYPE_LONG_WRAPPER.equals(fqn)
                    || TYPE_BYTE_WRAPPER.equals(fqn)
                    || TYPE_SHORT_WRAPPER.equals(fqn)) {
                return true;
            }
            if (allowBigNumbers) {
                if ("java.math.BigInteger".equals(fqn) || "java.math.BigDecimal".equals(fqn)) {
                    return true;
                }
            }
        }

        return false;
    }
}