#!/usr/bin/env python3
#
# Copyright (c) 2014, 2016 ARM Limited
# All rights reserved
#
# The license below extends only to copyright in the software and shall
# not be construed as granting a license to any other intellectual
# property including but not limited to intellectual property relating
# to a hardware implementation of the functionality of the software
# licensed hereunder.  You may use the software subject to the license
# terms below provided that you ensure that this notice is replicated
# unmodified and in its entirety in all distributions of the software,
# modified or unmodified, in source code or in binary form.
#
# Copyright (c) 2006 The Regents of The University of Michigan
# Copyright (c) 2007,2011 The Hewlett-Packard Development Company
# Copyright (c) 2016 Advanced Micro Devices, Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met: redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer;
# redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution;
# neither the name of the copyright holders nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

from abc import ABCMeta, abstractmethod
from difflib import SequenceMatcher
import inspect
import os
import re
import sys

from . import style
from . import sort_includes
from .region import *
from .file_types import lang_type


def safefix(fix_func):
    """Decorator for the fix functions of the Verifier class.
    This function wraps the fix function and creates a backup file
    just in case there is an error.
    """

    def safefix_wrapper(*args, **kwargs):
        # Check to be sure that this is decorating a function we expect:
        # a class method with filename as the first argument (after self)
        assert os.path.exists(args[1])
        self = args[0]
        assert is_verifier(self.__class__)
        filename = args[1]

        # Now, Let's make a backup file.
        from shutil import copyfile

        backup_name = filename + ".bak"
        copyfile(filename, backup_name)

        # Try to apply the fix. If it fails, then we revert the file
        # Either way, we need to clean up our backup file
        try:
            fix_func(*args, **kwargs)
        except Exception as e:
            # Restore the original file to the backup file
            self.ui.write("Error! Restoring the original file.\n")
            copyfile(backup_name, filename)
            raise
        finally:
            # Clean up the backup file
            os.remove(backup_name)

    return safefix_wrapper


def _modified_regions(old, new):
    try:
        m = SequenceMatcher(a=old, b=new, autojunk=False)
    except TypeError:
        # autojunk was introduced in Python 2.7. We need a fallback
        # mechanism to support old Python versions.
        m = SequenceMatcher(a=old, b=new)
    regions = Regions()
    for tag, i1, i2, j1, j2 in m.get_opcodes():
        if tag != "equal":
            regions.extend(Region(i1, i2))
    return regions


class Verifier(object, metaclass=ABCMeta):
    """Base class for style verifiers

    Verifiers check for style violations and optionally fix such
    violations. Implementations should either inherit from this class
    (Verifier) if they need to work on entire files or LineVerifier if
    they operate on a line-by-line basis.

    Subclasses must define these class attributes:
      languages = set of strings identifying applicable languages
      test_name = long descriptive name of test, will be used in
                  messages such as "error in <foo>" or "invalid <foo>"
      opt_name = short name used to generate command-line options to
                 control the test (--fix-<foo>, --ignore-<foo>, etc.)

    """

    def __init__(self, ui, opts, base=None):
        self.ui = ui
        self.base = base

        # opt_name must be defined as a class attribute of derived classes.
        # Check test-specific opts first as these have precedence.
        self.opt_fix = opts.get("fix_" + self.opt_name, False)
        self.opt_ignore = opts.get("ignore_" + self.opt_name, False)
        self.opt_skip = opts.get("skip_" + self.opt_name, False)
        # If no test-specific opts were set, then set based on "-all" opts.
        if not (self.opt_fix or self.opt_ignore or self.opt_skip):
            self.opt_fix = opts.get("fix_all", False)
            self.opt_ignore = opts.get("ignore_all", False)
            self.opt_skip = opts.get("skip_all", False)

    def normalize_filename(self, name):
        abs_name = os.path.abspath(name)
        if self.base is None:
            return abs_name

        abs_base = os.path.abspath(self.base)
        return os.path.relpath(abs_name, start=abs_base)

    def open(self, filename, mode):
        try:
            f = open(filename, mode)
        except OSError as msg:
            print(f"could not open file {filename}: {msg}")
            return None

        return f

    def skip(self, filename):
        # We never want to handle symlinks, so always skip them: If the
        # location pointed to is a directory, skip it. If the location is a
        # file inside the gem5 directory, it will be checked as a file, so
        # symlink can be skipped. If the location is a file outside gem5, we
        # don't want to check it anyway.
        if os.path.islink(filename):
            return True
        return lang_type(filename) not in self.languages

    def apply(self, filename, regions=all_regions):
        """Possibly apply to specified regions of file 'filename'.

        Verifier is skipped if --skip-<test> option was provided or if
        file is not of an applicable type.  Otherwise file is checked
        and error messages printed.  Errors are fixed or ignored if
        the corresponding --fix-<test> or --ignore-<test> options were
        provided.  If neither, the user is prompted for an action.

        Returns True to abort, False otherwise.
        """
        if not (self.opt_skip or self.skip(filename)):
            errors = self.check(filename, regions)
            if errors and not self.opt_ignore:
                if self.opt_fix:
                    self.fix(filename, regions)
                else:
                    result = self.ui.prompt(
                        "(a)bort, (i)gnore, or (f)ix?", "aif", "a"
                    )
                    if result == "f":
                        self.fix(filename, regions)
                    elif result == "a":
                        return True  # abort

        return False

    @abstractmethod
    def check(self, filename, regions=all_regions, fobj=None, silent=False):
        """Check specified regions of file 'filename'.

        Given that it is possible that the current contents of the file
        differ from the file as 'staged to commit', for those cases, and
        maybe others, the argument fobj should be a file object open and reset
        with the contents matching what the file would look like after the
        commit. This is needed keep the messages using 'filename' meaningful.

        The argument silent is useful to prevent output when we run check in
        the staged file vs the actual file to detect if the user forgot
        staging fixes to the commit. This way, we prevent reporting errors
        twice in stderr.

        Line-by-line checks can simply provide a check_line() method
        that returns True if the line is OK and False if it has an
        error.  Verifiers that need a multi-line view (like
        SortedIncludes) must override this entire function.

        Returns a count of errors (0 if none), though actual non-zero
        count value is not currently used anywhere.
        """
        pass

    @abstractmethod
    def fix(self, filename, regions=all_regions):
        """Fix specified regions of file 'filename'.

        Line-by-line fixes can simply provide a fix_line() method that
        returns the fixed line. Verifiers that need a multi-line view
        (like SortedIncludes) must override this entire function.
        """
        pass


class LineVerifier(Verifier):
    def check(self, filename, regions=all_regions, fobj=None, silent=False):
        close = False
        if fobj is None:
            fobj = self.open(filename, "rb")
            close = True

        lang = lang_type(filename)
        assert lang in self.languages

        errors = 0
        for num, line in enumerate(fobj):
            if num not in regions:
                continue
            s_line = line.decode("utf-8").rstrip("\n")
            if not self.check_line(s_line, language=lang):
                if not silent:
                    self.ui.write(
                        "invalid %s in %s:%d\n"
                        % (self.test_name, filename, num + 1)
                    )
                    if self.ui.verbose:
                        self.ui.write(f">>{s_line[:-1]}<<\n")
                errors += 1
        if close:
            fobj.close()
        return errors

    @safefix
    def fix(self, filename, regions=all_regions):
        f = self.open(filename, "r+")

        lang = lang_type(filename)
        assert lang in self.languages

        lines = list(f)

        f.seek(0)
        f.truncate()

        for i, line in enumerate(lines):
            line = line.rstrip("\n")
            if i in regions:
                line = self.fix_line(line, language=lang)

            f.write(line)
            f.write("\n")
        f.close()
        self.current_language = None

    @abstractmethod
    def check_line(self, line, **kwargs):
        pass

    @abstractmethod
    def fix_line(self, line, **kwargs):
        pass


class Whitespace(LineVerifier):
    """Check whitespace.

    Specifically:
    - No tabs used for indent
    - No trailing whitespace
    """

    languages = set(
        ("C", "C++", "swig", "python", "asm", "isa", "scons", "make", "dts")
    )
    trail_only = set(("make", "dts"))

    test_name = "whitespace"
    opt_name = "white"

    _lead = re.compile(r"^([ \t]+)")
    _trail = re.compile(r"([ \t]+)$")

    def skip_lead(self, language):
        return language in Whitespace.trail_only

    def check_line(self, line, language):
        if not self.skip_lead(language):
            match = Whitespace._lead.search(line)
            if match and match.group(1).find("\t") != -1:
                return False

        match = Whitespace._trail.search(line)
        if match:
            return False

        return True

    def fix_line(self, line, language):
        if not self.skip_lead(language) and Whitespace._lead.search(line):
            newline = ""
            for i, c in enumerate(line):
                if c == " ":
                    newline += " "
                elif c == "\t":
                    newline += " " * (
                        style.tabsize - len(newline) % style.tabsize
                    )
                else:
                    newline += line[i:]
                    break

            line = newline

        return line.rstrip()


class SortedIncludes(Verifier):
    """Check for proper sorting of include statements"""

    languages = sort_includes.default_languages
    test_name = "include file order"
    opt_name = "include"

    def __init__(self, *args, **kwargs):
        super(SortedIncludes, self).__init__(*args, **kwargs)
        self.sort_includes = sort_includes.SortIncludes()

    def check(self, filename, regions=all_regions, fobj=None, silent=False):
        close = False
        if fobj is None:
            fobj = self.open(filename, "rb")
            close = True
        norm_fname = self.normalize_filename(filename)

        old = [l.decode("utf-8").rstrip("\n") for l in fobj]
        if close:
            fobj.close()

        if len(old) == 0:
            return 0

        language = lang_type(filename, old[0])
        new = list(self.sort_includes(old, norm_fname, language))

        modified = _modified_regions(old, new) & regions

        if modified:
            if not silent:
                self.ui.write(
                    "invalid sorting of includes in %s. Note: If "
                    "there is more than one empty line under the "
                    "#include region, please reduce it to one.\n" % (filename)
                )
                if self.ui.verbose:
                    for start, end in modified.regions:
                        self.ui.write("bad region [%d, %d)\n" % (start, end))
            return 1

        return 0

    @safefix
    def fix(self, filename, regions=all_regions):
        f = self.open(filename, "r+")
        norm_fname = self.normalize_filename(filename)

        old = f.readlines()
        lines = [l.rstrip("\n") for l in old]
        language = lang_type(filename, lines[0])
        sort_lines = list(self.sort_includes(lines, norm_fname, language))
        new = "".join(line + "\n" for line in sort_lines)

        f.seek(0)
        f.truncate()

        for i, line in enumerate(sort_lines):
            f.write(line)
            f.write("\n")
        f.close()


class ControlSpace(LineVerifier):
    """Check for exactly one space after if/while/for"""

    languages = set(("C", "C++"))
    test_name = "spacing after if/while/for"
    opt_name = "control"

    _any_control = re.compile(r"\b(if|while|for)([ \t]*)\(")

    def check_line(self, line, **kwargs):
        match = ControlSpace._any_control.search(line)
        return not (match and match.group(2) != " ")

    def fix_line(self, line, **kwargs):
        new_line = ControlSpace._any_control.sub(r"\1 (", line)
        return new_line


class LineLength(LineVerifier):
    languages = set(("C", "C++", "swig", "python", "asm", "isa", "scons"))
    test_name = "line length"
    opt_name = "length"

    def check_line(self, line, **kwargs):
        return style.normalized_len(line) <= 79

    def fix(self, filename, regions=all_regions, **kwargs):
        self.ui.write("Warning: cannot automatically fix overly long lines.\n")

    def fix_line(self, line):
        pass


class ControlCharacters(LineVerifier):
    languages = set(("C", "C++", "swig", "python", "asm", "isa", "scons"))
    test_name = "control character"
    opt_name = "ascii"

    invalid = "".join(
        [chr(i) for i in range(0, 0x20) if chr(i) not in ("\n", "\t")]
    )

    def check_line(self, line, **kwargs):
        return self.fix_line(line) == line

    def fix_line(self, line, **kwargs):
        return "".join(c for c in line if c not in ControlCharacters.invalid)


class BoolCompare(LineVerifier):
    languages = set(("C", "C++", "python"))
    test_name = "boolean comparison"
    opt_name = "boolcomp"

    regex = re.compile(r"\s*==\s*([Tt]rue|[Ff]alse)\b")

    def check_line(self, line, **kwargs):
        return self.regex.search(line) == None

    def fix_line(self, line, **kwargs):
        match = self.regex.search(line)
        if match:
            if match.group(1) in ("true", "True"):
                line = self.regex.sub("", line)
            else:
                self.ui.write(
                    "Warning: cannot automatically fix "
                    "comparisons with false/False.\n"
                )
        return line


class StructureBraces(LineVerifier):
    """Check if the opening braces of structures are not on the same line of
    the structure name. This includes classes, structs, enums and unions.

    This verifier matches lines starting in optional indent, followed by
    an optional typedef and the structure's keyword, followed by any
    character until the first opening brace is seen. Any extra characters
    after the opening brace are saved for a recursive check, if needed.

    This fixes, for example:
        1) "struct A {"
        2) "enum{"
        3) "    class B { // This is a class"
        4) "union { struct C {"
    to:
        1) "struct A\n{"
        2) "enum\n{"
        3) "    class B\n    {\n        // This is a class"
        4) "union\n{\n        struct C\n        {"

    @todo Make this work for multi-line structure declarations. e.g.,

        class MultiLineClass
          : public BaseClass {
    """

    languages = set(("C", "C++"))
    test_name = "structure opening brace position"
    opt_name = "structurebrace"

    # Matches the indentation of the line
    regex_indentation = "(?P<indentation>\s*)"
    # Matches an optional "typedef" before the keyword
    regex_typedef = "(?P<typedef>(typedef\s+)?)"
    # Matches the structure's keyword
    regex_keyword = "(?P<keyword>class|struct|enum|union)"
    # A negative lookahead to avoid incorrect matches with variable's names
    # e.g., "classifications = {" should not be fixed here.
    regex_avoid = "(?![^\{\s])"
    # Matches anything after the keyword and before the opening brace.
    # e.g., structure name, base type, type of inheritance, etc
    regex_name = "(?P<name>[^\{]*)"
    # Matches anything after the opening brace, which should be
    # parsed recursively
    regex_extra = "(?P<extra>.*)$"
    regex = re.compile(
        r"^"
        + regex_indentation
        + regex_typedef
        + regex_keyword
        + regex_avoid
        + regex_name
        + "\{"
        + regex_extra
    )

    def check_line(self, line, **kwargs):
        return (self.regex.search(line) == None) or (
            line.count("{") == line.count("};")
        )

    def fix_line(self, line, **kwargs):
        match = self.regex.search(line)

        if match:
            # Move the opening brace to the next line
            match_indentation = match.group("indentation")
            match_typedef = match.group("typedef")
            match_keyword = match.group("keyword")
            match_name = match.group("name").rstrip()
            match_extra = match.group("extra").lstrip()
            line = (
                match_indentation
                + match_typedef
                + match_keyword
                + match_name
                + "\n"
                + match_indentation
                + "{"
            )

            # The opening brace should be alone in its own line, so move any
            # extra contents to the next line
            if match_extra != "":
                # Check if the extra line obeys the opening brace rule
                # (in case there are nested declarations)
                line_extra = match_indentation + "    " + match_extra
                if not self.check_line(line_extra):
                    line_extra = self.fix_line(line_extra)
                line += "\n" + line_extra

        return line


def is_verifier(cls):
    """Determine if a class is a Verifier that can be instantiated"""

    return (
        inspect.isclass(cls)
        and issubclass(cls, Verifier)
        and not inspect.isabstract(cls)
    )


# list of all verifier classes
all_verifiers = [
    v for n, v in inspect.getmembers(sys.modules[__name__], is_verifier)
]