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

"""

 (c) 2015-2019 - Copyright Red Hat Inc

 Authors:

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

"""

from __future__ import unicode_literals, absolute_import

import flask

import logging

from sqlalchemy.exc import SQLAlchemyError

from six import string_types

from pygit2 import GitError, Repository

import pagure

import pagure.forms

import pagure.exceptions

import pagure.lib.git

import pagure.lib.query

import pagure.utils

from pagure.api import (

    API,

    api_method,

    APIERROR,

    api_login_required,

    get_authorized_api_project,

    api_login_optional,

    get_request_data,

    get_page,

    get_per_page,

)

from pagure.api.utils import _get_repo, _check_token

from pagure.config import config as pagure_config

_log = logging.getLogger(__name__)

@API.route("/<repo>/git/tags")</repo>

@API.route("/<namespace>/<repo>/git/tags")</repo></namespace>

@API.route("/fork/<username>/<repo>/git/tags")</repo></username>

@API.route("/fork/<username>/<namespace>/<repo>/git/tags")</repo></namespace></username>

@api_method

def api_git_tags(repo, username=None, namespace=None):

    """

    Project git tags

    ----------------

    List the tags made on the project Git repository.

    ::

        GET /api/0/<repo>/git/tags</repo>

        GET /api/0/<namespace>/<repo>/git/tags</repo></namespace>

    ::

        GET /api/0/fork/<username>/<repo>/git/tags</repo></username>

        GET /api/0/fork/<username>/<namespace>/<repo>/git/tags</repo></namespace></username>

    Parameters

    ^^^^^^^^^^

    +-----------------+----------+---------------+--------------------------+

    | Key             | Type     | Optionality   | Description              |

    +=================+==========+===============+==========================+

    | ``with_commits``| string   | Optional      | | Include the commit hash|

    |                 |          |               |   corresponding to the   |

    |                 |          |               |   tags found in the repo |

    +-----------------+----------+---------------+--------------------------+

    Sample response

    ^^^^^^^^^^^^^^^

    ::

        {

          "total_tags": 2,

          "tags": ["0.0.1", "0.0.2"]

        }

        {

          "total_tags": 2,

          "tags": {

            "0.0.1": "bb8fa2aa199da08d6085e1c9badc3d83d188d38c",

            "0.0.2": "d16fe107eca31a1bdd66fb32c6a5c568e45b627e"

          }

        }

    """

    with_commits = pagure.utils.is_true(

        flask.request.values.get("with_commits", False)

    )

    repo = _get_repo(repo, username, namespace)

    tags = pagure.lib.git.get_git_tags(repo, with_commits=with_commits)

    jsonout = flask.jsonify({"total_tags": len(tags), "tags": tags})

    return jsonout

@API.route("/<repo>/watchers")</repo>

@API.route("/<namespace>/<repo>/watchers")</repo></namespace>

@API.route("/fork/<username>/<repo>/watchers")</repo></username>

@API.route("/fork/<username>/<namespace>/<repo>/watchers")</repo></namespace></username>

@api_method

def api_project_watchers(repo, username=None, namespace=None):

    """

    Project watchers

    ----------------

    List the watchers on the project.

    ::

        GET /api/0/<repo>/watchers</repo>

        GET /api/0/<namespace>/<repo>/watchers</repo></namespace>

    ::

        GET /api/0/fork/<username>/<repo>/watchers</repo></username>

        GET /api/0/fork/<username>/<namespace>/<repo>/watchers</repo></namespace></username>

    Sample response

    ^^^^^^^^^^^^^^^

    ::

        {

            "total_watchers": 1,

            "watchers": {

                "mprahl": [

                    "issues",

                    "commits"

                ]

            }

        }

    """

    repo = _get_repo(repo, username, namespace)

    implicit_watch_users = set([repo.user.username])

    for access_type in repo.access_users:

        implicit_watch_users = implicit_watch_users.union(

            set([user.username for user in repo.access_users[access_type]])

        )

    watching_users_to_watch_level = {}

    for implicit_watch_user in implicit_watch_users:

        user_watch_level = pagure.lib.query.get_watch_level_on_repo(

            flask.g.session, implicit_watch_user, repo

        )

        watching_users_to_watch_level[implicit_watch_user] = user_watch_level

    for access_type in repo.access_groups.keys():

        group_names = [

            "@" + group.group_name for group in repo.access_groups[access_type]

        ]

        for group_name in group_names:

            if group_name not in watching_users_to_watch_level:

                watching_users_to_watch_level[group_name] = set()

            # By the logic in pagure.lib.query.get_watch_level_on_repo, group

            # members only by default watch issues.  If they want to watch

            # commits they have to explicitly subscribe.

            watching_users_to_watch_level[group_name].add("issues")

    for key in watching_users_to_watch_level:

        watching_users_to_watch_level[key] = list(

            watching_users_to_watch_level[key]

        )

    # Get the explicit watch statuses

    for watcher in repo.watchers:

        if watcher.watch_issues or watcher.watch_commits:

            watching_users_to_watch_level[

                watcher.user.username

            ] = pagure.lib.query.get_watch_level_on_repo(

                flask.g.session, watcher.user.username, repo

            )

        else:

            if watcher.user.username in watching_users_to_watch_level:

                watching_users_to_watch_level.pop(watcher.user.username, None)

    return flask.jsonify(

        {

            "total_watchers": len(watching_users_to_watch_level),

            "watchers": watching_users_to_watch_level,

        }

    )

@API.route("/<repo>/git/urls")</repo>

@API.route("/<namespace>/<repo>/git/urls")</repo></namespace>

@API.route("/fork/<username>/<repo>/git/urls")</repo></username>

@API.route("/fork/<username>/<namespace>/<repo>/git/urls")</repo></namespace></username>

@api_login_optional()

@api_method

def api_project_git_urls(repo, username=None, namespace=None):

    """

    Project Git URLs

    ----------------

    List the Git URLS on the project.

    ::

        GET /api/0/<repo>/git/urls</repo>

        GET /api/0/<namespace>/<repo>/git/urls</repo></namespace>

    ::

        GET /api/0/fork/<username>/<repo>/git/urls</repo></username>

        GET /api/0/fork/<username>/<namespace>/<repo>/git/urls</repo></namespace></username>

    Sample response

    ^^^^^^^^^^^^^^^

    ::

        {

            "total_urls": 2,

            "urls": {

                "ssh": "ssh://git@pagure.io/mprahl-test123.git",

                "git": "https://pagure.io/mprahl-test123.git"

            }

        }

    """

    repo = _get_repo(repo, username, namespace)

    git_urls = {}

    git_url_ssh = pagure_config.get("GIT_URL_SSH")

    if pagure.utils.api_authenticated() and git_url_ssh:

        try:

            git_url_ssh = git_url_ssh.format(

                username=flask.g.fas_user.username

            )

        except (KeyError, IndexError):

            pass

    if git_url_ssh:

        git_urls["ssh"] = "{0}{1}.git".format(git_url_ssh, repo.fullname)

    if pagure_config.get("GIT_URL_GIT"):

        git_urls["git"] = "{0}{1}.git".format(

            pagure_config["GIT_URL_GIT"], repo.fullname

        )

    return flask.jsonify({"total_urls": len(git_urls), "urls": git_urls})

@API.route("/<repo>/git/branches")</repo>

@API.route("/<namespace>/<repo>/git/branches")</repo></namespace>

@API.route("/fork/<username>/<repo>/git/branches")</repo></username>

@API.route("/fork/<username>/<namespace>/<repo>/git/branches")</repo></namespace></username>

@api_method

def api_git_branches(repo, username=None, namespace=None):

    """

    List project branches

    ---------------------

    List the branches associated with a Pagure git repository

    ::

        GET /api/0/<repo>/git/branches</repo>

        GET /api/0/<namespace>/<repo>/git/branches</repo></namespace>

    ::

        GET /api/0/fork/<username>/<repo>/git/branches</repo></username>

        GET /api/0/fork/<username>/<namespace>/<repo>/git/branches</repo></namespace></username>

    Parameters

    ^^^^^^^^^^

    +-----------------+----------+---------------+--------------------------+

    | Key             | Type     | Optionality   | Description              |

    +=================+==========+===============+==========================+

    | ``with_commits``| boolean  | Optional      | | Include the commit hash|

    |                 |          |               |   corresponding to the   |

    |                 |          |               |   HEAD of each branch    |

    +-----------------+----------+---------------+--------------------------+

    Sample response

    ^^^^^^^^^^^^^^^

    ::

        {

          "total_branches": 2,

          "branches": ["master", "dev"]

        }

        {

          "total_branches": 2,

          "branches": {

            "master": "16ae2a4df107658b52750063ae203f978cf02ff7",

            "dev": "8351c460167a41defc393f5b6c1d51fe1b3b82b8"

          }

        }

    """

    with_commits = pagure.utils.is_true(

        flask.request.values.get("with_commits", False)

    )

    repo = _get_repo(repo, username, namespace)

    branches = pagure.lib.git.get_git_branches(repo, with_commits=with_commits)

    return flask.jsonify(

        {"total_branches": len(branches), "branches": branches}

    )

@API.route("/projects")

@api_method

def api_projects():

    """

    List projects

    --------------

    Search projects given the specified criterias.

    ::

        GET /api/0/projects

    ::

        GET /api/0/projects?tags=fedora-infra

    ::

        GET /api/0/projects?page=1&per_page=50

    Parameters

    ^^^^^^^^^^

    +---------------+----------+---------------+--------------------------+

    | Key           | Type     | Optionality   | Description              |

    +===============+==========+===============+==========================+

    | ``tags``      | string   | Optional      | | Filters the projects   |

    |               |          |               |   returned by their tags |

    +---------------+----------+---------------+--------------------------+

    | ``pattern``   | string   | Optional      | | Filters the projects   |

    |               |          |               |   by the pattern string  |

    +---------------+----------+---------------+--------------------------+

    | ``username``  | string   | Optional      | | Filters the projects   |

    |               |          |               |   returned by the users  |

    |               |          |               |   having commit rights   |

    |               |          |               |   to it                  |

    +---------------+----------+---------------+--------------------------+

    | ``owner``     | string   | Optional      | | Filters the projects   |

    |               |          |               |   by ownership.          |

    |               |          |               |   If the argument is of  |

    |               |          |               |   the form  then |

    |               |          |               |   the project returned   |

    |               |          |               |   are the ones *not*     |

    |               |          |               |   owned by this user.    |

    +---------------+----------+---------------+--------------------------+

    | ``namespace`` | string   | Optional      | | Filters the projects   |

    |               |          |               |   by namespace           |

    +---------------+----------+---------------+--------------------------+

    | ``fork``      | boolean  | Optional      | | Filters the projects   |

    |               |          |               |   returned depending if  |

    |               |          |               |   they are forks or not  |

    +---------------+----------+---------------+--------------------------+

    | ``short``     | boolean  | Optional      | | Whether to return the  |

    |               |          |               |   entrie project JSON    |

    |               |          |               |   or just a sub-set      |

    +---------------+----------+---------------+--------------------------+

    | ``page``      | int      | Optional      | | Specifies which        |

    |               |          |               |   page to return         |

    |               |          |               |   (defaults to: 1)       |

    +---------------+----------+---------------+--------------------------+

    | ``per_page``  | int      | Optional      | | The number of projects |

    |               |          |               |   to return per page.    |

    |               |          |               |   The maximum is 100.    |

    +---------------+----------+---------------+--------------------------+

    Sample response

    ^^^^^^^^^^^^^^^

    ::

        {

          "args": {

            "fork": null,

            "namespace": null,

            "owner": null,

            "page": 1,

            "pattern": null,

            "per_page": 2,

            "short": false,

            "tags": [],

            "username": null

          },

          "pagination": {

            "first": "http://127.0.0.1:5000/api/0/projects?per_page=2&page=1",

            "last": "http://127.0.0.1:5000/api/0/projects?per_page=2&page=500",

            "next": "http://127.0.0.1:5000/api/0/projects?per_page=2&page=2",

            "page": 1,

            "pages": 500,

            "per_page": 2,

            "prev": null

          },

          "projects": [

            {

              "access_groups": {

                "admin": [],

                "commit": [],

                "ticket": []

              },

              "access_users": {

                "admin": [],

                "commit": [],

                "owner": [

                  "mprahl"

                ],

                "ticket": []

              },

              "close_status": [],

              "custom_keys": [],

              "date_created": "1498841289",

              "description": "test1",

              "fullname": "test1",

              "id": 1,

              "milestones": {},

              "name": "test1",

              "namespace": null,

              "parent": null,

              "priorities": {},

              "tags": [],

              "url_path": "test1",

              "user": {

                "fullname": "Matt Prahl",

                "name": "mprahl"

              }

            },

            {

              "access_groups": {

                "admin": [],

                "commit": [],

                "ticket": []

              },

              "access_users": {

                "admin": [],

                "commit": [],

                "owner": [

                  "mprahl"

                ],

                "ticket": []

              },

              "close_status": [],

              "custom_keys": [],

              "date_created": "1499795310",

              "description": "test2",

              "fullname": "test2",

              "id": 2,

              "milestones": {},

              "name": "test2",

              "namespace": null,

              "parent": null,

              "priorities": {},

              "tags": [],

              "url_path": "test2",

              "user": {

                "fullname": "Matt Prahl",

                "name": "mprahl"

              }

            }

          ],

          "total_projects": 1000

        }

    """

    tags = flask.request.values.getlist("tags")

    username = flask.request.values.get("username", None)

    fork = flask.request.values.get("fork", None)

    namespace = flask.request.values.get("namespace", None)

    owner = flask.request.values.get("owner", None)

    pattern = flask.request.values.get("pattern", None)

    short = pagure.utils.is_true(flask.request.values.get("short", False))

    if fork is not None:

        fork = pagure.utils.is_true(fork)

    private = False

    if pagure.utils.authenticated() and username == flask.g.fas_user.username:

        private = flask.g.fas_user.username

    project_count = pagure.lib.query.search_projects(

        flask.g.session,

        username=username,

        fork=fork,

        tags=tags,

        pattern=pattern,

        private=private,

        namespace=namespace,

        owner=owner,

        count=True,

    )

    # Pagination code inspired by Flask-SQLAlchemy

    page = get_page()

    per_page = get_per_page()

    pagination_metadata = pagure.lib.query.get_pagination_metadata(

        flask.request, page, per_page, project_count

    )

    query_start = (page - 1) * per_page

    query_limit = per_page

    projects = pagure.lib.query.search_projects(

        flask.g.session,

        username=username,

        fork=fork,

        tags=tags,

        pattern=pattern,

        private=private,

        namespace=namespace,

        owner=owner,

        limit=query_limit,

        start=query_start,

    )

    # prepare the output json

    jsonout = {

        "total_projects": project_count,

        "projects": projects,

        "args": {

            "tags": tags,

            "username": username,

            "fork": fork,

            "pattern": pattern,

            "namespace": namespace,

            "owner": owner,

            "short": short,

        },

    }

    if not short:

        projects = [p.to_json(api=True, public=True) for p in projects]

    else:

        projects = [

            {

                "name": p.name,

                "namespace": p.namespace,

                "fullname": p.fullname.replace("forks/", "fork/", 1)

                if p.fullname.startswith("forks/")

                else p.fullname,

                "description": p.description,

            }

            for p in projects

        ]

    jsonout["projects"] = projects

    if pagination_metadata:

        jsonout["args"]["page"] = page

        jsonout["args"]["per_page"] = per_page

        jsonout["pagination"] = pagination_metadata

    return flask.jsonify(jsonout)

@API.route("/<repo>")</repo>

@API.route("/<namespace>/<repo>")</repo></namespace>

@API.route("/fork/<username>/<repo>")</repo></username>

@API.route("/fork/<username>/<namespace>/<repo>")</repo></namespace></username>

@api_method

def api_project(repo, username=None, namespace=None):

    """

    Project information

    -------------------

    Return information about a specific project

    ::

        GET /api/0/<repo></repo>

        GET /api/0/<namespace>/<repo></repo></namespace>

    ::

        GET /api/0/fork/<username>/<repo></repo></username>

        GET /api/0/fork/<username>/<namespace>/<repo></repo></namespace></username>

    Sample response

    ^^^^^^^^^^^^^^^

    ::

        {

          "access_groups": {

            "admin": [],

            "commit": [],

            "ticket": []

          },

          "access_users": {

            "admin": [

              "ryanlerch"

            ],

            "commit": [

              "puiterwijk"

            ],

            "owner": [

              "pingou"

            ],

            "ticket": [

              "vivekanand1101",

              "mprahl",

              "jcline",

              "lslebodn",

              "cverna",

              "farhaan"

            ]

          },

          "close_status": [

            "Invalid",

            "Insufficient data",

            "Fixed",

            "Duplicate"

          ],

          "custom_keys": [],

          "date_created": "1431549490",

          "date_modified": "1431549490",

          "description": "A git centered forge",

          "fullname": "pagure",

          "id": 10,

          "milestones": {},

          "name": "pagure",

          "namespace": null,

          "parent": null,

          "priorities": {},

          "tags": [

            "pagure",

            "fedmsg"

          ],

          "user": {

            "fullname": "Pierre-YvesChibon",

            "name": "pingou"

          }

        }

    """

    repo = _get_repo(repo, username, namespace)

    expand_group = pagure.utils.is_true(

        flask.request.values.get("expand_group", False)

    )

    output = repo.to_json(api=True, public=True)

    if expand_group:

        group_details = {}

        for grp in repo.projects_groups:

            group_details[grp.group.group_name] = [

                user.username for user in grp.group.users

            ]

        output["group_details"] = group_details

    jsonout = flask.jsonify(output)

    return jsonout

@API.route("/new/", methods=["POST"])

@API.route("/new", methods=["POST"])

@api_login_required(acls=["create_project"])

@api_method

def api_new_project():

    """

    Create a new project

    --------------------

    Create a new project on this pagure instance.

    This is an asynchronous call.

    ::

        POST /api/0/new

    Input

    ^^^^^

    +----------------------------+---------+--------------+---------------------------+

    | Key                        | Type    | Optionality  | Description               |

    +============================+=========+==============+===========================+

    | ``name``                   | string  | Mandatory    | | The name of the new     |

    |                            |         |              |   project.                |

    +----------------------------+---------+--------------+---------------------------+

    | ``description``            | string  | Mandatory    | | A short description of  |

    |                            |         |              |   the new project.        |

    +----------------------------+---------+--------------+---------------------------+

    | ``namespace``              | string  | Optional     | | The namespace of the    |

    |                            |         |              |   project to fork.        |

    +----------------------------+---------+--------------+---------------------------+

    | ``url``                    | string  | Optional     | | An url providing more   |

    |                            |         |              |   information about the   |

    |                            |         |              |   project.                |

    +----------------------------+---------+--------------+---------------------------+

    | ``avatar_email``           | string  | Optional     | | An email address for the|

    |                            |         |              |   avatar of the project.  |

    +----------------------------+---------+--------------+---------------------------+

    | ``create_readme``          | boolean | Optional     | | A boolean to specify if |

    |                            |         |              |   there should be a readme|

    |                            |         |              |   added to the project on |

    |                            |         |              |   creation.               |

    +----------------------------+---------+--------------+---------------------------+

    | ``private``                | boolean | Optional     | | A boolean to specify if |

    |                            |         |              |   the project to create   |

    |                            |         |              |   is private.             |

    |                            |         |              |   Note: not all pagure    |

    |                            |         |              |   instance support private|

    |                            |         |              |   projects, confirm this  |

    |                            |         |              |   with your administrators|

    +----------------------------+---------+--------------+---------------------------+

    | ``ignore_existing_repos``  | boolean | Optional     | | Only available to admins|

    |                            |         |              |   this option allows them |

    |                            |         |              |   to make project creation|

    |                            |         |              |   pass even if there is   |

    |                            |         |              |   already a coresopnding  |

    |                            |         |              |   git repository on disk  |

    +----------------------------+---------+--------------+---------------------------+

    | ``repospanner_region``     | boolean | Optional     | | Only available to admins|

    |                            |         |              |   this option allows them |

    |                            |         |              |   to override the default |

    |                            |         |              |   respoSpanner region     |

    |                            |         |              |   configured              |

    +----------------------------+---------+--------------+---------------------------+

    | ``wait``                   | boolean | Optional     | | A boolean to specify if |

    |                            |         |              |   this API call should    |

    |                            |         |              |   return a taskid or if it|

    |                            |         |              |   should wait for the task|

    |                            |         |              |   to finish.              |

    +----------------------------+---------+--------------+---------------------------+

    Sample response

    ^^^^^^^^^^^^^^^

    ::

        wait=False:

        {

          'message': 'Project creation queued',

          'taskid': '123-abcd'

        }

        wait=True:

        {

          'message': 'Project creation queued'

        }

    """  # noqa

    user = pagure.lib.query.search_user(

        flask.g.session, username=flask.g.fas_user.username

    )

    output = {}

    if not pagure_config.get("ENABLE_NEW_PROJECTS", True):

        raise pagure.exceptions.APIError(

            404, error_code=APIERROR.ENEWPROJECTDISABLED

        )

    namespaces = pagure_config["ALLOWED_PREFIX"][:]

    if user:

        namespaces.extend([grp for grp in user.groups])

    form = pagure.forms.ProjectForm(namespaces=namespaces, csrf_enabled=False)

    if form.validate_on_submit():

        name = form.name.data

        description = form.description.data

        namespace = form.namespace.data

        url = form.url.data

        avatar_email = form.avatar_email.data

        create_readme = form.create_readme.data

        if namespace:

            namespace = namespace.strip()

        private = False

        if pagure_config.get("PRIVATE_PROJECTS", False):

            private = form.private.data

        if form.repospanner_region:

            repospanner_region = form.repospanner_region.data

        else:

            repospanner_region = None

        if form.ignore_existing_repos:

            ignore_existing_repos = form.ignore_existing_repos.data

        else:

            ignore_existing_repos = False

        try:

            task = pagure.lib.query.new_project(

                flask.g.session,

                name=name,

                namespace=namespace,

                repospanner_region=repospanner_region,

                ignore_existing_repo=ignore_existing_repos,

                description=description,

                private=private,

                url=url,

                avatar_email=avatar_email,

                user=flask.g.fas_user.username,

                blacklist=pagure_config["BLACKLISTED_PROJECTS"],

                allowed_prefix=pagure_config["ALLOWED_PREFIX"],

                add_readme=create_readme,

                userobj=user,

                prevent_40_chars=pagure_config.get(

                    "OLD_VIEW_COMMIT_ENABLED", False

                ),

                user_ns=pagure_config.get("USER_NAMESPACE", False),

            )

            flask.g.session.commit()

            output = {"message": "Project creation queued", "taskid": task.id}

            if get_request_data().get("wait", True):

                result = task.get()

                project = pagure.lib.query._get_project(

                    flask.g.session,

                    name=result["repo"],

                    namespace=result["namespace"],

                )

                output = {"message": 'Project "%s" created' % project.fullname}

        except pagure.exceptions.PagureException as err:

            raise pagure.exceptions.APIError(

                400, error_code=APIERROR.ENOCODE, error=str(err)

            )

        except SQLAlchemyError as err:  # pragma: no cover

            _log.exception(err)

            flask.g.session.rollback()

            raise pagure.exceptions.APIError(400, error_code=APIERROR.EDBERROR)

    else:

        raise pagure.exceptions.APIError(

            400, error_code=APIERROR.EINVALIDREQ, errors=form.errors

        )

    jsonout = flask.jsonify(output)

    return jsonout

@API.route("/<repo>", methods=["PATCH"])</repo>

@API.route("/<namespace>/<repo>", methods=["PATCH"])</repo></namespace>

@api_login_required(acls=["modify_project"])

@api_method

def api_modify_project(repo, namespace=None):

    """

    Modify a project

    ----------------

    Modify an existing project on this Pagure instance.

    ::

        PATCH /api/0/<repo></repo>

    Input

    ^^^^^

    +------------------+---------+--------------+---------------------------+

    | Key              | Type    | Optionality  | Description               |

    +==================+=========+==============+===========================+

    | ``main_admin``   | string  | Mandatory    | | The new main admin of   |

    |                  |         |              |   the project.            |

    +------------------+---------+--------------+---------------------------+

    | ``retain_access``| string  | Optional     | | The old main admin      |

    |                  |         |              |   retains access on the   |

    |                  |         |              |   project when giving the |

    |                  |         |              |   project. Defaults to    |

    |                  |         |              |   ``False``.              |

    +------------------+---------+--------------+---------------------------+

    Sample response

    ^^^^^^^^^^^^^^^

    ::

        {

          "access_groups": {

            "admin": [],

            "commit": [],