# Copyright (C) 2021-2022 Apple 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:
# 1.  Redistributions of source code must retain the above copyright
#     notice, this list of conditions and the following disclaimer.
# 2.  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.
#
# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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.

import re
import subprocess
import sys
import time

from .canonicalize import Canonicalize
from .command import Command
from .branch import Branch
from .pull_request import PullRequest
from argparse import Namespace
from webkitbugspy import Tracker
from webkitcorepy import arguments, run, string_utils, Terminal
from webkitscmpy import Commit, local, log, remote


class Land(Command):
    name = 'land'
    help = 'If on a pull-request or commit-queue branch, rebase the ' \
           'current branch onto the target production branch and push.'

    OOPS_RE = re.compile(r'\(O+P+S!*\)')
    REVIEWED_BY_RE = re.compile('Reviewed by (?P<approver>.+)')
    GIT_SVN_COMMITTED_RE = re.compile(r'Committed r(?P<revision>\d+)')
    REMOTE = 'origin'
    MIRROR_TIMEOUT = 60

    @classmethod
    def revert_branch(cls, repository, remote, branch):
        if run(
            [repository.executable(), 'branch', '-f', branch, 'remotes/{}/{}'.format(remote, branch)],
            cwd=repository.root_path,
        ).returncode:
            return False
        return True

    @classmethod
    def parser(cls, parser, loggers=None):
        PullRequest.parser(parser, loggers=loggers)
        parser.add_argument(
            '--no-force-review', '--force-review', '--no-review',
            dest='review', default=True,
            help='Check if the change has been approved or blocked by reviewers',
            action=arguments.NoAction,
        )
        parser.add_argument(
            '--no-oops', '--no-allow-oops', '--allow-oops',
            dest='oops', default=False,
            help="Allow (OOPS!) in commit messages",
            action=arguments.NoAction,
        )
        parser.add_argument(
            '--safe', '--unsafe',
            dest='safe', default=None,
            help='Land change via safe (or unsafe) merge queue, if available.',
            action=arguments.NoAction,
        )

    @classmethod
    def merge_queue(cls, args, repository, branch_point, merge_labels=None):
        log.info('Detected merging automation, using that instead of local git tooling')
        merge_type = {
            True: 'safe',
            False: 'unsafe',
        }.get(args.safe, sorted(merge_labels.keys())[0])
        merge_label = merge_labels.get(merge_type)
        if not merge_label:
            sys.stderr.write("No {} merge-queue available for this repository\n".format(merge_type))
            return 1

        def callback(pr):
            pr_issue = pr._metadata.get('issue')
            if not pr_issue:
                sys.stderr.write("Cannot set any labels on '{}' because the service doesn't support labels\n".format(pr))
                return 1

            labels = pr_issue.labels
            if PullRequest.BLOCKED_LABEL in labels and merge_type == 'unsafe':
                log.info("Removing '{}' from PR {}...".format(cls.BLOCKED_LABEL, existing_pr.number))
                labels.remove(PullRequest.BLOCKED_LABEL)
            log.info("Adding '{}' to '{}'".format(merge_label, pr))
            labels.append(merge_label)
            if pr_issue.set_labels(labels):
                print("Added '{}' to '{}', change is in the queue to be landed".format(merge_label, pr))
                return 0
            sys.stderr.write("Failed to add '{}' to '{}', change is not landing\n".format(merge_label, pr))
            if pr.url:
                sys.stderr.write("See if you can add the label manually on '{}'".format(pr.url))
            return 1

        return PullRequest.create_pull_request(
            repository, args, branch_point,
            callback=callback,
            unblock=True if merge_type == 'unsafe' else False,
        )

    @classmethod
    def main(cls, args, repository, identifier_template=None, canonical_svn=False, **kwargs):
        if not repository:
            sys.stderr.write('No repository provided\n')
            return 1

        if not repository.path:
            sys.stderr.write("Cannot 'land' change in remote repository\n")
            return 1

        if not isinstance(repository, local.Git):
            sys.stderr.write("'land' only supported by local git repositories\n")
            return 1

        if canonical_svn and not repository.is_svn:
            sys.stderr.write("Cannot 'land' on a canonical SVN repository that is not configured as git-svn\n")
            return 1

        if not PullRequest.check_pull_request_args(repository, args):
            return 1

        modified_files = [] if args.will_add is False else repository.modified()
        if args.will_add:
            modified_files = list(set(modified_files).union(set(repository.modified(staged=False))))
        if not Branch.editable(repository.branch, repository=repository) and not modified_files:
            sys.stderr.write("Can only 'land' editable branches\n")
            return 1

        branch_point = PullRequest.pull_request_branch_point(repository, args, **kwargs)
        if not branch_point:
            return 1
        source_branch = repository.branch
        if not Branch.editable(source_branch, repository=repository):
            sys.stderr.write("Can only 'land' editable branches\n")
            return 1

        result = PullRequest.create_commit(args, repository, **kwargs)
        if result:
            return result

        commits = list(repository.commits(begin=dict(hash=branch_point.hash), end=dict(branch=source_branch)))
        if not commits:
            sys.stderr.write('Failed to find commits to land\n')
            return 1

        if args.squash or (args.squash is None and len(commits) > 1):
            result = Squash.squash_commit(args, repository, branch_point, **kwargs)
            if result:
                return result
            commits = list(repository.commits(begin=dict(hash=branch_point.hash), end=dict(branch=source_branch)))

        rmt = repository.remote()
        if rmt and isinstance(rmt, remote.GitHub):
            merge_labels = dict()
            for name in rmt.tracker.labels.keys():
                if name in PullRequest.MERGE_LABELS:
                    merge_labels['safe'] = name
                if name in PullRequest.UNSAFE_MERGE_LABELS:
                    merge_labels['unsafe'] = name
            if merge_labels:
                return cls.merge_queue(args, repository, branch_point, merge_labels=merge_labels)

        if args.safe is not None:
            sys.stderr.write("No merge-queue available for this repository\n")
            return 1

        pull_request = None
        if rmt and rmt.pull_requests:
            candidates = list(rmt.pull_requests.find(opened=True, head=source_branch))
            if len(candidates) == 1:
                pull_request = candidates[0]
            elif candidates:
                sys.stderr.write("Multiple pull-request match '{}'\n".format(source_branch))

        if pull_request and args.review:
            if pull_request.blockers:
                sys.stderr.write("{} {} blocking landing '{}'\n".format(
                    string_utils.join([p.name for p in pull_request.blockers]),
                    'are' if len(pull_request.blockers) > 1 else 'is',
                    pull_request,
                ))
                return 1
            need_review = False
            if pull_request.approvers:
                review_lines = [cls.REVIEWED_BY_RE.search(commit.message) for commit in commits]
                need_review = any([cls.OOPS_RE.search(match.group('approver')) for match in review_lines if match])
            if need_review and (args.defaults or Terminal.choose("Set '{}' as your reviewer{}?".format(
                string_utils.join([p.name for p in pull_request.approvers]),
                's' if len(pull_request.approvers) > 1 else '',
            ), default='Yes') == 'Yes'):
                log.info("Setting {} as reviewer{}".format(
                    string_utils.join([p.name for p in pull_request.approvers]),
                    's' if len(pull_request.approvers) > 1 else '',
                ))
                if run([
                    repository.executable(), 'filter-branch', '-f',
                    '--env-filter', "GIT_AUTHOR_DATE='{date}';GIT_COMMITTER_DATE='{date}'".format(
                        date='{} -{}'.format(int(time.time()), repository.gmtoffset())
                    ), '--msg-filter', 'sed "s/NOBODY (OO*PP*S!*)/{}/g"'.format(string_utils.join([p.name for p in pull_request.approvers])),
                    '{}...{}'.format(source_branch, branch_point.hash),
                ], cwd=repository.root_path, env={'FILTER_BRANCH_SQUELCH_WARNING': '1'}, capture_output=True).returncode:
                    sys.stderr.write('Failed to set reviewers\n')
                    return 1
                commits = list(repository.commits(begin=dict(hash=branch_point.hash), end=dict(branch=source_branch)))
                if not commits:
                    sys.stderr.write('Failed to find commits after setting reviewers\n')
                    return 1

        elif not pull_request:
            sys.stderr.write("Failed to find pull-request associated with '{}'\n".format(source_branch))

        if not args.oops and any([cls.OOPS_RE.search(commit.message) for commit in commits if commit.message]):
            sys.stderr.write("Found '(OOPS!)' message in commit messages, please resolve before committing\n")
            return 1

        if not args.oops:
            for line in repository.diff_lines(branch_point.hash, source_branch):
                if cls.OOPS_RE.search(line):
                    sys.stderr.write("Found '(OOPS!)' in commit diff, please resolve before committing\n")
                    return 1

        issue = None
        for line in commits[0].message.split() if commits[0] and commits[0].message else []:
            issue = Tracker.from_string(line)
            if issue:
                break

        target = pull_request.base if pull_request else branch_point.branch
        log.info("Rebasing '{}' from '{}' to '{}'...".format(source_branch, branch_point.branch, target))
        if repository.fetch(branch=target, remote=cls.REMOTE):
            sys.stderr.write("Failed to fetch '{}' from '{}'\n".format(target, cls.REMOTE))
            return 1
        if repository.rebase(target=target, base=branch_point.branch, head=source_branch):
            sys.stderr.write("Failed to rebase '{}' onto '{}', please resolve conflicts\n".format(source_branch, target))
            return 1
        log.info("Rebased '{}' from '{}' to '{}'!".format(source_branch, branch_point.branch, target))

        if run([repository.executable(), 'branch', '-f', target, source_branch], cwd=repository.root_path).returncode:
            sys.stderr.write("Failed to move '{}' ref\n".format(target))
            return 1 if cls.revert_branch(repository, cls.REMOTE, target) else -1

        if identifier_template:
            repository.checkout(target)
            if Canonicalize.main(Namespace(
                identifier=True, remote=cls.REMOTE, number=len(commits),
            ), repository, identifier_template=identifier_template):
                sys.stderr.write("Failed to embed identifiers to '{}'\n".format(target))
                return 1 if cls.revert_branch(repository, cls.REMOTE, target) else -1
            if run([repository.executable(), 'branch', '-f', source_branch, target], cwd=repository.root_path).returncode:
                sys.stderr.write("Failed to move '{}' ref to the canonicalized head of '{}'\n".format(source, target))
                cls.revert_branch(repository, cls.REMOTE, target)
                return -1

        # Need to compute the remote source
        remote_target = 'fork' if isinstance(rmt, remote.GitHub) else 'origin'

        if canonical_svn:
            if run([repository.executable(), 'svn', 'fetch'], cwd=repository.root_path).returncode:
                sys.stderr.write("Failed to update subversion refs\n".format(target))
                return 1 if cls.revert_branch(repository, cls.REMOTE, target) else -1

            dcommit = run(
                [repository.executable(), 'svn', 'dcommit'],
                cwd=repository.root_path,
                stdout=subprocess.PIPE,
                encoding='utf-8',
            )
            if dcommit.returncode:
                sys.stderr.write(dcommit.stdout)
                sys.stderr.write(dcommit.stderr)
                sys.stderr.write("Failed to commit '{}' to Subversion remote\n".format(target))
                return 1 if cls.revert_branch(repository, cls.REMOTE, target) else -1
            revisions = []
            for line in dcommit.stdout.splitlines():
                match = cls.GIT_SVN_COMMITTED_RE.match(line)
                if not match:
                    continue
                revisions.append(int(match.group('revision')))
            if not revisions:
                sys.stderr.write(dcommit.stdout)
                sys.stderr.write(dcommit.stderr)
                sys.stderr.write("Failed to find revision in '{}' when committing to Subversion remote\n".format(target))
                return 1 if cls.revert_branch(repository, cls.REMOTE, target) else -1

            run([repository.executable(), 'reset', 'HEAD~{}'.format(len(commits)), '--hard'], cwd=repository.root_path)

            # Verify the mirror processed our change
            started = time.time()
            latest = repository.find('HEAD', include_log=True, include_identifier=False)
            while latest.revision < revisions[-1]:
                if time.time() - started > cls.MIRROR_TIMEOUT:
                    sys.stderr.write("Timed out waiting for the git-svn mirror, '{}' landed but not closed\n".format(pull_request or source_branch))
                    return 1
                log.info('    Verifying mirror processesed change')
                time.sleep(5)
                run([repository.executable(), 'pull'], cwd=repository.root_path)
                latest = repository.find('HEAD', include_log=True, include_identifier=False)
            if repository.cache and target in repository.cache._last_populated:
                del repository.cache._last_populated[target]

            commits = []
            for revision in revisions:
                commits.append(repository.commit(revision=revision, include_log=True))
            commit = commits[-1]

            if pull_request:
                run([repository.executable(), 'branch', '-f', source_branch, target], cwd=repository.root_path)
                run([repository.executable(), 'push', '-f', remote_target, source_branch], cwd=repository.root_path)
                rmt.pull_requests.update(
                    pull_request=pull_request,
                    title=PullRequest.title_for(commits),
                    commits=commits,
                    base=branch_point.branch,
                    head=source_branch,
                )

        else:
            if pull_request:
                log.info("Updating '{}' to match landing commits...".format(pull_request))
                commits = list(repository.commits(begin=dict(argument='{}~{}'.format(source_branch, len(commits))), end=dict(branch=source_branch)))
                run([repository.executable(), 'push', '-f', remote_target, source_branch], cwd=repository.root_path)
                rmt.pull_requests.update(
                    pull_request=pull_request,
                    title=PullRequest.title_for(commits),
                    commits=commits,
                    base=branch_point.branch,
                    head=source_branch,
                )

            if run([repository.executable(), 'push', cls.REMOTE, target], cwd=repository.root_path).returncode:
                sys.stderr.write("Failed to push '{}' to '{}'\n".format(target, cls.REMOTE))
                return 1 if cls.revert_branch(repository, cls.REMOTE, target) else -1
            repository.checkout(target)
            commit = repository.commit(branch=target, include_log=False)

        if identifier_template and commit.identifier:
            land_message = 'Landed {} ({})!'.format(identifier_template.format(commit).split(': ')[-1], commit.hash[:Commit.HASH_LABEL_SIZE])
        else:
            land_message = 'Landed {}!'.format(commit.hash[:Commit.HASH_LABEL_SIZE])
        print(land_message)

        if pull_request:
            pull_request.comment(land_message)
        if issue:
            if canonical_svn and commit.revision:
                land_message = land_message.replace(commit.hash[:Commit.HASH_LABEL_SIZE], 'r{}'.format(commit.revision))
            issue.close(why=land_message)

        if args.defaults or Terminal.choose("Delete branch '{}'?".format(source_branch), default='Yes') == 'Yes':
            regex = re.compile(r'^{}-(?P<count>\d+)$'.format(source_branch))
            for to_delete in repository.branches_for(remote=remote_target):
                if to_delete == source_branch or regex.match(to_delete) and remote_target == 'fork':
                    run([repository.executable(), 'branch', '-D', to_delete], cwd=repository.root_path)
                    run([repository.executable(), 'push', remote_target, '--delete', to_delete], cwd=repository.root_path)
        return 0