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

"""

Helper functions

Consists of functions to typically be used within templates, but also

available to Controllers. This module is available to both as 'h'.

"""

import hashlib

import json

import StringIO

import logging

import re

import urlparse

import textwrap

from beaker.cache import cache_region

from pygments.formatters.html import HtmlFormatter

from pygments import highlight as code_highlight

from tg.i18n import ugettext as _

from webhelpers.html import literal, HTML, escape

from webhelpers.html.tags import checkbox, end_form, hidden, link_to, \

    select, submit, text, password, textarea, radio, form as insecure_form

from webhelpers.number import format_byte_size

from webhelpers.pylonslib import Flash as _Flash

from webhelpers.pylonslib.secure_form import secure_form, authentication_token

from webhelpers.text import chop_at, truncate, wrap_paragraphs

from webhelpers.html.tags import _set_input_attrs, _set_id_attr, \

    convert_boolean_attrs, NotGiven, _make_safe_id_component

from kallithea.config.routing import url

from kallithea.lib.annotate import annotate_highlight

from kallithea.lib.pygmentsutils import get_custom_lexer

from kallithea.lib.utils2 import str2bool, safe_unicode, safe_str, \

    time_to_datetime, AttributeDict, safe_int, MENTIONS_REGEX

from kallithea.lib.markup_renderer import url_re

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError

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

log = logging.getLogger(__name__)

def canonical_url(*args, **kargs):

    '''Like url(x, qualified=True), but returns url that not only is qualified

    but also canonical, as configured in canonical_url'''

    from kallithea import CONFIG

    try:

        parts = CONFIG.get('canonical_url', '').split('://', 1)

        kargs['protocol'] = parts[0]

    except IndexError:

        kargs['qualified'] = True

    return url(*args, **kargs)

def canonical_hostname():

    '''Return canonical hostname of system'''

    from kallithea import CONFIG

    try:

        parts = CONFIG.get('canonical_url', '').split('://', 1)

        return parts[1].split('/', 1)[0]

    except IndexError:

        parts = url('home', qualified=True).split('://', 1)

        return parts[1].split('/', 1)[0]

def html_escape(s):

    """Return string with all html escaped.

    This is also safe for javascript in html but not necessarily correct.

    """

    return (s

        .replace('&', '&')

        .replace(">", ">")

        .replace("<", "&lt;")

        .replace('"', """)

        .replace("'", "'") # Note: this is HTML5 not HTML4 and might not work in mails

        )

def js(value):

    """Convert Python value to the corresponding JavaScript representation.

    This is necessary to safely insert arbitrary values into HTML <script>

    sections e.g. using Mako template expression substitution.

    Note: Rather than using this function, it's preferable to avoid the

    insertion of values into HTML <script> sections altogether. Instead,

    data should (to the extent possible) be passed to JavaScript using

    data attributes or AJAX calls, eliminating the need for JS specific

    escaping.

    Note: This is not safe for use in attributes (e.g. onclick), because

    quotes are not escaped.

    Because the rules for parsing <script> varies between XHTML (where

    normal rules apply for any special characters) and HTML (where

    entities are not interpreted, but the literal string "</script>"

    is forbidden), the function ensures that the result never contains

    '&', '<' and '>', thus making it safe in both those contexts (but

    not in attributes).

    """

    return literal(

        ('(' + json.dumps(value) + ')')

        # In JSON, the following can only appear in string literals.

        .replace('&', r'\x26')

        .replace('<', r'\x3c')

        .replace('>', r'\x3e')

    )

def jshtml(val):

    """HTML escapes a string value, then converts the resulting string

    to its corresponding JavaScript representation (see `js`).

    This is used when a plain-text string (possibly containing special

    HTML characters) will be used by a script in an HTML context (e.g.

    element.innerHTML or jQuery's 'html' method).

    If in doubt, err on the side of using `jshtml` over `js`, since it's

    better to escape too much than too little.

    """

    return js(escape(val))

def shorter(s, size=20, firstline=False, postfix='...'):

    """Truncate s to size, including the postfix string if truncating.

    If firstline, truncate at newline.

    """

    if firstline:

        s = s.split('\n', 1)[0].rstrip()

    if len(s) > size:

        return s[:size - len(postfix)] + postfix

    return s

def _reset(name, value=None, id=NotGiven, type="reset", **attrs):

    """

    Reset button

    """

    _set_input_attrs(attrs, type, name, value)

    _set_id_attr(attrs, id, name)

    convert_boolean_attrs(attrs, ["disabled"])

    return HTML.input(**attrs)

reset = _reset

        (r'#(\d+)', 'http://foo/{repo}/issue/\\1', '#\\1',

            'an issue   #123       with extra whitespace',

            """an issue   <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a>       with extra whitespace"""),

        (r'(?:\s*#)(\d+)', 'http://foo/{repo}/issue/\\1', '#\\1',

            'an issue   #123       with extra whitespace',

            """an issue<a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a>       with extra whitespace"""),

        # invalid issue pattern

        (r'(PR\d+', 'http://foo/{repo}/issue/{id}', '',

            'PR135',

            """PR135"""),

        # other character than #

        (r'(?:^|(?<=\s))\$(\d+)', 'http://foo/{repo}/issue/\\1', '',

            'empty issue_sub $123 and issue$456',

            """empty issue_sub <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">$123</a> and """

            """issue$456"""),

        # named groups

        (r'(PR|pullrequest|pull request) ?(?P<sitecode>BRU|CPH|BER)-(?P<id>\d+)', 'http://foo/\g<sitecode>/pullrequest/\g<id>/', 'PR-\g<sitecode>-\g<id>',

            'pullrequest CPH-789 is similar to PRBRU-747',

            """<a class="issue-tracker-link" href="http://foo/CPH/pullrequest/789/">PR-CPH-789</a> is similar to """

            """<a class="issue-tracker-link" href="http://foo/BRU/pullrequest/747/">PR-BRU-747</a>"""),

    ])

    def test_urlify_issues(self, issue_pat, issue_server, issue_sub, sample, expected):

        from kallithea.lib.helpers import urlify_text

        config_stub = {

            'sqlalchemy.url': 'foo',

            'issue_pat': issue_pat,

            'issue_server_link': issue_server,

            'issue_sub': issue_sub,

        }

        # force recreation of lazy function

        with mock.patch('kallithea.lib.helpers._urlify_issues_f', None):

            with mock.patch('kallithea.CONFIG', config_stub):

                assert urlify_text(sample, 'repo_name') == expected

    @parametrize('sample,expected', [

        ('abc X5', 'abc <a class="issue-tracker-link" href="http://main/repo_name/main/5/">#5</a>'),

        ('abc pullrequest #6 xyz', 'abc <a class="issue-tracker-link" href="http://pr/repo_name/pr/6">PR#6</a> xyz'),

        ('pull request7 #', '<a class="issue-tracker-link" href="http://pr/repo_name/pr/7">PR#7</a> #'),

        ('look PR9 and pr #11', 'look <a class="issue-tracker-link" href="http://pr/repo_name/pr/9">PR#9</a> and <a class="issue-tracker-link" href="http://pr/repo_name/pr/11">PR#11</a>'),

        ('pullrequest#10 solves issue 9', '<a class="issue-tracker-link" href="http://pr/repo_name/pr/10">PR#10</a> solves <a class="issue-tracker-link" href="http://bug/repo_name/bug/9">bug#9</a>'),

        ('issue FAIL67', 'issue <a class="issue-tracker-link" href="http://fail/repo_name/67">FAIL67</a>'),

        ('issue FAILMORE89', 'issue FAILMORE89'), # no match because absent prefix

    ])

    def test_urlify_issues_multiple_issue_patterns(self, sample, expected):

        from kallithea.lib.helpers import urlify_text

        config_stub = {

            'sqlalchemy.url': 'foo',

            'issue_pat': 'X(\d+)',

            'issue_server_link': 'http://main/{repo}/main/\\1/',

            'issue_sub': '#\\1',

            'issue_pat_pr': '(?:pullrequest|pull request|PR|pr) ?#?(\d+)',

            'issue_server_link_pr': 'http://pr/{repo}/pr/\\1',

            'issue_sub_pr': 'PR#\\1',

            'issue_pat_bug': '(?:BUG|bug|issue) ?#?(\d+)',

            'issue_server_link_bug': 'http://bug/{repo}/bug/\\1',

            'issue_sub_bug': 'bug#\\1',

            'issue_pat_empty_prefix': 'FAIL(\d+)',

            'issue_server_link_empty_prefix': 'http://fail/{repo}/\\1',

            'issue_sub_empty_prefix': '',

            'issue_pat_absent_prefix': 'FAILMORE(\d+)',

            'issue_server_link_absent_prefix': 'http://failmore/{repo}/\\1',

        }

        # force recreation of lazy function

        with mock.patch('kallithea.lib.helpers._urlify_issues_f', None):

            with mock.patch('kallithea.CONFIG', config_stub):

                assert urlify_text(sample, 'repo_name') == expected

    @parametrize('test,expected', [

      ("", None),

      ("/_2", '2'),

      ("_2", '2'),

      ("/_2/", '2'),

      ("_2/", '2'),

      ("/_21", '21'),

      ("_21", '21'),

      ("/_21/", '21'),

      ("_21/", '21'),

      ("/_21/foobar", '21'),

      ("_21/121", '21'),

      ("/_21/_12", '21'),

      ("_21/prefix/foo", '21'),

    ])

    def test_get_repo_by_id(self, test, expected):

        from kallithea.lib.utils import _extract_id_from_repo_name

        _test = _extract_id_from_repo_name(test)

        assert _test == expected, 'url:%s, got:`%s` expected: `%s`' % (test, _test, expected)

    @parametrize('canonical,test,expected', [

        ('http://www.example.org/', '/abc/xyz', 'http://www.example.org/abc/xyz'),

        ('http://www.example.org', '/abc/xyz', 'http://www.example.org/abc/xyz'),

        ('http://www.example.org', '/abc/xyz/', 'http://www.example.org/abc/xyz/'),

        ('http://www.example.org', 'abc/xyz/', 'http://www.example.org/abc/xyz/'),

        ('http://www.example.org', 'about', 'http://www.example.org/about-page'),

    ])

    def test_canonical_url(self, canonical, test, expected):

        from kallithea.lib.helpers import canonical_url

        from tg import request

        # setup url(), used by canonical_url

        import routes

        m = routes.Mapper()

        m.connect('about', '/about-page')

        url = routes.URLGenerator(m, {'HTTP_HOST': 'http_host.example.org'})

        config_mock = {

            'canonical_url': canonical,

        }

        with test_context(self.app):

            request.environ['routes.url'] = url

            with mock.patch('kallithea.CONFIG', config_mock):

                assert canonical_url(test) == expected

    @parametrize('canonical,expected', [

        ('http://www.example.org', 'www.example.org'),

    ])

    def test_canonical_hostname(self, canonical, expected):

        from kallithea.lib.helpers import canonical_hostname

        from tg import request

        # setup url(), used by canonical_hostname

        import routes

        m = routes.Mapper()

        url = routes.URLGenerator(m, {'HTTP_HOST': 'http_host.example.org'})

        config_mock = {

            'canonical_url': canonical,

        }

        with test_context(self.app):

            request.environ['routes.url'] = url

            with mock.patch('kallithea.CONFIG', config_mock):

                assert canonical_hostname() == expected