import os.path
import sys
import traceback
from collections import OrderedDict, defaultdict

from typing import Tuple, List, TypeVar, Set, Dict, Optional

from mypy.scope import Scope
from mypy.options import Options
from mypy.version import __version__ as mypy_version

MYPY = False
if MYPY:
    from typing_extensions import Final

T = TypeVar('T')
allowed_duplicates = ['@overload', 'Got:', 'Expected:']  # type: Final


class ErrorInfo:
    """Representation of a single error message."""

    # Description of a sequence of imports that refer to the source file
    # related to this error. Each item is a (path, line number) tuple.
    import_ctx = None  # type: List[Tuple[str, int]]

    # The path to source file that was the source of this error.
    file = ''

    # The fully-qualified id of the source module for this error.
    module = None  # type: Optional[str]

    # The name of the type in which this error is located at.
    type = ''  # type: Optional[str]   # Unqualified, may be None

    # The name of the function or member in which this error is located at.
    function_or_member = ''  # type: Optional[str]   # Unqualified, may be None

    # The line number related to this error within file.
    line = 0     # -1 if unknown

    # The column number related to this error with file.
    column = 0   # -1 if unknown

    # Either 'error', 'note', or 'warning'.
    severity = ''

    # The error message.
    message = ''

    # If True, we should halt build after the file that generated this error.
    blocker = False

    # Only report this particular messages once per program.
    only_once = False

    # Actual origin of the error message as tuple (path, line number)
    origin = None  # type: Tuple[str, int]

    # Fine-grained incremental target where this was reported
    target = None  # type: Optional[str]

    def __init__(self,
                 import_ctx: List[Tuple[str, int]],
                 file: str,
                 module: Optional[str],
                 typ: Optional[str],
                 function_or_member: Optional[str],
                 line: int,
                 column: int,
                 severity: str,
                 message: str,
                 blocker: bool,
                 only_once: bool,
                 origin: Optional[Tuple[str, int]] = None,
                 target: Optional[str] = None) -> None:
        self.import_ctx = import_ctx
        self.file = file
        self.module = module
        self.type = typ
        self.function_or_member = function_or_member
        self.line = line
        self.column = column
        self.severity = severity
        self.message = message
        self.blocker = blocker
        self.only_once = only_once
        self.origin = origin or (file, line)
        self.target = target


class Errors:
    """Container for compile errors.

    This class generates and keeps tracks of compile errors and the
    current error context (nested imports).
    """

    # Map from files to generated error messages. Is an OrderedDict so
    # that it can be used to order messages based on the order the
    # files were processed.
    error_info_map = None  # type: Dict[str, List[ErrorInfo]]

    # Files that we have reported the errors for
    flushed_files = None  # type: Set[str]

    # Current error context: nested import context/stack, as a list of (path, line) pairs.
    import_ctx = None  # type: List[Tuple[str, int]]

    # Path name prefix that is removed from all paths, if set.
    ignore_prefix = None  # type: Optional[str]

    # Path to current file.
    file = ''  # type: str

    # Ignore errors on these lines of each file.
    ignored_lines = None  # type: Dict[str, Set[int]]

    # Lines on which an error was actually ignored.
    used_ignored_lines = None  # type: Dict[str, Set[int]]

    # Files where all errors should be ignored.
    ignored_files = None  # type: Set[str]

    # Collection of reported only_once messages.
    only_once_messages = None  # type: Set[str]

    # Set to True to show "In function "foo":" messages.
    show_error_context = False  # type: bool

    # Set to True to show column numbers in error messages.
    show_column_numbers = False  # type: bool

    # State for keeping track of the current fine-grained incremental mode target.
    # (See mypy.server.update for more about targets.)
    # Current module id.
    target_module = None  # type: Optional[str]
    scope = None  # type: Optional[Scope]

    def __init__(self, show_error_context: bool = False,
                 show_column_numbers: bool = False) -> None:
        self.show_error_context = show_error_context
        self.show_column_numbers = show_column_numbers
        self.initialize()

    def initialize(self) -> None:
        self.error_info_map = OrderedDict()
        self.flushed_files = set()
        self.import_ctx = []
        self.type_name = [None]
        self.function_or_member = [None]
        self.ignored_lines = OrderedDict()
        self.used_ignored_lines = defaultdict(set)
        self.ignored_files = set()
        self.only_once_messages = set()
        self.scope = None
        self.target_module = None

    def reset(self) -> None:
        self.initialize()

    def copy(self) -> 'Errors':
        new = Errors(self.show_error_context, self.show_column_numbers)
        new.file = self.file
        new.import_ctx = self.import_ctx[:]
        new.type_name = self.type_name[:]
        new.function_or_member = self.function_or_member[:]
        new.target_module = self.target_module
        new.scope = self.scope
        return new

    def set_ignore_prefix(self, prefix: str) -> None:
        """Set path prefix that will be removed from all paths."""
        prefix = os.path.normpath(prefix)
        # Add separator to the end, if not given.
        if os.path.basename(prefix) != '':
            prefix += os.sep
        self.ignore_prefix = prefix

    def simplify_path(self, file: str) -> str:
        file = os.path.normpath(file)
        return remove_path_prefix(file, self.ignore_prefix)

    def set_file(self, file: str,
                 module: Optional[str],
                 scope: Optional[Scope] = None) -> None:
        """Set the path and module id of the current file."""
        # The path will be simplified later, in render_messages. That way
        #  * 'file' is always a key that uniquely identifies a source file
        #    that mypy read (simplified paths might not be unique); and
        #  * we only have to simplify in one place, while still supporting
        #    reporting errors for files other than the one currently being
        #    processed.
        self.file = file
        self.target_module = module
        self.scope = scope

    def set_file_ignored_lines(self, file: str,
                               ignored_lines: Set[int],
                               ignore_all: bool = False) -> None:
        self.ignored_lines[file] = ignored_lines
        if ignore_all:
            self.ignored_files.add(file)

    def current_target(self) -> Optional[str]:
        """Retrieves the current target from the associated scope.

        If there is no associated scope, use the target module."""
        if self.scope is not None:
            return self.scope.current_target()
        return self.target_module

    def current_module(self) -> Optional[str]:
        return self.target_module

    def import_context(self) -> List[Tuple[str, int]]:
        """Return a copy of the import context."""
        return self.import_ctx[:]

    def set_import_context(self, ctx: List[Tuple[str, int]]) -> None:
        """Replace the entire import context with a new value."""
        self.import_ctx = ctx[:]

    def report(self,
               line: int,
               column: Optional[int],
               message: str,
               blocker: bool = False,
               severity: str = 'error',
               file: Optional[str] = None,
               only_once: bool = False,
               origin_line: Optional[int] = None,
               offset: int = 0) -> None:
        """Report message at the given line using the current error context.

        Args:
            line: line number of error
            message: message to report
            blocker: if True, don't continue analysis after this error
            severity: 'error', 'note' or 'warning'
            file: if non-None, override current file as context
            only_once: if True, only report this exact message once per build
            origin_line: if non-None, override current context as origin
        """
        if self.scope:
            type = self.scope.current_type_name()
            if self.scope.ignored > 0:
                type = None  # Omit type context if nested function
            function = self.scope.current_function_name()
        else:
            type = None
            function = None

        if column is None:
            column = -1
        if file is None:
            file = self.file
        if offset:
            message = " " * offset + message
        info = ErrorInfo(self.import_context(), file, self.current_module(), type,
                         function, line, column, severity, message,
                         blocker, only_once,
                         origin=(self.file, origin_line) if origin_line else None,
                         target=self.current_target())
        self.add_error_info(info)

    def _add_error_info(self, file: str, info: ErrorInfo) -> None:
        assert file not in self.flushed_files
        if file not in self.error_info_map:
            self.error_info_map[file] = []
        self.error_info_map[file].append(info)

    def add_error_info(self, info: ErrorInfo) -> None:
        file, line = info.origin
        if not info.blocker:  # Blockers cannot be ignored
            if file in self.ignored_lines and line in self.ignored_lines[file]:
                # Annotation requests us to ignore all errors on this line.
                self.used_ignored_lines[file].add(line)
                return
            if file in self.ignored_files:
                return
        if info.only_once:
            if info.message in self.only_once_messages:
                return
            self.only_once_messages.add(info.message)
        self._add_error_info(file, info)

    def clear_errors_in_targets(self, path: str, targets: Set[str]) -> None:
        """Remove errors in specific fine-grained targets within a file."""
        if path in self.error_info_map:
            new_errors = []
            for info in self.error_info_map[path]:
                if info.target not in targets:
                    new_errors.append(info)
                elif info.only_once:
                    self.only_once_messages.remove(info.message)
            self.error_info_map[path] = new_errors

    def generate_unused_ignore_notes(self, file: str) -> None:
        ignored_lines = self.ignored_lines[file]
        if not self.is_typeshed_file(file) and file not in self.ignored_files:
            for line in ignored_lines - self.used_ignored_lines[file]:
                # Don't use report since add_error_info will ignore the error!
                info = ErrorInfo(self.import_context(), file, self.current_module(), None,
                                 None, line, -1, 'note', "unused 'type: ignore' comment",
                                 False, False)
                self._add_error_info(file, info)

    def is_typeshed_file(self, file: str) -> bool:
        # gross, but no other clear way to tell
        return 'typeshed' in os.path.normpath(file).split(os.sep)

    def num_messages(self) -> int:
        """Return the number of generated messages."""
        return sum(len(x) for x in self.error_info_map.values())

    def is_errors(self) -> bool:
        """Are there any generated errors?"""
        return bool(self.error_info_map)

    def is_blockers(self) -> bool:
        """Are the any errors that are blockers?"""
        return any(err for errs in self.error_info_map.values() for err in errs if err.blocker)

    def blocker_module(self) -> Optional[str]:
        """Return the module with a blocking error, or None if not possible."""
        for errs in self.error_info_map.values():
            for err in errs:
                if err.blocker:
                    return err.module
        return None

    def is_errors_for_file(self, file: str) -> bool:
        """Are there any errors for the given file?"""
        return file in self.error_info_map

    def raise_error(self) -> None:
        """Raise a CompileError with the generated messages.

        Render the messages suitable for displaying.
        """
        # self.new_messages() will format all messages that haven't already
        # been returned from a file_messages() call.
        raise CompileError(self.new_messages(),
                           use_stdout=True,
                           module_with_blocker=self.blocker_module())

    def format_messages(self, error_info: List[ErrorInfo]) -> List[str]:
        """Return a string list that represents the error messages.

        Use a form suitable for displaying to the user.
        """
        a = []  # type: List[str]
        errors = self.render_messages(self.sort_messages(error_info))
        errors = self.remove_duplicates(errors)
        for file, line, column, severity, message in errors:
            s = ''
            if file is not None:
                if self.show_column_numbers and line is not None and line >= 0 \
                        and column is not None and column >= 0:
                    srcloc = '{}:{}:{}'.format(file, line, 1 + column)
                elif line is not None and line >= 0:
                    srcloc = '{}:{}'.format(file, line)
                else:
                    srcloc = file
                s = '{}: {}: {}'.format(srcloc, severity, message)
            else:
                s = message
            a.append(s)
        return a

    def file_messages(self, path: str) -> List[str]:
        """Return a string list of new error messages from a given file.

        Use a form suitable for displaying to the user.
        """
        if path not in self.error_info_map:
            return []
        self.flushed_files.add(path)
        return self.format_messages(self.error_info_map[path])

    def new_messages(self) -> List[str]:
        """Return a string list of new error messages.

        Use a form suitable for displaying to the user.
        Errors from different files are ordered based on the order in which
        they first generated an error.
        """
        msgs = []
        for path in self.error_info_map.keys():
            if path not in self.flushed_files:
                msgs.extend(self.file_messages(path))
        return msgs

    def targets(self) -> Set[str]:
        """Return a set of all targets that contain errors."""
        # TODO: Make sure that either target is always defined or that not being defined
        #       is okay for fine-grained incremental checking.
        return set(info.target
                   for errs in self.error_info_map.values()
                   for info in errs
                   if info.target)

    def render_messages(self, errors: List[ErrorInfo]) -> List[Tuple[Optional[str], int, int,
                                                                     str, str]]:
        """Translate the messages into a sequence of tuples.

        Each tuple is of form (path, line, col, severity, message).
        The rendered sequence includes information about error contexts.
        The path item may be None. If the line item is negative, the
        line number is not defined for the tuple.
        """
        result = []  # type: List[Tuple[Optional[str], int, int, str, str]]
        # (path, line, column, severity, message)

        prev_import_context = []  # type: List[Tuple[str, int]]
        prev_function_or_member = None  # type: Optional[str]
        prev_type = None  # type: Optional[str]

        for e in errors:
            # Report module import context, if different from previous message.
            if not self.show_error_context:
                pass
            elif e.import_ctx != prev_import_context:
                last = len(e.import_ctx) - 1
                i = last
                while i >= 0:
                    path, line = e.import_ctx[i]
                    fmt = '{}:{}: note: In module imported here'
                    if i < last:
                        fmt = '{}:{}: note: ... from here'
                    if i > 0:
                        fmt += ','
                    else:
                        fmt += ':'
                    # Remove prefix to ignore from path (if present) to
                    # simplify path.
                    path = remove_path_prefix(path, self.ignore_prefix)
                    result.append((None, -1, -1, 'note', fmt.format(path, line)))
                    i -= 1

            file = self.simplify_path(e.file)

            # Report context within a source file.
            if not self.show_error_context:
                pass
            elif (e.function_or_member != prev_function_or_member or
                    e.type != prev_type):
                if e.function_or_member is None:
                    if e.type is None:
                        result.append((file, -1, -1, 'note', 'At top level:'))
                    else:
                        result.append((file, -1, -1, 'note', 'In class "{}":'.format(
                            e.type)))
                else:
                    if e.type is None:
                        result.append((file, -1, -1, 'note',
                                       'In function "{}":'.format(
                                           e.function_or_member)))
                    else:
                        result.append((file, -1, -1, 'note',
                                       'In member "{}" of class "{}":'.format(
                                           e.function_or_member, e.type)))
            elif e.type != prev_type:
                if e.type is None:
                    result.append((file, -1, -1, 'note', 'At top level:'))
                else:
                    result.append((file, -1, -1, 'note',
                                   'In class "{}":'.format(e.type)))

            result.append((file, e.line, e.column, e.severity, e.message))

            prev_import_context = e.import_ctx
            prev_function_or_member = e.function_or_member
            prev_type = e.type

        return result

    def sort_messages(self, errors: List[ErrorInfo]) -> List[ErrorInfo]:
        """Sort an array of error messages locally by line number.

        I.e., sort a run of consecutive messages with the same
        context by line number, but otherwise retain the general
        ordering of the messages.
        """
        result = []  # type: List[ErrorInfo]
        i = 0
        while i < len(errors):
            i0 = i
            # Find neighbouring errors with the same context and file.
            while (i + 1 < len(errors) and
                    errors[i + 1].import_ctx == errors[i].import_ctx and
                    errors[i + 1].file == errors[i].file):
                i += 1
            i += 1

            # Sort the errors specific to a file according to line number and column.
            a = sorted(errors[i0:i], key=lambda x: (x.line, x.column))
            result.extend(a)
        return result

    def remove_duplicates(self, errors: List[Tuple[Optional[str], int, int, str, str]]
                          ) -> List[Tuple[Optional[str], int, int, str, str]]:
        """Remove duplicates from a sorted error list."""
        res = []  # type: List[Tuple[Optional[str], int, int, str, str]]
        i = 0
        while i < len(errors):
            dup = False
            j = i - 1
            while (j >= 0 and errors[j][0] == errors[i][0] and
                    errors[j][1] == errors[i][1]):
                if (errors[j][3] == errors[i][3] and
                        # Allow duplicate notes in overload conflicts reporting.
                        not (errors[i][3] == 'note' and
                             errors[i][4].strip() in allowed_duplicates
                             or errors[i][4].strip().startswith('def ')) and
                        errors[j][4] == errors[i][4]):  # ignore column
                    dup = True
                    break
                j -= 1
            if not dup:
                res.append(errors[i])
            i += 1
        return res


class CompileError(Exception):
    """Exception raised when there is a compile error.

    It can be a parse, semantic analysis, type check or other
    compilation-related error.

    CompileErrors raised from an errors object carry all of the
    messages that have not been reported out by error streaming.
    This is patched up by build.build to contain either all error
    messages (if errors were streamed) or none (if they were not).

    """

    messages = None  # type: List[str]
    use_stdout = False
    # Can be set in case there was a module with a blocking error
    module_with_blocker = None  # type: Optional[str]

    def __init__(self,
                 messages: List[str],
                 use_stdout: bool = False,
                 module_with_blocker: Optional[str] = None) -> None:
        super().__init__('\n'.join(messages))
        self.messages = messages
        self.use_stdout = use_stdout
        self.module_with_blocker = module_with_blocker


def remove_path_prefix(path: str, prefix: Optional[str]) -> str:
    """If path starts with prefix, return copy of path with the prefix removed.
    Otherwise, return path. If path is None, return None.
    """
    if prefix is not None and path.startswith(prefix):
        return path[len(prefix):]
    else:
        return path


def report_internal_error(err: Exception, file: Optional[str], line: int,
                          errors: Errors, options: Options) -> None:
    """Report internal error and exit.

    This optionally starts pdb or shows a traceback.
    """
    # Dump out errors so far, they often provide a clue.
    # But catch unexpected errors rendering them.
    try:
        for msg in errors.new_messages():
            print(msg)
    except Exception as e:
        print("Failed to dump errors:", repr(e), file=sys.stderr)

    # Compute file:line prefix for official-looking error messages.
    if file:
        if line:
            prefix = '{}:{}: '.format(file, line)
        else:
            prefix = '{}: '.format(file)
    else:
        prefix = ''

    # Print "INTERNAL ERROR" message.
    print('{}error: INTERNAL ERROR --'.format(prefix),
          'please report a bug at https://github.com/python/mypy/issues',
          'version: {}'.format(mypy_version),
          file=sys.stderr)

    # If requested, drop into pdb. This overrides show_tb.
    if options.pdb:
        print('Dropping into pdb', file=sys.stderr)
        import pdb
        pdb.post_mortem(sys.exc_info()[2])

    # If requested, print traceback, else print note explaining how to get one.
    if options.raise_exceptions:
        raise err
    if not options.show_traceback:
        if not options.pdb:
            print('{}: note: please use --show-traceback to print a traceback '
                  'when reporting a bug'.format(prefix),
                  file=sys.stderr)
    else:
        tb = traceback.extract_stack()[:-2]
        tb2 = traceback.extract_tb(sys.exc_info()[2])
        print('Traceback (most recent call last):')
        for s in traceback.format_list(tb + tb2):
            print(s.rstrip('\n'))
        print('{}: {}'.format(type(err).__name__, err))
        print('{}: note: use --pdb to drop into pdb'.format(prefix), file=sys.stderr)

    # Exit.  The caller has nothing more to say.
    # We use exit code 2 to signal that this is no ordinary error.
    raise SystemExit(2)
