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

"""

    rhodecode.controllers.pullrequests

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    pull requests controller for rhodecode for initializing pull requests

    :created_on: May 7, 2012

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

import traceback

import formencode

from webob.exc import HTTPNotFound, HTTPForbidden

from collections import defaultdict

from itertools import groupby

from pylons import request, response, session, tmpl_context as c, url

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode.lib.compat import json

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator,\

    NotAnonymous

from rhodecode.lib import helpers as h

from rhodecode.lib import diffs

from rhodecode.lib.utils import action_logger, jsonify

from rhodecode.lib.vcs.exceptions import EmptyRepositoryError

from rhodecode.lib.vcs.backends.base import EmptyChangeset

from rhodecode.lib.diffs import LimitedDiffContainer

from rhodecode.model.db import User, PullRequest, ChangesetStatus,\

    ChangesetComment

from rhodecode.model.pull_request import PullRequestModel

from rhodecode.model.meta import Session

from rhodecode.model.repo import RepoModel

from rhodecode.model.comment import ChangesetCommentsModel

from rhodecode.model.changeset_status import ChangesetStatusModel

from rhodecode.model.forms import PullRequestForm

log = logging.getLogger(__name__)

class PullrequestsController(BaseRepoController):

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def __before__(self):

        super(PullrequestsController, self).__before__()

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

    def _get_repo_refs(self, repo):

        hist_l = []

        branches_group = ([('branch:%s:%s' % (k, v), k) for

                         k, v in repo.branches.iteritems()], _("Branches"))

        bookmarks_group = ([('book:%s:%s' % (k, v), k) for

                         k, v in repo.bookmarks.iteritems()], _("Bookmarks"))

        tags_group = ([('tag:%s:%s' % (k, v), k) for

                         k, v in repo.tags.iteritems()

                         if k != 'tip'], _("Tags"))

        tip = repo.tags['tip']

        tipref = 'tag:tip:%s' % tip

        colontip = ':' + tip

        tips = [x[1] for x in branches_group[0] + bookmarks_group[0] + tags_group[0]

                if x[0].endswith(colontip)]

        tags_group[0].append((tipref, 'tip (%s)' % ', '.join(tips)))

        hist_l.append(bookmarks_group)

        hist_l.append(branches_group)

        hist_l.append(tags_group)

        return hist_l, tipref

    def _get_is_allowed_change_status(self, pull_request):

        owner = self.rhodecode_user.user_id == pull_request.user_id

        reviewer = self.rhodecode_user.user_id in [x.user_id for x in

                                                   pull_request.reviewers]

        return (self.rhodecode_user.admin or owner or reviewer)

    def show_all(self, repo_name):

        c.pull_requests = PullRequestModel().get_all(repo_name)

        c.repo_name = repo_name

        return render('/pullrequests/pullrequest_show_all.html')

    @NotAnonymous()

    def index(self):

        org_repo = c.rhodecode_db_repo

        if org_repo.scm_instance.alias != 'hg':

            log.error('Review not available for GIT REPOS')

            raise HTTPNotFound

        try:

            org_repo.scm_instance.get_changeset()

        except EmptyRepositoryError, e:

            h.flash(h.literal(_('There are no changesets yet')),

                    category='warning')

            redirect(url('summary_home', repo_name=org_repo.repo_name))

        other_repos_info = {}

        c.org_repos = []

        c.default_org_repo = org_repo.repo_name

        c.org_refs, c.default_org_ref = self._get_repo_refs(org_repo.scm_instance)

        c.other_repos = []

        # add org repo to other so we can open pull request against itself

        c.other_repos.extend(c.org_repos)

        c.default_other_repo = org_repo.repo_name

        c.default_other_refs, c.default_other_ref = self._get_repo_refs(org_repo.scm_instance)

        other_repos_info[org_repo.repo_name] = {

            'description': org_repo.description,

            'revs': h.select('other_ref', c.default_other_ref, c.default_other_refs, class_='refs')

        }

        # gather forks and add to this list ... even though it is rare to request forks to pull their parent

        for fork in org_repo.forks:

            refs, default_ref = self._get_repo_refs(fork.scm_instance)

            other_repos_info[fork.repo_name] = {

                'description': fork.description,

                'revs': h.select('other_ref', default_ref, refs, class_='refs')

            }

        # add parents of this fork also, but only if it's not empty

        if org_repo.parent and org_repo.parent.scm_instance.revisions:

            c.default_other_repo = org_repo.parent.repo_name

            c.default_other_refs, c.default_other_ref = self._get_repo_refs(org_repo.parent.scm_instance)

            other_repos_info[org_repo.parent.repo_name] = {

                'description': org_repo.parent.description,

                'revs': h.select('other_ref', c.default_other_ref, c.default_other_refs, class_='refs')

            }

        c.other_repos_info = json.dumps(other_repos_info)

        c.review_members = [org_repo.user]

        return render('/pullrequests/pullrequest.html')

    @NotAnonymous()

    def create(self, repo_name):

        repo = RepoModel()._get_repo(repo_name)

        try:

            _form = PullRequestForm(repo.repo_id)().to_python(request.POST)

        except formencode.Invalid, errors:

            log.error(traceback.format_exc())

            if errors.error_dict.get('revisions'):

                msg = 'Revisions: %s' % errors.error_dict['revisions']

            elif errors.error_dict.get('pullrequest_title'):

                msg = _('Pull request requires a title with min. 3 chars')

            else:

                msg = _('error during creation of pull request')

            h.flash(msg, 'error')

            return redirect(url('pullrequest_home', repo_name=repo_name))

        org_repo = _form['org_repo']

        org_ref = _form['org_ref']

        other_repo = _form['other_repo']

        other_ref = _form['other_ref']

        revisions = _form['revisions']

        reviewers = _form['review_members']

        # if we have cherry picked pull request we don't care what is in

        # org_ref/other_ref

        rev_start = request.POST.get('rev_start')

        rev_end = request.POST.get('rev_end')

        if rev_start and rev_end:

            # this is swapped to simulate that rev_end is a revision from

            # parent of the fork

            org_ref = 'rev:%s:%s' % (rev_end, rev_end)

            other_ref = 'rev:%s:%s' % (rev_start, rev_start)

        title = _form['pullrequest_title']

        description = _form['pullrequest_desc']

        try:

            pull_request = PullRequestModel().create(

                self.rhodecode_user.user_id, org_repo, org_ref, other_repo,

                other_ref, revisions, reviewers, title, description

            )

            Session().commit()

            h.flash(_('Successfully opened new pull request'),

                    category='success')

        except Exception:

            h.flash(_('Error occurred during sending pull request'),

                    category='error')

            log.error(traceback.format_exc())

            return redirect(url('pullrequest_home', repo_name=repo_name))

        return redirect(url('pullrequest_show', repo_name=other_repo,

                            pull_request_id=pull_request.pull_request_id))

    @NotAnonymous()

    @jsonify

    def update(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        #only owner or admin can update it

        owner = pull_request.author.user_id == c.rhodecode_user.user_id

        if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:

            reviewers_ids = map(int, filter(lambda v: v not in [None, ''],

                       request.POST.get('reviewers_ids', '').split(',')))

            PullRequestModel().update_reviewers(pull_request_id, reviewers_ids)

            Session().commit()

            return True

        raise HTTPForbidden()

    @NotAnonymous()

    @jsonify

    def delete(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        #only owner can delete it !

        if pull_request.author.user_id == c.rhodecode_user.user_id:

            PullRequestModel().delete(pull_request)

            Session().commit()

            h.flash(_('Successfully deleted pull request'),

                    category='success')

            return redirect(url('admin_settings_my_account', anchor='pullrequests'))

        raise HTTPForbidden()

    def _load_compare_data(self, pull_request, enable_comments=True):

        """

        Load context data needed for generating compare diff

        :param pull_request:

        :type pull_request:

        """

        rev_start = request.GET.get('rev_start')

        rev_end = request.GET.get('rev_end')

        org_repo = pull_request.org_repo

        (org_ref_type,

         org_ref_name,

         org_ref_rev) = pull_request.org_ref.split(':')

        other_repo = org_repo

        (other_ref_type,

         other_ref_name,

         other_ref_rev) = pull_request.other_ref.split(':')

        # despite opening revisions for bookmarks/branches/tags, we always

        # convert this to rev to prevent changes after book or branch change

        org_ref = ('rev', org_ref_rev)

        other_ref = ('rev', other_ref_rev)

        c.org_repo = org_repo

        c.other_repo = other_repo

        c.fulldiff = fulldiff = request.GET.get('fulldiff')

        c.cs_ranges = [org_repo.get_changeset(x) for x in pull_request.revisions]

        other_ref = ('rev', getattr(c.cs_ranges[0].parents[0]

                                  if c.cs_ranges[0].parents

                                  else EmptyChangeset(), 'raw_id'))

        c.statuses = org_repo.statuses([x.raw_id for x in c.cs_ranges])

        # defines that we need hidden inputs with changesets

        c.as_form = request.GET.get('as_form', False)

        c.org_ref = org_ref[1]

        c.other_ref = other_ref[1]

        diff_limit = self.cut_off_limit if not fulldiff else None

        #we swap org/other ref since we run a simple diff on one repo

        _diff = diffs.differ(org_repo, other_ref, other_repo, org_ref)

        diff_processor = diffs.DiffProcessor(_diff or '', format='gitdiff',

                                             diff_limit=diff_limit)

        _parsed = diff_processor.prepare()

        c.limited_diff = False

        if isinstance(_parsed, LimitedDiffContainer):

            c.limited_diff = True

        c.files = []

        c.changes = {}

        c.lines_added = 0

        c.lines_deleted = 0

        for f in _parsed:

            st = f['stats']

            if st[0] != 'b':

                c.lines_added += st[0]

                c.lines_deleted += st[1]

            fid = h.FID('', f['filename'])

            c.files.append([fid, f['operation'], f['filename'], f['stats']])

            diff = diff_processor.as_html(enable_comments=enable_comments,

                                          parsed_lines=[f])

            c.changes[fid] = [f['operation'], f['filename'], diff]

    def show(self, repo_name, pull_request_id):

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

        c.pull_request = PullRequest.get_or_404(pull_request_id)

        c.allowed_to_change_status = self._get_is_allowed_change_status(c.pull_request)

        cc_model = ChangesetCommentsModel()

        cs_model = ChangesetStatusModel()

        _cs_statuses = cs_model.get_statuses(c.pull_request.org_repo,

                                            pull_request=c.pull_request,

                                            with_revisions=True)

        cs_statuses = defaultdict(list)

        for st in _cs_statuses:

            cs_statuses[st.author.username] += [st]

        c.pull_request_reviewers = []

        c.pull_request_pending_reviewers = []

        for o in c.pull_request.reviewers:

            st = cs_statuses.get(o.user.username, None)

            if st:

                sorter = lambda k: k.version

                st = [(x, list(y)[0])

                      for x, y in (groupby(sorted(st, key=sorter), sorter))]

            else:

                c.pull_request_pending_reviewers.append(o.user)

            c.pull_request_reviewers.append([o.user, st])

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${c.repo_name} ${_('New pull request')}

</%def>

<%def name="breadcrumbs_links()">

    ${h.link_to(_(u'Home'),h.url('/'))}

    »

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

    »

    ${_('New pull request')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    ${h.form(url('pullrequest', repo_name=c.repo_name), method='post', id='pull_request_form')}

    <div style="float:left;padding:0px 30px 30px 30px">

        <input type="hidden" name="rev_start" value="${request.GET.get('rev_start')}" />

        <input type="hidden" name="rev_end" value="${request.GET.get('rev_end')}" />

        ##ORG

        <div style="float:left">

                <span style="font-size: 20px">

                ${h.select('org_repo','',c.org_repos,class_='refs')}:${h.select('org_ref',c.default_org_ref,c.org_refs,class_='refs')}

                </span>

                 <div style="padding:5px 3px 3px 42px;">${c.rhodecode_db_repo.description}</div>

            </div>

            <div style="clear:both;padding-top: 10px"></div>

        </div>

          <div style="float:left;font-size:24px;padding:0px 20px">

          <img height=32 width=32 src="${h.url('/images/arrow_right_64.png')}"/>

          </div>

        ##OTHER, most Probably the PARENT OF THIS FORK

        <div style="float:left">

                <span style="font-size: 20px">

                ${h.select('other_repo',c.default_other_repo,c.other_repos,class_='refs')}:${h.select('other_ref',c.default_other_ref,c.default_other_refs,class_='refs')}

                </span>

                 <div id="other_repo_desc" style="padding:5px 3px 3px 42px;"></div>

            </div>

            <div style="clear:both;padding-top: 10px"></div>

        </div>

       <div style="clear:both;padding-top: 10px"></div>

       ## overview pulled by ajax

       <div style="float:left" id="pull_request_overview"></div>

       <div style="float:left;clear:both;padding:10px 10px 10px 0px;display:none">

            <a id="pull_request_overview_url" href="#">${_('Detailed compare view')}</a>

       </div>

     </div>

    <div style="float:left; border-left:1px dashed #eee">

        <h4>${_('Pull request reviewers')}</h4>

        <div id="reviewers" style="padding:0px 0px 0px 15px">

          ## members goes here !

          <div class="group_members_wrap">

            <ul id="review_members" class="group_members">

            %for member in c.review_members:

              <li id="reviewer_${member.user_id}">

                <div class="reviewers_member">

                  <div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(member.email,14)}"/> </div>

                  <div style="float:left">${member.full_name} (${_('owner')})</div>

                  <input type="hidden" value="${member.user_id}" name="review_members" />

                  <span class="delete_icon action_button" onclick="removeReviewer(${member.user_id})"></span>

                </div>

              </li>

            %endfor

            </ul>

          </div>

          <div class='ac'>

            <div class="reviewer_ac">

               ${h.text('user', class_='yui-ac-input')}

               <span class="help-block">${_('Add reviewer to this pull request.')}</span>

               <div id="reviewers_container"></div>

            </div>

          </div>

        </div>

    </div>

    <h3>${_('Create new pull request')}</h3>

    <div class="form">

        <!-- fields -->

        <div class="fields">

             <div class="field">

                <div class="label">

                    <label for="pullrequest_title">${_('Title')}:</label>

                </div>

                <div class="input">

                    ${h.text('pullrequest_title',size=30)}

                </div>

             </div>

            <div class="field">

                <div class="label label-textarea">

                    <label for="pullrequest_desc">${_('description')}:</label>

                </div>

                <div class="textarea text-area editor">

                    ${h.textarea('pullrequest_desc',size=30)}

                </div>

            </div>

            <div class="buttons">

                ${h.submit('save',_('Send pull request'),class_="ui-btn large")}

                ${h.reset('reset',_('Reset'),class_="ui-btn large")}

           </div>

        </div>

    </div>

    ${h.end_form()}

</div>

<script type="text/javascript">

  var _USERS_AC_DATA = ${c.users_array|n};

  var _GROUPS_AC_DATA = ${c.users_groups_array|n};

  PullRequestAutoComplete('user', 'reviewers_container', _USERS_AC_DATA, _GROUPS_AC_DATA);

  var other_repos_info = ${c.other_repos_info|n};

  var loadPreview = function(){

      YUD.setStyle(YUD.get('pull_request_overview_url').parentElement,'display','none');

      //url template

      var url = "${h.url('compare_url',

                         repo_name='__other_repo__',

                         org_ref_type='__other_ref_type__',

                         org_ref='__other_ref__',

                         other_repo='__org_repo__',

                         other_ref_type='__org_ref_type__',

                         other_ref='__org_ref__',

                         as_form=True,

                         rev_start=request.GET.get('rev_start',''),

                         rev_end=request.GET.get('rev_end',''))}";

      var org_repo = YUQ('#pull_request_form #org_repo')[0].value;

      var org_ref = YUQ('#pull_request_form #org_ref')[0].value.split(':');

      var other_repo = YUQ('#pull_request_form #other_repo')[0].value;

      var other_ref = YUQ('#pull_request_form #other_ref')[0].value.split(':');

      var select_refs = YUQ('#pull_request_form select.refs')

      var rev_data = {

    	  'org_repo': org_repo,

    	  'org_ref': org_ref[1],

    	  'org_ref_type': org_ref[0],

    	  'other_repo': other_repo,

          'other_ref': other_ref[1],

          'other_ref_type': other_ref[0],    	  

      }; // gather the org/other ref and repo here

      for (k in rev_data){

    	  url = url.replace('__'+k+'__',rev_data[k]);

      }

      ypjax(url,'pull_request_overview', function(data){

          var sel_box = YUQ('#pull_request_form #other_repo')[0];

          var repo_name = sel_box.options[sel_box.selectedIndex].value;

          YUD.get('pull_request_overview_url').href = url;

          YUD.setStyle(YUD.get('pull_request_overview_url').parentElement,'display','');

          YUD.get('other_repo_gravatar').src = other_repos_info[repo_name]['gravatar'];

          YUD.get('other_repo_desc').innerHTML = other_repos_info[repo_name]['description'];

          YUD.get('other_ref').innerHTML = other_repos_info[repo_name]['revs'];

          // select back the revision that was just compared

          setSelectValue(YUD.get('other_ref'), rev_data['other_ref']);

      })

  }

  ## refresh automatically when something changes (org_repo can't change)

  YUE.on('org_ref', 'change', function(e){

     loadPreview();

  });

  YUE.on('other_repo', 'change', function(e){

      var repo_name = e.currentTarget.value;

      // replace the <select> of changed repo

      YUD.get('other_ref').innerHTML = other_repos_info[repo_name]['revs'];

      loadPreview();

  });

  YUE.on('other_ref', 'change', function(e){

     loadPreview();

  });

  //lazy load overview after 0.5s

  setTimeout(loadPreview, 500)

</script>

</%def>