# Copyright (c) 2011, Apple Inc. All rights reserved.
# Copyright (c) 2009, 2011, 2012 Google Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
#     * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
#     * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# WebKit's Python module for committer and reviewer validation.

import fnmatch
import json
import sys

from functools import reduce
from webkitpy.common.editdistance import edit_distance
from webkitpy.common.memoized import memoized
from webkitpy.common.system.filesystem import FileSystem
from webkitpy.common.unicode_compatibility import encode_for, unicode


class Contributor(object):
    def __init__(self, name, email_or_emails, irc_nickname_or_nicknames=None, alias_or_aliases=None, expertise=None):
        assert(name)
        assert(email_or_emails)
        self.full_name = name
        if isinstance(email_or_emails, str):
            self.emails = [email_or_emails]
        else:
            self.emails = email_or_emails
        self._case_preserved_emails = self.emails
        self.emails = list(map(lambda email: email.lower(), self.emails))  # Emails are case-insensitive.

        if isinstance(irc_nickname_or_nicknames, str):
            self.irc_nicknames = [irc_nickname_or_nicknames]
        else:
            self.irc_nicknames = irc_nickname_or_nicknames

        if isinstance(alias_or_aliases, str):
            self.aliases = [alias_or_aliases]
        else:
            self.aliases = alias_or_aliases

        self.expertise = expertise
        self.can_commit = False
        self.can_review = False
        self.is_bot = False

    def bugzilla_email(self):
        # FIXME: We're assuming the first email is a valid bugzilla email,
        # which might not be right.
        return self.emails[0]

    def __str__(self):
        return encode_for(u'"{}" <{}>'.format(unicode(self.full_name), unicode(self.emails[0])), str)

    def __unicode__(self):
        return u'"{}" <{}>'.format(unicode(self.full_name), unicode(self.emails[0]))

    def __hash__(self):
        return hash(self.full_name) \
            ^ reduce(lambda a, b: hash(a) ^ hash(b), (self.emails or []) + [0]) \
            ^ reduce(lambda a, b: hash(a) ^ hash(b), (self._case_preserved_emails or []) + [0]) \
            ^ reduce(lambda a, b: hash(a) ^ hash(b), (self.irc_nicknames or []) + [0]) \
            ^ hash(self.expertise) \
            ^ hash(self.can_commit) \
            ^ hash(self.can_review)

    def __eq__(self, other):
        return (other is not None
            and self.full_name == other.full_name
            and self.emails == other.emails
            and self._case_preserved_emails == other._case_preserved_emails
            and self.irc_nicknames == other.irc_nicknames
            and self.expertise == other.expertise
            and self.can_commit == other.can_commit
            and self.can_review == other.can_review)

    def contains_string(self, search_string):
        string = search_string.lower()
        if string in self.full_name.lower():
            return True
        if self.irc_nicknames:
            for nickname in self.irc_nicknames:
                if string in nickname.lower():
                    return True
        if self.aliases:
            for alias in self.aliases:
                if string in alias.lower():
                    return True
        for email in self.emails:
            if string in email:
                return True
        return False

    def mentioned_in_text(self, text):
        lower_text = text.lower()
        if self.full_name.lower() in lower_text:
            return True
        if self.irc_nicknames:
            for nickname in self.irc_nicknames:
                if nickname.lower() in lower_text:
                    return True
        if self.aliases:
            for alias in self.aliases:
                if alias.lower() in lower_text:
                    return True
        for email in self.emails:
            if email in lower_text:
                return True
        return False

    def matches_glob(self, glob_string):
        if fnmatch.fnmatch(self.full_name, glob_string):
            return True
        if self.irc_nicknames:
            for nickname in self.irc_nicknames:
                if fnmatch.fnmatch(nickname, glob_string):
                    return True
        for email in self.emails:
            if fnmatch.fnmatch(email, glob_string):
                return True
        return False

    def as_dict(self):
        info = {"emails" : self._case_preserved_emails}

        if self.aliases:
            info["aliases"] = self.aliases

        if self.can_review:
            info["status"] = "reviewer"
        elif self.can_commit:
            info["status"] = "committer"

        if self.irc_nicknames:
            info["nicks"] = self.irc_nicknames

        if self.expertise:
            info["expertise"] = self.expertise

        if self.is_bot:
            info["class"] = "bot"

        return info


class Committer(Contributor):
    def __init__(self, name, email_or_emails, irc_nickname=None, alias_or_aliases=None, expertise=None):
        Contributor.__init__(self, name, email_or_emails, irc_nickname, alias_or_aliases, expertise)
        self.can_commit = True


class Reviewer(Committer):
    def __init__(self, name, email_or_emails, irc_nickname=None, alias_or_aliases=None, expertise=None):
        Committer.__init__(self, name, email_or_emails, irc_nickname, alias_or_aliases, expertise)
        self.can_review = True


class Bot(Contributor):
    def __init__(self, name, email_or_emails, irc_nickname=None, alias_or_aliases=None, expertise=None):
        Contributor.__init__(self, name, email_or_emails, irc_nickname, alias_or_aliases, expertise)
        self.is_bot = True


class CommitterList(object):

    # Committers and reviewers are passed in to allow easy testing
    def __init__(self,
                 committers=[],
                 reviewers=[],
                 contributors=[]):
        if committers or reviewers or contributors:
            self.load_test_data(committers, reviewers, contributors)
        else:
            self.load_json()

        self._contributors_by_name = {}
        self._accounts_by_email = {}
        self._accounts_by_login = {}

    def load_json(self):
        filesystem = FileSystem()
        json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'contributors.json')
        try:
            contributors = json.loads(filesystem.read_text_file(json_path))
        except ValueError as e:
            sys.exit('contributors.json is malformed: ' + str(e))

        self._contributors = []
        self._committers = []
        self._reviewers = []

        for name, data in contributors.items():
            contributor = None
            status = data.get('status')
            if status == "reviewer":
                contributor = Reviewer(name, data.get('emails'), data.get('nicks'), data.get('aliases'), data.get('expertise'))
                self._reviewers.append(contributor)
                self._committers.append(contributor)
            elif status == "committer":
                contributor = Committer(name, data.get('emails'), data.get('nicks'), data.get('aliases'), data.get('expertise'))
                self._committers.append(contributor)
            elif data.get('class') == 'bot':
                contributor = Bot(name, data.get('emails'), data.get('nicks'), data.get('aliases'), data.get('expertise'))
            else:
                contributor = Contributor(name, data.get('emails'), data.get('nicks'), data.get('aliases'), data.get('expertise'))

            self._contributors.append(contributor)

    def load_test_data(self, committers, reviewers, contributors):
        self._contributors = contributors + committers + reviewers
        self._committers = committers + reviewers
        self._reviewers = reviewers

    @staticmethod
    def _contributor_list_to_dict(list):
        committers_dict = {}
        for contributor in sorted(list):
            committers_dict[contributor.full_name] = contributor.as_dict()
        return committers_dict

    def as_json(self):
        result = CommitterList._contributor_list_to_dict(self._contributors)
        return json.dumps(result, sort_keys=True, indent=3, separators=(',', ' : '))

    def reformat_in_place(self):
        filesystem = FileSystem()
        json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'contributors.json')
        filesystem.write_text_file(json_path, self.as_json())

    # Contributors who are not in any other category.
    def _exclusive_contributors(self):
        return list(filter(lambda contributor: not (contributor.can_commit or contributor.can_review), self._contributors))

    # Committers who are not reviewers.
    def _exclusive_committers(self):
        return list(filter(lambda contributor: contributor.can_commit and not contributor.can_review, self._committers))

    # This is the superset of contributors + committers + reviewers
    def contributors(self):
        return self._contributors

    # This is the superset of committers + reviewers
    def committers(self):
        return self._committers

    def reviewers(self):
        return self._reviewers

    def _name_to_contributor_map(self):
        if not len(self._contributors_by_name):
            for contributor in self._contributors:
                assert contributor.full_name
                assert contributor.full_name.lower() not in self._contributors_by_name  # We should never have duplicate names.
                self._contributors_by_name[contributor.full_name.lower()] = contributor
                if contributor.aliases is None:
                    continue
                for alias in contributor.aliases:
                    assert alias.lower() not in self._contributors_by_name
                    self._contributors_by_name[alias.lower()] = contributor
        return self._contributors_by_name

    def _email_to_account_map(self):
        if not len(self._accounts_by_email):
            for account in self._contributors:
                for email in account.emails:
                    assert(email not in self._accounts_by_email)  # We should never have duplicate emails.
                    self._accounts_by_email[email] = account
        return self._accounts_by_email

    def _login_to_account_map(self):
        if not len(self._accounts_by_login):
            for account in self._contributors:
                if account.emails:
                    login = account.bugzilla_email()
                    assert(login not in self._accounts_by_login)  # We should never have duplicate emails.
                    self._accounts_by_login[login] = account
        return self._accounts_by_login

    def _committer_only(self, record):
        if record and not record.can_commit:
            return None
        return record

    def _reviewer_only(self, record):
        if record and not record.can_review:
            return None
        return record

    def contributor_by_irc_nickname(self, irc_nickname):
        for contributor in self.contributors():
            # FIXME: This should do case-insensitive comparison or assert that all IRC nicknames are in lowercase
            if contributor.irc_nicknames and irc_nickname in contributor.irc_nicknames:
                return contributor
        return None

    def contributors_by_search_string(self, string):
        glob_matches = list(filter(lambda contributor: contributor.matches_glob(string), self.contributors()))
        return glob_matches or list(filter(lambda contributor: contributor.contains_string(string), self.contributors()))

    def contributors_by_email_username(self, string):
        string = string + '@'
        result = []
        for contributor in self.contributors():
            for email in contributor.emails:
                if email.startswith(string):
                    result.append(contributor)
                    break
        return result

    def _contributor_name_shorthands(self, contributor):
        if ' ' not in contributor.full_name:
            return []
        split_fullname = contributor.full_name.split()
        first_name = split_fullname[0]
        last_name = split_fullname[-1]
        return first_name, last_name, first_name + last_name[0], first_name + ' ' + last_name[0]

    def _tokenize_contributor_name(self, contributor):
        full_name_in_lowercase = contributor.full_name.lower()
        tokens = [full_name_in_lowercase] + full_name_in_lowercase.split()
        if contributor.irc_nicknames:
            return tokens + [nickname.lower() for nickname in contributor.irc_nicknames if len(nickname) > 5]
        return tokens

    def contributors_by_fuzzy_match(self, string):
        string_in_lowercase = string.lower()

        # 1. Exact match for fullname, email and irc_nicknames
        account = self.contributor_by_name(string_in_lowercase) or self.contributor_by_email(string_in_lowercase) or self.contributor_by_irc_nickname(string_in_lowercase)
        if account:
            return [account], 0

        # 2. Exact match for email username (before @)
        accounts = self.contributors_by_email_username(string_in_lowercase)
        if accounts and len(accounts) == 1:
            return accounts, 0

        # 3. Exact match for first name, last name, and first name + initial combinations such as "Dan B" and "Tim H"
        accounts = [contributor for contributor in self.contributors() if string in self._contributor_name_shorthands(contributor)]
        if accounts and len(accounts) == 1:
            return accounts, 0

        # 4. Finally, fuzzy-match using edit-distance
        string = string_in_lowercase
        contributorWithMinDistance = []
        minDistance = len(string) / 2 - 1
        for contributor in self.contributors():
            tokens = self._tokenize_contributor_name(contributor)
            editdistances = [edit_distance(token, string) for token in tokens if abs(len(token) - len(string)) <= minDistance]
            if not editdistances:
                continue
            distance = min(editdistances)
            if distance == minDistance:
                contributorWithMinDistance.append(contributor)
            elif distance < minDistance:
                contributorWithMinDistance = [contributor]
                minDistance = distance
        if not len(contributorWithMinDistance):
            return [], len(string)
        return contributorWithMinDistance, minDistance

    def contributor_by_email(self, email):
        return self._email_to_account_map().get(email.lower()) if email else None

    def contributor_by_name(self, name):
        return self._name_to_contributor_map().get(name.lower()) if name else None

    def committer_by_email(self, email):
        return self._committer_only(self.contributor_by_email(email))

    def committer_by_name(self, name):
        return self._committer_only(self.contributor_by_name(name))

    def reviewer_by_email(self, email):
        return self._reviewer_only(self.contributor_by_email(email))

    def reviewer_by_name(self, email):
        return self._reviewer_only(self.contributor_by_name(email))