"""Pylons middleware initialization"""

from beaker.middleware import SessionMiddleware

from paste.cascade import Cascade

from paste.registry import RegistryManager

from paste.urlparser import StaticURLParser

from paste.deploy.converters import asbool

from pylons.middleware import ErrorHandler, StatusCodeRedirect

from pylons.wsgiapp import PylonsApp

from routes.middleware import RoutesMiddleware

from rhodecode.lib.middleware.simplehg import SimpleHg

from rhodecode.lib.middleware.https_fixup import HttpsFixup

from rhodecode.config.environment import load_environment

def make_app(global_conf, full_stack=True, static_files=True, **app_conf):

    """Create a Pylons WSGI application and return it

    ``global_conf``

        The inherited configuration for this application. Normally from

        the [DEFAULT] section of the Paste ini file.

    ``full_stack``

        Whether or not this application provides a full WSGI stack (by

        default, meaning it handles its own exceptions and errors).

        Disable full_stack when this application is "managed" by

        another WSGI middleware.

    ``app_conf``

        The application's local configuration. Normally specified in

        the [app:<name>] section of the Paste ini file (where <name>

        defaults to main).

    """

    # Configure the Pylons environment

    config = load_environment(global_conf, app_conf)

    # The Pylons WSGI app

    app = PylonsApp(config=config)

    # Routing/Session/Cache Middleware

    app = RoutesMiddleware(app, config['routes.map'])

    app = SessionMiddleware(app, config)

    # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)

    app = SimpleHg(app, config)

    if asbool(full_stack):

        # Handle Python exceptions

        app = ErrorHandler(app, global_conf, **config['pylons.errorware'])

        # Display error documents for 401, 403, 404 status codes (and

        # 500 when debug is disabled)

        if asbool(config['debug']):

            app = StatusCodeRedirect(app)

        else:

            app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])

    #enable https redirets based on HTTP_X_URL_SCHEME set by proxy

    app = HttpsFixup(app)

    # Establish the Registry for this application

    app = RegistryManager(app)

    if asbool(static_files):

        # Serve static files

        static_app = StaticURLParser(config['pylons.paths']['static_files'])

        app = Cascade([static_app, app])

    app.config = config

    return app

from celery.decorators import task

from operator import itemgetter

from pylons.i18n.translation import _

from rhodecode.lib.celerylib import run_task, locked_task

from rhodecode.lib.helpers import person

from rhodecode.lib.smtp_mailer import SmtpMailer

from rhodecode.lib.utils import OrderedDict

from time import mktime

from vcs.backends.hg import MercurialRepository

from vcs.backends.git import GitRepository

import os

import traceback

from vcs.backends import get_repo

from vcs.utils.helpers import get_scm

try:

    import json

except ImportError:

    #python 2.5 compatibility

    import simplejson as json

try:

    from celeryconfig import PYLONS_CONFIG as config

    celery_on = True

except ImportError:

    #if celeryconfig is not present let's just load our pylons

    #config instead

    from pylons import config

    celery_on = False

__all__ = ['whoosh_index', 'get_commits_stats',

           'reset_user_password', 'send_email']

def get_session():

    if celery_on:

        from sqlalchemy import engine_from_config

        from sqlalchemy.orm import sessionmaker, scoped_session

        engine = engine_from_config(dict(config.items('app:main')), 'sqlalchemy.db1.')

        sa = scoped_session(sessionmaker(bind=engine))

    else:

        #If we don't use celery reuse our current application Session

        from rhodecode.model.meta import Session

        sa = Session()

    return sa

def get_hg_settings():

    from rhodecode.model.db import RhodeCodeSettings

    sa = get_session()

    ret = sa.query(RhodeCodeSettings).all()

    if not ret:

        raise Exception('Could not get application settings !')

    settings = {}

    for each in ret:

        settings['rhodecode_' + each.app_settings_name] = each.app_settings_value

    return settings

def get_hg_ui_settings():

    from rhodecode.model.db import RhodeCodeUi

    sa = get_session()

    ret = sa.query(RhodeCodeUi).all()

    if not ret:

        raise Exception('Could not get application ui settings !')

    settings = {}

    for each in ret:

        k = each.ui_key

        v = each.ui_value

        if k == '/':

            k = 'root_path'

        if k.find('.') != -1:

            k = k.replace('.', '_')

        if each.ui_section == 'hooks':

            v = each.ui_active

        settings[each.ui_section + '_' + k] = v

    return settings

@task

@locked_task

def whoosh_index(repo_location, full_index):

    log = whoosh_index.get_logger()

    from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

    WhooshIndexingDaemon(repo_location=repo_location).run(full_index=full_index)

@task

@locked_task

def get_commits_stats(repo_name, ts_min_y, ts_max_y):

    from rhodecode.model.db import Statistics, Repository

    log = get_commits_stats.get_logger()

    author_key_cleaner = lambda k: person(k).replace('"', "") #for js data compatibilty

    commits_by_day_author_aggregate = {}

    commits_by_day_aggregate = {}

    repos_path = get_hg_ui_settings()['paths_root_path']

    p = os.path.join(repos_path, repo_name)

    skip_date_limit = True

    parse_limit = 250 #limit for single task changeset parsing optimal for

    last_rev = 0

    last_cs = None

    timegetter = itemgetter('time')

    sa = get_session()

    dbrepo = sa.query(Repository)\

        .filter(Repository.repo_name == repo_name).scalar()

    cur_stats = sa.query(Statistics)\

        .filter(Statistics.repository == dbrepo).scalar()

    if cur_stats:

        last_rev = cur_stats.stat_on_revision

    if not repo.revisions:

        return True

    if last_rev == repo.revisions[-1] and len(repo.revisions) > 1:

        #pass silently without any work if we're not on first revision or current

        #state of parsing revision(from db marker) is the last revision

        return True

    if cur_stats:

        commits_by_day_aggregate = OrderedDict(

                                       json.loads(

                                        cur_stats.commit_activity_combined))

        commits_by_day_author_aggregate = json.loads(cur_stats.commit_activity)

    log.debug('starting parsing %s', parse_limit)

    lmktime = mktime

    for cnt, rev in enumerate(repo.revisions[last_rev:]):

        last_cs = cs = repo.get_changeset(rev)

        k = '%s-%s-%s' % (cs.date.timetuple()[0], cs.date.timetuple()[1],

                          cs.date.timetuple()[2])

        timetupple = [int(x) for x in k.split('-')]

        timetupple.extend([0 for _ in xrange(6)])

        k = lmktime(timetupple)

        if commits_by_day_author_aggregate.has_key(author_key_cleaner(cs.author)):

            try:

                l = [timegetter(x) for x in commits_by_day_author_aggregate\

                        [author_key_cleaner(cs.author)]['data']]

                time_pos = l.index(k)

            except ValueError:

                time_pos = False

            if time_pos >= 0 and time_pos is not False:

                datadict = commits_by_day_author_aggregate\

                    [author_key_cleaner(cs.author)]['data'][time_pos]

                datadict["commits"] += 1

                datadict["added"] += len(cs.added)

                datadict["changed"] += len(cs.changed)

                datadict["removed"] += len(cs.removed)

            else:

                if k >= ts_min_y and k <= ts_max_y or skip_date_limit:

                    datadict = {"time":k,

                                "commits":1,

                                "added":len(cs.added),

                                "changed":len(cs.changed),

                                "removed":len(cs.removed),

                               }

                    commits_by_day_author_aggregate\

                        [author_key_cleaner(cs.author)]['data'].append(datadict)

        else:

            if k >= ts_min_y and k <= ts_max_y or skip_date_limit:

                commits_by_day_author_aggregate[author_key_cleaner(cs.author)] = {

                                    "label":author_key_cleaner(cs.author),

                                    "data":[{"time":k,

                                             "commits":1,

                                             "added":len(cs.added),

                                             "changed":len(cs.changed),

                                             "removed":len(cs.removed),

                                             }],

                                    "schema":["commits"],

                                    }

        #gather all data by day

        if commits_by_day_aggregate.has_key(k):

            commits_by_day_aggregate[k] += 1

        else:

            commits_by_day_aggregate[k] = 1

        if cnt >= parse_limit:

            #don't fetch to much data since we can freeze application

            break

    overview_data = []

    for k, v in commits_by_day_aggregate.items():

        overview_data.append([k, v])

    overview_data = sorted(overview_data, key=itemgetter(0))

    if not commits_by_day_author_aggregate:

        commits_by_day_author_aggregate[author_key_cleaner(repo.contact)] = {

            "label":author_key_cleaner(repo.contact),

            "data":[0, 1],

            "schema":["commits"],

        }

    stats = cur_stats if cur_stats else Statistics()

    stats.commit_activity = json.dumps(commits_by_day_author_aggregate)

    stats.commit_activity_combined = json.dumps(overview_data)

    log.debug('last revison %s', last_rev)

    leftovers = len(repo.revisions[last_rev:])

    log.debug('revisions to parse %s', leftovers)

    if last_rev == 0 or leftovers < parse_limit:

        stats.languages = json.dumps(__get_codes_stats(repo_name))

    stats.repository = dbrepo

    stats.stat_on_revision = last_cs.revision

    try:

        sa.add(stats)

        sa.commit()

    except:

        log.error(traceback.format_exc())

        sa.rollback()

        return False

    if len(repo.revisions) > 1:

        run_task(get_commits_stats, repo_name, ts_min_y, ts_max_y)

    return True

@task

def reset_user_password(user_email):

    log = reset_user_password.get_logger()

    from rhodecode.lib import auth

    from rhodecode.model.db import User

    try:

        try:

            sa = get_session()

            user = sa.query(User).filter(User.email == user_email).scalar()

            new_passwd = auth.PasswordGenerator().gen_password(8,

                             auth.PasswordGenerator.ALPHABETS_BIG_SMALL)

            if user:

                user.password = auth.get_crypt_password(new_passwd)

                sa.add(user)

                sa.commit()

                log.info('change password for %s', user_email)

            if new_passwd is None:

                raise Exception('unable to generate new password')

        except:

            log.error(traceback.format_exc())

            sa.rollback()

        run_task(send_email, user_email,

                 "Your new rhodecode password",

                 'Your new rhodecode password:%s' % (new_passwd))

        log.info('send new password mail to %s', user_email)

    except:

        log.error('Failed to update user password')

        log.error(traceback.format_exc())

    return True

@task

def send_email(recipients, subject, body):

    log = send_email.get_logger()

    email_config = dict(config.items('DEFAULT'))

    mail_from = email_config.get('app_email_from')

    user = email_config.get('smtp_username')

    passwd = email_config.get('smtp_password')

    mail_server = email_config.get('smtp_server')

    mail_port = email_config.get('smtp_port')

    tls = email_config.get('smtp_use_tls')

    ssl = False

    try:

        m = SmtpMailer(mail_from, user, passwd, mail_server,

                       mail_port, ssl, tls)

        m.send(recipients, subject, body)

    except:

        log.error('Mail sending failed')

        log.error(traceback.format_exc())

        return False

    return True

@task

def create_repo_fork(form_data, cur_user):

    import os

    from rhodecode.model.repo import RepoModel

    repo_model = RepoModel(get_session())

    repo_model.create(form_data, cur_user, just_db=True, fork=True)

    repos_path = get_hg_ui_settings()['paths_root_path'].replace('*', '')

    repo_path = os.path.join(repos_path, form_data['repo_name'])

    repo_fork_path = os.path.join(repos_path, form_data['fork_name'])

    MercurialRepository(str(repo_fork_path), True, clone_url=str(repo_path))

def __get_codes_stats(repo_name):

    LANGUAGES_EXTENSIONS = ['action', 'adp', 'ashx', 'asmx',

    'aspx', 'asx', 'axd', 'c', 'cfg', 'cfm', 'cpp', 'cs', 'diff', 'do', 'el',

    'erl', 'h', 'java', 'js', 'jsp', 'jspx', 'lisp', 'lua', 'm', 'mako', 'ml',

    'pas', 'patch', 'php', 'php3', 'php4', 'phtml', 'pm', 'py', 'rb', 'rst',

    's', 'sh', 'tpl', 'txt', 'vim', 'wss', 'xhtml', 'xml', 'xsl', 'xslt', 'yaws']

    repos_path = get_hg_ui_settings()['paths_root_path']

    p = os.path.join(repos_path, repo_name)

    tip = repo.get_changeset()

    code_stats = {}

    def aggregate(cs):

        for f in cs[2]:

            k = f.mimetype

            if f.extension in LANGUAGES_EXTENSIONS:

                if code_stats.has_key(k):

                    code_stats[k] += 1

                else:

                    code_stats[k] = 1

    map(aggregate, tip.walk('/'))

    return code_stats or {}

"""Helper functions

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

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

"""

from pygments.formatters import HtmlFormatter

from pygments import highlight as code_highlight

from pylons import url, app_globals as g

from pylons.i18n.translation import _, ungettext

from vcs.utils.annotate import annotate_highlight

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

#Custom helpers here :)

class _Link(object):

    '''

    Make a url based on label and url with help of url_for

    :param label:name of link    if not defined url is used

    :param url: the url for link

    '''

    def __call__(self, label='', *url_, **urlargs):

        if label is None or '':

            label = url

        link_fn = link_to(label, url(*url_, **urlargs))

        return link_fn

link = _Link()

class _GetError(object):

    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()

def recursive_replace(str, replace=' '):

    """

    Recursive replace of given sign to just one instance

    :param str: given string

    :param replace:char to find and replace multiple instances

    Examples::

    >>> recursive_replace("Mighty---Mighty-Bo--sstones",'-')

    'Mighty-Mighty-Bo-sstones'

    """

    if str.find(replace * 2) == -1:

        return str

    else:

        str = str.replace(replace * 2, replace)

        return recursive_replace(str, replace)

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 wrap_paragraphs(escape(tooltip_title), trim_at)\

                       .replace('\n', '<br/>')

    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 not have and id autgenerate 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(),

                monitorresize:false,

                xyoffset :[0,0],

                autodismissdelay:300000,

                hidedelay:5,

                showdelay:20,

            });

            //Mouse Over event disabled for new repositories since they dont

            //have last commit message

            myToolTips.contextMouseOverEvent.subscribe(

                function(type, args) {

                    var context = args[0];

                    var txt = context.getAttribute('tooltip_title');

                    if(txt){                                       

                        return true;

                    }

                    else{

                        return false;

                    }

                });

            // Set the text for the tooltip just before we display it. Lazy method

            myToolTips.contextTriggerEvent.subscribe( 

                 function(type, args) { 

                        var context = args[0]; 

                        var txt = context.getAttribute('tooltip_title');

                        this.cfg.setProperty("text", txt);

                        // positioning of tooltip

                        var tt_w = this.element.clientWidth;

                        var tt_h = this.element.clientHeight;

                        var context_w = context.offsetWidth;

                        var context_h = context.offsetHeight;

                        var pos_x = YAHOO.util.Dom.getX(context);

                        var pos_y = YAHOO.util.Dom.getY(context);

                        var display_strategy = 'top';

                        var xy_pos = [0,0];

                        switch (display_strategy){

                            case 'top':

                                var cur_x = (pos_x+context_w/2)-(tt_w/2);

                                var cur_y = pos_y-tt_h-4;

                                xy_pos = [cur_x,cur_y];                                

                                break;

                            case 'bottom':

                                var cur_x = (pos_x+context_w/2)-(tt_w/2);

                                var cur_y = pos_y+context_h+4;

                                xy_pos = [cur_x,cur_y];                                

                                break;

                            case 'left':

                                var cur_x = (pos_x-tt_w-4);

                                var cur_y = pos_y-((tt_h/2)-context_h/2);

                                xy_pos = [cur_x,cur_y];                                

                                break;

                            case 'right':

                                var cur_x = (pos_x+context_w+4);

                                var cur_y = pos_y-((tt_h/2)-context_h/2);

                                xy_pos = [cur_x,cur_y];                                

                                break;

                             default:

                                var cur_x = (pos_x+context_w/2)-(tt_w/2);

                                var cur_y = pos_y-tt_h-4;

                                xy_pos = [cur_x,cur_y];                                

                                break;                             

                        }

                        this.cfg.setProperty("xy",xy_pos);

                  });

            //Mouse out 

            myToolTips.contextMouseOutEvent.subscribe(

                function(type, args) {

                    var context = args[0];

                });

        });

        '''

        return literal(js)

tooltip = _ToolTip()

class _FilesBreadCrumbs(object):

    def __call__(self, repo_name, rev, 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, 1):

            if p != '':

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

                                            repo_name=repo_name,

                                            revision=rev,

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

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

files_breadcrumbs = _FilesBreadCrumbs()

class CodeHtmlFormatter(HtmlFormatter):

    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, 1):

            i, t = it

            t = '<div id="#S-%s">%s</div>' % (cnt, t)

            yield i, t

def pygmentize(filenode, **kwargs):

    """

    pygmentize function using pygments

    :param filenode:

    """

    return literal(code_highlight(filenode.content,

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

def pygmentize_annotation(filenode, **kwargs):

    """

    pygmentize function for annotation

    :param filenode:

    """

    color_dict = {}

    def gen_color():

        """generator for getting 10k of evenly distibuted colors using hsv color

        and golden ratio.

        """

        import colorsys

        n = 10000

        golden_ratio = 0.618033988749895

        h = 0.22717784590367374

        #generate 10k nice web friendly colors in the same order

        for c in xrange(n):

            h += golden_ratio

            h %= 1

            HSV_tuple = [h, 0.95, 0.95]

            RGB_tuple = colorsys.hsv_to_rgb(*HSV_tuple)

            yield map(lambda x:str(int(x * 256)), RGB_tuple)

    cgenerator = gen_color()

    def get_color_string(cs):

        if color_dict.has_key(cs):

            col = color_dict[cs]

        else:

            col = color_dict[cs] = cgenerator.next()

        return "color: rgb(%s)! important;" % (', '.join(col))

    def url_func(changeset):

        tooltip_html = "<div style='font-size:0.8em'><b>Author:</b>" + \

        " %s<br/><b>Date:</b> %s</b><br/><b>Message:</b> %s<br/></div>"

        tooltip_html = tooltip_html % (changeset.author,

                                               changeset.date,

                                               tooltip(changeset.message))

        lnk_format = 'r%-5s:%s' % (changeset.revision,

                                 changeset.short_id)

        uri = link_to(

                lnk_format,

                url('changeset_home', repo_name=changeset.repository.name,

                    revision=changeset.short_id),

                style=get_color_string(changeset.short_id),

                class_='tooltip',

                tooltip_title=tooltip_html

              )

        uri += '\n'

        return uri

    return literal(annotate_highlight(filenode, url_func, **kwargs))

def repo_name_slug(value):

    """Return slug of name of repository

    This function is called on each creation/modification

    of repository to prevent bad names in repo

    """

    slug = remove_formatting(value)

    slug = strip_tags(slug)

    for c in """=[]\;'"<>,/~!@#$%^&*()+{}|: """:

        slug = slug.replace(c, '-')

    slug = recursive_replace(slug, '-')

    slug = collapse(slug, '-')

    return slug

def get_changeset_safe(repo, rev):

    from vcs.backends.base import BaseRepository

    from vcs.exceptions import RepositoryError

    if not isinstance(repo, BaseRepository):

        raise Exception('You must pass an Repository '

                        'object as first argument got %s', type(repo))

    try:

        cs = repo.get_changeset(rev)

    except RepositoryError:

        from rhodecode.lib.utils import EmptyChangeset

        cs = EmptyChangeset()

    return cs

flash = _Flash()

# MERCURIAL FILTERS available via h.

from mercurial import util

capitalize = lambda x: x.capitalize()

email = util.email

email_or_none = lambda x: util.email(x) if util.email(x) != x else None

person = lambda x: _person(x)

# PERMS

from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \

HasRepoPermissionAny, HasRepoPermissionAll

# GRAVATAR URL

import hashlib

import urllib

from pylons import request

def gravatar_url(email_address, size=30):

    ssl_enabled = 'https' == request.environ.get('HTTP_X_URL_SCHEME')

    default = 'identicon'

    baseurl_nossl = "http://www.gravatar.com/avatar/"

    baseurl_ssl = "https://secure.gravatar.com/avatar/"

    baseurl = baseurl_ssl if ssl_enabled else baseurl_nossl

    # construct the url

    gravatar_url = baseurl + hashlib.md5(email_address.lower()).hexdigest() + "?"

    gravatar_url += urllib.urlencode({'d':default, 's':str(size)})

    return gravatar_url

def safe_unicode(str):

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

    unicode with errors replace, if this failes we return unicode with 

    string_escape decoding """

    try:

        u_str = unicode(str)

    except UnicodeDecodeError:

        try:

            u_str = unicode(str, 'utf-8', 'replace')

        except UnicodeDecodeError:

            #incase we have a decode error just represent as byte string

            u_str = unicode(str(str).encode('string_escape'))

    return u_str

#!/usr/bin/env python

# encoding: utf-8

# middleware to handle git api calls

# Copyright (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>

#

# 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; version 2

# of the License or (at your opinion) any later version of the license.

# 

# 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, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.