import logging

import traceback

import formencode

import mercurial.unionrepo

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPForbidden, HTTPFound, HTTPNotFound

import kallithea.lib.helpers as h

from kallithea.controllers.changeset import create_cs_pr_comment, delete_cs_pr_comment

from kallithea.lib import auth, diffs, webutils

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.graphmod import graph_data

from kallithea.lib.page import Page

from kallithea.lib.utils2 import ascii_bytes, safe_bytes, safe_int

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.forms import PullRequestForm, PullRequestPostForm

from kallithea.model.pull_request import CreatePullRequestAction, CreatePullRequestIterationAction, PullRequestModel

log = logging.getLogger(__name__)

def _get_reviewer(user_id):

    """Look up user by ID and validate it as a potential reviewer."""

    try:

        user = db.User.get(int(user_id))

    except ValueError:

        user = None

    if user is None or user.is_default_user:

        webutils.flash(_('Invalid reviewer "%s" specified') % user_id, category='error')

        raise HTTPBadRequest()

    return user

class PullrequestsController(BaseRepoController):

    def _get_repo_refs(self, repo, rev=None, branch=None, branch_rev=None):

        the selectors in pullrequest.html

        rev: a revision that must be in the list somehow and selected by default

        branch: a branch that must be in the list and selected by default - even if closed

        branch_rev: a revision of which peers should be preferred and available."""

        # list named branches that has been merged to this named branch - it should probably merge back

        peers = []

        if branch_rev:

            # a revset not restricting to merge() would be better

            # (especially because it would get the branch point)

            # ... but is currently too expensive

            # including branches of children could be nice too

            peerbranches = set()

            for i in repo._repo.revs(

                b"sort(parents(branch(id(%s)) and merge()) - branch(id(%s)), -rev)",

                ascii_bytes(branch_rev), ascii_bytes(branch_rev),

            ):

                for abranch in repo.get_changeset(i).branches:

                    if abranch not in peerbranches:

                        n = 'branch:%s:%s' % (abranch, repo.get_changeset(abranch).raw_id)

                        peers.append((n, abranch))

                        peerbranches.add(abranch)

        selected = None

        tiprev = repo.tags.get('tip')

        tipbranch = None

        branches = []

        for abranch, branchrev in repo.branches.items():

            n = 'branch:%s:%s' % (abranch, branchrev)

            desc = abranch

            if branchrev == tiprev:

                tipbranch = abranch

                desc = '%s (current tip)' % desc

            branches.append((n, desc))

            if rev == branchrev:

                selected = n

            if branch == abranch:

                if not rev:

                    selected = n

                branch = None

        if branch:  # branch not in list - it is probably closed

            branchrev = repo.closed_branches.get(branch)

            if branchrev:

                n = 'branch:%s:%s' % (branch, branchrev)

                branches.append((n, _('%s (closed)') % branch))

                selected = n

                branch = None

            if branch:

                log.debug('branch %r not found in %s', branch, repo)

        bookmarks = []

        for bookmark, bookmarkrev in repo.bookmarks.items():

            n = 'book:%s:%s' % (bookmark, bookmarkrev)

            bookmarks.append((n, bookmark))

            if rev == bookmarkrev:

                selected = n

        tags = []

        for tag, tagrev in repo.tags.items():

            if tag == 'tip':

                continue

            n = 'tag:%s:%s' % (tag, tagrev)

            tags.append((n, tag))

            # note: even if rev == tagrev, don't select the static tag - it must be chosen explicitly

        # prio 1: rev was selected as existing entry above

        # prio 2: create special entry for rev; rev _must_ be used

        specials = []

        if rev and selected is None:

            selected = 'rev:%s:%s' % (rev, rev)

            specials = [(selected, '%s: %s' % (_("Changeset"), rev[:12]))]

        # prio 3: most recent peer branch

        if peers and not selected:

            selected = peers[0][0]

        # prio 4: tip revision

        if not selected:

                if tipbranch:

                    selected = 'branch:%s:%s' % (tipbranch, tiprev)

                else:

                    selected = 'tag:null:' + repo.EMPTY_CHANGESET

                    tags.append((selected, 'null'))

            else:  # Git

                if not repo.branches:

                    selected = ''  # doesn't make sense, but better than nothing

                elif 'master' in repo.branches:

                    selected = 'branch:master:%s' % repo.branches['master']

                else:

                    k, v = list(repo.branches.items())[0]

                    selected = 'branch:%s:%s' % (k, v)

        groups = [(specials, _("Special")),

                  (peers, _("Peer branches")),

                  (bookmarks, _("Bookmarks")),

                  (branches, _("Branches")),

                  (tags, _("Tags")),

                  ]

        return [g for g in groups if g[0]], selected

    def _is_allowed_to_change_status(self, pull_request):

        if pull_request.is_closed():

            return False

        owner = request.authuser.user_id == pull_request.owner_id

        reviewer = db.PullRequestReviewer.query() \

            .filter(db.PullRequestReviewer.pull_request == pull_request) \

            .filter(db.PullRequestReviewer.user_id == request.authuser.user_id) \

            .count() != 0

        return request.authuser.admin or owner or reviewer

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def show_all(self, repo_name):

        c.from_ = request.GET.get('from_') or ''

        c.closed = request.GET.get('closed') or ''

        url_params = {}

        if c.from_:

            url_params['from_'] = 1

        if c.closed:

            url_params['closed'] = 1

        p = safe_int(request.GET.get('page'), 1)

        q = db.PullRequest.query(include_closed=c.closed, sorted=True)

        if c.from_:

            q = q.filter_by(org_repo=c.db_repo)

        else:

            q = q.filter_by(other_repo=c.db_repo)

        c.pull_requests = q.all()

        c.pullrequests_pager = Page(c.pull_requests, page=p, items_per_page=100, **url_params)

        message = escape(changeset.message)

        tooltip_html = ("<b>Author:</b> %s<br/>"

                        "<b>Date:</b> %s</b><br/>"

                        "<b>Message:</b> %s") % (author, date, message)

        lnk_format = show_id(changeset)

        uri = link_to(

                lnk_format,

                url('changeset_home', repo_name=repo_name,

                    revision=changeset.raw_id),

                style=get_color_string(changeset.raw_id),

                **{'data-toggle': 'popover',

                   'data-content': tooltip_html}

              )

        uri += '\n'

        return uri

    return literal(markup_whitespace(annotate_highlight(filenode, url_func, **kwargs)))

def capitalize(x):

    return x.capitalize()

def short_id(x):

    return x[:12]

def hide_credentials(x):

    return ''.join(credentials_filter(x))

def show_id(cs):

    """

    Configurable function that shows ID

    by default it's r123:fffeeefffeee

    :param cs: changeset instance

    """

    def_len = safe_int(kallithea.CONFIG.get('show_sha_length', 12))

    show_rev = asbool(kallithea.CONFIG.get('show_revision_number', False))

    raw_id = cs.raw_id[:def_len]

    if show_rev:

        return 'r%s:%s' % (cs.revision, raw_id)

    else:

        return raw_id

@cache_region('long_term', 'user_attr_or_none')

def user_attr_or_none(author, show_attr):

    """Try to match email part of VCS committer string with a local user and return show_attr

    - or return None if user not found"""

    email = author_email(author)

    if email:

        user = db.User.get_by_email(email)

        if user is not None:

            return getattr(user, show_attr)

    return None

def email_or_none(author):

    """Try to match email part of VCS committer string with a local user.

    Return primary email of user, email part of the specified author name, or None."""

    if not author:

        return None

    email = user_attr_or_none(author, 'email')

    if email is not None:

        return email # always use user's main email address - not necessarily the one used to find user

    # extract email from the commit string

    email = author_email(author)

    if email:

        return email

    # No valid email, not a valid user in the system, none!

    return None

def person(author, show_attr="username"):

    """Find the user identified by 'author', return one of the users attributes,

    default to the username attribute, None if there is no user"""

    # if author is already an instance use it for extraction

    if isinstance(author, db.User):

        return getattr(author, show_attr)

    value = user_attr_or_none(author, show_attr)

    if value is not None:

        return value

    # Still nothing?  Just pass back the author name if any, else the email

    return author_name(author) or author_email(author)

def person_by_id(id_, show_attr="username"):

    # maybe it's an ID ?

    if str(id_).isdigit() or isinstance(id_, int):

                  <tr>

                    %if c.visual.use_gravatar:

                    <td>${h.gravatar_div(h.email_or_none(cs.author), size=14)}</td>

                    %endif

                    <td>${h.link_to(cs.short_id,h.url('changeset_home',repo_name=c.cs_repo.repo_name,revision=cs.raw_id))}</td>

                    <td class="author">${h.person(cs.author)}</td>

                    <td><span data-toggle="tooltip" title="${h.age(cs.date)}">${cs.date}</span></td>

                    <td>

                      %if c.statuses:

                        <i class="icon-circle changeset-status-${c.statuses[cnt]}" title="${_('Changeset status: %s') % h.changeset_status_lbl(c.statuses[cnt])}"></i>

                      %endif

                    </td>

                    <td><div class="message">${h.urlify_text(h.wrap_paragraphs(cs.message),c.repo_name)}</div></td>

                  </tr>

                %endfor

                </table>

                <h4>${_('Files affected')}</h4>

                <div class="cs_files">

                    %for cs in c.cs_ranges:

                        <h6>${h.link_to(h.show_id(cs),h.url('changeset_home',repo_name=c.cs_repo.repo_name,revision=cs.raw_id))}</h6>

                        <% a_rev, cs_rev, file_diff_data = c.changes[cs.raw_id] %>

                        %for fid, url_fid, op, a_path, path, diff, stats in file_diff_data:

                            <div class="cs_${op} clearfix">

                                <span class="node">

                                    <i class="icon-diff-${op}"></i>

                                    ${h.link_to(path, '#%s' % fid)}

                                </span>

                                <div class="changes">${h.fancy_file_stats(stats)}</div>

                            </div>

                        %endfor

                    %endfor

                </div>

        </div>

    </div>

    <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>

    <%namespace name="diff_block" file="/changeset/diff_block.html"/>

    ${diff_block.diff_block_js()}

    %for cs in c.cs_ranges:

        <div class="panel-body">

          ## diff block

          <div class="h3">

          ${h.gravatar_div(h.email_or_none(cs.author), size=20)}

          <a data-toggle="tooltip" title="${cs.message}" href="${h.url('changeset_home',repo_name=c.cs_repo.repo_name,revision=cs.raw_id)}">${h.show_id(cs)}</a>

            <div class="right">

              <span>

                %if len(cs.parents)>1:

                <span class="label label-merge">${_('Merge')}</span>

                %endif

                  %for book in cs.bookmarks:

                  <span class="label label-bookmark" title="${_('Bookmark %s') % book}">

                     ${h.link_to(book,h.url('changeset_home',repo_name=c.cs_repo.repo_name,revision=cs.raw_id))}

                  </span>

                  %endfor

                %endif

                %for tag in cs.tags:

                    <span class="label label-tag" title="${_('Tag %s') % tag}">

                    ${h.link_to(tag,h.url('changeset_home',repo_name=c.cs_repo.repo_name,revision=cs.raw_id))}</span>

                %endfor

                %for branch in cs.branches:

                  <span class="label label-branch" title="${_('Branch %s') % branch}">

                    ${h.link_to(branch,h.url('changeset_home',repo_name=c.cs_repo.repo_name,revision=cs.raw_id))}

                  </span>

                %endfor

              </span>

            </div>

          </div>

          <% a_rev, cs_rev, file_diff_data = c.changes[cs.raw_id] %>

          ${diff_block.diff_block(c.repo_name, 'rev', a_rev, a_rev,

                                  c.repo_name, 'rev', cs_rev, cs_rev, file_diff_data)}

        </div>

    %endfor

</div>

</%def>

# ${c.db_repo_scm_instance.alias.upper()} changeset patch

# User ${c.changeset.author |n}

# Date ${c.changeset.date}

# Node ID ${c.changeset.raw_id}

${c.parent_tmpl}

${c.changeset.message |n}

From ${c.changeset.raw_id} ${c.changeset.date}

From: ${c.changeset.author |n}

Date: ${c.changeset.date}

Subject: [PATCH] ${c.changeset.message |n}

---

%endif

${c.diff|n}

              <div>

                  ${h.textarea('pullrequest_desc',content=c.pull_request.description,placeholder=_('Write a short description on this pull request'),class_='form-control')}

              </div>

        </div>

        %endif

        <div class="form-group">

          <label>${_('Voting Result')}:</label>

          <div>

            %if c.current_voting_result:

              <i class="icon-circle changeset-status-${c.current_voting_result}" title="${_('Pull request status calculated from votes')}"></i>

              <span class="changeset-status-lbl" data-toggle="tooltip" title="${_('Pull request status calculated from votes')}">

                %if c.pull_request.is_closed():

                    ${_('Closed')},

                %endif

                ${h.changeset_status_lbl(c.current_voting_result)}

              </span>

            %endif

          </div>

        </div>

        <div class="form-group">

          <label>${_('Origin')}:</label>

          <div>

            <div>

              ${h.link_to_ref(c.pull_request.org_repo.repo_name, c.cs_ref_type, c.cs_ref_name, c.cs_rev)}

              %if c.cs_ref_type != 'branch':

                ${_('on')} ${h.link_to_ref(c.pull_request.org_repo.repo_name, 'branch', c.cs_branch_name)}

              %endif

            </div>

          </div>

        </div>

        <div class="form-group">

          <label>${_('Target')}:</label>

          <div>

            %if c.is_range:

              ${_("This is just a range of changesets and doesn't have a target or a real merge ancestor.")}

            %else:

              ${h.link_to_ref(c.pull_request.other_repo.repo_name, c.a_ref_type, c.a_ref_name)}

              ## we don't know other rev - c.a_rev is ancestor and not necessarily on other_name_branch branch

            %endif

          </div>

        </div>

        <div class="form-group">

          <label>${_('Pull changes')}:</label>

          <div>

            %if c.cs_ranges:

              <div>

               ## TODO: use cs_ranges[-1] or org_ref_parts[1] in both cases?

                 <span>hg pull ${c.pull_request.org_repo.clone_url(clone_uri_tmpl=c.clone_uri_tmpl)} -r ${c.cs_ranges[-1].short_id}</span>

                 <span>git pull ${c.pull_request.org_repo.clone_url(clone_uri_tmpl=c.clone_uri_tmpl)} ${c.pull_request.org_ref_parts[1]}</span>

               %endif

              </div>

            %endif

          </div>

        </div>

        <div class="form-group">

          <label>${_('Created on')}:</label>

          <div>

              <div>${h.fmt_date(c.pull_request.created_on)}</div>

          </div>

        </div>

        <div class="form-group">

          <label>${_('Owner')}:</label>

          <div class="pr-not-edit">

                  ${h.gravatar_div(c.pull_request.owner.email, size=20)}

                  <span>${c.pull_request.owner.full_name_and_username}</span><br/>

                  <span><a href="mailto:${c.pull_request.owner.email}">${c.pull_request.owner.email}</a></span><br/>

          </div>

          <div class="pr-do-edit" style="display:none">

               ${h.text('owner', class_='form-control', value=c.pull_request.owner.username, placeholder=_('Type name of user'))}

          </div>

        </div>

        <div class="form-group">

          <label>${_('Next iteration')}:</label>

            <div>

              <p>${c.update_msg}</p>

              %if c.avail_cs:

              <div id="updaterevs" class="clearfix">

                <div id="updaterevs-graph">

                  <canvas id="avail_graph_canvas"></canvas>

                </div>

                <table class="table" id="updaterevs-table">

                  %for cnt, cs in enumerate(c.avail_cs):

                    <tr id="chg_available_${cnt+1}" class="${'mergerow' if len(cs.parents) > 1 and not (editable and cs.revision in c.avail_revs) else ''}">

                      %if c.cs_ranges and cs.revision == c.cs_ranges[-1].revision:

                        %if editable:

                        <td>

                            ${h.radio(name='updaterev', value='', checked=True)}

                        </td>

                        %endif

                        <td colspan="4"><span>${_("Current revision - no change")}</span></td>

                      %else:

                        %if editable:

                        <td>

                          ${h.radio(name='updaterev', value=cs.raw_id, style=None if cs.revision in c.avail_revs else 'visibility: hidden')}

                        </td>

              <a href="${h.url('atom_feed_home',repo_name=c.db_repo.repo_name,api_key=request.authuser.api_key)}"><i class="icon-rss-squared"></i>${_('Feed')}</a>

            %else:

              <a href="${h.url('atom_feed_home',repo_name=c.db_repo.repo_name)}"><i class="icon-rss-squared"></i>${_('Feed')}</a>

            %endif

            </li>

            %if c.show_stats:

            <li class="list-group-item">

              <a title="${_('Statistics')}" href="${h.url('repo_stats_home',repo_name=c.repo_name)}">

                <i class="icon-graph"></i>${_('Statistics')}

              </a>

            </li>

            %endif

        </ul>

    </div>

</div>

<div class="panel panel-primary">

    <div class="panel-heading">

        <div class="panel-title">

        %if c.cs_pagination:

            ${h.link_to(_('Latest Changes'),h.url('changelog_home',repo_name=c.repo_name))}

        %else:

            ${_('Quick Start')}

        %endif

        </div>

    </div>

    <div class="panel-body">

        <div id="shortlog_data">

            %if c.cs_pagination:

                ${changelog_table.changelog(c.repo_name, c.cs_pagination, c.cs_statuses, c.cs_comments, show_checkbox=False)}

                ${c.cs_pagination.pager()}

            %else:

                %if h.HasRepoPermissionLevel('write')(c.repo_name):

                <h4>${_('Add or upload files directly via Kallithea')}</h4>

                <div>

                  <div id="add_node_id" class="add_node">

                      <a class="btn btn-default btn-xs" href="${h.url('files_add_home',repo_name=c.repo_name,revision=0,f_path='', anchor='edit')}">${_('Add New File')}</a>

                  </div>

                </div>

                %endif

                <h4>${_('Push new repository')}</h4>

                <pre>

${c.db_repo_scm_instance.alias} clone ${c.clone_repo_url}

${c.db_repo_scm_instance.alias} add README # add first file

${c.db_repo_scm_instance.alias} commit -m "Initial" # commit with message

                </pre>

                <h4>${_('Existing repository?')}</h4>

                <pre>

git remote add origin ${c.clone_repo_url}

git push -u origin master

                %else:

hg push ${c.clone_repo_url}

                %endif

                </pre>

            %endif

        </div>

    </div>

</div>

%if c.readme_data:

<div id="readme" class="anchor">

</div>

<div class="panel panel-primary">

    <div class="panel-heading" title="${_('Readme file from revision %s:%s') % (c.db_repo.landing_rev[0], c.db_repo.landing_rev[1])}">

        <div class="panel-title">

            <a href="${h.url('files_home',repo_name=c.repo_name,revision='tip',f_path=c.readme_file)}">${c.readme_file}</a>

        </div>

    </div>

    <div class="readme panel-body">

        ${c.readme_data|n}

    </div>

</div>

%endif

<script>

'use strict';

$(document).ready(function(){

    $('#clone-url input').click(function(){

        if($(this).hasClass('selected')){

            $(this).removeClass('selected');

            return ;

        }else{

            $(this).addClass('selected');

            $(this).select();

        }

    });

    var $clone_url = $('#clone-url');

    var $clone_by_name = $('#clone_by_name');

    var $clone_by_id = $('#clone_by_id');

    var $clone_ssh = $('#clone_ssh');

    $clone_url.on('click', '.btn.use-name', function(){

        $clone_by_name.show();

        $clone_by_id.hide();

        $clone_ssh.hide();

    });