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

"""

    rhodecode.controllers.compare

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

    compare controller for pylons showoing differences between two

    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 binascii

from webob.exc import HTTPNotFound

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

from pylons.controllers.util import abort, redirect

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

log = logging.getLogger(__name__)

class CompareController(BaseRepoController):

    @LoginRequired()

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

                                   'repository.admin')

    def __before__(self):

        super(CompareController, self).__before__()

    def _handle_ref(self, ref):

        """

        Parse the org...other string

        Possible formats are 

            `(branch|book|tag):<name>...(branch|book|tag):<othername>`

        :param ref: <orginal_reference>...<other_reference>

        :type ref: str

        """

        def org_parser(org):

            _repo = org_repo

            name, val = org.split(':')

            return _repo, (name, val)

        def other_parser(other):

            _other_repo = request.GET.get('repo')

            _repo = org_repo

            name, val = other.split(':')

            if _other_repo:

                _repo = _other_repo

            return _repo, (name, val)

        if '...' in ref:

            try:

                org, other = ref.split('...')

                org_repo, org_ref = org_parser(org)

                other_repo, other_ref = other_parser(other)

                return org_repo, org_ref, other_repo, other_ref

            except:

                log.error(traceback.format_exc())

        raise HTTPNotFound

    def _get_discovery(self,org_repo, org_ref, other_repo, other_ref):

        from mercurial import discovery

        other = org_repo._repo

        repo = other_repo._repo

        tmp = discovery.findcommonincoming(

                  repo=repo,  # other_repo we check for incoming

                  remote=other,  # org_repo source for incoming

                  force=False

        )

        return tmp

    def _get_changesets(self, org_repo, org_ref, other_repo, other_ref, tmp):

        changesets = []

        #case two independent repos

        if org_repo != other_repo:

            common, incoming, rheads = tmp

            if not incoming:

                revs = []

            else:

                revs = org_repo._repo.changelog.findmissing(common, rheads)

            for cs in reversed(map(binascii.hexlify, revs)):

                changesets.append(org_repo.get_changeset(cs))

        else:

            revs = ['ancestors(%s) and not ancestors(%s)' % (org_ref[1],

                                                             other_ref[1])]

            from mercurial import scmutil

            out = scmutil.revrange(org_repo._repo, revs)

            for cs in reversed(out):

                changesets.append(org_repo.get_changeset(cs))

        return changesets

    def index(self, ref):

        org_repo, org_ref, other_repo, other_ref = self._handle_ref(ref)

        c.swap_url = h.url('compare_home', repo_name=other_repo,

                           ref='%s...%s' % (':'.join(other_ref),

                                            ':'.join(org_ref)),

                           repo=org_repo)

        c.org_repo = org_repo = Repository.get_by_repo_name(org_repo)

        c.other_repo = other_repo = Repository.get_by_repo_name(other_repo)

                                           org_ref,

                                           other_repo.scm_instance,

                                           other_ref)

        c.cs_ranges = self._get_changesets(org_repo.scm_instance,

                                           org_ref,

                                           other_repo.scm_instance,

                                           other_ref,

        c.org_ref = org_ref[1]

        c.other_ref = other_ref[1]

        # diff needs to have swapped org with other to generate proper diff

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

        _parsed = diff_processor.prepare()

        c.files = []

        c.changes = {}

        # sort Added first then Modified last Deleted files

        sorter = lambda info: {'A': 0, 'M': 1, 'D': 2}.get(info['operation'])

        for f in sorted(_parsed, key=sorter):

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

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

            diff = diff_processor.as_html(enable_comments=False, diff_lines=[f])

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

        return render('compare/compare_diff.html')

            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 operation (A/M/D), 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)

                operation = 'D' if new_filename == '/dev/null' else None

                if not operation:

                    operation = 'M' if old_filename != '/dev/null' else 'A'

                return operation, filename, new_rev, old_rev

        except (ValueError, IndexError):

            pass

        return None, 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))

            return map(line_decoder, l)

        elif size == 1:

            return  map(line_decoder, output[0].splitlines(1))

        elif size == 0:

            return []

        raise Exception('wrong size of diff %s' % size)

    def _highlight_line_difflib(self, line, next_):

        """

        Highlight inline changes in both lines.

        """

        if line['action'] == 'del':

            old, new = line, next_

        else:

            old, new = next_, line

        oldwords = re.split(r'(\W)', old['line'])

        newwords = re.split(r'(\W)', new['line'])

        sequence = difflib.SequenceMatcher(None, oldwords, newwords)

        oldfragments, newfragments = [], []

        for tag, i1, i2, j1, j2 in sequence.get_opcodes():

            oldfrag = ''.join(oldwords[i1:i2])

            newfrag = ''.join(newwords[j1:j2])

            if tag != 'equal':

                if oldfrag:

                    oldfrag = '<del>%s</del>' % oldfrag

                if newfrag:

                    newfrag = '<ins>%s</ins>' % newfrag

            oldfragments.append(oldfrag)

            newfragments.append(newfrag)

        old['line'] = "".join(oldfragments)

        new['line'] = "".join(newfragments)

    def _highlight_line_udiff(self, line, next_):

        """

        Highlight inline changes in both lines.

        """

        start = 0

        limit = min(len(line['line']), len(next_['line']))

        while start < limit and line['line'][start] == next_['line'][start]:

            start += 1

        end = -1

        limit -= start

        while -end <= limit and line['line'][end] == next_['line'][end]:

            end -= 1

        end += 1

        if start or end:

            def do(l):

                last = end + len(l['line'])

                if l['action'] == 'add':

                    tag = 'ins'

                else:

                    tag = 'del'

                l['line'] = '%s<%s>%s</%s>%s' % (

                    l['line'][:start],

                    tag,

                    l['line'][start:last],

                    tag,

                    l['line'][last:]

                )

            do(line)

            do(next_)

    def _parse_udiff(self):

        """

        Parse the diff an return data for the template.

        """

        lineiter = self.lines

        files = []

        try:

            line = lineiter.next()

            while 1:

                # continue until we found the old file

                if not line.startswith('--- '):

                    line = lineiter.next()

                    continue

                chunks = []

                stats = [0, 0]

                operation, filename, old_rev, new_rev = \

                    self._extract_rev(line, lineiter.next())

                files.append({

                    'filename':         filename,

                    'old_revision':     old_rev,

                    'new_revision':     new_rev,

                    'chunks':           chunks,

                    'operation':        operation,

                    'stats':            stats,

                })

                line = lineiter.next()

                while line:

                    match = self._chunk_re.match(line)

                    if not match:

                        break

                    lines = []

                    chunks.append(lines)

                    old_line, old_end, new_line, new_end = \

                        [int(x or 1) for x in match.groups()[:-1]]

                    old_line -= 1

                    new_line -= 1

                    gr = match.groups()

                    context = len(gr) == 5

                    old_end += old_line

                    new_end += new_line

                    if context:

                        # skip context only if it's first line

                        if int(gr[0]) > 1:

                            lines.append({

                                'old_lineno': '...',

                                'new_lineno': '...',

                                'action':     'context',

                                'line':       line,

                            })

                    line = lineiter.next()

                    while old_line < old_end or new_line < new_end:

                        if line:

                            command, line = line[0], line[1:]

                        else:

                            command = ' '

                        affects_old = affects_new = False

                        # ignore those if we don't expect them

                        if command in '#@':

                            continue

                        elif command == '+':

                            affects_new = True

                            action = 'add'

                            stats[0] += 1

                        elif command == '-':

                            affects_old = True

                            action = 'del'

                            stats[1] += 1

                        else:

                            affects_old = affects_new = True

                            action = 'unmod'

                        if line.find('No newline at end of file') != -1:

                            lines.append({

                                'old_lineno':   '...',

                                'new_lineno':   '...',

                                'action':       'context',

                                'line':         line

                            })

                        else:

                            old_line += affects_old

                            new_line += affects_new

                            lines.append({

                                'old_lineno':   affects_old and old_line or '',

                                'new_lineno':   affects_new and new_line or '',

                                'action':       action,

                                'line':         line

                            })

                        line = lineiter.next()

        except StopIteration:

            pass

        # highlight inline changes

        for diff_data in files:

            for chunk in diff_data['chunks']:

                lineiter = iter(chunk)

                try:

                    while 1:

                        line = lineiter.next()

                        if line['action'] != 'unmod':

                            nextline = lineiter.next()

                            if nextline['action'] in ['unmod', 'context'] or \

                               nextline['action'] == line['action']:

                                continue

                            self.differ(line, nextline)

                except StopIteration:

                    pass

        return files

    def prepare(self):

        """

        Prepare the passed udiff for HTML rendering. It'l return a list

        of dicts

        """

        return self._parse_udiff()

    def _safe_id(self, idstring):

        """Make a string safe for including in an id attribute.

        The HTML spec says that id attributes 'must begin with

        a letter ([A-Za-z]) and may be followed by any number

        of letters, digits ([0-9]), hyphens ("-"), underscores

        ("_"), colons (":"), and periods (".")'. These regexps

        are slightly over-zealous, in that they remove colons

        and periods unnecessarily.

        Whitespace is transformed into underscores, and then

        anything which is not a hyphen or a character that

        matches \w (alphanumerics and underscore) is removed.

        """

        # Transform all whitespace to underscore

        idstring = re.sub(r'\s', "_", '%s' % idstring)

        # Remove everything that is not a hyphen or a member of \w

        idstring = re.sub(r'(?!-)\W', "", idstring).lower()

        return idstring

    def raw_diff(self):

        """

        Returns raw string as udiff

        """

        udiff_copy = self.copy_iterator()

        if self.__format == 'gitdiff':

            udiff_copy = self._parse_gitdiff(udiff_copy)

        return u''.join(udiff_copy)

    def as_html(self, table_class='code-difftable', line_class='line',

                new_lineno_class='lineno old', old_lineno_class='lineno new',

                code_class='code', enable_comments=False, diff_lines=None):

        """

        Return given diff as html table with customized css classes

        """

        def _link_to_if(condition, label, url):

            """

            Generates a link if condition is meet or just the label if not.

            """

            if condition:

                return '''<a href="%(url)s">%(label)s</a>''' % {

                    'url': url,

                    'label': label

                }

            else:

                return label

        if diff_lines is None:

            diff_lines = self.prepare()

        _html_empty = True

        _html = []

        _html.append('''<table class="%(table_class)s">\n''' % {

            'table_class': table_class

        })

        for diff in diff_lines:

            for line in diff['chunks']:

                _html_empty = False

                for change in line:

                    _html.append('''<tr class="%(lc)s %(action)s">\n''' % {

                        'lc': line_class,

                        'action': change['action']

                    })

                    anchor_old_id = ''

                    anchor_new_id = ''

                    anchor_old = "%(filename)s_o%(oldline_no)s" % {

                        'filename': self._safe_id(diff['filename']),

                        'oldline_no': change['old_lineno']

                    }

                    anchor_new = "%(filename)s_n%(oldline_no)s" % {

                        'filename': self._safe_id(diff['filename']),

                        'oldline_no': change['new_lineno']

                    }

                    cond_old = (change['old_lineno'] != '...' and

                                change['old_lineno'])

                    cond_new = (change['new_lineno'] != '...' and

                                change['new_lineno'])

                    if cond_old:

                        anchor_old_id = 'id="%s"' % anchor_old

                    if cond_new:

                        anchor_new_id = 'id="%s"' % anchor_new

                    ###########################################################

                    # OLD LINE NUMBER

                    ###########################################################

                    _html.append('''\t<td %(a_id)s class="%(olc)s">''' % {

                        'a_id': anchor_old_id,

                        'olc': old_lineno_class

                    })

                    _html.append('''%(link)s''' % {

                        'link': _link_to_if(True, change['old_lineno'],

                                            '#%s' % anchor_old)

                    })

                    _html.append('''</td>\n''')

                    ###########################################################

                    # NEW LINE NUMBER

                    ###########################################################

                    _html.append('''\t<td %(a_id)s class="%(nlc)s">''' % {

                        'a_id': anchor_new_id,

                        'nlc': new_lineno_class

                    })

                    _html.append('''%(link)s''' % {

                        'link': _link_to_if(True, change['new_lineno'],

                                            '#%s' % anchor_new)

                    })

                    _html.append('''</td>\n''')

                    ###########################################################

                    # CODE

                    ###########################################################

                    comments = '' if enable_comments else 'no-comment'

                    _html.append('''\t<td class="%(cc)s %(inc)s">''' % {

                        'cc': code_class,

                        'inc': comments

                    })

                    _html.append('''\n\t\t<pre>%(code)s</pre>\n''' % {

                        'code': change['line']

                    })

                    _html.append('''\t</td>''')

                    _html.append('''\n</tr>\n''')

        _html.append('''</table>''')

        if _html_empty:

            return None

        return ''.join(_html)

    def stat(self):

        """

        Returns tuple of added, and removed lines for this instance

        """

        return self.adds, self.removes

def differ(org_repo, org_ref, other_repo, other_ref, discovery_data=None):

    """

    General differ between branches, bookmarks or separate but releated 

    repositories

    :param org_repo:

    :type org_repo:

    :param org_ref:

    :type org_ref:

    :param other_repo:

    :type other_repo:

    :param other_ref:

    :type other_ref:

    """

    context = 3

    org_repo = org_repo.scm_instance._repo

    other_repo = other_repo.scm_instance._repo

    opts = diffopts(git=True, ignorews=ignore_whitespace, context=context)

    org_ref = org_ref[1]

    other_ref = other_ref[1]

    if org_repo != other_repo:

        common, incoming, rheads = discovery_data

        # create a bundle (uncompressed if other repo is not local)

            # disable repo hooks here since it's just bundle !

            # patch and reset hooks section of UI config to not run any

            # hooks on fetching archives with subrepos

            for k, _ in other_repo.ui.configitems('hooks'):

                other_repo.ui.setconfig('hooks', k, None)

            unbundle = other_repo.getbundle('incoming', common=common,

                                            heads=rheads)

            buf = io.BytesIO()

            while True:

                chunk = unbundle._stream.read(1024*4)

                if not chunk:

                    break

                buf.write(chunk)

            buf.seek(0)

            unbundle._stream = buf

        ui = make_ui('db')

                                        bundlestream=unbundle)

    else:

        return ''.join(patch.diff(org_repo, node1=org_ref, node2=other_ref,

                                  opts=opts))

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

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

<%def name="title()">

    ${c.repo_name} ${_('Branches')} - ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

    <input class="q_filter_box" id="q_filter_branches" size="15" type="text" name="filter" value="${_('quick filter...')}"/>

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

    »

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

    »

    ${_('branches')}

</%def>

<%def name="page_nav()">

    ${self.menu('branches')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <!-- end box / title -->

    <div class="info_box" id="compare_branches" style="clear: both;padding: 10px 19px;vertical-align: right;text-align: right;"><a href="#" class="ui-btn small">${_('Compare branches')}</a></div>

    <div class="table">

        <%include file='branches_data.html'/>

    </div>

</div>

<script type="text/javascript">

YUE.on('compare_branches','click',function(e){

	YUE.preventDefault(e);

	var org = YUQ('input[name=compare_org]:checked')[0];

	var other = YUQ('input[name=compare_other]:checked')[0];

	var compare_url = "${h.url('compare_home',repo_name=c.repo_name,ref='__ORG__...__OTHER__')}";

	if(org && other){

		var u = compare_url.replace('__ORG__','branch:'+org.value)

		                   .replace('__OTHER__','branch:'+other.value);

		window.location=u;

	}

})

// main table sorting

var myColumnDefs = [

    {key:"name",label:"${_('Name')}",sortable:true},

    {key:"date",label:"${_('Date')}",sortable:true,

        sortOptions: { sortFunction: dateSort }},

    {key:"author",label:"${_('Author')}",sortable:true},

    {key:"revision",label:"${_('Revision')}",sortable:true,

        sortOptions: { sortFunction: revisionSort }},

    {key:"compare",label:"${_('Compare')}",sortable:false,},

];

var myDataSource = new YAHOO.util.DataSource(YUD.get("branches_data"));

myDataSource.responseType = YAHOO.util.DataSource.TYPE_HTMLTABLE;

myDataSource.responseSchema = {

    fields: [

        {key:"name"},

        {key:"date"},

        {key:"author"},

        {key:"revision"},

        {key:"compare"},

    ]

};

var myDataTable = new YAHOO.widget.DataTable("table_wrap", myColumnDefs, myDataSource,

        {

         sortedBy:{key:"name",dir:"asc"},

         MSG_SORTASC:"${_('Click to sort ascending')}",

         MSG_SORTDESC:"${_('Click to sort descending')}",

         MSG_EMPTY:"${_('No records found.')}",

         MSG_ERROR:"${_('Data error.')}",

         MSG_LOADING:"${_('Loading...')}",

        }

);

myDataTable.subscribe('postRenderEvent',function(oArgs) {

    tooltip_activate();

    var func = function(node){

        return node.parentNode.parentNode.parentNode.parentNode.parentNode;

    }

    q_filter('q_filter_branches',YUQ('div.table tr td .logtags .branchtag a'),func);

});

</script>

</%def>

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

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

<%def name="title()">

    ${c.repo_name} ${_('Compare')} ${'%s@%s' % (c.org_repo.repo_name, c.org_ref)} -> ${'%s@%s' % (c.other_repo.repo_name, c.other_ref)}

</%def>

<%def name="breadcrumbs_links()">

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

    »

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

    »

    ${_('Compare')}

</%def>

<%def name="page_nav()">

    ${self.menu('changelog')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <div class="table">

        <div id="body" class="diffblock">

            <div class="code-header cv">

                <div>

                </div>

            </div>

        </div>

        <div id="changeset_compare_view_content">

            <div class="container">

            <table class="compare_view_commits noborder">

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

                <tr>

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

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

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

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

                <td>

                  %if hasattr(c,'statuses') and c.statuses:

                    <div title="${_('Changeset status')}" class="changeset-status-ico"><img src="${h.url('/images/icons/flag_status_%s.png' % c.statuses[cnt])}" /></div>

                  %endif

                </td>

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

                </tr>

            %endfor

            </table>

            </div>

            <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${_('Files affected')}</div>

            <div class="cs_files">

              %for fid, change, f, stat in c.files:              

                  <div class="cs_${change}">

                    <div class="node">${h.link_to(h.safe_unicode(f),h.url.current(anchor=fid))}</div>

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

                  </div>

              %endfor

            </div>

        </div>

    </div>

    ## diff block

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

    %for fid, change, f, stat in c.files:

      ${diff_block.diff_block_simple([c.changes[fid]])}

    %endfor

     <script type="text/javascript">

      YUE.onDOMReady(function(){

          YUE.on(YUQ('.diff-menu-activate'),'click',function(e){

              var act = e.currentTarget.nextElementSibling;

              if(YUD.hasClass(act,'active')){

                  YUD.removeClass(act,'active');

                  YUD.setStyle(act,'display','none');

              }else{

                  YUD.addClass(act,'active');

                  YUD.setStyle(act,'display','');

              }

          });

      })

    </script>

    </div>

</%def>