# Copyright (c) 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from threading import Lock

from common import utils
import crash_utils


class Blame(object):
  """Represents a blame object.

  The object contains blame information for one line of stack, and this
  information is shown when there are no CLs that change the crashing files.
  Attributes:
    line_content: The content of the line to find the blame for.
    component_name: The name of the component for this line.
    stack_frame_index: The stack frame index of this file.
    file_name: The name of the file.
    line_number: The line that caused a crash.
    author: The author of this line on the latest revision.
    revision: The latest revision of this line before the crash revision.
    message: The commit message for the revision.
    time: When the revision was committed.
    url: The url of the change for the revision.
    range_start: The starting range of the regression for this component.
    range_end: The ending range of the regression.

  """

  def __init__(self, line_content, component_name, stack_frame_index,
               file_name, line_number, author, revision, message, time,
               url, range_start, range_end):
    # Set all the variables from the arguments.
    self.line_content = line_content
    self.component_name = component_name
    self.stack_frame_index = stack_frame_index
    self.file = file_name
    self.line_number = line_number
    self.author = author
    self.revision = revision
    self.message = message
    self.time = time
    self.url = url
    self.range_start = range_start
    self.range_end = range_end


class BlameList(object):
  """Represents a list of blame objects.

  Thread-safe.
  """

  def __init__(self):
    self.blame_list = []
    self.blame_list_lock = Lock()

  def __getitem__(self, index):
    return self.blame_list[index]

  def FindBlame(self, callstack, component_to_crash_revision_dict,
                component_to_regression_dict, parsers,
                top_n_frames=10):
    """Given a stack within a stacktrace, retrieves blame information.

    Only either first 'top_n_frames' or the length of stack, whichever is
    shorter, results are returned. The default value of 'top_n_frames' is 10.

    Args:
      callstack: The list of stack frames.
      component_to_crash_revision_dict: A dictionary that maps component to its
                                        crash revision.
      component_to_regression_dict: A dictionary that maps component to its
                                    revision range.
      parsers: A list of two parsers, svn_parser and git_parser
      top_n_frames: A number of stack frames to show the blame result for.
    """
    # Only return blame information for first 'top_n_frames' frames.
    stack_frames = callstack.GetTopNFrames(top_n_frames)
    tasks = []
    # Iterate through frames in stack.
    for stack_frame in stack_frames:
      # If the component this line is from does not have a crash revision,
      # it is not possible to get blame information, so ignore this line.
      component_path = stack_frame.component_path
      if component_path not in component_to_crash_revision_dict:
        continue

      crash_revision = component_to_crash_revision_dict[
          component_path]['revision']
      range_start = None
      range_end = None
      repository_type = crash_utils.GetRepositoryType(crash_revision)
      repository_parser = parsers[repository_type]

      # If the revision is in SVN, and if regression information is available,
      # get it. For Git, we cannot know the ordering between hash numbers.
      if repository_type == 'svn':
        if component_to_regression_dict and \
            component_path in component_to_regression_dict:
          component_object = component_to_regression_dict[component_path]
          range_start = int(component_object['old_revision'])
          range_end = int(component_object['new_revision'])

      # Create a task to generate blame entry.
      tasks.append({
          'function': self.__GenerateBlameEntry,
          'args': [repository_parser, stack_frame, crash_revision,
                   range_start, range_end]})

    # Run all the tasks.
    crash_utils.RunTasks(tasks)

  def __GenerateBlameEntry(self, repository_parser, stack_frame,
                           crash_revision, range_start, range_end):
    """Generates blame list from the arguments."""
    stack_frame_index = stack_frame.index
    component_path = stack_frame.component_path
    component_name = stack_frame.component_name
    file_name = stack_frame.file_name
    file_path = stack_frame.file_path
    crashed_line_number = stack_frame.crashed_line_range[0]

    if file_path.startswith(component_path):
      file_path = file_path[len(component_path):]

    # Parse blame information.
    parsed_blame_info = repository_parser.ParseBlameInfo(
        component_path, file_path, crashed_line_number, crash_revision)

    # If it fails to retrieve information, do not do anything.
    if not parsed_blame_info:
      return

    # Create blame object from the parsed info and add it to the list.
    (line_content, revision, author, url, message, time) = parsed_blame_info
    blame = Blame(line_content, component_name, stack_frame_index, file_name,
                  crashed_line_number, author, revision, message, time, url,
                  range_start, range_end)

    with self.blame_list_lock:
      self.blame_list.append(blame)

  def FilterAndSortBlameList(self):
    """Filters and sorts the blame list."""
    # Sort the blame list by its position in stack.
    self.blame_list.sort(key=lambda blame: blame.stack_frame_index)

    filtered_blame_list = []

    for blame in self.blame_list:
      # If regression information is available, check if it needs to be
      # filtered.
      if blame.range_start and blame.range_end:

        # Discards results that are after the end of regression.
        if not utils.IsGitHash(blame.revision) and (
            int(blame.range_end) <= int(blame.revision)):
          continue

      filtered_blame_list.append(blame)

    self.blame_list = filtered_blame_list