# 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

            '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