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

# 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/>.

"""

kallithea.controllers.changeset

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

changeset controller showing changes between revisions

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 25, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import binascii

import logging

import traceback

from collections import OrderedDict, defaultdict

from tg import request, response

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.lib import diffs

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.utils import action_logger

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

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

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.db import ChangesetComment, ChangesetStatus

from kallithea.model.meta import Session

from kallithea.model.pull_request import PullRequestModel

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 = [k for k in GET.getall(fid) if k.startswith('WS')]

    if ig_ws:

        try:

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

        except ValueError:

            raise HTTPBadRequest()

    return ig_ws_global

def _ignorews_url(GET, fileid=None):

    fileid = str(fileid) if fileid else None

    params = defaultdict(list)

    _update_with_GET(params, GET)

    lbl = _('Show whitespace')

    ig_ws = get_ignore_ws(fileid, GET)

    ln_ctx = get_line_ctx(fileid, GET)

    # global option

    if fileid is None:

        if ig_ws is None:

            params['ignorews'] += [1]

            lbl = _('Ignore whitespace')

        ctx_key = 'context'

        ctx_val = ln_ctx

    # per file options

                                              changeset.raw_id, with_revisions=True)

                                if st.comment_id is not None)

                inlines = ChangesetCommentsModel() \

                            .get_inline_comments(c.db_repo.repo_id,

                                                 revision=changeset.raw_id)

                c.inline_comments.extend(inlines)

            cs2 = changeset.raw_id

            cs1 = changeset.parents[0].raw_id if changeset.parents else EmptyChangeset().raw_id

            context_lcl = get_line_ctx('', request.GET)

            ign_whitespace_lcl = get_ignore_ws('', request.GET)

            raw_diff = diffs.get_diff(c.db_repo_scm_instance, cs1, cs2,

                ignore_whitespace=ign_whitespace_lcl, context=context_lcl)

            diff_limit = None if c.fulldiff else self.cut_off_limit

            file_diff_data = []

            if method == 'show':

                diff_processor = diffs.DiffProcessor(raw_diff,

                                                     vcs=c.db_repo_scm_instance.alias,

                                                     diff_limit=diff_limit)

                c.limited_diff = diff_processor.limited_diff

                for f in diff_processor.parsed:

                    st = f['stats']

                    c.lines_added += st['added']

                    c.lines_deleted += st['deleted']

                    filename = f['filename']

                    fid = h.FID(changeset.raw_id, filename)

                    url_fid = h.FID('', filename)

                    html_diff = diffs.as_html(enable_comments=enable_comments, parsed_lines=[f])

                    file_diff_data.append((fid, url_fid, f['operation'], f['old_filename'], filename, html_diff, st))

            else:

                # downloads/raw we only need RAW diff nothing else

                file_diff_data.append(('', None, None, None, raw_diff, None))

            c.changes[changeset.raw_id] = (cs1, cs2, file_diff_data)

        # sort comments in creation order

        c.comments = [com for com_id, com in sorted(comments.items())]

        # count inline comments

        for __, lines in c.inline_comments:

            for comments in lines.values():

                c.inline_cnt += len(comments)

        if len(c.cs_ranges) == 1:

            c.changeset = c.cs_ranges[0]

            c.parent_tmpl = ''.join(['# Parent  %s\n' % x.raw_id

                                     for x in c.changeset.parents])

        if method == 'download':

            response.content_type = 'text/plain'

            response.content_disposition = 'attachment; filename=%s.diff' \

                                            % revision[:12]

            return raw_diff

        elif method == 'patch':

            response.content_type = 'text/plain'

            c.diff = safe_unicode(raw_diff)

            return render('changeset/patch_changeset.html')

        elif method == 'raw':

            response.content_type = 'text/plain'

            return raw_diff

        elif method == 'show':

            if len(c.cs_ranges) == 1:

                return render('changeset/changeset.html')

            else:

                c.cs_ranges_org = None

                c.cs_comments = {}

                revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

                c.jsdata = graph_data(c.db_repo_scm_instance, revs)

                return render('changeset/changeset_range.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def index(self, revision, method='show'):

        return self._index(revision, method=method)

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def changeset_raw(self, revision):

        return self._index(revision, method='raw')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def changeset_patch(self, revision):

        return self._index(revision, method='patch')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def changeset_download(self, revision):

        return self._index(revision, method='download')

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def comment(self, repo_name, revision):

        return create_cs_pr_comment(repo_name, revision=revision)