# -*- coding: utf-8 -*-

"""

 (c) 2015-2016 - Copyright Red Hat Inc

 Authors:

   Pierre-Yves Chibon <pingou@pingoured.fr></pingou@pingoured.fr>

"""

from __future__ import print_function, unicode_literals, absolute_import

# pylint: disable=too-many-branches

# pylint: disable=too-many-arguments

# pylint: disable=too-many-locals

# pylint: disable=too-many-statements

# pylint: disable=too-many-lines

import datetime

import json

import logging

import os

import shutil

import subprocess

import requests

import tempfile

import tarfile

import zipfile

import arrow

import pygit2

import six

from sqlalchemy.exc import SQLAlchemyError

# from sqlalchemy.orm.session import Session

from pygit2.remote import RemoteCollection

import pagure.utils

import pagure.exceptions

import pagure.lib.query

import pagure.lib.notify

import pagure.lib.tasks

from pagure.config import config as pagure_config

from pagure.lib import model

from pagure.lib.repo import PagureRepo

import pagure.hooks

# from pagure.hooks import run_project_hooks

_log = logging.getLogger(__name__)

def commit_to_patch(

    repo_obj, commits, diff_view=False, find_similar=False, separated=False

):

    """ For a given commit (PyGit2 commit object) of a specified git repo,

    returns a string representation of the changes the commit did in a

    format that allows it to be used as patch.

    :arg repo_obj: the `pygit2.Repository` object of the git repo to

        retrieve the commits in

    :type repo_obj: `pygit2.Repository`

    :arg commits: the list of commits to convert to path

    :type commits: str or list

    :kwarg diff_view: a boolean specifying if what is returned is a git

        patch or a git diff

    :type diff_view: boolean

    :kwarg find_similar: a boolean specifying if what we run find_similar

        on the diff to group renamed files

    :type find_similar: boolean

    :kwarg separated: a boolean specifying if the data returned should be

        returned as one text blob or not. If diff_view is True, then the diff

        are also split by file, otherwise, the different patches are returned

        as different text blob.

    :type separated: boolean

    :return: the patch or diff representation of the provided commits

    :rtype: str

    """

    if not isinstance(commits, list):

        commits = [commits]

    patch = []

    for cnt, commit in enumerate(commits):

        if commit.parents:

            diff = repo_obj.diff(commit.parents[0], commit)

        else:

            # First commit in the repo

            diff = commit.tree.diff_to_tree(swap=True)

        if diff.patch is None:

            continue

        if find_similar and diff:

            diff.find_similar()

        if diff_view:

            if separated:

                for el in diff.patch.split("\ndiff --git a/"):

                    if el and not el.startswith("diff --git a/"):

                        patch.append("\ndiff --git a/" + el)

                    elif el:

                        patch.append(el)

            else:

                patch.append(diff.patch)

        else:

            subject = message = ""

            if "\n" in commit.message:

                subject, message = commit.message.split("\n", 1)

            else:

                subject = commit.message

            if len(commits) > 1:

                subject = "[PATCH %s/%s] %s" % (cnt + 1, len(commits), subject)

            patch.append(

                """From {commit} Mon Sep 17 00:00:00 2001

From: {author_name} <{author_email}>

Date: {date}

Subject: {subject}

{msg}

---

{patch}

""".format(

                    commit=commit.oid.hex,

                    author_name=commit.author.name,

                    author_email=commit.author.email,

                    date=datetime.datetime.utcfromtimestamp(

                        commit.commit_time

                    ).strftime("%b %d %Y %H:%M:%S +0000"),

                    subject=subject,

                    msg=message,

                    patch=diff.patch,

                )

            )

    if separated:

        return patch

    else:

        return "".join(filter(None, patch))

def generate_gitolite_acls(project=None, group=None):

    """ Generate the gitolite configuration file.

    :arg project: the project of which to update the ACLs. This argument

            can take three values: ``-1``, ``None`` and a project.

            If project is ``-1``, the configuration should be refreshed for

            *all* projects.

            If project is ``None``, there no specific project to refresh

            but the ssh key of an user was added and updated.

            If project is a pagure.lib.model.Project, the configuration of

            this project should be updated.

    :type project: None, int or pagure.lib.model.Project

    :kwarg group: the group to refresh the members of

    :type group: None or str

    """

    if project != -1:

        task = pagure.lib.tasks.generate_gitolite_acls.delay(

            namespace=project.namespace if project else None,

            name=project.name if project else None,

            user=project.user.user if project and project.is_fork else None,

            group=group,

        )

    else:

        task = pagure.lib.tasks.generate_gitolite_acls.delay(

            name=-1, group=group

        )

    return task

def update_git(obj, repo):

    """ Schedules an update_repo task after determining arguments. """

    ticketuid = None

    requestuid = None

    if obj.isa == "issue":

        ticketuid = obj.uid

    elif obj.isa == "pull-request":

        requestuid = obj.uid

    else:

        raise NotImplementedError("Unknown object type %s" % obj.isa)

    queued = pagure.lib.tasks.update_git.delay(

        repo.name,

        repo.namespace,

        repo.user.username if repo.is_fork else None,

        ticketuid,

        requestuid,

    )

    _maybe_wait(queued)

    return queued

def _maybe_wait(result):

    """ Function to patch if one wants to wait for finish.

    This function should only ever be overridden by a few tests that depend

    on counting and very precise timing. """

    pass

def _make_signature(name, email):

    if six.PY2:

        if isinstance(name, six.text_type):

            name = name.encode("utf-8")

        if isinstance(email, six.text_type):

            email = email.encode("utf-8")

    return pygit2.Signature(name=name, email=email)

def _update_git(obj, repo):

    """ Update the given issue in its git.

    This method forks the provided repo, add/edit the issue whose file name

    is defined by the uid field of the issue and if there are additions/

    changes commit them and push them back to the original repo.

    """

    _log.info("Update the git repo: %s for: %s", repo.path, obj)

    with TemporaryClone(repo, obj.repotype, "update_git") as tempclone:

        if tempclone is None:

            # Turns out we don't have a repo for this kind of object.

            return

        newpath = tempclone.repopath

        new_repo = tempclone.repo

        file_path = os.path.join(newpath, obj.uid)

        # Get the current index

        index = new_repo.index

        # Are we adding files

        added = False

        if not os.path.exists(file_path):

            added = True

        # Write down what changed

        with open(file_path, "w") as stream:

            stream.write(

                json.dumps(

                    obj.to_json(),

                    sort_keys=True,

                    indent=4,

                    separators=(",", ": "),

                )

            )

        # Retrieve the list of files that changed

        diff = new_repo.diff()

        files = []

        for patch in diff:

            files.append(patch.delta.new_file.path)

        # Add the changes to the index

        if added:

            index.add(obj.uid)

        for filename in files:

            index.add(filename)

        # If not change, return

        if not files and not added:

            return

        # See if there is a parent to this commit

        parent = None

        try:

            parent = new_repo.head.peel().oid

        except pygit2.GitError:

            pass

        parents = []

        if parent:

            parents.append(parent)

        # Author/commiter will always be this one

        author = _make_signature(name="pagure", email="pagure")

        # Actually commit

        new_repo.create_commit(

            "refs/heads/master",

            author,

            author,

            "Updated %s %s: %s" % (obj.isa, obj.uid, obj.title),

            new_repo.index.write_tree(),

            parents,

        )

        index.write()

        # And push it back

        tempclone.push("pagure", "master", internal="yes")

def clean_git(repo, obj_repotype, obj_uid):

    if repo is None:

        return

    task = pagure.lib.tasks.clean_git.delay(

        repo.name,

        repo.namespace,

        repo.user.username if repo.is_fork else None,

        obj_repotype,

        obj_uid,

    )

    _maybe_wait(task)

    return task

def _clean_git(repo, obj_repotype, obj_uid):

    """ Update the given issue remove it from its git.

    """

    _log.info("Update the git repo: %s to remove: %s", repo.path, obj_uid)

    with TemporaryClone(repo, obj_repotype, "clean_git") as tempclone:

        if tempclone is None:

            # This repo is not tracked on disk

            return

        newpath = tempclone.repopath

        new_repo = tempclone.repo

        file_path = os.path.join(newpath, obj_uid)

        # Get the current index

        index = new_repo.index

        # Are we adding files

        if not os.path.exists(file_path):

            return

        # Remove the file

        os.unlink(file_path)

        # Add the changes to the index

        index.remove(obj_uid)

        # See if there is a parent to this commit

        parent = None

        if not new_repo.is_empty:

            parent = new_repo.head.peel().oid

        parents = []

        if parent:

            parents.append(parent)

        # Author/commiter will always be this one

        author = _make_signature(name="pagure", email="pagure")

        # Actually commit

        new_repo.create_commit(

            "refs/heads/master",

            author,

            author,

            "Removed object %s: %s" % (obj_repotype, obj_uid),

            new_repo.index.write_tree(),

            parents,

        )

        index.write()

        master_ref = new_repo.lookup_reference("HEAD").resolve().name

        tempclone.push("pagure", master_ref, internal="yes")

def get_user_from_json(session, jsondata, key="user"):

    """ From the given json blob, retrieve the user info and search for it

    in the db and create the user if it does not already exist.

    """

    user = None

    username = fullname = useremails = default_email = None

    data = jsondata.get(key, None)

    if data:

        username = data.get("name")

        fullname = data.get("fullname")

        useremails = data.get("emails")

        default_email = data.get("default_email")

    if not default_email and useremails:

        default_email = useremails[0]

    if not username and not useremails:

        return

    user = pagure.lib.query.search_user(session, username=username)

    if not user:

        for email in useremails:

            user = pagure.lib.query.search_user(session, email=email)

            if user:

                break

    if not user:

        user = pagure.lib.query.set_up_user(

            session=session,

            username=username,

            fullname=fullname or username,

            default_email=default_email,

            emails=useremails,

            keydir=pagure_config.get("GITOLITE_KEYDIR", None),

        )

        session.commit()

    return user

def get_project_from_json(session, jsondata):

    """ From the given json blob, retrieve the project info and search for

    it in the db and create the projec if it does not already exist.

    """

    project = None

    user = get_user_from_json(session, jsondata)

    name = jsondata.get("name")

    namespace = jsondata.get("namespace")

    project_user = None

    if jsondata.get("parent"):

        project_user = user.username

    project = pagure.lib.query._get_project(

        session, name, user=project_user, namespace=namespace

    )

    if not project:

        parent = None

        if jsondata.get("parent"):

            parent = get_project_from_json(session, jsondata.get("parent"))

            pagure.lib.query.fork_project(

                session=session, repo=parent, user=user.username

            )

        else:

            pagure.lib.query.new_project(

                session,

                user=user.username,

                name=name,

                namespace=namespace,

                repospanner_region=None,

                description=jsondata.get("description"),

                parent_id=parent.id if parent else None,

                blacklist=pagure_config.get("BLACKLISTED_PROJECTS", []),

                allowed_prefix=pagure_config.get("ALLOWED_PREFIX", []),

                prevent_40_chars=pagure_config.get(

                    "OLD_VIEW_COMMIT_ENABLED", False

                ),

            )

        session.commit()

        project = pagure.lib.query._get_project(

            session, name, user=user.username, namespace=namespace

        )

        tags = jsondata.get("tags", None)

        if tags:

            pagure.lib.query.add_tag_obj(

                session, project, tags=tags, user=user.username

            )

    return project

def update_custom_field_from_json(session, repo, issue, json_data):

    """ Update the custom fields according to the custom fields of

    the issue. If the custom field is not present for the repo in

    it's settings, this will create them.

    :arg session: the session to connect to the database with.

    :arg repo: the sqlalchemy object of the project

    :arg issue: the sqlalchemy object of the issue

    :arg json_data: the json representation of the issue taken from the git

        and used to update the data in the database.

    """

    # Update custom key value, if present

    custom_fields = json_data.get("custom_fields")

    if not custom_fields:

        return

    current_keys = []

    for key in repo.issue_keys:

        current_keys.append(key.name)

    for new_key in custom_fields:

        if new_key["name"] not in current_keys:

            issuekey = model.IssueKeys(

                project_id=repo.id,

                name=new_key["name"],

                key_type=new_key["key_type"],

            )

            try:

                session.add(issuekey)

                session.commit()

            except SQLAlchemyError:

                session.rollback()

                continue

        # The key should be present in the database now

        key_obj = pagure.lib.query.get_custom_key(

            session, repo, new_key["name"]

        )

        value = new_key.get("value")

        if value:

            value = value.strip()

        pagure.lib.query.set_custom_key_value(

            session, issue=issue, key=key_obj, value=value

        )

        try:

            session.commit()

        except SQLAlchemyError:

            session.rollback()

def update_ticket_from_git(

    session, reponame, namespace, username, issue_uid, json_data, agent

):

    """ Update the specified issue (identified by its unique identifier)

    with the data present in the json blob provided.

    :arg session: the session to connect to the database with.

    :arg repo: the name of the project to update

    :arg namespace: the namespace of the project to update

    :arg username: the username of the project to update (if the project

        is a fork)

    :arg issue_uid: the unique identifier of the issue to update

    :arg json_data: the json representation of the issue taken from the git

        and used to update the data in the database.

    :arg agent: the username of the person who pushed the changes (and thus

        is assumed did the action).

    """

    repo = pagure.lib.query._get_project(

        session, reponame, user=username, namespace=namespace

    )

    if not repo:

        raise pagure.exceptions.PagureException(

            "Unknown repo %s of username: %s in namespace: %s"

            % (reponame, username, namespace)

        )

    user = get_user_from_json(session, json_data)

    # rely on the agent provided, but if something goes wrong, behave as

    # ticket creator

    agent = pagure.lib.query.search_user(session, username=agent) or user

    issue = pagure.lib.query.get_issue_by_uid(session, issue_uid=issue_uid)

    messages = []

    if not issue:

        # Create new issue

        pagure.lib.query.new_issue(

            session,

            repo=repo,

            title=json_data.get("title"),

            content=json_data.get("content"),

            priority=json_data.get("priority"),

            user=user.username,

            issue_id=json_data.get("id"),

            issue_uid=issue_uid,

            private=json_data.get("private"),

            status=json_data.get("status"),

            close_status=json_data.get("close_status"),

            date_created=datetime.datetime.utcfromtimestamp(

                float(json_data.get("date_created"))

            ),

            notify=False,

        )

    else:

        # Edit existing issue

        msgs = pagure.lib.query.edit_issue(

            session,

            issue=issue,

            user=agent.username,

            title=json_data.get("title"),

            content=json_data.get("content"),

            priority=json_data.get("priority"),

            status=json_data.get("status"),

            close_status=json_data.get("close_status"),

            private=json_data.get("private"),

        )

        if msgs:

            messages.extend(msgs)

    session.commit()

    issue = pagure.lib.query.get_issue_by_uid(session, issue_uid=issue_uid)

    update_custom_field_from_json(

        session, repo=repo, issue=issue, json_data=json_data

    )

    # Update milestone

    milestone = json_data.get("milestone")

    # If milestone is not in the repo settings, add it

    if milestone:

        if milestone.strip() not in repo.milestones:

            try:

                tmp_milestone = repo.milestones.copy()

                tmp_milestone[milestone.strip()] = None

                repo.milestones = tmp_milestone

                session.add(repo)

                session.commit()

            except SQLAlchemyError:

                session.rollback()

    try:

        msgs = pagure.lib.query.edit_issue(

            session,

            issue=issue,

            user=agent.username,

            milestone=milestone,

            title=json_data.get("title"),

            content=json_data.get("content"),

            status=json_data.get("status"),

            close_status=json_data.get("close_status"),

            private=json_data.get("private"),

        )

        if msgs:

            messages.extend(msgs)

    except SQLAlchemyError:

        session.rollback()

    # Update close_status

    close_status = json_data.get("close_status")

    if close_status:

        if close_status.strip() not in repo.close_status:

            try:

                repo.close_status.append(close_status.strip())

                session.add(repo)

                session.commit()

            except SQLAlchemyError:

                session.rollback()

    # Update tags

    tags = json_data.get("tags", [])

    msgs = pagure.lib.query.update_tags(

        session, issue, tags, username=user.user

    )

    if msgs:

        messages.extend(msgs)

    # Update assignee

    assignee = get_user_from_json(session, json_data, key="assignee")

    if assignee:

        msg = pagure.lib.query.add_issue_assignee(

            session, issue, assignee.username, user=agent.user, notify=False

        )

        if msg:

            messages.append(msg)

    # Update depends

    depends = json_data.get("depends", [])

    msgs = pagure.lib.query.update_dependency_issue(

        session, issue.project, issue, depends, username=agent.user

    )

    if msgs:

        messages.extend(msgs)

    # Update blocks

    blocks = json_data.get("blocks", [])

    msgs = pagure.lib.query.update_blocked_issue(

        session, issue.project, issue, blocks, username=agent.user

    )

    if msgs:

        messages.extend(msgs)

    for comment in json_data["comments"]:

        usercomment = get_user_from_json(session, comment)

        commentobj = pagure.lib.query.get_issue_comment_by_user_and_comment(

            session, issue_uid, usercomment.id, comment["comment"]

        )

        if not commentobj:

            pagure.lib.query.add_issue_comment(

                session,

                issue=issue,

                comment=comment["comment"],

                user=usercomment.username,

                notify=False,

                date_created=datetime.datetime.fromtimestamp(

                    float(comment["date_created"])

                ),

            )

    if messages:

        pagure.lib.query.add_metadata_update_notif(

            session=session, obj=issue, messages=messages, user=agent.username

        )

    session.commit()

def update_request_from_git(

    session, reponame, namespace, username, request_uid, json_data

):

    """ Update the specified request (identified by its unique identifier)

    with the data present in the json blob provided.

    :arg session: the session to connect to the database with.

    :arg repo: the name of the project to update

    :arg username: the username to find the repo, is not None for forked

        projects

    :arg request_uid: the unique identifier of the issue to update

    :arg json_data: the json representation of the issue taken from the git

        and used to update the data in the database.

    """

    repo = pagure.lib.query._get_project(

        session, reponame, user=username, namespace=namespace

    )

    if not repo:

        raise pagure.exceptions.PagureException(

            "Unknown repo %s of username: %s in namespace: %s"

            % (reponame, username, namespace)

        )

    user = get_user_from_json(session, json_data)

    request = pagure.lib.query.get_request_by_uid(

        session, request_uid=request_uid

    )

    if not request:

        repo_from = get_project_from_json(session, json_data.get("repo_from"))

        repo_to = get_project_from_json(session, json_data.get("project"))

        status = json_data.get("status")

        if pagure.utils.is_true(status):

            status = "Open"

        elif pagure.utils.is_true(status, ["false"]):

            status = "Merged"

        # Create new request

        pagure.lib.query.new_pull_request(

            session,

            repo_from=repo_from,

            branch_from=json_data.get("branch_from"),

            repo_to=repo_to if repo_to else None,

            remote_git=json_data.get("remote_git"),

            branch_to=json_data.get("branch"),

            title=json_data.get("title"),

            user=user.username,

            requestuid=json_data.get("uid"),

            requestid=json_data.get("id"),

            status=status,

            notify=False,

        )

        session.commit()

    request = pagure.lib.query.get_request_by_uid(

        session, request_uid=request_uid

    )

    # Update start and stop commits

    request.commit_start = json_data.get("commit_start")

    request.commit_stop = json_data.get("commit_stop")

    # Update assignee

    assignee = get_user_from_json(session, json_data, key="assignee")

    if assignee:

        pagure.lib.query.add_pull_request_assignee(

            session, request, assignee.username, user=user.user

        )

    for comment in json_data["comments"]:

        user = get_user_from_json(session, comment)

        commentobj = pagure.lib.query.get_request_comment(

            session, request_uid, comment["id"]

        )

        if not commentobj:

            pagure.lib.query.add_pull_request_comment(

                session,

                request,

                commit=comment["commit"],

                tree_id=comment.get("tree_id") or None,

                filename=comment["filename"],

                row=comment["line"],

                comment=comment["comment"],

                user=user.username,

                notify=False,

            )

    # Add/update tags:

    tags = json_data.get("tags") or []

    if tags:

        user = get_user_from_json(session, json_data)

        pagure.lib.query.add_tag_obj(session, request, tags, user.username)

    session.commit()

def _add_file_to_git(repo, issue, attachmentfolder, user, filename):

    """ Add a given file to the specified ticket git repository.

    :arg repo: the Project object from the database

    :arg attachmentfolder: the folder on the filesystem where the attachments

        are stored

    :arg ticketfolder: the folder on the filesystem where the git repo for

        tickets are stored

    :arg user: the user object with its username and email

    :arg filename: the name of the file to save

    """

    with TemporaryClone(repo, issue.repotype, "add_file_to_git") as tempclone:

        newpath = tempclone.repopath

        new_repo = tempclone.repo

        folder_path = os.path.join(newpath, "files")

        file_path = os.path.join(folder_path, filename)

        # Get the current index

        index = new_repo.index

        # Are we adding files

        if os.path.exists(file_path):

            # File exists, remove the clone and return

            shutil.rmtree(newpath)

            return os.path.join("files", filename)

        if not os.path.exists(folder_path):

            os.mkdir(folder_path)

        # Copy from attachments directory

        src = os.path.join(attachmentfolder, repo.fullname, "files", filename)

        shutil.copyfile(src, file_path)

        # Retrieve the list of files that changed

        diff = new_repo.diff()

        files = [patch.new_file_path for patch in diff]

        # Add the changes to the index

        index.add(os.path.join("files", filename))

        for filename in files:

            index.add(filename)

        # See if there is a parent to this commit

        parent = None

        try:

            parent = new_repo.head.peel().oid

        except pygit2.GitError:

            pass

        parents = []

        if parent:

            parents.append(parent)

        # Author/commiter will always be this one

        author = _make_signature(name=user.username, email=user.default_email)

        # Actually commit

        new_repo.create_commit(

            "refs/heads/master",

            author,

            author,

            "Add file %s to ticket %s: %s"

            % (filename, issue.uid, issue.title),

            new_repo.index.write_tree(),

            parents,

        )

        index.write()

        master_ref = new_repo.lookup_reference("HEAD").resolve()

        tempclone.push(user.username, master_ref.name)

    return os.path.join("files", filename)