"""

    rhodecode.lib.diffs

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

    Set of diffing helpers, previously part of vcs

    :created_on: Dec 4, 2011

    :author: marcink

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

    :original copyright: 2007-2008 by Armin Ronacher

    :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 re

import difflib

import markupsafe

from itertools import tee, imap

from pylons.i18n.translation import _

from vcs.exceptions import VCSError

from vcs.nodes import FileNode

from rhodecode.lib.utils import EmptyChangeset

def wrap_to_table(str_):

    return '''<table class="code-difftable">

                <tr class="line no-comment">

                <td class="lineno new"></td>

                <td class="code no-comment"><pre>%s</pre></td>

                </tr>

              </table>''' % str_

def wrapped_diff(filenode_old, filenode_new, cut_off_limit=None,

                ignore_whitespace=True, line_context=3,

                enable_comments=False):

    """

    returns a wrapped diff into a table, checks for cut_off_limit and presents

    proper message

    """

    if filenode_old is None:

        filenode_old = FileNode(filenode_new.path, '', EmptyChangeset())

    if filenode_old.is_binary or filenode_new.is_binary:

        diff = wrap_to_table(_('binary file'))

        stats = (0, 0)

        size = 0

    elif cut_off_limit != -1 and (cut_off_limit is None or

    (filenode_old.size < cut_off_limit and filenode_new.size < cut_off_limit)):

        f_gitdiff = get_gitdiff(filenode_old, filenode_new,

                                ignore_whitespace=ignore_whitespace,

                                context=line_context)

        diff_processor = DiffProcessor(f_gitdiff, format='gitdiff')

        diff = diff_processor.as_html(enable_comments=enable_comments)

        stats = diff_processor.stat()

        size = len(diff or '')

    else:

        diff = wrap_to_table(_('Changeset was to big and was cut off, use '

                               'diff menu to display this diff'))

        stats = (0, 0)

        size = 0

    if not diff:

        diff = wrap_to_table(_('No changes detected'))

    cs1 = filenode_old.last_changeset.raw_id

    cs2 = filenode_new.last_changeset.raw_id

    return size, cs1, cs2, diff, stats

def get_gitdiff(filenode_old, filenode_new, ignore_whitespace=True, context=3):

    """

    Returns git style diff between given ``filenode_old`` and ``filenode_new``.

    :param ignore_whitespace: ignore whitespaces in diff

    """

    for filenode in (filenode_old, filenode_new):

        if not isinstance(filenode, FileNode):

            raise VCSError("Given object should be FileNode object, not %s"

                % filenode.__class__)

    vcs_gitdiff = repo.get_diff(old_raw_id, new_raw_id, filenode_new.path,

                                 ignore_whitespace, context)

    return vcs_gitdiff

class DiffProcessor(object):

    """

    Give it a unified diff and it returns a list of the files that were

    mentioned in the diff together with a dict of meta information that

    can be used to render it in a HTML template.

    """

    _chunk_re = re.compile(r'@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)')

    def __init__(self, diff, differ='diff', format='udiff'):

        """

        :param diff:   a text in diff format or generator

        :param format: format of diff passed, `udiff` or `gitdiff`

        """

        if isinstance(diff, basestring):

            diff = [diff]

        self.__udiff = diff

        self.__format = format

        self.adds = 0

        self.removes = 0

        if isinstance(self.__udiff, basestring):

            self.lines = iter(self.__udiff.splitlines(1))

        elif self.__format == 'gitdiff':

            udiff_copy = self.copy_iterator()

            self.lines = imap(self.escaper, self._parse_gitdiff(udiff_copy))

        else:

            udiff_copy = self.copy_iterator()

            self.lines = imap(self.escaper, udiff_copy)

        # Select a differ.

        if differ == 'difflib':

            self.differ = self._highlight_line_difflib

        else:

            self.differ = self._highlight_line_udiff

    def escaper(self, string):

        return markupsafe.escape(string)

    def copy_iterator(self):

        """

        make a fresh copy of generator, we should not iterate thru

        an original as it's needed for repeating operations on

        this instance of DiffProcessor

        """

        self.__udiff, iterator_copy = tee(self.__udiff)

        return iterator_copy

    def _extract_rev(self, line1, line2):

        """

        Extract the filename and revision hint from a line.

        """

        try:

            if line1.startswith('--- ') and line2.startswith('+++ '):

                l1 = line1[4:].split(None, 1)

                old_filename = (l1[0].replace('a/', '', 1)

                                if len(l1) >= 1 else None)

                old_rev = l1[1] if len(l1) == 2 else 'old'

                l2 = line2[4:].split(None, 1)

                new_filename = (l2[0].replace('b/', '', 1)

                                if len(l1) >= 1 else None)

                new_rev = l2[1] if len(l2) == 2 else 'new'

                filename = (old_filename

                            if old_filename != '/dev/null' else new_filename)

                return filename, new_rev, old_rev

        except (ValueError, IndexError):

            pass

        return None, None, None

    def _parse_gitdiff(self, diffiterator):

        def line_decoder(l):

            if l.startswith('+') and not l.startswith('+++'):

                self.adds += 1

            elif l.startswith('-') and not l.startswith('---'):

                self.removes += 1

            return l.decode('utf8', 'replace')

        output = list(diffiterator)

        size = len(output)

        if size == 2:

            l = []

            l.extend([output[0]])

            l.extend(output[1].splitlines(1))