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

"""

    rhodecode.controllers.summary

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

    Summary controller for Rhodecode

    :created_on: Apr 18, 2010

    :author: marcink

    :copyright: (C) 2009-2011 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 calendar

import logging

from time import mktime

from datetime import datetime, timedelta, date

from vcs.exceptions import ChangesetError

from pylons import tmpl_context as c, request, url

from pylons.i18n.translation import _

from rhodecode.model.db import Statistics, Repository

from rhodecode.model.repo import RepoModel

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import EmptyChangeset

from rhodecode.lib.odict import OrderedDict

from rhodecode.lib.celerylib import run_task

from rhodecode.lib.celerylib.tasks import get_commits_stats, \

    LANGUAGES_EXTENSIONS_MAP

from rhodecode.lib.helpers import RepoPage

try:

    import json

except ImportError:

    #python 2.5 compatibility

    import simplejson as json

log = logging.getLogger(__name__)

class SummaryController(BaseRepoController):

    @LoginRequired()

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

                                   'repository.admin')

    def __before__(self):

        super(SummaryController, self).__before__()

    def index(self, repo_name):

        e = request.environ

        c.following = self.scm_model.is_following_repo(repo_name,

                                                self.rhodecode_user.user_id)

        def url_generator(**kw):

            return url('shortlog_home', repo_name=repo_name, size=10, **kw)

        c.repo_changesets = RepoPage(c.rhodecode_repo, page=1,

                                     items_per_page=10, url=url_generator)

        if self.rhodecode_user.username == 'default':

            #for default(anonymous) user we don't need to pass credentials

            username = ''

            password = ''

        else:

            username = str(self.rhodecode_user.username)

            password = '@'

        if e.get('wsgi.url_scheme') == 'https':

            split_s = 'https://'

        else:

            split_s = 'http://'

        qualified_uri = [split_s] + [url.current(qualified=True)\

                                     .split(split_s)[-1]]

        uri = u'%(proto)s%(user)s%(pass)s%(rest)s' \

                % {'user': username,

                     'pass': password,

                     'proto': qualified_uri[0],

                     'rest': qualified_uri[1]}

        c.clone_repo_url = uri

        c.repo_tags = OrderedDict()

        for name, hash in c.rhodecode_repo.tags.items()[:10]:

            try:

                c.repo_tags[name] = c.rhodecode_repo.get_changeset(hash)

            except ChangesetError:

                c.repo_tags[name] = EmptyChangeset(hash)

        c.repo_branches = OrderedDict()

        for name, hash in c.rhodecode_repo.branches.items()[:10]:

            try:

                c.repo_branches[name] = c.rhodecode_repo.get_changeset(hash)

            except ChangesetError:

                c.repo_branches[name] = EmptyChangeset(hash)

        td = date.today() + timedelta(days=1)

        td_1m = td - timedelta(days=calendar.mdays[td.month])

        td_1y = td - timedelta(days=365)

        ts_min_m = mktime(td_1m.timetuple())

        ts_min_y = mktime(td_1y.timetuple())

        ts_max_y = mktime(td.timetuple())

        if dbrepo.enable_statistics:

            c.no_data_msg = _('No data loaded yet')

            run_task(get_commits_stats, c.dbrepo.repo_name, ts_min_y, ts_max_y)

        else:

            c.no_data_msg = _('Statistics are disabled for this repository')

        c.ts_min = ts_min_m

        c.ts_max = ts_max_y

        stats = self.sa.query(Statistics)\

            .filter(Statistics.repository == dbrepo)\

            .scalar()

        c.stats_percentage = 0

        if stats and stats.languages:

            c.no_data = False is dbrepo.enable_statistics

            lang_stats_d = json.loads(stats.languages)

            c.commit_data = stats.commit_activity

            c.overview_data = stats.commit_activity_combined

            lang_stats = [(x, {"count": y,

                               "desc": LANGUAGES_EXTENSIONS_MAP.get(x)})

                          for x, y in lang_stats_d.items()]

            c.trending_languages = json.dumps(OrderedDict(

                                       sorted(lang_stats, reverse=True,

                                            key=lambda k: k[1])[:10]

                                        )

                                    )

            last_rev = stats.stat_on_revision

            c.repo_last_rev = c.rhodecode_repo.count() - 1 \

                if c.rhodecode_repo.revisions else 0

            if last_rev == 0 or c.repo_last_rev == 0:

                pass

            else:

                c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                                c.repo_last_rev) * 100)

        else:

            c.commit_data = json.dumps({})

            c.overview_data = json.dumps([[ts_min_y, 0], [ts_max_y, 10]])

            c.trending_languages = json.dumps({})

            c.no_data = True

        c.enable_downloads = dbrepo.enable_downloads

        if c.enable_downloads:

            c.download_options = self._get_download_links(c.rhodecode_repo)

        return render('summary/summary.html')

    def _get_download_links(self, repo):

        download_l = []

        branches_group = ([], _("Branches"))

        tags_group = ([], _("Tags"))

        for name, chs in c.rhodecode_repo.branches.items():

            #chs = chs.split(':')[-1]

            branches_group[0].append((chs, name),)

        download_l.append(branches_group)

        for name, chs in c.rhodecode_repo.tags.items():

            #chs = chs.split(':')[-1]

            tags_group[0].append((chs, name),)

        download_l.append(tags_group)

        return download_l

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

"""

    rhodecode.lib.__init__

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

    Some simple helper functions

    :created_on: Jan 5, 2011

    :author: marcink

    :copyright: (C) 2009-2010 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/>.

def __get_lem():

    from pygments import lexers

    from string import lower

    from collections import defaultdict

    d = defaultdict(lambda: [])

    def __clean(s):

        s = s.lstrip('*')

        s = s.lstrip('.')

        if s.find('[') != -1:

            exts = []

            start, stop = s.find('['), s.find(']')

            for suffix in s[start + 1:stop]:

                exts.append(s[:s.find('[')] + suffix)

            return map(lower, exts)

        else:

            return map(lower, [s])

    for lx, t in sorted(lexers.LEXERS.items()):

        m = map(__clean, t[-2])

        if m:

            m = reduce(lambda x, y: x + y, m)

            for ext in m:

                desc = lx.replace('Lexer', '')

                d[ext].append(desc)

    return dict(d)

# language map is also used by whoosh indexer, which for those specified

# extensions will index it's content

LANGUAGES_EXTENSIONS_MAP = __get_lem()

# Additional mappings that are not present in the pygments lexers

# NOTE: that this will overide any mappings in LANGUAGES_EXTENSIONS_MAP

ADDITIONAL_MAPPINGS = {'xaml': 'XAML'}

LANGUAGES_EXTENSIONS_MAP.update(ADDITIONAL_MAPPINGS)

def str2bool(_str):

    """

    returs True/False value from given string, it tries to translate the

    string into boolean

    :param _str: string value to translate into boolean

    :rtype: boolean

    :returns: boolean from given string

    """

    if _str is None:

        return False

    if _str in (True, False):

        return _str

    _str = str(_str).strip().lower()

    return _str in ('t', 'true', 'y', 'yes', 'on', '1')

    from string import replace

    if mode == 0:

    elif mode == 1:

    elif mode == 2:

            import re

def detect_mode(line, default):

    """

    Detects line break for given line, if line break couldn't be found

    given default value is returned

    :param line: str line

    :param default: default

    :rtype: int

    :return: value of line end on of 0 - Unix, 1 - Mac, 2 - DOS

    """

    if line.endswith('\r\n'):

        return 2

    elif line.endswith('\n'):

        return 0

    elif line.endswith('\r'):

        return 1

    else:

        return default

def generate_api_key(username, salt=None):

    """

    Generates unique API key for given username,if salt is not given

    it'll be generated from some random string

    :param username: username as string

    :param salt: salt to hash generate KEY

    :rtype: str

    :returns: sha1 hash from username+salt

    """

    from tempfile import _RandomNameSequence

    import hashlib

    if salt is None:

        salt = _RandomNameSequence().next()

    return hashlib.sha1(username + salt).hexdigest()

def safe_unicode(_str, from_encoding='utf8'):

    """

    safe unicode function. In case of UnicodeDecode error we try to return

    unicode with errors replace

    :param _str: string to decode

    :rtype: unicode

    :returns: unicode object

    """

    if isinstance(_str, unicode):

        return _str

    try:

        u_str = unicode(_str, from_encoding)

    except UnicodeDecodeError:

        u_str = unicode(_str, from_encoding, 'replace')

    return u_str

def engine_from_config(configuration, prefix='sqlalchemy.', **kwargs):

    """

    Custom engine_from_config functions that makes sure we use NullPool for

    file based sqlite databases. This prevents errors on sqlite. This only 

    applies to sqlalchemy versions < 0.7.0

    """

    import sqlalchemy

    from sqlalchemy import engine_from_config as efc

    import logging

    if int(sqlalchemy.__version__.split('.')[1]) < 7:

        # This solution should work for sqlalchemy < 0.7.0, and should use

        # proxy=TimerProxy() for execution time profiling

        from sqlalchemy.pool import NullPool

        url = configuration[prefix + 'url']

        if url.startswith('sqlite'):

            kwargs.update({'poolclass': NullPool})

        return efc(configuration, prefix, **kwargs)

    else:

        import time

        from sqlalchemy import event

        from sqlalchemy.engine import Engine

        log = logging.getLogger('sqlalchemy.engine')

        BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = xrange(30, 38)

        engine = efc(configuration, prefix, **kwargs)

        def color_sql(sql):

            COLOR_SEQ = "\033[1;%dm"

            COLOR_SQL = YELLOW

            normal = '\x1b[0m'

            return ''.join([COLOR_SEQ % COLOR_SQL, sql, normal])

        if configuration['debug']:

            #attach events only for debug configuration

            def before_cursor_execute(conn, cursor, statement,

                                    parameters, context, executemany):

                context._query_start_time = time.time()

                log.info(color_sql(">>>>> STARTING QUERY >>>>>"))

            def after_cursor_execute(conn, cursor, statement,

                                    parameters, context, executemany):

                total = time.time() - context._query_start_time

                log.info(color_sql("<<<<< TOTAL TIME: %f <<<<<" % total))

            event.listen(engine, "before_cursor_execute",

                         before_cursor_execute)

            event.listen(engine, "after_cursor_execute",

                         after_cursor_execute)

    return engine

def age(curdate):

    """

    turns a datetime into an age string.

    :param curdate: datetime object

    :rtype: unicode

    :returns: unicode words describing age

    """

    from datetime import datetime

    from webhelpers.date import time_ago_in_words

    _ = lambda s:s

    if not curdate:

        return ''

    agescales = [(_(u"year"), 3600 * 24 * 365),

                 (_(u"month"), 3600 * 24 * 30),

                 (_(u"day"), 3600 * 24),

                 (_(u"hour"), 3600),

                 (_(u"minute"), 60),

                 (_(u"second"), 1), ]

    age = datetime.now() - curdate

    age_seconds = (age.days * agescales[2][1]) + age.seconds

    pos = 1

    for scale in agescales:

        if scale[1] <= age_seconds:

            if pos == 6:pos = 5

            return '%s %s' % (time_ago_in_words(curdate,

                                                agescales[pos][0]), _('ago'))

        pos += 1

    return _(u'just now')

    """

    Removes user:password from given url string

    :param uri:

    :rtype: unicode

    """

    if not uri:

        return ''

    proto = ''

    for pat in ('https://', 'http://'):

        if uri.startswith(pat):

            uri = uri[len(pat):]

            proto = pat

            break

    # remove passwords and username

    uri = uri[uri.find('@') + 1:]

    # get the port

    cred_pos = uri.find(':')

    if cred_pos == -1:

        host, port = uri, None

    else:

        host, port = uri[:cred_pos], uri[cred_pos + 1:]

    return filter(None, [proto, host, port])

"""The base Controller API

Provides the BaseController class for subclassing.

"""

from pylons.controllers import WSGIController

from pylons.templating import render_mako as render

from rhodecode import __version__

from rhodecode.lib.auth import AuthUser

from rhodecode.lib.utils import get_repo_slug

from rhodecode.model import meta

from rhodecode.model.scm import ScmModel

from rhodecode import BACKENDS

from rhodecode.model.db import Repository

class BaseController(WSGIController):

    def __before__(self):

        c.rhodecode_version = __version__

        c.rhodecode_name = config.get('rhodecode_title')

        c.ga_code = config.get('rhodecode_ga_code')

        c.repo_name = get_repo_slug(request)

        c.backends = BACKENDS.keys()

        self.cut_off_limit = int(config.get('cut_off_limit'))

        self.sa = meta.Session()

        self.scm_model = ScmModel(self.sa)

        #c.unread_journal = scm_model.get_unread_journal()

    def __call__(self, environ, start_response):

        """Invoke the Controller"""

        # WSGIController.__call__ dispatches to the Controller method

        # the request is routed to. This routing information is

        # available in environ['pylons.routes_dict']

        try:

            # putting this here makes sure that we update permissions each time

            api_key = request.GET.get('api_key')

            user_id = getattr(session.get('rhodecode_user'), 'user_id', None)

            self.rhodecode_user = c.rhodecode_user = AuthUser(user_id, api_key)

            self.rhodecode_user.set_authenticated(

                                        getattr(session.get('rhodecode_user'),

                                       'is_authenticated', False))

            session['rhodecode_user'] = self.rhodecode_user

            session.save()

            return WSGIController.__call__(self, environ, start_response)

        finally:

            meta.Session.remove()

class BaseRepoController(BaseController):

    """

    Base class for controllers responsible for loading all needed data

    for those controllers, loaded items are

    c.rhodecode_repo: instance of scm repository (taken from cache)

    """

    def __before__(self):

        super(BaseRepoController, self).__before__()

        if c.repo_name:

"""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 random

import hashlib

import StringIO

import urllib

from datetime import datetime

from pygments.formatters import HtmlFormatter

from pygments import highlight as code_highlight

from pylons import url, request, config

from pylons.i18n.translation import _, ungettext

from webhelpers.html import literal, HTML, escape

from webhelpers.html.tools import *

from webhelpers.html.builder import make_tag

from webhelpers.html.tags import auto_discovery_link, checkbox, css_classes, \

    end_form, file, form, hidden, image, javascript_link, link_to, link_to_if, \

    link_to_unless, ol, required_legend, select, stylesheet_link, submit, text, \

    password, textarea, title, ul, xml_declaration, radio

from webhelpers.html.tools import auto_link, button_to, highlight, js_obfuscate, \

    mail_to, strip_links, strip_tags, tag_re

from webhelpers.number import format_byte_size, format_bit_size

from webhelpers.pylonslib import Flash as _Flash

from webhelpers.pylonslib.secure_form import secure_form

from webhelpers.text import chop_at, collapse, convert_accented_entities, \

    convert_misc_entities, lchop, plural, rchop, remove_formatting, \

    replace_whitespace, urlify, truncate, wrap_paragraphs

from webhelpers.date import time_ago_in_words

from webhelpers.paginate import Page

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

    convert_boolean_attrs, NotGiven

from vcs.utils.annotate import annotate_highlight

from rhodecode.lib.utils import repo_name_slug

from rhodecode.lib import str2bool, safe_unicode

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

def get_token():

    """Return the current authentication token, creating one if one doesn't

    already exist.

    """

    token_key = "_authentication_token"

    from pylons import session

    if not token_key in session:

        try:

            token = hashlib.sha1(str(random.getrandbits(128))).hexdigest()

        except AttributeError: # Python < 2.4

            token = hashlib.sha1(str(random.randrange(2 ** 128))).hexdigest()

        session[token_key] = token

        if hasattr(session, 'save'):

            session.save()

    return session[token_key]

class _GetError(object):

    """Get error from form_errors, and represent it as span wrapped error

    message

    :param field_name: field to fetch errors for

    :param form_errors: form errors dict

    """

    def __call__(self, field_name, form_errors):

        tmpl = """<span class="error_msg">%s</span>"""

        if form_errors and form_errors.has_key(field_name):

            return literal(tmpl % form_errors.get(field_name))

get_error = _GetError()

class _ToolTip(object):

    def __call__(self, tooltip_title, trim_at=50):

        """Special function just to wrap our text into nice formatted

        autowrapped text

        :param tooltip_title:

        """

        return escape(tooltip_title)

    def activate(self):

        """Adds tooltip mechanism to the given Html all tooltips have to have

        set class `tooltip` and set attribute `tooltip_title`.

        Then a tooltip will be generated based on that. All with yui js tooltip

        """

        js = '''

        YAHOO.util.Event.onDOMReady(function(){

            function toolTipsId(){

                var ids = [];

                var tts = YAHOO.util.Dom.getElementsByClassName('tooltip');

                for (var i = 0; i < tts.length; i++) {

                    //if element doesn't not have and id autogenerate one for tooltip

                    if (!tts[i].id){

                        tts[i].id='tt'+i*100;

                    }

                    ids.push(tts[i].id);

                }

                return ids

            };

            var myToolTips = new YAHOO.widget.Tooltip("tooltip", {

                context: [[toolTipsId()],"tl","bl",null,[0,5]],

                monitorresize:false,

                xyoffset :[0,0],

                autodismissdelay:300000,

                hidedelay:5,

                showdelay:20,

            });

        });

        '''

        return literal(js)

tooltip = _ToolTip()

class _FilesBreadCrumbs(object):

    def __call__(self, repo_name, rev, paths):

        if isinstance(paths, str):

            paths = safe_unicode(paths)

        url_l = [link_to(repo_name, url('files_home',

                                        repo_name=repo_name,

                                        revision=rev, f_path=''))]

        paths_l = paths.split('/')

        for cnt, p in enumerate(paths_l):

            if p != '':

                url_l.append(link_to(p, url('files_home',

                                            repo_name=repo_name,

                                            revision=rev,

                                            f_path='/'.join(paths_l[:cnt + 1]))))

        return literal('/'.join(url_l))

files_breadcrumbs = _FilesBreadCrumbs()

class CodeHtmlFormatter(HtmlFormatter):

    """My code Html Formatter for source codes

    """

    def wrap(self, source, outfile):

        return self._wrap_div(self._wrap_pre(self._wrap_code(source)))

    def _wrap_code(self, source):

        for cnt, it in enumerate(source):

            i, t = it

            t = '<div id="L%s">%s</div>' % (cnt + 1, t)

            yield i, t

    def _wrap_tablelinenos(self, inner):

        dummyoutfile = StringIO.StringIO()

        lncount = 0

        for t, line in inner:

            if t:

                lncount += 1

            dummyoutfile.write(line)

        fl = self.linenostart

        mw = len(str(lncount + fl - 1))

        sp = self.linenospecial

        st = self.linenostep

        la = self.lineanchors

        aln = self.anchorlinenos

        nocls = self.noclasses

        if sp:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if i % sp == 0:

                        if aln:

                            lines.append('<a href="#%s%d" class="special">%*d</a>' %

                                         (la, i, mw, i))

                        else:

                            lines.append('<span class="special">%*d</span>' % (mw, i))

                    else:

                        if aln:

                            lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))

                        else:

                            lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

        else:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if aln:

                        lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))

                    else:

                        lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

        # in case you wonder about the seemingly redundant <div> here: since the

        # content in the other cell also is wrapped in a div, some browsers in

        # some configurations seem to mess up the formatting...

        if nocls:

            yield 0, ('<table class="%stable">' % self.cssclass +

                      '<tr><td><div class="linenodiv" '

                      'style="background-color: #f0f0f0; padding-right: 10px">'

                      '<pre style="line-height: 125%">' +

                      ls + '</pre></div></td><td id="hlcode" class="code">')

        else:

            yield 0, ('<table class="%stable">' % self.cssclass +

                      '<tr><td class="linenos"><div class="linenodiv"><pre>' +

                      ls + '</pre></div></td><td id="hlcode" class="code">')

        yield 0, dummyoutfile.getvalue()

        yield 0, '</td></tr></table>'

def pygmentize(filenode, **kwargs):

    """pygmentize function using pygments

    :param filenode:

    """

    return literal(code_highlight(filenode.content,

                                  filenode.lexer, CodeHtmlFormatter(**kwargs)))

def pygmentize_annotation(repo_name, filenode, **kwargs):

    """pygmentize function for annotation

    :param filenode:

    """

    color_dict = {}

    def gen_color(n=10000):

        """generator for getting n of evenly distributed colors using

        hsv color and golden ratio. It always return same order of colors

        :returns: RGB tuple

        """

        import colorsys

        golden_ratio = 0.618033988749895

        h = 0.22717784590367374

        for _ in xrange(n):

            h += golden_ratio

            h %= 1