# Copyright 2008 Google Inc.
#
# 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.

"""Utility to read and apply a unified diff without forking patch(1).

For a discussion of the unified diff format, see my blog on Artima:
http://www.artima.com/weblogs/viewpost.jsp?thread=164293
"""

import difflib
import logging
import re
import sys


_CHUNK_RE = re.compile(r"""
  @@
  \s+
  -
  (?: (\d+) (?: , (\d+) )?)
  \s+
  \+
  (?: (\d+) (?: , (\d+) )?)
  \s+
  @@
""", re.VERBOSE)


def PatchLines(old_lines, patch_lines, name="<patch>"):
  """Patches the old_lines with patches read from patch_lines.

  This only reads unified diffs.  The header lines are ignored.
  Yields (tag, old, new) tuples where old and new are lists of lines.
  The tag can either start with "error" or be a tag from difflib: "equal",
  "insert", "delete", "replace".  After "error" is yielded, no more
  tuples are yielded.  It is possible that consecutive "equal" tuples
  are yielded.
  """
  chunks = ParsePatchToChunks(patch_lines, name)
  if chunks is None:
    return iter([("error: ParsePatchToChunks failed", [], [])])
  return PatchChunks(old_lines, chunks)


def PatchChunks(old_lines, chunks):
  """Patche old_lines with chunks.

  Yields (tag, old, new) tuples where old and new are lists of lines.
  The tag can either start with "error" or be a tag from difflib: "equal",
  "insert", "delete", "replace".  After "error" is yielded, no more
  tuples are yielded.  It is possible that consecutive "equal" tuples
  are yielded.
  """
  if not chunks:
    # The patch is a no-op
    yield ("equal", old_lines, old_lines)
    return

  old_pos = 0
  for (old_i, old_j), (new_i, new_j), old_chunk, new_chunk in chunks:
    eq = old_lines[old_pos:old_i]
    if eq:
      yield "equal", eq, eq
    old_pos = old_i
    # Check that the patch matches the target file
    if old_lines[old_i:old_j] != old_chunk:
      logging.error("mismatch:%s.%s.", old_lines[old_i:old_j], old_chunk)
      yield ("error: old chunk mismatch", old_lines[old_i:old_j], old_chunk)
      return
    # TODO(guido): ParsePatch knows the diff details, but throws the info away
    sm = difflib.SequenceMatcher(None, old_chunk, new_chunk)
    for tag, i1, i2, j1, j2 in sm.get_opcodes():
      yield tag, old_chunk[i1:i2], new_chunk[j1:j2]
    old_pos = old_j

  # Copy the final matching chunk if any.
  eq = old_lines[old_pos:]
  if eq:
    yield ("equal", eq, eq)


_NO_NEWLINE_MESSAGE = "\\ No newline at end of file"


def ParsePatchToChunks(lines, name="<patch>"):
  """Parses a patch from a list of lines.

  Return a list of chunks, where each chunk is a tuple:

    old_range, new_range, old_lines, new_lines

  Returns a list of chunks (possibly empty); or None if there's a problem.
  """
  lineno = 0
  raw_chunk = []
  chunks = []
  old_range = new_range = None
  old_last = new_last = 0
  in_prelude = True
  for line in lines:
    lineno += 1
    if in_prelude:
      # Skip leading lines until after we've seen one starting with '+++'
      if line.startswith("+++"):
        in_prelude = False
      continue
    match = _CHUNK_RE.match(line)
    if match:
      if raw_chunk:
        # Process the lines in the previous chunk
        old_chunk = []
        new_chunk = []
        for tag, rest in raw_chunk:
          if tag in (" ", "-"):
            old_chunk.append(rest)
          if tag in (" ", "+"):
            new_chunk.append(rest)
        # Check consistency
        old_i, old_j = old_range
        new_i, new_j = new_range
        if len(old_chunk) != old_j - old_i or len(new_chunk) != new_j - new_i:
          logging.warn("%s:%s: previous chunk has incorrect length",
                       name, lineno)
          return None
        chunks.append((old_range, new_range, old_chunk, new_chunk))
        raw_chunk = []
      # Parse the @@ header
      old_ln, old_n, new_ln, new_n = match.groups()
      old_ln, old_n, new_ln, new_n = map(long,
                                         (old_ln, old_n or 1,
                                          new_ln, new_n or 1))
      # Convert the numbers to list indices we can use
      if old_n == 0:
        old_i = old_ln
      else:
        old_i = old_ln - 1
      old_j = old_i + old_n
      old_range = old_i, old_j
      if new_n == 0:
        new_i = new_ln
      else:
        new_i = new_ln - 1
      new_j =new_i + new_n
      new_range = new_i, new_j
      # Check header consistency with previous header
      if old_i < old_last or new_i < new_last:
        logging.warn("%s:%s: chunk header out of order: %r",
                     name, lineno, line)
        return None
      if old_i - old_last != new_i - new_last:
        logging.warn("%s:%s: inconsistent chunk header: %r",
                     name, lineno, line)
        return None
      old_last = old_j
      new_last = new_j
    else:
      tag, rest = line[0], line[1:]
      if tag in (" ", "-", "+"):
        raw_chunk.append((tag, rest))
      elif line.startswith(_NO_NEWLINE_MESSAGE):
        # TODO(guido): need to check that no more lines follow for this file
        if raw_chunk:
          last_tag, last_rest = raw_chunk[-1]
          if last_rest.endswith("\n"):
            raw_chunk[-1] = (last_tag, last_rest[:-1])
      else:
        # Only log if it's a non-blank line.  Blank lines we see a lot.
        if line and line.strip():
          logging.warn("%s:%d: indecypherable input: %r", name, lineno, line)
        if chunks or raw_chunk:
          break  # Trailing garbage isn't so bad
        return None
  if raw_chunk:
    # Process the lines in the last chunk
    old_chunk = []
    new_chunk = []
    for tag, rest in raw_chunk:
      if tag in (" ", "-"):
        old_chunk.append(rest)
      if tag in (" ", "+"):
        new_chunk.append(rest)
    # Check consistency
    old_i, old_j = old_range
    new_i, new_j = new_range
    if len(old_chunk) != old_j - old_i or len(new_chunk) != new_j - new_i:
      print >>sys.stderr, ("%s:%s: last chunk has incorrect length" %
                           (name, lineno))
      return None
    chunks.append((old_range, new_range, old_chunk, new_chunk))
    raw_chunk = []
  return chunks


# TODO: can we share some of this code with ParsePatchToChunks?
def ParsePatchToLines(lines):
  """Parses a patch from a list of lines.

  Returns None on error, otherwise a list of 3-tuples:
    (old_line_no, new_line_no, line)

    A line number can be 0 if it doesn't exist in the old/new file.
  """
  result = []
  in_prelude = True
  for line in lines:
    if in_prelude:
      result.append((0, 0, line))
      # Skip leading lines until after we've seen one starting with '+++'
      if line.startswith("+++"):
        in_prelude = False
    elif line.startswith("@"):
      result.append((0, 0, line))
      match = _CHUNK_RE.match(line)
      if not match:
        logging.warn("ParsePatchToLines match failed on %s", line)
        return None
      old_ln = int(match.groups()[0])
      new_ln = int(match.groups()[2])
    else:
      if line[0] == "-":
        result.append((old_ln, 0, line))
        old_ln += 1
      elif line[0] == "+":
        result.append((0, new_ln, line))
        new_ln += 1
      elif line[0] == " ":
        result.append((old_ln, new_ln, line))
        old_ln += 1
        new_ln += 1
      elif line.startswith(_NO_NEWLINE_MESSAGE):
        continue
      else:  # Something else, could be property changes etc.
        result.append((0, 0, line))
  return result