# 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

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

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

from webob.exc import HTTPNotFound, HTTPBadRequest

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.helpers import RepoPage

from rhodecode.lib.compat import json

from rhodecode.lib.graphmod import _colored, _dagwalker

from rhodecode.lib.vcs.exceptions import RepositoryError, ChangesetDoesNotExistError,\

    ChangesetError, NodeDoesNotExistError, EmptyRepositoryError

log = logging.getLogger(__name__)

def _load_changelog_summary():

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

    size = safe_int(request.GET.get('size'), 10)

    def url_generator(**kw):

        return url('changelog_summary_home',

                   repo_name=c.rhodecode_db_repo.repo_name, size=size, **kw)

    collection = c.rhodecode_repo

    c.repo_changesets = RepoPage(collection, page=p,

                                 items_per_page=size,

                                 url=url_generator)

    page_revisions = [x.raw_id for x in list(c.repo_changesets)]

    c.comments = c.rhodecode_db_repo.get_comments(page_revisions)

    c.statuses = c.rhodecode_db_repo.statuses(page_revisions)

class ChangelogController(BaseRepoController):

        c.affected_files_cut_off = 60

    def __get_cs_or_redirect(self, rev, repo, redirect_after=True,

                             partial=False):

        """

        Safe way to get changeset if error occur it redirects to changeset with

        proper message. If partial is set then don't do redirect raise Exception

        instead

        :param rev: revision to fetch

        :param repo: repo instance

        """

        try:

            return c.rhodecode_repo.get_changeset(rev)

        except EmptyRepositoryError, e:

            if not redirect_after:

                return None

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

                    category='warning')

            redirect(url('changelog_home', repo_name=repo.repo_name))

        except RepositoryError, e:

            log.error(traceback.format_exc())

            if not partial:

                redirect(h.url('changelog_home', repo_name=repo.repo_name))

            raise HTTPBadRequest()

    def _graph(self, repo, revs_int, repo_size, size, p):

        """

        Generates a DAG graph for repo

        :param repo:

        :param revs_int:

        :param repo_size:

        :param size:

        :param p:

        """

        if not revs_int:

            c.jsdata = json.dumps([])

            return

        data = []

        revs = revs_int

        dag = _dagwalker(repo, revs, repo.alias)

        dag = _colored(dag)

        for (_id, _type, ctx, vtx, edges) in dag:

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

        branch_name = request.GET.get('branch', None)

        if (branch_name and

            branch_name not in c.rhodecode_repo.branches and

            branch_name not in c.rhodecode_repo.closed_branches and

            not revision):

            return redirect(url('changelog_file_home', repo_name=c.repo_name,

                                    revision=branch_name, f_path=f_path or ''))

        c.changelog_for_path = f_path

        try:

            if f_path:

                log.debug('generating changelog for path %s' % f_path)

                # get the history for the file !

                tip_cs = c.rhodecode_repo.get_changeset()

                try:

                    collection = tip_cs.get_file_history(f_path)

                except (NodeDoesNotExistError, ChangesetError):

                    #this node is not present at tip !

                    try:

                        cs = self.__get_cs_or_redirect(revision, repo_name)

                        collection = cs.get_file_history(f_path)

                    except RepositoryError, e:

                        redirect(h.url('changelog_home', repo_name=repo_name))

                collection = list(reversed(collection))

            else:

                collection = c.rhodecode_repo.get_changesets(start=0,

                                                        branch_name=branch_name)

            c.total_cs = len(collection)

            c.pagination = RepoPage(collection, page=p, item_count=c.total_cs,

                                    items_per_page=c.size, branch=branch_name,)

            collection = list(c.pagination)

            page_revisions = [x.raw_id for x in c.pagination]

            c.comments = c.rhodecode_db_repo.get_comments(page_revisions)

            c.statuses = c.rhodecode_db_repo.statuses(page_revisions)

        except (EmptyRepositoryError), e:

            return redirect(url('summary_home', repo_name=c.repo_name))

        except (RepositoryError, ChangesetDoesNotExistError, Exception), e:

            log.error(traceback.format_exc())

            return redirect(url('changelog_home', repo_name=c.repo_name))

        c.branch_name = branch_name

        c.branch_filters = [('', _('All Branches'))] + \

            [(k, k) for k in c.rhodecode_repo.branches.keys()]

        if c.rhodecode_repo.closed_branches:

            prefix = _('(closed)') + ' '

            c.branch_filters += [('-', '-')] + \

                [(k, prefix + k) for k in c.rhodecode_repo.closed_branches.keys()]

        _revs = []

        if not f_path:

            _revs = [x.revision for x in c.pagination]

        self._graph(c.rhodecode_repo, _revs, c.total_cs, c.size, p)

        return render('changelog/changelog.html')

    @LoginRequired()

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

                                   'repository.admin')

    def changelog_details(self, cs):

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            c.cs = c.rhodecode_repo.get_changeset(cs)

            return render('changelog/changelog_details.html')

        raise HTTPNotFound()

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

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from rhodecode.lib.utils import jsonify

from rhodecode.lib.vcs.exceptions import RepositoryError, \

    ChangesetDoesNotExistError

import rhodecode.lib.helpers as h

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

    NotAnonymous

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import action_logger

from rhodecode.lib.compat import OrderedDict

from rhodecode.lib import diffs

from rhodecode.model.db import ChangesetComment, ChangesetStatus

from rhodecode.model.comment import ChangesetCommentsModel

from rhodecode.model.changeset_status import ChangesetStatusModel

from rhodecode.model.meta import Session

from rhodecode.model.repo import RepoModel

from rhodecode.lib.diffs import LimitedDiffContainer

from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError

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

log = logging.getLogger(__name__)

def _update_with_GET(params, GET):

    for k in ['diff1', 'diff2', 'diff']:

        params[k] += GET.getall(k)

def anchor_url(revision, path, GET):

    fid = h.FID(revision, path)

    return h.url.current(anchor=fid, **dict(GET))

def get_ignore_ws(fid, GET):

    ig_ws_global = GET.get('ignorews')

    ig_ws = filter(lambda k: k.startswith('WS'), GET.getall(fid))

    if ig_ws:

        try:

            return int(ig_ws[0].split(':')[-1])

        except Exception:

            pass

    return ig_ws_global

    def _index(self, revision, method):

        c.anchor_url = anchor_url

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

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

        #get ranges of revisions if preset

        rev_range = revision.split('...')[:2]

        enable_comments = True

        try:

            if len(rev_range) == 2:

                enable_comments = False

                rev_start = rev_range[0]

                rev_end = rev_range[1]

                rev_ranges = c.rhodecode_repo.get_changesets(start=rev_start,

                                                             end=rev_end)

            else:

                rev_ranges = [c.rhodecode_repo.get_changeset(revision)]

            c.cs_ranges = list(rev_ranges)

            if not c.cs_ranges:

                raise RepositoryError('Changeset range returned empty result')

        except (RepositoryError, ChangesetDoesNotExistError, Exception), e:

            log.error(traceback.format_exc())

            raise HTTPNotFound()

        c.changes = OrderedDict()

        c.lines_added = 0  # count of lines added

        c.lines_deleted = 0  # count of lines removes

        c.changeset_statuses = ChangesetStatus.STATUSES

        c.comments = []

        c.statuses = []

        c.inline_comments = []

        c.inline_cnt = 0

        # Iterate over ranges (default changeset view is always one changeset)

        for changeset in c.cs_ranges:

            inlines = []

            if method == 'show':

                c.statuses.extend([ChangesetStatusModel().get_status(

                            c.rhodecode_db_repo.repo_id, changeset.raw_id)])

                c.comments.extend(ChangesetCommentsModel()\

                                  .get_comments(c.rhodecode_db_repo.repo_id,

                                                revision=changeset.raw_id))

    repos, branches, bookmarks or tips

    :created_on: May 6, 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 re

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.vcs.exceptions import EmptyRepositoryError, RepositoryError

from rhodecode.lib.vcs.utils import safe_str

from rhodecode.lib.vcs.utils.hgcompat import scmutil, unionrepo

from rhodecode.lib import helpers as h

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib import diffs

from rhodecode.model.db import Repository

from rhodecode.lib.diffs import LimitedDiffContainer

log = logging.getLogger(__name__)

class CompareController(BaseRepoController):

    def __before__(self):

        super(CompareController, self).__before__()

    def __get_rev_or_redirect(self, ref, repo, redirect_after=True,

                             partial=False):

        """

        Safe way to get changeset if error occur it redirects to changeset with

        proper message. If partial is set then don't do redirect raise Exception

        instead

        :param rev: revision to fetch

        :param repo: repo instance

        """

        rev = ref[1] # default and used for git

        if repo.scm_instance.alias == 'hg':

            # lookup up the exact node id

            _revset_predicates = {

                    'branch': 'branch',

                    'book': 'bookmark',

                    'tag': 'tag',

                    'rev': 'id',

                }

            rev_spec = "max(%s(%%s))" % _revset_predicates[ref[0]]

            revs = repo.scm_instance._repo.revs(rev_spec, safe_str(ref[1]))

            if revs:

                rev = revs[-1]

            # else: TODO: just report 'not found'

        try:

            return repo.scm_instance.get_changeset(rev).raw_id

        except EmptyRepositoryError, e:

            if not redirect_after:

                return None

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

                    category='warning')

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

        except RepositoryError, e:

            log.error(traceback.format_exc())

            if not partial:

                redirect(h.url('summary_home', repo_name=repo.repo_name))

            raise HTTPBadRequest()

    def _get_changesets(self, alias, org_repo, org_rev, other_repo, other_rev, merge):

        """

        Returns a list of changesets that can be merged from org_repo@org_rev

        to other_repo@other_rev ... and the ancestor that would be used for merge

        """

        ancestor = None

        if org_rev == other_rev:

            changesets = []

            if merge:

                ancestor = org_rev

        elif alias == 'hg':

            #case two independent repos

            if org_repo != other_repo:

                hgrepo = unionrepo.unionrepository(other_repo.baseui,

                                                   other_repo.path,

                                                   org_repo.path)

                # all the changesets we are looking for will be in other_repo,

    def __get_cs_or_redirect(self, rev, repo_name, redirect_after=True):

        """

        Safe way to get changeset if error occur it redirects to tip with

        proper message

        :param rev: revision to fetch

        :param repo_name: repo name to redirect after

        """

        try:

            return c.rhodecode_repo.get_changeset(rev)

        except EmptyRepositoryError, e:

            if not redirect_after:

                return None

            url_ = url('files_add_home',

                       repo_name=c.repo_name,

                       revision=0, f_path='')

            add_new = h.link_to(_('Click here to add new file'), url_)

            h.flash(h.literal(_('There are no files yet %s') % add_new),

                    category='warning')

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

        except RepositoryError, e:  # including ChangesetDoesNotExistError

            raise HTTPNotFound()

    def __get_filenode_or_redirect(self, repo_name, cs, path):

        """

        Returns file_node, if error occurs or given path is directory,

        it'll redirect to top level path

        :param repo_name: repo_name

        :param cs: given changeset

        :param path: path to lookup

        """

        try:

            file_node = cs.get_node(path)

            if file_node.is_dir():

                raise RepositoryError('given path is a directory')

        except RepositoryError, e:

            raise HTTPNotFound()

        return file_node

    @LoginRequired()

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

                                   'repository.admin')

    def index(self, repo_name, revision, f_path, annotate=False):

        # redirect to given revision from form if given

        post_revision = request.POST.get('at_rev', None)

        if post_revision:

            cs = self.__get_cs_or_redirect(post_revision, repo_name)

        c.changeset = self.__get_cs_or_redirect(revision, repo_name)

        c.branch = request.GET.get('branch', None)

        c.f_path = f_path

        c.annotate = annotate

        c.changeset = self.__get_cs_or_redirect(revision, repo_name)

        cur_rev = c.changeset.revision

        # prev link

        try:

            prev_rev = c.rhodecode_repo.get_changeset(cur_rev).prev(c.branch)

            c.url_prev = url('files_home', repo_name=c.repo_name,

        # files or dirs

        try:

            c.file = c.changeset.get_node(f_path)

            if c.file.is_file():

                c.load_full_history = False

                file_last_cs = c.file.last_changeset

                c.file_changeset = (c.changeset

                                    if c.changeset.revision < file_last_cs.revision

                                    else file_last_cs)

                #determine if we're on branch head

                _branches = c.rhodecode_repo.branches

                c.on_branch_head = revision in _branches.keys() + _branches.values()

                _hist = []

                c.file_history = []

                if c.load_full_history:

                    c.file_history, _hist = self._get_node_history(c.changeset, f_path)

                c.authors = []

                for a in set([x.author for x in _hist]):

                    c.authors.append((h.email(a), h.person(a)))

            else:

                c.authors = c.file_history = []

        except RepositoryError, e:

            raise HTTPNotFound()

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return render('files/files_ypjax.html')

        return render('files/files.html')

    @LoginRequired()

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

                                   'repository.admin')

    def history(self, repo_name, revision, f_path, annotate=False):

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            c.changeset = self.__get_cs_or_redirect(revision, repo_name)

            c.f_path = f_path

            c.annotate = annotate

            c.file = c.changeset.get_node(f_path)

            if c.file.is_file():

                file_last_cs = c.file.last_changeset

                c.file_changeset = (c.changeset

                                    if c.changeset.revision < file_last_cs.revision

                                    else file_last_cs)

                c.file_history, _hist = self._get_node_history(c.changeset, f_path)

                c.authors = []

                for a in set([x.author for x in _hist]):