# 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 os
import re
import sys

from .command import Command
from .branch import Branch
from .squash import Squash

from webkitbugspy import Tracker
from webkitcorepy import arguments, run, Terminal
from webkitscmpy import local, log, remote


class PullRequest(Command):
    name = 'pull-request'
    aliases = ['pr', 'pfr', 'upload']
    help = 'Push the current checkout state as a pull-request'
    BLOCKED_LABEL = 'merging-blocked'
    MERGE_LABELS = ['merge-queue']
    UNSAFE_MERGE_LABELS = ['unsafe-merge-queue']

    @classmethod
    def parser(cls, parser, loggers=None):
        Branch.parser(parser, loggers=loggers)
        Squash.parser(parser, loggers=loggers)
        parser.add_argument(
            '--add', '--no-add',
            dest='will_add', default=None,
            help='When drafting a change, add (or never add) modified files to set of staged changes to be committed',
            action=arguments.NoAction,
        )
        parser.add_argument(
            '--rebase', '--no-rebase', '--update', '--no-update',
            dest='rebase', default=None,
            help='Rebase (or do not rebase) the pull-request on the source branch before pushing',
            action=arguments.NoAction,
        )
        parser.add_argument(
            '--squash', '--no-squash',
            dest='squash', default=None,
            help='Combine all commits on the current development branch into a single commit before pushing',
            action=arguments.NoAction,
        )
        parser.add_argument(
            '--defaults', '--no-defaults', action=arguments.NoAction, default=None,
            help='Do not prompt the user for defaults, always use (or do not use) them',
        )
        parser.add_argument(
            '--overwrite', '--amend', action='store_const', const='overwrite',
            dest='technique', default=None,
            help='When creating a pull request, overwrite the existing commit by default',
        )
        parser.add_argument(
            '--append', action='store_const', const='append',
            dest='technique', default=None,
            help='When creating a pull request, append a new commit on the existing branch by default',
        )
        parser.add_argument(
            '--with-history', '--no-history',
            dest='history', default=None,
            help='Create numbered branches to track the history of a change',
            action=arguments.NoAction,
        )
        parser.add_argument(
            '--draft', dest='draft', action='store_true', default=None,
            help='Mark a pull request as a draft when creating it',
        )
        parser.add_argument(
            '--remote', dest='remote', type=str, default=None,
            help='Make a pull request against a specific remote',
        )
        parser.add_argument(
            '--checks', '--no-checks',
            dest='checks', default=None,
            help='Explicitly enable or disable automatic pre-flight checks',
            action=arguments.NoAction,
        )

    @classmethod
    def create_commit(cls, args, repository, **kwargs):
        # First, find the set of files to be modified
        modified = [] if args.will_add is False else repository.modified()
        if args.will_add:
            modified = list(set(modified).union(set(repository.modified(staged=False))))

        # Next, add all modified file
        for file in set(modified) - set(repository.modified(staged=True)):
            log.info('    Adding {}...'.format(file))
            if run([repository.executable(), 'add', file], cwd=repository.root_path).returncode:
                sys.stderr.write("Failed to add '{}'\n".format(file))
                return 1

        # Then, see if we already have a commit associated with this branch we need to modify
        has_commit = repository.commit(include_log=False, include_identifier=False).branch == repository.branch and repository.branch != repository.default_branch
        if not modified and has_commit:
            log.info('Using committed changes...')
            return 0

        bug_urls = getattr(args, '_bug_urls', None) or ''
        if isinstance(bug_urls, (list, tuple)):
            bug_urls = '\n'.join(bug_urls)

        # Otherwise, we need to create a commit
        will_amend = has_commit and args.technique == 'overwrite'
        if not modified:
            sys.stderr.write('No modified files\n')
            return 1
        log.info('Amending commit...' if will_amend else 'Creating commit...')
        env = os.environ
        env['COMMIT_MESSAGE_TITLE'] = getattr(args, '_title', None) or ''
        env['COMMIT_MESSAGE_BUG'] = bug_urls
        if run(
            [repository.executable(), 'commit', '--date=now'] + (['--amend'] if will_amend else []),
            cwd=repository.root_path,
            env=env,
        ).returncode:
            sys.stderr.write('Failed to generate commit\n')
            return 1

        return 0

    @classmethod
    def title_for(cls, commits):
        title = os.path.commonprefix([commit.message.splitlines()[0] for commit in commits])
        if not title:
            title = commits[0].message.splitlines()[0]
        title = title.rstrip().lstrip()
        return title[:-5].rstrip() if title.endswith('(Part') else title

    @classmethod
    def check_pull_request_args(cls, repository, args):
        if not args.technique:
            args.technique = repository.config()['webkitscmpy.pull-request']
        if args.history is None:
            args.history = dict(
                always=True,
                disabled=False,
                never=False,
            ).get(repository.config()['webkitscmpy.history'])
        if args.history and repository.config()['webkitscmpy.history'] == 'never':
            sys.stderr.write('History retention was requested, but repository configuration forbids it\n')
            return False
        return True

    @classmethod
    def pull_request_branch_point(cls, repository, args, **kwargs):
        # FIXME: We can do better by infering the remote from the branch point, if it's not specified
        source_remote = args.remote or 'origin'

        if repository.branch is None or repository.branch in repository.DEFAULT_BRANCHES or repository.PROD_BRANCHES.match(repository.branch):
            if Branch.main(
                args, repository,
                why="'{}' is not a pull request branch".format(repository.branch),
                redact=source_remote != 'origin', **kwargs
            ):
                sys.stderr.write("Abandoning pushing pull-request because '{}' could not be created\n".format(args.issue))
                return None
        elif args.issue and repository.branch != args.issue:
            sys.stderr.write("Creating a pull-request for '{}' but we're on '{}'\n".format(args.issue, repository.branch))
            return None

        if not repository.config().get('remote.{}.url'.format(source_remote)):
            sys.stderr.write("'{}' is not a remote in this repository\n".format(source_remote))
            return None

        branch_point = Branch.branch_point(repository)
        if run([
            repository.executable(), 'branch', '-f',
            branch_point.branch,
            'remotes/{}/{}'.format(source_remote, branch_point.branch),
        ], cwd=repository.root_path).returncode:
            sys.stderr.write("Failed to match '{}' to it's remote '{}'\n".format(branch_point.branch, source_remote))
            return None
        return branch_point

    @classmethod
    def find_existing_pull_request(cls, repository, remote):
        existing_pr = None
        for pr in remote.pull_requests.find(opened=None, head=repository.branch):
            existing_pr = pr
            if existing_pr.opened:
                break
        return existing_pr

    @classmethod
    def pre_pr_checks(cls, repository):
        num_checks = 0
        log.info('Running pre-PR checks...')
        for key, path in repository.config().items():
            if not key.startswith('webkitscmpy.pre-pr.'):
                continue
            num_checks += 1
            name = key.split('.')[-1]
            log.info('    Running {}...'.format(name))
            command = run(path.split(' '), cwd=repository.root_path)
            if command.returncode:
                if Terminal.choose(
                    '{} failed, continue uploading pull request?'.format(name),
                    default='No',
                ) == 'No':
                    sys.stderr.write('Pre-PR check {} failed\n'.format(name))
                    return False
                else:
                    log.info('    {} failed, continuing PR upload anyway'.format(name))
            else:
                log.info('    Ran {}!'.format(name))

        if num_checks:
            log.info('All pre-PR checks run!')
        else:
            log.info('No pre-PR checks to run')
        return True

    @classmethod
    def is_revert_commit(cls, commit):
        msg = commit.message.split()
        if not len(msg):
            return False
        title = msg[0]
        return title.startswith('Revert')

    @classmethod
    def add_comment_to_reverted_commit_bug_tracker(cls, repository, args, pr, commit):
        source_remote = args.remote or 'origin'
        rmt = repository.remote(name=source_remote)
        if not rmt:
            sys.stderr.write("'{}' doesn't have a recognized remote\n".format(repository.root_path))
            return 1
        if not rmt.pull_requests:
            sys.stderr.write("'{}' cannot generate pull-requests\n".format(rmt.url))
            return 1

        log.info('Adding comment for reverted commits...')
        for line in commit.message.split():
            tracker = Tracker.from_string(line)
            if tracker:
                tracker.add_comment('Reverted by {}'.format(pr.link))
                tracker.set(opened=True)
                continue
        return 0

    @classmethod
    def create_pull_request(cls, repository, args, branch_point, callback=None, unblock=True):
        # FIXME: We can do better by inferring the remote from the branch point, if it's not specified
        source_remote = args.remote or 'origin'
        if not repository.config().get('remote.{}.url'.format(source_remote)):
            sys.stderr.write("'{}' is not a remote in this repository\n".format(source_remote))
            return 1

        rebasing = args.rebase if args.rebase is not None else repository.config().get(
            'webkitscmpy.auto-rebase-branch',
            repository.config().get('pull.rebase', 'true'),
        ) == 'true'

        if rebasing:
            log.info("Rebasing '{}' on '{}'...".format(repository.branch, branch_point.branch))
            if repository.pull(rebase=True, branch=branch_point.branch):
                sys.stderr.write("Failed to rebase '{}' on '{},' please resolve conflicts\n".format(repository.branch, branch_point.branch))
                return 1
            log.info("Rebased '{}' on '{}!'".format(repository.branch, branch_point.branch))
            branch_point = Branch.branch_point(repository)

        if args.checks is None:
            args.checks = repository.config().get('webkitscmpy.auto-check', 'false') == 'true'
        if args.checks and not cls.pre_pr_checks(repository):
            sys.stderr.write('Checks have failed, aborting pull request.\n')
            return 1

        remote_repo = repository.remote(name=source_remote)
        if not remote_repo:
            sys.stderr.write("'{}' doesn't have a recognized remote\n".format(repository.root_path))
            return 1

        existing_pr = None
        if remote_repo.pull_requests:
            existing_pr = cls.find_existing_pull_request(repository, remote_repo)
            if existing_pr and not existing_pr.opened and not args.defaults and (args.defaults is False or Terminal.choose(
                    "'{}' is already associated with '{}', which is closed.\nWould you like to create a new pull-request?".format(
                        repository.branch, existing_pr,
                    ), default='No',
            ) == 'Yes'):
                existing_pr = None

        # Remove any active labels
        if existing_pr and existing_pr._metadata and existing_pr._metadata.get('issue'):
            log.info("Checking PR labels for active labels...")
            pr_issue = existing_pr._metadata['issue']
            labels = pr_issue.labels
            did_remove = False
            for to_remove in cls.MERGE_LABELS + cls.UNSAFE_MERGE_LABELS + ([cls.BLOCKED_LABEL] if unblock else []):
                if to_remove in labels:
                    log.info("Removing '{}' from PR {}...".format(to_remove, existing_pr.number))
                    labels.remove(to_remove)
                    did_remove = True
            if did_remove:
                pr_issue.set_labels(labels)

        if isinstance(remote_repo, remote.GitHub):
            target = 'fork' if source_remote == 'origin' else '{}-fork'.format(source_remote)
            if not repository.config().get('remote.{}.url'.format(target)):
                sys.stderr.write("'{}' is not a remote in this repository. Have you run `{} setup` yet?\n".format(
                    source_remote, os.path.basename(sys.argv[0]),
                ))
                return 1
        else:
            target = source_remote

        log.info("Pushing '{}' to '{}'...".format(repository.branch, target))
        if run([repository.executable(), 'push', '-f', target, repository.branch], cwd=repository.root_path).returncode:
            sys.stderr.write("Failed to push '{}' to '{}' (alias of '{}')\n".format(repository.branch, target, repository.url(name=target)))
            sys.stderr.write("Your checkout may be mis-configured, try re-running 'git-webkit setup' or\n")
            sys.stderr.write("your checkout may not have permission to push to '{}'\n".format(repository.url(name=target)))
            return 1

        if rebasing and target.endswith('fork') and repository.config().get('webkitscmpy.update-fork', 'false') == 'true':
            log.info("Syncing '{}' to remote '{}'".format(branch_point.branch, target))
            if run([repository.executable(), 'push', target, '{branch}:{branch}'.format(branch=branch_point.branch)], cwd=repository.root_path).returncode:
                sys.stderr.write("Failed to sync '{}' to '{}.' Error is non fatal, continuing...\n".format(branch_point.branch, target))

        if args.history or (target != source_remote and args.history is None and args.technique == 'overwrite'):
            regex = re.compile(r'^{}-(?P<count>\d+)$'.format(repository.branch))
            count = max([
                int(regex.match(branch).group('count')) if regex.match(branch) else 0 for branch in
                repository.branches_for(remote=target)
            ] + [0]) + 1

            history_branch = '{}-{}'.format(repository.branch, count)
            log.info("Creating '{}' as a reference branch".format(history_branch))
            if run([
                repository.executable(), 'branch', history_branch, repository.branch,
            ], cwd=repository.root_path).returncode or run([
                repository.executable(), 'push', '-f', target, history_branch,
            ], cwd=repository.root_path).returncode:
                sys.stderr.write("Failed to create and push '{}' to '{}'\n".format(history_branch, target))

        if not remote_repo.pull_requests:
            sys.stderr.write("'{}' cannot generate pull-requests\n".format(remote_repo.url))
            return 1
        if args.draft and not remote_repo.pull_requests.SUPPORTS_DRAFTS:
            sys.stderr.write("'{}' does not support draft pull requests, aborting\n".format(remote_repo.url))
            return 1

        commits = list(repository.commits(begin=dict(hash=branch_point.hash), end=dict(branch=repository.branch)))

        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

        if existing_pr:
            log.info("Updating pull-request for '{}'...".format(repository.branch))
            pr = remote_repo.pull_requests.update(
                pull_request=existing_pr,
                title=cls.title_for(commits),
                commits=commits,
                base=branch_point.branch,
                head=repository.branch,
                opened=None if existing_pr.opened else True,
                draft=args.draft,
            )
            if not pr:
                sys.stderr.write("Failed to update pull-request '{}'\n".format(existing_pr))
                return 1
            print("Updated '{}'!".format(pr))
        else:
            log.info("Creating pull-request for '{}'...".format(repository.branch))
            pr = remote_repo.pull_requests.create(
                title=cls.title_for(commits),
                commits=commits,
                base=branch_point.branch,
                head=repository.branch,
                draft=args.draft,
            )
            if not pr:
                sys.stderr.write("Failed to create pull-request for '{}'\n".format(repository.branch))
                return 1
            print("Created '{}'!".format(pr))
            if cls.is_revert_commit(commits[0]):
                cls.add_comment_to_reverted_commit_bug_tracker(repository, args, pr, commits[0])

        if issue:
            log.info('Checking issue assignee...')
            if issue.assignee != issue.tracker.me():
                issue.assign(issue.tracker.me())
                print('Assigning associated issue to {}'.format(issue.tracker.me()))
            log.info('Checking for pull request link in associated issue...')
            if pr.url and not any([pr.url in comment.content for comment in issue.comments]):
                if issue.opened:
                    issue.add_comment('Pull request: {}'.format(pr.url))
                else:
                    issue.open(why='Re-opening for pull request {}'.format(pr.url))
                print('Posted pull request link to {}'.format(issue.link))

        if issue and pr._metadata and pr._metadata.get('issue'):
            log.info('Syncing PR labels with issue component...')
            pr_issue = pr._metadata['issue']
            project = pr_issue.tracker.name
            component = issue.component
            if pr_issue.component == component or component not in pr_issue.tracker.projects.get(project, {}).get('components', {}):
                component = None
            version = issue.version
            if pr_issue.version == version or version not in pr_issue.tracker.projects.get(project, {}).get('versions', []):
                version = None
            if component or version:
                pr_issue.set_component(component=component, version=version)
                log.info('Synced PR labels with issue component!')
            else:
                log.info('No label syncing required')

        if pr.url:
            print(pr.url)

        if callback:
            return callback(pr)
        return 0

    @classmethod
    def main(cls, args, repository, **kwargs):
        if not isinstance(repository, local.Git):
            sys.stderr.write("Can only '{}' on a native Git repository\n".format(cls.name))
            return 1
        if not cls.check_pull_request_args(repository, args):
            return 1

        branch_point = cls.pull_request_branch_point(repository, args, **kwargs)
        if not branch_point:
            return 1

        result = cls.create_commit(args, repository, **kwargs)
        if result:
            return result
        if args.squash:
            result = Squash.squash_commit(args, repository, branch_point, **kwargs)
            if result:
                return result

        return cls.create_pull_request(repository, args, branch_point)