#!/usr/bin/env python
# Copyright 2014 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import difflib
import os
import re
import unittest

from strict_enum_value_checker import StrictEnumValueChecker

class MockLogging(object):
  def __init__(self):
    self.lines = []

  def info(self, message):
    self.lines.append(message)

  def debug(self, message):
    self.lines.append(message)

class MockInputApi(object):
  def __init__(self):
    self.re = re
    self.os_path = os.path
    self.files = []
    self.is_committing = False
    self.logging = MockLogging()

  def AffectedFiles(self, include_deletes=None):
    return self.files


class MockOutputApi(object):
  class PresubmitResult(object):
    def __init__(self, message, items=None, long_text=""):
      self.message = message
      self.items = items
      self.long_text = long_text

  class PresubmitError(PresubmitResult):
    def __init__(self, message, items, long_text=""):
      MockOutputApi.PresubmitResult.__init__(self, message, items, long_text)
      self.type = "error"

  class PresubmitPromptWarning(PresubmitResult):
    def __init__(self, message, items, long_text=""):
      MockOutputApi.PresubmitResult.__init__(self, message, items, long_text)
      self.type = "warning"

  class PresubmitNotifyResult(PresubmitResult):
    def __init__(self, message, items, long_text=""):
      MockOutputApi.PresubmitResult.__init__(self, message, items, long_text)
      self.type = "notify"


class MockFile(object):
  def __init__(self, local_path, old_contents, new_contents):
    self._local_path = local_path
    self._new_contents = new_contents
    self._old_contents = old_contents
    self._cached_changed_contents = None

  def ChangedContents(self):
    return self._changed_contents

  def NewContents(self):
    return self._new_contents

  def LocalPath(self):
    return self._local_path

  def IsDirectory(self):
    return False

  def GenerateScmDiff(self):
    result = ""
    for line in difflib.unified_diff(self._old_contents, self._new_contents,
                                     self._local_path, self._local_path):
      result += line
    return result

  # NOTE: This method is a copy of ChangeContents method of AffectedFile in
  # presubmit_support.py
  def ChangedContents(self):
    """Returns a list of tuples (line number, line text) of all new lines.

     This relies on the scm diff output describing each changed code section
     with a line of the form

     ^@@ <old line num>,<old size> <new line num>,<new size> @@$
    """
    if self._cached_changed_contents is not None:
      return self._cached_changed_contents[:]
    self._cached_changed_contents = []
    line_num = 0

    if self.IsDirectory():
      return []

    for line in self.GenerateScmDiff().splitlines():
      m = re.match(r"^@@ [0-9\,\+\-]+ \+([0-9]+)\,[0-9]+ @@", line)
      if m:
        line_num = int(m.groups(1)[0])
        continue
      if line.startswith("+") and not line.startswith("++"):
        self._cached_changed_contents.append((line_num, line[1:]))
      if not line.startswith("-"):
        line_num += 1
    return self._cached_changed_contents[:]


class MockChange(object):
  def __init__(self, changed_files):
    self._changed_files = changed_files

  def LocalPaths(self):
    return self._changed_files


class StrictEnumValueCheckerTest(unittest.TestCase):
  TEST_FILE_PATTERN = "changed_file_%s.h"
  MOCK_FILE_LOCAL_PATH = "mock_enum.h"
  START_MARKER = "enum MockEnum {"
  END_MARKER = "  mBoundary"

  def _ReadTextFileContents(self, path):
    """Given a path, returns a list of strings corresponding to the text lines
    in the file. Reads files in text format.

    """
    fo = open(path, "r")
    try:
      contents = fo.readlines()
    finally:
      fo.close()
    return contents

  def _ReadInputFile(self):
    return self._ReadTextFileContents("mock_enum.h")

  def _PrepareTest(self, new_file_path):
    old_contents = self._ReadInputFile()
    if not new_file_path:
      new_contents = []
    else:
      new_contents = self._ReadTextFileContents(new_file_path)
    input_api = MockInputApi()
    mock_file = MockFile(self.MOCK_FILE_LOCAL_PATH,
                         old_contents,
                         new_contents)
    input_api.files.append(mock_file)
    output_api = MockOutputApi()
    return input_api, output_api

  def _RunTest(self, new_file_path):
    input_api, output_api = self._PrepareTest(new_file_path)
    checker = StrictEnumValueChecker(input_api, output_api, self.START_MARKER,
                                     self.END_MARKER, self.MOCK_FILE_LOCAL_PATH)
    results = checker.Run()
    return results

  def testDeleteFile(self):
    results = self._RunTest(new_file_path=None)
    # TODO(rpaquay) How to check it's the expected warning?'
    self.assertEquals(1, len(results),
                      "We should get a single warning about file deletion.")

  def testSimpleValidEdit(self):
    results = self._RunTest(self.TEST_FILE_PATTERN % "1")
    # TODO(rpaquay) How to check it's the expected warning?'
    self.assertEquals(0, len(results),
                      "We should get no warning for simple edits.")

  def testSingleDeletionOfEntry(self):
    results = self._RunTest(self.TEST_FILE_PATTERN % "2")
    # TODO(rpaquay) How to check it's the expected warning?'
    self.assertEquals(1, len(results),
                      "We should get a warning for an entry deletion.")

  def testSingleRenameOfEntry(self):
    results = self._RunTest(self.TEST_FILE_PATTERN % "3")
    # TODO(rpaquay) How to check it's the expected warning?'
    self.assertEquals(1, len(results),
                      "We should get a warning for an entry rename, even "
                      "though it is not optimal.")

  def testMissingEnumStartOfEntry(self):
    results = self._RunTest(self.TEST_FILE_PATTERN % "4")
    # TODO(rpaquay) How to check it's the expected warning?'
    self.assertEquals(1, len(results),
                      "We should get a warning for a missing enum marker.")

  def testMissingEnumEndOfEntry(self):
    results = self._RunTest(self.TEST_FILE_PATTERN % "5")
    # TODO(rpaquay) How to check it's the expected warning?'
    self.assertEquals(1, len(results),
                      "We should get a warning for a missing enum marker.")

  def testInvertedEnumMarkersOfEntry(self):
    results = self._RunTest(self.TEST_FILE_PATTERN % "6")
    # TODO(rpaquay) How to check it's the expected warning?'
    self.assertEquals(1, len(results),
                      "We should get a warning for inverted enum markers.")

  def testMultipleInvalidEdits(self):
    results = self._RunTest(self.TEST_FILE_PATTERN % "7")
    # TODO(rpaquay) How to check it's the expected warning?'
    self.assertEquals(3, len(results),
                      "We should get 3 warnings (one per edit).")

  def testSingleInvalidInserts(self):
    results = self._RunTest(self.TEST_FILE_PATTERN % "8")
    # TODO(rpaquay) How to check it's the expected warning?'
    self.assertEquals(1, len(results),
                      "We should get a warning for a single invalid "
                      "insertion inside the enum.")

  def testMulitpleValidInserts(self):
    results = self._RunTest(self.TEST_FILE_PATTERN % "9")
    # TODO(rpaquay) How to check it's the expected warning?'
    self.assertEquals(0, len(results),
                      "We should not get a warning mulitple valid edits")

  def testSingleValidDeleteOutsideOfEnum(self):
    results = self._RunTest(self.TEST_FILE_PATTERN % "10")
    # TODO(rpaquay) How to check it's the expected warning?'
    self.assertEquals(0, len(results),
                      "We should not get a warning for a deletion outside of "
                      "the enum")


if __name__ == '__main__':
  unittest.main()