#!/usr/bin/env python2

import json
import logging
import os.path
import re
import pprint
import sys

__author__ = 'lawrence'

MAX_TRAILING_SPACES_MSGS_PER_FILE = 1000
MAX_MIXED_TABS_MSGS_PER_FILE = 1000
MAX_SPACING_MSGS_PER_FILE = 1000
MAX_INDENT_MSGS_PER_FILE = 1000

INDENT_UNKNOWN = 0
INDENT_SPACES = 1
INDENT_TABS = 2

class ChangedFile:
    SOURCE_EXT = ['.c', '.cpp', '.cc', '.h', '.java', '.mk', '.xml']
    C_JAVA_EXT = ['.c', '.cpp', '.java']
    TEXT_RESOURCE_EXT = ['.rc', '.prop', '.te', '.kl', '.cfg', '.conf', '.dtd']
    BINARY_RESOURCE_EXT = ['.txt', '.so', '.ko', '.apk', '.png', '.jpg', '.jpeg', '.gif']

    def __init__(self, filename=None, is_new=False, mode=None):
        self.filename = filename
        self.file_ext = None
        if filename:
            self.on_update_filename()
        self.is_new = is_new
        self.mode = mode
        self.formattable_carriage_returns = False
        self.comments = {}

    def on_update_filename(self):
        if not self.filename:
            logging.error("couldn't get filename")
            return
        self.file_ext = os.path.splitext(self.filename)[1].lower()

    def is_source(self):
        #if self.file_ext in self.SOURCE_EXT:
        #    return True
        return True # return true directly, doesn't check file type
        if self.filename:
            b = os.path.basename(self.filename)
            if (b and (
                    b.startswith("Kconfig") or
                    b == "Makefile")):
                return True
        return False

    def is_binary_resource(self):
        if self.file_ext in self.BINARY_RESOURCE_EXT:
            return True
        return False

    def is_text_resource(self):
        if self.file_ext in self.TEXT_RESOURCE_EXT:
            return True
        return False

    def has_errors(self):
        if self.comments:
            return True
        # same as add_file_comments:
        if self.mode == 755 and self.should_not_be_executable():
            return True
        if self.formattable_carriage_returns and self.should_not_have_carriage_return():
            return True
        return False

    def should_check_line_diff(self):
        if self.is_source() or self.is_text_resource():
            return True
        return False

    def should_not_be_executable(self):
        return self.is_source() or self.is_text_resource() or self.is_binary_resource()

    def should_not_have_carriage_return(self):
        if self.is_new:
            if self.is_source() or self.is_text_resource():
                return True
        return False

    def should_check_statement_spacing(self):
        if self.file_ext in self.C_JAVA_EXT:
            return True
        return False

    def should_check_indent(self):
        if self.file_ext in self.C_JAVA_EXT:
            return True
        return False

    def add_file_comments(self):
        if self.mode == 755 and self.should_not_be_executable():
            self.append_comment(0, "{} file should not be executable".format(self.file_ext))
        if self.formattable_carriage_returns and self.should_not_have_carriage_return():
            self.append_comment(0, "{} file should not have carriage returns (DOS line endings)".format(self.file_ext))

    def append_comment(self, line, msg):
        if line in self.comments:
            self.comments[line] += "\n\n"
            self.comments[line] += msg
        else:
            self.comments[line] = msg


    # types of files/checks
    # source/resource:
    #       should be non-executable            (new/changed source + .ko, etc)
    #   source:
    #       should not have carriage return     (new source + text resources)
    #   text resource:
    #       should not have trailing spaces     (source + text resources)
    #       should not have mixed spaces/tabs   (source + text resources)
    #   source + syntax
    #       should have space in if statements  (source c/java)
    #       added line indent should match context
    # *could be imported code - warn only..?


def check(filename):
    """
    Checks unified diff.
    :param filename: diff file to check
    :return: 0 on patch errors, 1 on no patch errors, < 0 on other errors
    """
    if not filename:
        return -1

    try:
        with open(filename) as fp:
            return check_fp(fp)
    except OSError:
        logging.error(" failed to open? OSError %s", filename)
        return -2
    except IOError:
        logging.error(" failed to open? IOError %s", filename)
        return -3
    return -4


# TODO split checks into separate functions
def check_fp(fp):
    file_sections = []
    f = None
    check_lines = False
    check_statement_spacing = False
    trailing_sp_msg_count = 0
    mixed_tabs_msg_count = 0
    spacing_msg_count = 0
    in_line_diff = False
    section_line_start = 0
    section_line_start_err = False
    cur_line = 0
    for line in fp:
        if line.startswith("diff"):
            if f and f.has_errors():
                f.add_file_comments()
                file_sections.append(f)
            # start of new file
            f = ChangedFile()
            check_lines = False
            trailing_sp_msg_count = 0
            mixed_tabs_msg_count = 0
            spacing_msg_count = 0
            indent_msg_count = 0
            context_indent = INDENT_UNKNOWN
            in_line_diff = False

            # get filename
            # might fail on paths like "dir b/file.txt"
            m = re.match(r"^diff --git a/(.*) b/.*", line)
            if m:
                f.filename = m.group(1)
                f.on_update_filename()
                check_lines = f.should_check_line_diff()
                check_statement_spacing = f.should_check_statement_spacing()
                check_indent = f.should_check_indent()
        elif line.startswith("new file mode "):
            f.is_new = True
            if line.startswith("100755", len("new file mode ")):
                f.mode = 755
        elif line.startswith("new mode 100755"):
            f.mode = 755
        elif f and not f.filename and line.startswith("+++ b/"):
            # get filename if previously failed for some reason
            f.filename = line[len("+++ b/"):].rstrip('\r\n ')
            f.on_update_filename()
            check_lines = f.should_check_line_diff()
            check_statement_spacing = f.should_check_statement_spacing()
            check_indent = f.should_check_indent()
        else:
            if not check_lines:
                continue
            if line.startswith("@@ "):
                # keep track of line numbers
                # @@ -584,7 +681,7 @@
                m = re.match(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)?\ @@", line)
                try:
                    section_line_start = int(m.group(1))
                except ValueError:
                    logging.error("failed to parse section line start")
                    section_line_start_err = True
                in_line_diff = True
                cur_line = section_line_start - 1  # next line is the start
                continue
            if in_line_diff:
                # keep track of line numbers
                if line[0] in ' +':
                    cur_line += 1
                # get last context line's indent
                if line[0] == " ":
                    if line.startswith("    ", 1):
                        context_indent = INDENT_SPACES
                    elif line.startswith("\t", 1):
                        context_indent = INDENT_TABS
            if line[0] == '+' and line[1] != '+':
                if check_lines and not section_line_start_err:
                    if (f.is_new and
                            not f.formattable_carriage_returns and
                                line[-2] == '\r'):
                        f.formattable_carriage_returns = True

                    if trailing_sp_msg_count < MAX_TRAILING_SPACES_MSGS_PER_FILE:
                        if (line.endswith(" \n") or
                                line.endswith(" \r\n") or
                                line.endswith("\t\n") or
                                line.endswith("\t\r\n")):
                            f.append_comment(cur_line, "trailing spaces")
                            trailing_sp_msg_count += 1

                    if mixed_tabs_msg_count < MAX_MIXED_TABS_MSGS_PER_FILE:
                        if re.match(r" +\t", line[1:]) or re.match(r"\t+ +\t", line[1:]):
                            # tab space can be correct, but not space tab and tab space tab
                            f.append_comment(cur_line, "possibly incorrect mixed spaces then tabs indentation")
                            mixed_tabs_msg_count += 1

                    if check_statement_spacing and spacing_msg_count < MAX_SPACING_MSGS_PER_FILE:
                        m = re.match(r"\s*(if|while|for|switch)", line[1:])
                        if (m):
                            # line starts with if|while|for|switch
                            keyword = m.group(1)
                            # check parenthesis/brace spacing. if( -> if (    or    ){ -> ) {
                            m = re.match(r"\s*(?:if|while|for|switch)( ?)\(.*\)( ?)(\{?)", line[1:])
                            if (m):
                                keyword_sp, brace_space, brace = m.groups()
                                if keyword_sp != ' ' or (
                                                brace == '{' and brace_space != ' '):
                                    f.append_comment(cur_line,
                                                     "%s (...) %s  // spacing around parenthesis" % (keyword, brace))
                                    spacing_msg_count += 1

                            # check binary operator spacing on if|while line
                            # cpplint.py: match = Search(r'[^<>=!\s](==|!=|<=|>=|\|\|)[^<>=!\s,;\)]', line
                            if keyword in ['if', 'while']:
                                m = re.search(r"[^<>=!\s](==|!=|<=|>=|\|\||&&)[^<>=!\s,;\)]", line[1:])
                                if (m):
                                    f.append_comment(cur_line, "spacing around %s" % m.group(1))
                                    spacing_msg_count += 1
                            continue
                        # do{ -> do {
                        elif re.match(r"\s*do\{", line[1:]):
                            f.append_comment(cur_line, 'do {')
                            spacing_msg_count += 1

                    if check_indent and indent_msg_count < MAX_INDENT_MSGS_PER_FILE:
                        if ((context_indent == INDENT_SPACES and line.startswith("\t", 1)) or
                                (context_indent == INDENT_TABS and line.startswith("    ", 1))):
                            f.append_comment(cur_line, "make sure indent style matches rest of file")
                            indent_msg_count += 1

    if f and f.has_errors():
        f.add_file_comments()
        file_sections.append(f)

    if False:
        for f in file_sections:
            assert isinstance(f, ChangedFile)
            if f.comments:
                print f.filename
                pprint.pprint(f.comments)
                print "---"
    json_ret = file_comments_to_review(file_sections)
    if json_ret:
        print json_ret
        return 0
    else:
        return 1

REPLY_MSG = "This is an automated message.\n\nIf you think these comments are incorrect, they can be ignored."
POSITIVE_REPLY_MSG = "This is an automated message.\n\nNo problems found."

def file_comments_to_array(changed_file):
    """
    Return a list of comments for a CommentInput entry from a ChangedFile
    :param changed_file: a ChangedFile object
    :return: a list of comments for CommentInput
    """
    ret = []
    assert isinstance(changed_file, ChangedFile)
    for line, msg in changed_file.comments.iteritems():
        ret.append({"line": line,
                    "message": msg})
    return ret

def file_comments_to_review(changed_files):
    """
    Create a JSON ReviewInput from a list of ChangedFiles
    :param changed_files: list of ChangedFiles
    :return: JSON ReviewInput string
    """
    review = {}
    review['comments'] = {}
    for f in changed_files:
        if f.filename and f.comments:

            c = file_comments_to_array(f)
            if not c:
                logging.error("no comments for file")
            review['comments'][f.filename] = c
    if review['comments']:
        review['message'] = REPLY_MSG
        review['labels'] = {'Verified': -1}
        review['notify'] = 'OWNER'
    else:
        del review['comments']
        review['message'] = POSITIVE_REPLY_MSG
        review['labels'] = {'Verified': +1}
        review['notify'] = 'OWNER'
    #return json.dumps(review, indent=2)
    return json.dumps(review)

if __name__ == '__main__':
    if len(sys.argv) == 2:
        r = check(sys.argv[1])
        sys.exit(r)
    else:
        sys.stderr.write("%s <patch filename>\n" % sys.argv[0])
    sys.exit(0)