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

"""
 (c) 2014-2017 - Copyright Red Hat Inc

 Authors:
   Pierre-Yves Chibon <pingou@pingoured.fr>

"""

# pylint: disable=too-many-lines
# pylint: disable=too-many-branches
# pylint: disable=too-many-locals
# pylint: disable=too-many-statements


from __future__ import unicode_literals, absolute_import

import datetime
import logging
import os
from collections import defaultdict, OrderedDict
from math import ceil

import flask
import pygit2
import werkzeug.datastructures
from sqlalchemy.exc import SQLAlchemyError
from binaryornot.helpers import is_binary_string

import pagure.doc_utils
import pagure.exceptions
import pagure.lib.query
import pagure.lib.mimetype
from pagure.decorators import has_issue_tracker, is_repo_admin

import pagure.forms
from pagure.config import config as pagure_config
from pagure.ui import UI_NS
from pagure.utils import (
    __get_file_in_tree,
    authenticated,
    login_required,
    urlpattern,
    is_true,
)


_log = logging.getLogger(__name__)


@UI_NS.route("/<repo>/issue/<int:issueid>/update/", methods=["GET", "POST"])
@UI_NS.route("/<repo>/issue/<int:issueid>/update", methods=["GET", "POST"])
@UI_NS.route(
    "/<namespace>/<repo>/issue/<int:issueid>/update/", methods=["GET", "POST"]
)
@UI_NS.route(
    "/<namespace>/<repo>/issue/<int:issueid>/update", methods=["GET", "POST"]
)
@UI_NS.route(
    "/fork/<username>/<repo>/issue/<int:issueid>/update/",
    methods=["GET", "POST"],
)
@UI_NS.route(
    "/fork/<username>/<repo>/issue/<int:issueid>/update",
    methods=["GET", "POST"],
)
@UI_NS.route(
    "/fork/<username>/<namespace>/<repo>/issue/<int:issueid>/update/",
    methods=["GET", "POST"],
)
@UI_NS.route(
    "/fork/<username>/<namespace>/<repo>/issue/<int:issueid>/update",
    methods=["GET", "POST"],
)
@login_required
@has_issue_tracker
def update_issue(repo, issueid, username=None, namespace=None):
    """ Add comment or update metadata of an issue. """
    is_js = flask.request.args.get("js", False)

    repo = flask.g.repo

    if flask.request.method == "GET":
        if not is_js:
            flask.flash("Invalid method: GET", "error")
        return flask.redirect(
            flask.url_for(
                "ui_ns.view_issue",
                username=username,
                repo=repo.name,
                namespace=repo.namespace,
                issueid=issueid,
            )
        )

    issue = pagure.lib.query.search_issues(
        flask.g.session, repo, issueid=issueid
    )

    if issue is None or issue.project != repo:
        flask.abort(404, description="Issue not found")

    if (
        issue.private
        and not flask.g.repo_committer
        and (
            not authenticated()
            or not issue.user.user == flask.g.fas_user.username
        )
    ):
        flask.abort(
            403,
            description="This issue is private and you are not allowed "
            "to view it",
        )

    if flask.request.form.get("edit_comment"):
        commentid = flask.request.form.get("edit_comment")
        form = pagure.forms.EditCommentForm()
        if form.validate_on_submit():
            return edit_comment_issue(
                repo.name, issueid, commentid, username=username
            )

    status = pagure.lib.query.get_issue_statuses(flask.g.session)
    form = pagure.forms.UpdateIssueForm(
        status=status,
        priorities=repo.priorities,
        milestones=repo.milestones,
        close_status=repo.close_status,
    )

    is_author = flask.g.fas_user.username == issue.user.user
    is_contributor = flask.g.repo_user
    is_open_access = repo.settings.get("open_metadata_access_to_all", False)

    if form.validate_on_submit():
        if flask.request.form.get("drop_comment"):
            commentid = flask.request.form.get("drop_comment")

            comment = pagure.lib.query.get_issue_comment(
                flask.g.session, issue.uid, commentid
            )
            if comment is None or comment.issue.project != repo:
                flask.abort(404, description="Comment not found")

            if (
                not is_author or comment.parent.status != "Open"
            ) and not flask.g.repo_committer:
                flask.abort(
                    403,
                    description="You are not allowed to remove this "
                    "comment from this issue",
                )

            issue.last_updated = datetime.datetime.utcnow()
            flask.g.session.add(issue)
            flask.g.session.delete(comment)
            pagure.lib.git.update_git(issue, repo=issue.project)
            try:
                flask.g.session.commit()
                if not is_js:
                    flask.flash("Comment removed")
            except SQLAlchemyError as err:  # pragma: no cover
                is_js = False
                flask.g.session.rollback()
                _log.error(err)
                if not is_js:
                    flask.flash(
                        "Could not remove the comment: %s" % commentid, "error"
                    )
            if is_js:
                return "ok"
            else:
                return flask.redirect(
                    flask.url_for(
                        "ui_ns.view_issue",
                        username=username,
                        repo=repo.name,
                        namespace=repo.namespace,
                        issueid=issueid,
                    )
                )

        comment = form.comment.data
        depends = []
        for depend in form.depending.data.split(","):
            if depend.strip():
                try:
                    depends.append(int(depend.strip()))
                except ValueError:
                    pass

        blocks = []
        for block in form.blocking.data.split(","):
            if block.strip():
                try:
                    blocks.append(int(block.strip()))
                except ValueError:
                    pass

        assignee = form.assignee.data.strip() or None
        new_status = form.status.data.strip() or None
        close_status = form.close_status.data or None
        if close_status not in repo.close_status:
            close_status = None

        new_priority = None
        try:
            new_priority = int(form.priority.data)
        except (ValueError, TypeError):
            pass
        tags = [tag.strip() for tag in form.tag.data.split(",") if tag.strip()]

        new_milestone = None
        try:
            if repo.milestones:
                new_milestone = form.milestone.data.strip() or None
        except AttributeError:
            pass

        try:
            messages = set()

            # The status field can be updated by both the admin and the
            # person who opened the ticket.
            # Update status
            if is_contributor or is_author:
                if new_status in status:
                    msgs = pagure.lib.query.edit_issue(
                        flask.g.session,
                        issue=issue,
                        status=new_status,
                        close_status=close_status,
                        milestone=issue.milestone,
                        private=issue.private,
                        user=flask.g.fas_user.username,
                    )
                    flask.g.session.commit()
                    if msgs:
                        messages = messages.union(set(msgs))

            # All the other meta-data can be changed only by admins
            # while other field will be missing for non-admin and thus
            # reset if we let them
            if is_contributor or is_open_access:
                # Adjust (add/remove) tags
                msgs = pagure.lib.query.update_tags(
                    flask.g.session,
                    issue,
                    tags,
                    username=flask.g.fas_user.username,
                )
                messages = messages.union(set(msgs))

                # The meta-data can only be changed by admins, which means
                # they will be missing for non-admin and thus reset if we
                # let them

                # Assign or update assignee of the ticket
                message = pagure.lib.query.add_issue_assignee(
                    flask.g.session,
                    issue=issue,
                    assignee=assignee or None,
                    user=flask.g.fas_user.username,
                )
                flask.g.session.commit()
                if message and message != "Nothing to change":
                    messages.add(message)

                # Adjust priority if needed
                if "%s" % new_priority not in repo.priorities:
                    new_priority = None

                # Update core metadata
                msgs = pagure.lib.query.edit_issue(
                    flask.g.session,
                    repo=repo,
                    issue=issue,
                    milestone=new_milestone,
                    priority=new_priority,
                    private=form.private.data,
                    user=flask.g.fas_user.username,
                )
                if msgs:
                    messages = messages.union(set(msgs))

                # Update the custom keys/fields
                for key in repo.issue_keys:
                    value = flask.request.form.get(key.name)
                    if value:
                        if key.key_type == "link":
                            links = value.split(",")
                            for link in links:
                                link = link.replace(" ", "")
                                if not urlpattern.match(link):
                                    flask.abort(
                                        400,
                                        description='Meta-data "link" field '
                                        "(%s) has invalid url (%s) "
                                        % (key.name, link),
                                    )

                    msg = pagure.lib.query.set_custom_key_value(
                        flask.g.session, issue, key, value
                    )
                    if key.key_notify and msg is not None:
                        # Custom field changed that is set for notifications
                        pagure.lib.notify.notify_meta_change_issue(
                            issue, flask.g.fas_user, msg
                        )
                    if msg:
                        messages.add(msg)

                # Update ticket this one depends on
                msgs = pagure.lib.query.update_dependency_issue(
                    flask.g.session,
                    repo,
                    issue,
                    depends,
                    username=flask.g.fas_user.username,
                )
                messages = messages.union(set(msgs))

                # Update ticket(s) depending on this one
                msgs = pagure.lib.query.update_blocked_issue(
                    flask.g.session,
                    repo,
                    issue,
                    blocks,
                    username=flask.g.fas_user.username,
                )
                messages = messages.union(set(msgs))

            flask.g.session.commit()

            # New comment
            if comment:
                message = pagure.lib.query.add_issue_comment(
                    flask.g.session,
                    issue=issue,
                    comment=comment,
                    user=flask.g.fas_user.username,
                )

                if not is_js:
                    if message:
                        messages.add(message)

            flask.g.session.commit()

            if not is_js:
                for message in messages:
                    flask.flash(message)

            # Add the comment for field updates:
            if messages:
                not_needed = set(["Comment added", "Updated comment"])
                pagure.lib.query.add_metadata_update_notif(
                    session=flask.g.session,
                    obj=issue,
                    messages=messages - not_needed,
                    user=flask.g.fas_user.username,
                )
                messages.add("Metadata fields updated")

        except pagure.exceptions.PagureException as err:
            is_js = False
            flask.g.session.rollback()
            flask.flash("%s" % err, "error")
        except SQLAlchemyError as err:  # pragma: no cover
            is_js = False
            flask.g.session.rollback()
            _log.exception(err)
            flask.flash("%s" % err, "error")
    else:
        if is_js:
            return "notok: %s" % form.errors

    if is_js:
        return "ok"
    else:
        return flask.redirect(
            flask.url_for(
                "ui_ns.view_issue",
                repo=repo.name,
                username=username,
                namespace=namespace,
                issueid=issueid,
            )
        )


_REACTION_URL_SNIPPET = "issue/<int:issueid>/comment/<int:commentid>/react"


@UI_NS.route("/<repo>/%s/" % _REACTION_URL_SNIPPET, methods=["POST"])
@UI_NS.route("/<repo>/%s" % _REACTION_URL_SNIPPET, methods=["POST"])
@UI_NS.route(
    "/<namespace>/<repo>/%s/" % _REACTION_URL_SNIPPET, methods=["POST"]
)
@UI_NS.route(
    "/<namespace>/<repo>/%s" % _REACTION_URL_SNIPPET, methods=["POST"]
)
@UI_NS.route(
    "/fork/<username>/<repo>/%s/" % _REACTION_URL_SNIPPET, methods=["POST"]
)
@UI_NS.route(
    "/fork/<username>/<repo>/%s" % _REACTION_URL_SNIPPET, methods=["POST"]
)
@UI_NS.route(
    "/fork/<username>/<namespace>/<repo>/%s/" % _REACTION_URL_SNIPPET,
    methods=["POST"],
)
@UI_NS.route(
    "/fork/<username>/<namespace>/<repo>/%s" % _REACTION_URL_SNIPPET,
    methods=["POST"],
)
@login_required
@has_issue_tracker
def issue_comment_add_reaction(
    repo, issueid, commentid, username=None, namespace=None
):
    """Add a reaction to a comment of an issue"""
    repo = flask.g.repo

    issue = pagure.lib.query.search_issues(
        flask.g.session, repo, issueid=issueid
    )

    if not issue or issue.project != repo:
        flask.abort(404, description="Comment not found")

    form = pagure.forms.ConfirmationForm()
    if not form.validate_on_submit():
        flask.abort(400, description="CSRF token not valid")

    if (
        issue.private
        and not flask.g.repo_committer
        and (
            not authenticated()
            or not issue.user.user == flask.g.fas_user.username
        )
    ):
        flask.abort(404, description="No such issue")

    comment = pagure.lib.query.get_issue_comment(
        flask.g.session, issue.uid, commentid
    )

    if "reaction" not in flask.request.form:
        flask.abort(400, description="Reaction not found")

    reactions = comment.reactions
    r = flask.request.form["reaction"]
    if not r:
        flask.abort(400, description="Empty reaction is not acceptable")
    if flask.g.fas_user.username in reactions.get(r, []):
        flask.abort(409, description="Already posted this one")

    reactions.setdefault(r, []).append(flask.g.fas_user.username)
    comment.reactions = reactions
    flask.g.session.add(comment)

    try:
        flask.g.session.commit()
    except SQLAlchemyError as err:  # pragma: no cover
        flask.g.session.rollback()
        _log.error(err)
        return "error"

    return "ok"


@UI_NS.route("/<repo>/issues/")
@UI_NS.route("/<repo>/issues")
@UI_NS.route("/<namespace>/<repo>/issues/")
@UI_NS.route("/<namespace>/<repo>/issues")
@UI_NS.route("/fork/<username>/<repo>/issues/")
@UI_NS.route("/fork/<username>/<repo>/issues")
@UI_NS.route("/fork/<username>/<namespace>/<repo>/issues/")
@UI_NS.route("/fork/<username>/<namespace>/<repo>/issues")
@has_issue_tracker
def view_issues(repo, username=None, namespace=None):
    """ List all issues associated to a repo
    """

    status = flask.request.args.get("status", "Open")
    status = flask.request.args.get("close_status") or status
    priority = flask.request.args.get("priority", None)
    tags = flask.request.args.getlist("tags")
    tags = [tag.strip() for tag in tags if tag.strip()]
    assignee = flask.request.args.get("assignee", None)
    author = flask.request.args.get("author", None)
    search_pattern = flask.request.args.get("search_pattern") or None
    milestones = flask.request.args.getlist("milestone", None)
    order = flask.request.args.get("order", "desc")
    order_key = flask.request.args.get("order_key", "date_created")

    # Custom fields
    custom_keys = flask.request.args.getlist("ckeys")
    custom_values = flask.request.args.getlist("cvalue")
    custom_search = {}
    if len(custom_keys) == len(custom_values):
        for idx, key in enumerate(custom_keys):
            custom_search[key] = custom_values[idx]

    try:
        priority = int(priority)
    except (ValueError, TypeError):
        priority = None

    fields = {
        "status": status,
        "priority": priority,
        "tags": tags,
        "assignee": assignee,
        "author": author,
        "milestones": milestones,
        "search_content": None,
    }

    no_stone = None
    if "none" in milestones:
        no_stone = True
        milestones.remove("none")

    search_string = search_pattern
    extra_fields, search_pattern = pagure.lib.query.tokenize_search_string(
        search_pattern
    )

    if "content" in extra_fields:
        extra_fields["search_content"] = extra_fields["content"]
        del (extra_fields["content"])

    for field in fields:
        if field in extra_fields:
            fields[field] = extra_fields[field]
            del (extra_fields[field])

    custom_search.update(extra_fields)

    repo = flask.g.repo

    # Hide private tickets
    private = False
    # If user is authenticated, show him/her his/her private tickets
    if authenticated():
        private = flask.g.fas_user.username
    # If user is repo committer, show all tickets including the private ones
    if flask.g.repo_committer:
        private = None

    total_closed = pagure.lib.query.search_issues(
        flask.g.session, repo, status="Closed", private=private, count=True
    )

    total_open = pagure.lib.query.search_issues(
        flask.g.session, repo, status="Open", private=private, count=True
    )

    status = fields["status"]
    del (fields["status"])

    if status.lower() in ["all"]:
        status = None

    oth_issues_cnt = None
    total_issues_cnt = pagure.lib.query.search_issues(
        flask.g.session, repo, private=private, count=True, **fields
    )

    close_status_cnt = None

    if status is not None:
        if status.lower() not in ["open", "closed", "true"]:
            if status.lower() not in (s.lower() for s in repo.close_status):
                flask.abort(404, description="No status of that name")
            status = status.capitalize()
            status_count = "Closed"
            other_status_count = "Open"
            close_status_cnt = pagure.lib.query.search_issues(
                flask.g.session,
                repo,
                private=private,
                search_pattern=search_pattern,
                custom_search=custom_search,
                no_milestones=no_stone,
                count=True,
                status=status,
                **fields
            )
        else:
            if status.lower() in ["open", "true"]:
                status = "Open"
                status_count = "Open"
                other_status_count = "Closed"
            else:
                status = "Closed"
                status_count = "Closed"
                other_status_count = "Open"

        issues = pagure.lib.query.search_issues(
            flask.g.session,
            repo,
            private=private,
            offset=flask.g.offset,
            limit=flask.g.limit,
            search_pattern=search_pattern,
            custom_search=custom_search,
            no_milestones=no_stone,
            order=order,
            order_key=order_key,
            status=status,
            **fields
        )
        issues_cnt = pagure.lib.query.search_issues(
            flask.g.session,
            repo,
            private=private,
            search_pattern=search_pattern,
            custom_search=custom_search,
            no_milestones=no_stone,
            count=True,
            status=status_count,
            **fields
        )
        oth_issues_cnt = pagure.lib.query.search_issues(
            flask.g.session,
            repo,
            private=private,
            search_pattern=search_pattern,
            custom_search=custom_search,
            no_milestones=no_stone,
            count=True,
            status=other_status_count,
            **fields
        )
    else:
        issues = pagure.lib.query.search_issues(
            flask.g.session,
            repo,
            private=private,
            offset=flask.g.offset,
            limit=flask.g.limit,
            search_pattern=search_pattern,
            custom_search=custom_search,
            order=order,
            order_key=order_key,
            **fields
        )
        issues_cnt = pagure.lib.query.search_issues(
            flask.g.session,
            repo,
            private=private,
            search_pattern=search_pattern,
            custom_search=custom_search,
            count=True,
            **fields
        )
        oth_issues_cnt = pagure.lib.query.search_issues(
            flask.g.session,
            repo,
            private=private,
            search_pattern=search_pattern,
            custom_search=custom_search,
            no_milestones=no_stone,
            count=True,
            status="Open",
            **fields
        )
    tag_list = pagure.lib.query.get_tags_of_project(flask.g.session, repo)

    total_page = 1

    if close_status_cnt:
        total_page = int(ceil(close_status_cnt / float(flask.g.limit)))
    elif issues_cnt:
        total_page = int(ceil(issues_cnt / float(flask.g.limit)))

    return flask.render_template(
        "issues.html",
        select="issues",
        repo=repo,
        username=username,
        tag_list=tag_list,
        issues=issues,
        issues_cnt=issues_cnt,
        total_issues_cnt=total_issues_cnt,
        oth_issues_cnt=oth_issues_cnt,
        close_status_cnt=close_status_cnt,
        total_page=total_page,
        add_report_form=pagure.forms.AddReportForm(),
        search_pattern=search_string,
        order=order,
        order_key=order_key,
        close_status=flask.request.args.get("close_status"),
        status=status,
        total_open=total_open,
        total_closed=total_closed,
        no_milestones=no_stone,
        **fields
    )


@UI_NS.route("/<repo>/roadmap/")
@UI_NS.route("/<repo>/roadmap")
@UI_NS.route("/<namespace>/<repo>/roadmap/")
@UI_NS.route("/<namespace>/<repo>/roadmap")
@UI_NS.route("/fork/<username>/<repo>/roadmap/")
@UI_NS.route("/fork/<username>/<repo>/roadmap")
@UI_NS.route("/fork/<username>/<namespace>/<repo>/roadmap/")
@UI_NS.route("/fork/<username>/<namespace>/<repo>/roadmap")
@has_issue_tracker
def view_roadmap(repo, username=None, namespace=None):
    """ List all issues associated to a repo as roadmap
    """
    milestones_status_arg = flask.request.args.get("status", "active")
    milestones_keyword_arg = flask.request.args.get("keyword", None)
    milestones_onlyincomplete_arg = flask.request.args.get(
        "onlyincomplete", False
    )

    if milestones_onlyincomplete_arg == "True":
        milestones_onlyincomplete_arg = True
    else:
        milestones_onlyincomplete_arg = False

    repo = flask.g.repo

    # Hide private tickets
    private = False
    # If user is authenticated, show him/her his/her private tickets
    if authenticated():
        private = flask.g.fas_user.username

    # If user is repo committer, show all tickets including the private ones
    if flask.g.repo_committer:
        private = None

    milestones_list = []
    milestones_totals = defaultdict(int)
    milestones_totals["active"] = 0
    milestones_totals["inactive"] = 0

    for key in repo.milestones_keys:
        if milestones_keyword_arg and milestones_keyword_arg not in key:
            continue
        if key not in repo.milestones:
            continue
        if repo.milestones[key]["active"]:
            milestones_totals["active"] += 1
            if (
                milestones_status_arg == "active"
                or milestones_status_arg == "all"
            ):
                milestones_list.append(key)
        else:
            milestones_totals["inactive"] += 1
            if (
                milestones_status_arg == "inactive"
                or milestones_status_arg == "all"
            ):
                milestones_list.append(key)

    issues = pagure.lib.query.search_issues(
        flask.g.session,
        repo,
        milestones=milestones_list,
        private=private,
        status=None,
    )

    # Change from a list of issues to a dict of milestone/issues
    milestone_issues = OrderedDict()
    if milestones_list:
        for milestone in milestones_list:
            milestone_issues[milestone] = defaultdict(int)
        for issue in issues:
            if issue.milestone:
                milestone_issues[issue.milestone][issue.status] += 1
                milestone_issues[issue.milestone]["Total"] += 1

    if milestones_onlyincomplete_arg:
        for m in milestone_issues:
            if milestone_issues[m]["Total"] == 0:
                continue
            elif milestone_issues[m]["Total"] == milestone_issues[m]["Closed"]:
                del milestone_issues[m]
                if repo.milestones[m]["active"]:
                    milestones_totals["active"] -= 1
                else:
                    milestones_totals["inactive"] -= 1

    return flask.render_template(
        "repo_roadmap.html",
        select="roadmap",
        milestones_status_select=milestones_status_arg,
        repo=repo,
        username=username,
        milestones=milestone_issues,
        milestones_totals=milestones_totals,
        keyword=milestones_keyword_arg,
        onlyincomplete=milestones_onlyincomplete_arg,
    )


@UI_NS.route("/<repo>/roadmap/<path:milestone>")
@UI_NS.route("/<repo>/roadmap/<path:milestone>/")
@UI_NS.route("/<namespace>/<repo>/roadmap/<path:milestone>/")
@UI_NS.route("/<namespace>/<repo>/roadmap/<path:milestone>")
@UI_NS.route("/fork/<username>/<repo>/roadmap/<path:milestone>/")
@UI_NS.route("/fork/<username>/<repo>/roadmap/<path:milestone>")
@UI_NS.route("/fork/<username>/<namespace>/<repo>/roadmap/<path:milestone>/")
@UI_NS.route("/fork/<username>/<namespace>/<repo>/roadmap/<path:milestone>")
@has_issue_tracker
def view_milestone(repo, username=None, namespace=None, milestone=None):
    """ List all issues associated to a repo as roadmap
    """

    repo = flask.g.repo

    # Hide private tickets
    private = False
    # If user is authenticated, show him/her his/her private tickets
    if authenticated():
        private = flask.g.fas_user.username

    # If user is repo committer, show all tickets including the private ones
    if flask.g.repo_committer:
        private = None

    open_issues = pagure.lib.query.search_issues(
        flask.g.session,
        repo,
        milestones=[milestone],
        private=private,
        status="Open",
    )

    closed_issues = pagure.lib.query.search_issues(
        flask.g.session,
        repo,
        milestones=[milestone],
        private=private,
        status="Closed",
    )

    return flask.render_template(
        "repo_milestone.html",
        select="roadmap",
        repo=repo,
        username=username,
        milestone=milestone,
        open_issues=open_issues,
        closed_issues=closed_issues,
        total_open=len(open_issues),
        total_closed=len(closed_issues),
    )


@UI_NS.route("/<repo>/new_issue/", methods=("GET", "POST"))
@UI_NS.route("/<repo>/new_issue", methods=("GET", "POST"))
@UI_NS.route("/<namespace>/<repo>/new_issue/", methods=("GET", "POST"))
@UI_NS.route("/<namespace>/<repo>/new_issue", methods=("GET", "POST"))
@UI_NS.route("/fork/<username>/<repo>/new_issue/", methods=("GET", "POST"))
@UI_NS.route("/fork/<username>/<repo>/new_issue", methods=("GET", "POST"))
@UI_NS.route(
    "/fork/<username>/<namespace>/<repo>/new_issue/", methods=("GET", "POST")
)
@UI_NS.route(
    "/fork/<username>/<namespace>/<repo>/new_issue", methods=("GET", "POST")
)
@login_required
@has_issue_tracker
def new_issue(repo, username=None, namespace=None):
    """ Create a new issue
    """
    template = flask.request.args.get("template") or "default"
    repo = flask.g.repo
    open_access = repo.settings.get("open_metadata_access_to_all", False)

    milestones = []
    for m in repo.milestones_keys or repo.milestones:
        if m in repo.milestones and repo.milestones[m]["active"]:
            milestones.append(m)

    form = pagure.forms.IssueFormSimplied(
        priorities=repo.priorities, milestones=milestones
    )

    if form.validate_on_submit():
        title = form.title.data
        content = form.issue_content.data
        private = form.private.data

        try:
            user_obj = pagure.lib.query.get_user(
                flask.g.session, flask.g.fas_user.username
            )
        except pagure.exceptions.PagureException:
            flask.abort(
                404,
                description="No such user found in the database: %s"
                % (flask.g.fas_user.username),
            )

        try:
            priority = None
            if repo.default_priority:
                for key, val in repo.priorities.items():
                    if repo.default_priority == val:
                        priority = key

            assignee = None
            milestone = None
            tags = None
            if flask.g.repo_user or open_access:
                assignee = (
                    flask.request.form.get("assignee", "").strip() or None
                )
                milestone = form.milestone.data or None
                priority = form.priority.data or priority
                tags = [
                    tag.strip()
                    for tag in flask.request.form.get("tag", "").split(",")
                    if tag.strip()
                ]

            issue = pagure.lib.query.new_issue(
                flask.g.session,
                repo=repo,
                title=title,
                content=content,
                private=private or False,
                user=flask.g.fas_user.username,
                assignee=assignee,
                milestone=milestone,
                priority=priority,
                tags=tags,
            )
            flask.g.session.commit()

            # If there is a file attached, attach it.
            form = pagure.forms.UploadFileForm()
            if form.validate_on_submit():
                streams = flask.request.files.getlist("filestream")
                n_img = issue.content.count("<!!image>")
                if n_img == len(streams):
                    for filestream in streams:
                        new_filename = pagure.lib.query.add_attachment(
                            repo=repo,
                            issue=issue,
                            attachmentfolder=pagure_config[
                                "ATTACHMENTS_FOLDER"
                            ],
                            user=user_obj,
                            filename=filestream.filename,
                            filestream=filestream.stream,
                        )
                        # Replace the <!!image> tag in the comment with the
                        # link to the actual image
                        filelocation = flask.url_for(
                            "ui_ns.view_issue_raw_file",
                            repo=repo.name,
                            username=username,
                            namespace=repo.namespace,
                            filename="files/%s" % new_filename,
                        )
                        new_filename = new_filename.split("-", 1)[1]
                        url = "[![%s](%s)](%s)" % (
                            new_filename,
                            filelocation,
                            filelocation,
                        )
                        issue.content = issue.content.replace(
                            "<!!image>", url, 1
                        )
                    flask.g.session.add(issue)
                    flask.g.session.commit()

            return flask.redirect(
                flask.url_for(
                    "ui_ns.view_issue",
                    username=username,
                    repo=repo.name,
                    namespace=namespace,
                    issueid=issue.id,
                )
            )
        except pagure.exceptions.PagureException as err:
            flask.flash(str(err), "error")
        except SQLAlchemyError as err:  # pragma: no cover
            flask.g.session.rollback()
            flask.flash(str(err), "error")

    types = None
    default = None
    ticketrepopath = repo.repopath("tickets")
    if os.path.exists(ticketrepopath):
        ticketrepo = pygit2.Repository(ticketrepopath)
        if not ticketrepo.is_empty and not ticketrepo.head_is_unborn:
            commit = ticketrepo[ticketrepo.head.target]
            # Get the different ticket types
            files = __get_file_in_tree(
                ticketrepo, commit.tree, ["templates"], bail_on_tree=True
            )
            if files:
                types = [f.name.rsplit(".md", 1)[0] for f in files]

            default_file = None
            if types and template in types:
                # Get the template
                default_file = __get_file_in_tree(
                    ticketrepo,
                    commit.tree,
                    ["templates", "%s.md" % template],
                    bail_on_tree=True,
                )
            if default_file:
                default, _ = pagure.doc_utils.convert_readme(
                    default_file.data, "md"
                )

    tag_list = pagure.lib.query.get_tags_of_project(flask.g.session, repo)
    if flask.request.method == "GET":
        form.private.data = repo.settings.get(
            "issues_default_to_private", False
        )
        form.title.data = flask.request.args.get("title")
        form.issue_content.data = flask.request.args.get("content")
        default_priority = None
        if repo.default_priority:
            for key, val in repo.priorities.items():
                if repo.default_priority == val:
                    default_priority = key
        form.priority.data = flask.request.form.get(
            "priority", "%s" % default_priority
        )

    return flask.render_template(
        "new_issue.html",
        select="issues",
        form=form,
        repo=repo,
        username=username,
        types=types,
        default=default,
        tag_list=tag_list,
        open_access=open_access,
    )


@UI_NS.route("/<repo>/issue/<int:issueid>/")
@UI_NS.route("/<repo>/issue/<int:issueid>")
@UI_NS.route("/<namespace>/<repo>/issue/<int:issueid>/")
@UI_NS.route("/<namespace>/<repo>/issue/<int:issueid>")
@UI_NS.route("/fork/<username>/<repo>/issue/<int:issueid>/")
@UI_NS.route("/fork/<username>/<repo>/issue/<int:issueid>")
@UI_NS.route("/fork/<username>/<namespace>/<repo>/issue/<int:issueid>/")
@UI_NS.route("/fork/<username>/<namespace>/<repo>/issue/<int:issueid>")
@has_issue_tracker
def view_issue(repo, issueid, username=None, namespace=None):
    """ List all issues associated to a repo
    """

    repo = flask.g.repo

    issue = pagure.lib.query.search_issues(
        flask.g.session, repo, issueid=issueid
    )

    if issue is None or issue.project != repo:
        flask.abort(404, description="Issue not found")

    if issue.private:
        assignee = issue.assignee.user if issue.assignee else None
        if not authenticated() or (
            not flask.g.repo_committer
            and issue.user.user != flask.g.fas_user.username
            and assignee != flask.g.fas_user.username
        ):
            flask.abort(404, description="Issue not found")

    status = pagure.lib.query.get_issue_statuses(flask.g.session)
    milestones = []
    for m in repo.milestones_keys or repo.milestones:
        if m in repo.milestones and repo.milestones[m]["active"]:
            milestones.append(m)

    form = pagure.forms.UpdateIssueForm(
        status=status,
        priorities=repo.priorities,
        milestones=milestones or None,
        close_status=repo.close_status,
    )
    form.status.data = issue.status
    form.priority.data = "%s" % issue.priority
    # issue.priority is an int that we need to convert to string as the form
    # relies on string
    form.milestone.data = issue.milestone
    form.private.data = issue.private
    form.close_status.data = ""
    if issue.close_status:
        form.close_status.data = issue.close_status
    tag_list = pagure.lib.query.get_tags_of_project(flask.g.session, repo)

    knowns_keys = {}
    for key in issue.other_fields:
        knowns_keys[key.key.name] = key

    open_access = repo.settings.get("open_metadata_access_to_all", False)

    return flask.render_template(
        "issue.html",
        select="issues",
        repo=repo,
        username=username,
        tag_list=tag_list,
        issue=issue,
        issueid=issueid,
        form=form,
        knowns_keys=knowns_keys,
        open_access=open_access,
        subscribers=pagure.lib.query.get_watch_list(flask.g.session, issue),
        attachments=issue.attachments,
    )


@UI_NS.route("/<repo>/issue/<int:issueid>/drop", methods=["POST"])
@UI_NS.route("/<namespace>/<repo>/issue/<int:issueid>/drop", methods=["POST"])
@UI_NS.route(
    "/fork/<username>/<repo>/issue/<int:issueid>/drop", methods=["POST"]
)
@UI_NS.route(
    "/fork/<username>/<namespace>/<repo>/issue/<int:issueid>/drop",
    methods=["POST"],
)
@has_issue_tracker
def delete_issue(repo, issueid, username=None, namespace=None):
    """ Delete the specified issue
    """

    repo = flask.g.repo

    issue = pagure.lib.query.search_issues(
        flask.g.session, repo, issueid=issueid
    )

    if issue is None or issue.project != repo:
        flask.abort(404, description="Issue not found")

    if not flask.g.repo_committer:
        flask.abort(
            403,
            description="You are not allowed to remove tickets of "
            "this project",
        )

    form = pagure.forms.ConfirmationForm()
    if form.validate_on_submit():
        try:
            pagure.lib.query.drop_issue(
                flask.g.session, issue, user=flask.g.fas_user.username
            )
            flask.g.session.commit()
            flask.flash("Issue deleted")
            return flask.redirect(
                flask.url_for(
                    "ui_ns.view_issues",
                    username=username,
                    repo=repo.name,
                    namespace=namespace,
                )
            )
        except SQLAlchemyError as err:  # pragma: no cover
            flask.g.session.rollback()
            _log.exception(err)
            flask.flash("Could not delete the issue", "error")

    return flask.redirect(
        flask.url_for(
            "ui_ns.view_issue",
            username=username,
            repo=repo.name,
            namespace=repo.namespace,
            issueid=issueid,
        )
    )


@UI_NS.route("/<repo>/issue/<int:issueid>/edit/", methods=("GET", "POST"))
@UI_NS.route("/<repo>/issue/<int:issueid>/edit", methods=("GET", "POST"))
@UI_NS.route(
    "/<namespace>/<repo>/issue/<int:issueid>/edit/", methods=("GET", "POST")
)
@UI_NS.route(
    "/<namespace>/<repo>/issue/<int:issueid>/edit", methods=("GET", "POST")
)
@UI_NS.route(
    "/fork/<username>/<repo>/issue/<int:issueid>/edit/",
    methods=("GET", "POST"),
)
@UI_NS.route(
    "/fork/<username>/<repo>/issue/<int:issueid>/edit", methods=("GET", "POST")
)
@UI_NS.route(
    "/fork/<username>/<namespace>/<repo>/issue/<int:issueid>/edit/",
    methods=("GET", "POST"),
)
@UI_NS.route(
    "/fork/<username>/<namespace>/<repo>/issue/<int:issueid>/edit",
    methods=("GET", "POST"),
)
@login_required
@has_issue_tracker
def edit_issue(repo, issueid, username=None, namespace=None):
    """ Edit the specified issue
    """
    repo = flask.g.repo

    issue = pagure.lib.query.search_issues(
        flask.g.session, repo, issueid=issueid
    )

    if issue is None or issue.project != repo:
        flask.abort(404, description="Issue not found")

    if not (
        flask.g.repo_committer
        or flask.g.fas_user.username == issue.user.username
    ):
        flask.abort(
            403,
            description="You are not allowed to edit issues for this project",
        )

    status = pagure.lib.query.get_issue_statuses(flask.g.session)
    form = pagure.forms.IssueForm(status=status)
    if form.validate_on_submit():
        title = form.title.data
        content = form.issue_content.data
        status = form.status.data
        private = form.private.data

        try:
            user_obj = pagure.lib.query.get_user(
                flask.g.session, flask.g.fas_user.username
            )
        except pagure.exceptions.PagureException:
            flask.abort(
                404,
                description="No such user found in the database: %s"
                % (flask.g.fas_user.username),
            )

        try:
            messages = pagure.lib.query.edit_issue(
                flask.g.session,
                issue=issue,
                title=title,
                content=content,
                status=status,
                user=flask.g.fas_user.username,
                private=private,
            )
            flask.g.session.commit()
            if messages:
                pagure.lib.query.add_metadata_update_notif(
                    session=flask.g.session,
                    obj=issue,
                    messages=messages,
                    user=flask.g.fas_user.username,
                )

            # If there is a file attached, attach it.
            filestream = flask.request.files.get("filestream")
            if filestream and "<!!image>" in issue.content:
                new_filename = pagure.lib.query.add_attachment(
                    repo=repo,
                    issue=issue,
                    attachmentfolder=pagure_config["ATTACHMENTS_FOLDER"],
                    user=user_obj,
                    filename=filestream.filename,
                    filestream=filestream.stream,
                )
                # Replace the <!!image> tag in the comment with the link
                # to the actual image
                filelocation = flask.url_for(
                    "view_issue_raw_file",
                    repo=repo.name,
                    namespace=repo.namespace,
                    username=username,
                    filename=new_filename,
                )
                new_filename = new_filename.split("-", 1)[1]
                url = "[![%s](%s)](%s)" % (
                    new_filename,
                    filelocation,
                    filelocation,
                )
                issue.content = issue.content.replace("<!!image>", url)
                flask.g.session.add(issue)
                flask.g.session.commit()
            if messages:
                for message in messages:
                    flask.flash(message)
            url = flask.url_for(
                "ui_ns.view_issue",
                username=username,
                namespace=namespace,
                repo=repo.name,
                issueid=issueid,
            )
            return flask.redirect(url)
        except pagure.exceptions.PagureException as err:
            flask.g.session.rollback()
            flask.flash(str(err), "error")
        except SQLAlchemyError as err:  # pragma: no cover
            flask.g.session.rollback()
            flask.flash(str(err), "error")

    elif flask.request.method == "GET":
        form.title.data = issue.title
        form.issue_content.data = issue.content
        form.status.data = issue.status
        form.private.data = issue.private

    return flask.render_template(
        "new_issue.html",
        select="issues",
        type="edit",
        form=form,
        repo=repo,
        username=username,
        issue=issue,
        issueid=issueid,
    )


@UI_NS.route("/<repo>/issue/<int:issueid>/upload", methods=["POST"])
@UI_NS.route(
    "/<namespace>/<repo>/issue/<int:issueid>/upload", methods=["POST"]
)
@UI_NS.route(
    "/fork/<username>/<repo>/issue/<int:issueid>/upload", methods=["POST"]
)
@UI_NS.route(
    "/fork/<username>/<namespace>/<repo>/issue/<int:issueid>/upload",
    methods=["POST"],
)
@login_required
@has_issue_tracker
def upload_issue(repo, issueid, username=None, namespace=None):
    """ Upload a file to a ticket.
    """
    repo = flask.g.repo

    issue = pagure.lib.query.search_issues(
        flask.g.session, repo, issueid=issueid
    )

    if issue is None or issue.project != repo:
        flask.abort(404, description="Issue not found")

    try:
        user_obj = pagure.lib.query.get_user(
            flask.g.session, flask.g.fas_user.username
        )
    except pagure.exceptions.PagureException:
        flask.abort(
            404,
            description="No such user found in the database: %s"
            % (flask.g.fas_user.username),
        )

    form = pagure.forms.UploadFileForm()

    if form.validate_on_submit():
        filenames = []
        for filestream in flask.request.files.getlist("filestream"):
            new_filename = pagure.lib.query.add_attachment(
                repo=repo,
                issue=issue,
                attachmentfolder=pagure_config["ATTACHMENTS_FOLDER"],
                user=user_obj,
                filename=filestream.filename,
                filestream=filestream.stream,
            )
            filenames.append(new_filename)

        return flask.jsonify(
            {
                "output": "ok",
                "filenames": [
                    filename.split("-", 1)[1] for filename in filenames
                ],
                "filelocations": [
                    flask.url_for(
                        "ui_ns.view_issue_raw_file",
                        repo=repo.name,
                        username=username,
                        namespace=repo.namespace,
                        filename="files/%s" % nfilename,
                    )
                    for nfilename in filenames
                ],
            }
        )
    else:
        return flask.jsonify({"output": "notok"})


@UI_NS.route("/<repo>/issue/raw/<path:filename>")
@UI_NS.route("/<namespace>/<repo>/issue/raw/<path:filename>")
@UI_NS.route("/fork/<username>/<repo>/issue/raw/<path:filename>")
@UI_NS.route("/fork/<username>/<namespace>/<repo>/issue/raw/<path:filename>")
@has_issue_tracker
def view_issue_raw_file(repo, filename=None, username=None, namespace=None):
    """ Displays the raw content of a file of a commit for the specified
    ticket repo.
    """
    raw = is_true(flask.request.args.get("raw"))

    repo = flask.g.repo

    attachdir = os.path.join(
        pagure_config["ATTACHMENTS_FOLDER"], repo.fullname
    )
    attachpath = os.path.join(attachdir, filename)
    if not os.path.exists(attachpath):
        if not os.path.exists(attachdir):
            os.makedirs(attachdir)

        # Try to copy from git repo to attachments folder
        reponame = repo.repopath("tickets")
        repo_obj = pygit2.Repository(reponame)

        if repo_obj.is_empty:
            flask.abort(404, description="Empty repo cannot have a file")

        branch = repo_obj.lookup_branch("master")
        commit = branch.peel()

        content = __get_file_in_tree(
            repo_obj, commit.tree, ["files", filename], bail_on_tree=True
        )
        if not content or isinstance(content, pygit2.Tree):
            flask.abort(404, description="File not found")

        data = repo_obj[content.oid].data

        if not data:
            flask.abort(404, description="No content found")

        _log.info(
            "Migrating file %s for project %s to attachments",
            filename,
            repo.fullname,
        )

        with open(attachpath, "wb") as stream:
            stream.write(data)
        data = None

    # At this moment, attachpath exists and points to the file
    with open(attachpath, "rb") as f:
        data = f.read()

    if (
        not raw
        and (filename.endswith(".patch") or filename.endswith(".diff"))
        and not is_binary_string(data)
    ):
        # We have a patch file attached to this issue, render the diff in html
        orig_filename = filename.partition("-")[2]
        return flask.render_template(
            "patchfile.html",
            select="issues",
            repo=repo,
            username=username,
            diff=data.decode("utf-8"),
            patchfile=orig_filename,
        )

    return (data, 200, pagure.lib.mimetype.get_type_headers(filename, data))


@UI_NS.route(
    "/<repo>/issue/<int:issueid>/comment/<int:commentid>/edit",
    methods=("GET", "POST"),
)
@UI_NS.route(
    "/<namespace>/<repo>/issue/<int:issueid>/comment/<int:commentid>/" "edit",
    methods=("GET", "POST"),
)
@UI_NS.route(
    "/fork/<username>/<repo>/issue/<int:issueid>/comment"
    "/<int:commentid>/edit",
    methods=("GET", "POST"),
)
@UI_NS.route(
    "/fork/<username>/<namespace>/<repo>/issue/<int:issueid>/comment"
    "/<int:commentid>/edit",
    methods=("GET", "POST"),
)
@login_required
@has_issue_tracker
def edit_comment_issue(
    repo, issueid, commentid, username=None, namespace=None
):
    """Edit comment of an issue
    """
    is_js = flask.request.args.get("js", False)

    project = flask.g.repo

    issue = pagure.lib.query.search_issues(
        flask.g.session, project, issueid=issueid
    )

    if issue is None or issue.project != project:
        flask.abort(404, description="Issue not found")

    comment = pagure.lib.query.get_issue_comment(
        flask.g.session, issue.uid, commentid
    )

    if comment is None or comment.parent.project != project:
        flask.abort(404, description="Comment not found")

    if (
        flask.g.fas_user.username != comment.user.username
        or comment.parent.status != "Open"
    ) and not flask.g.repo_user:
        flask.abort(
            403, description="You are not allowed to edit this comment"
        )

    form = pagure.forms.EditCommentForm()

    if form.validate_on_submit():

        updated_comment = form.update_comment.data
        try:
            message = pagure.lib.query.edit_comment(
                flask.g.session,
                parent=issue,
                comment=comment,
                user=flask.g.fas_user.username,
                updated_comment=updated_comment,
            )
            flask.g.session.commit()
            if not is_js:
                flask.flash(message)
        except SQLAlchemyError as err:  # pragma: no cover
            flask.g.session.rollback()
            _log.error(err)
            if is_js:
                return "error"
            flask.flash("Could not edit the comment: %s" % commentid, "error")

        if is_js:
            return "ok"

        return flask.redirect(
            flask.url_for(
                "ui_ns.view_issue",
                username=username,
                namespace=namespace,
                repo=project.name,
                issueid=issueid,
            )
        )

    if is_js and flask.request.method == "POST":
        return "failed"

    return flask.render_template(
        "comment_update.html",
        select="issues",
        requestid=issueid,
        repo=project,
        username=username,
        form=form,
        comment=comment,
        is_js=is_js,
    )


@UI_NS.route("/<repo>/issues/reports", methods=["POST"])
@UI_NS.route("/<namespace>/<repo>/issues/reports", methods=["POST"])
@UI_NS.route("/fork/<username>/<repo>/issues/reports", methods=["POST"])
@UI_NS.route(
    "/fork/<username>/<namespace>/<repo>/issues/reports", methods=["POST"]
)
@login_required
@is_repo_admin
def save_reports(repo, username=None, namespace=None):
    """ Marked for watching or Unwatching
    """

    return_point = flask.url_for(
        "ui_ns.view_issues", repo=repo, username=username, namespace=namespace
    )
    if pagure.utils.is_safe_url(flask.request.referrer):
        return_point = flask.request.referrer

    form = pagure.forms.AddReportForm()
    if not form.validate_on_submit():
        flask.abort(400)

    name = form.report_name.data

    try:
        msg = pagure.lib.query.save_report(
            flask.g.session,
            flask.g.repo,
            name=name,
            url=flask.request.referrer,
            username=flask.g.fas_user.username,
        )
        flask.g.session.commit()
        flask.flash(msg)
    except pagure.exceptions.PagureException as msg:
        flask.flash(msg, "error")

    return flask.redirect(return_point)


@UI_NS.route("/<repo>/report/<report>")
@UI_NS.route("/<namespace>/<repo>/report/<report>")
@UI_NS.route("/fork/<username>/<repo>/report/<report>")
@UI_NS.route("/fork/<username>/<namespace>/<repo>/report/<report>")
def view_report(repo, report, username=None, namespace=None):
    """ Show the specified report.
    """
    reports = flask.g.repo.reports
    if report not in reports:
        flask.abort(404, description="No such report found")

    flask.request.args = werkzeug.datastructures.ImmutableMultiDict(
        reports[report]
    )

    return view_issues(repo=repo, username=username, namespace=namespace)
