"""The base Controller API

Provides the BaseController class for subclassing.

"""

from pylons import config, tmpl_context as c, request, session

from pylons.controllers import WSGIController

from pylons.templating import render_mako as render

from rhodecode import __version__

from rhodecode.lib import auth

from rhodecode.lib.utils import get_repo_slug

from rhodecode.model import meta

from rhodecode.model.scm import ScmModel

from rhodecode import BACKENDS

class BaseController(WSGIController):

    def __before__(self):

        c.rhodecode_version = __version__

        c.rhodecode_name = config['rhodecode_title']

        c.repo_name = get_repo_slug(request)

        c.cached_repo_list = ScmModel().get_repos()

        c.backends = BACKENDS.keys()

        if c.repo_name:

            cached_repo = scm_model.get(c.repo_name)

            if cached_repo:

                c.repository_tags = cached_repo.tags

                c.repository_branches = cached_repo.branches

                c.repository_followers = scm_model.get_followers(cached_repo.dbrepo.repo_id)

                c.repository_forks = scm_model.get_forks(cached_repo.dbrepo.repo_id)

            else:

                c.repository_tags = {}

                c.repository_branches = {}

                c.repository_followers = 0

                c.repository_forks = 0

    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 every time

            self.rhodecode_user = c.rhodecode_user = auth.get_user(session)

            return WSGIController.__call__(self, environ, start_response)

        finally:

            meta.Session.remove()

           if particular attributes have been configured.

           Note that this approach does *not* detach the loaded objects from

           the current session. If the cache backend is an in-process cache

           (like "memory") and lives beyond the scope of the current session's

           transaction, those objects may be expired. The method here can be

           modified to first expunge() each loaded item from the current

           session before returning the list of items, so that the items

           in the cache are not the same ones in the current Session.

        """

        if hasattr(self, '_cache_parameters'):

            return self.get_value(createfunc=lambda: list(Query.__iter__(self)))

        else:

            return Query.__iter__(self)

    def invalidate(self):

        """Invalidate the value represented by this Query."""

        cache, cache_key = _get_cache_parameters(self)

        cache.remove(cache_key)

    def get_value(self, merge=True, createfunc=None):

        """Return the value from the cache for this query.

        Raise KeyError if no value present and no

        createfunc specified.

        """

        cache, cache_key = _get_cache_parameters(self)

        ret = cache.get_value(cache_key, createfunc=createfunc)

        if merge:

            ret = self.merge_result(ret, load=False)

        return ret

    def set_value(self, value):

        """Set the value in the cache for this query."""

        cache, cache_key = _get_cache_parameters(self)

        cache.put(cache_key, value)        

def query_callable(manager):

    def query(*arg, **kw):

        return CachingQuery(manager, *arg, **kw)

    return query

def get_cache_region(name, region):

    if region not in beaker.cache.cache_regions:

            'Check if proper cache settings are in the .ini files' % region)

    kw = beaker.cache.cache_regions[region]

    return beaker.cache.Cache._get_cache(name, kw)

def _get_cache_parameters(query):

    """For a query with cache_region and cache_namespace configured,

    return the correspoinding Cache instance and cache key, based

    on this query's current criterion and parameter values.

    """

    if not hasattr(query, '_cache_parameters'):

        raise ValueError("This Query does not have caching parameters configured.")

    region, namespace, cache_key = query._cache_parameters

    namespace = _namespace_from_query(namespace, query)

    if cache_key is None:

        # cache key - the value arguments from this query's parameters.

        args = _params_from_query(query)

        cache_key = " ".join([str(x) for x in args])

    # get cache

    #cache = query.cache_manager.get_cache_region(namespace, region)

    cache = get_cache_region(namespace, region)

    # optional - hash the cache_key too for consistent length

    # import uuid

    # cache_key= str(uuid.uuid5(uuid.NAMESPACE_DNS, cache_key))

    return cache, cache_key

def _namespace_from_query(namespace, query):

    # cache namespace - the token handed in by the 

    # option + class we're querying against

    namespace = " ".join([namespace] + [str(x) for x in query._entities])

    # memcached wants this

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

    return namespace

def _set_cache_parameters(query, region, namespace, cache_key):

    if hasattr(query, '_cache_parameters'):

        region, namespace, cache_key = query._cache_parameters

        raise ValueError("This query is already configured "

                        "for region %r namespace %r" % 

                        (region, namespace)

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

"""

    package.rhodecode.model.scm

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

    scm model for RhodeCode 

    :created_on: Apr 9, 2010

    :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; 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.

import os

import time

import traceback

import logging

from vcs import get_backend

from vcs.utils.helpers import get_scm

from vcs.exceptions import RepositoryError, VCSError

from vcs.utils.lazy import LazyProperty

from mercurial import ui

from beaker.cache import cache_region, region_invalidate

from rhodecode import BACKENDS

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import HasRepoPermissionAny

from rhodecode.lib.utils import get_repos, make_ui, action_logger

from rhodecode.model import BaseModel

from rhodecode.model.user import UserModel

from rhodecode.model.db import Repository, RhodeCodeUi, CacheInvalidation, \

from rhodecode.model.caching_query import FromCache

from sqlalchemy.orm import joinedload

from sqlalchemy.orm.session import make_transient

from sqlalchemy.exc import DatabaseError

log = logging.getLogger(__name__)

class UserTemp(object):

    def __init__(self, user_id):

        self.user_id = user_id

class RepoTemp(object):

    def __init__(self, repo_id):

        self.repo_id = repo_id

class ScmModel(BaseModel):

    """

    Mercurial Model

    """

    @LazyProperty

    def repos_path(self):

        """

        Get's the repositories root path from database

        """

        q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()

        return q.ui_value

    def repo_scan(self, repos_path, baseui):

        """

        Listing of repositories in given path. This path should not be a 

        repository itself. Return a dictionary of repository objects

        :param repos_path: path to directory containing repositories

        :param baseui

        """

        log.info('scanning for repositories in %s', repos_path)

        if not isinstance(baseui, ui.ui):

            baseui = make_ui('db')

        repos_list = {}

        for name, path in get_repos(repos_path):

            try:

                if repos_list.has_key(name):

                    raise RepositoryError('Duplicate repository name %s '

        if f is not None:

            try:

                self.sa.delete(f)

                self.sa.commit()

                return

            except:

                log.error(traceback.format_exc())

                self.sa.rollback()

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            f.follows_user_id = follow_user_id

            self.sa.add(f)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def is_following_repo(self, repo_name, user_id):

        r = self.sa.query(Repository)\

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

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_repository == r)\

            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None

    def is_following_user(self, username, user_id):

        u = UserModel(self.sa).get_by_username(username)

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_user == u)\

            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None

    def get_followers(self, repo_id):

        return self.sa.query(UserFollowing)\

                .filter(UserFollowing.follows_repo_id == repo_id).count()

    def get_forks(self, repo_id):

        return self.sa.query(Repository)\

                .filter(Repository.fork_id == repo_id).count()

    def _should_invalidate(self, repo_name):

        """

        Looks up database for invalidation signals for this repo_name

        :param repo_name:

        """

        ret = self.sa.query(CacheInvalidation)\

            .options(FromCache('sql_cache_short',

                           'get_invalidation_%s' % repo_name))\

            .filter(CacheInvalidation.cache_key == repo_name)\

            .filter(CacheInvalidation.cache_active == False)\

            .scalar()

        return ret

    def _mark_invalidated(self, cache_key):

        """

        Marks all occurences of cache to invaldation as already invalidated

        :param repo_name:

        """

        if cache_key:

            log.debug('marking %s as already invalidated', cache_key)

        try:

            cache_key.cache_active = True

            self.sa.add(cache_key)

            self.sa.commit()

        except (DatabaseError,):

            log.error(traceback.format_exc())

            self.sa.rollback()

position:absolute;

background:#FFF;

margin:7px 0 0 162px;

padding:0;

}

div.options a {

height:1%;

display:block;

text-decoration:none;

margin:0;

padding:3px 8px;

}

.top-left-rounded-corner {

-webkit-border-top-left-radius: 8px;

-khtml-border-radius-topleft: 8px; 

-moz-border-radius-topleft: 8px;

border-top-left-radius: 8px;

}

.top-right-rounded-corner {

-webkit-border-top-right-radius: 8px;

-khtml-border-radius-topright: 8px;    

-moz-border-radius-topright: 8px;

border-top-right-radius: 8px;

}

.bottom-left-rounded-corner {

-webkit-border-bottom-left-radius: 8px;

-khtml-border-radius-bottomleft: 8px;  

-moz-border-radius-bottomleft: 8px;

border-bottom-left-radius: 8px;

}

.bottom-right-rounded-corner {

-webkit-border-bottom-right-radius: 8px;

-khtml-border-radius-bottomright: 8px; 

-moz-border-radius-bottomright: 8px;

border-bottom-right-radius: 8px;

}

#header {

margin:0;

padding:0 30px;

}

#header ul#logged-user li {

list-style:none;

float:left;

}

#header ul#logged-user li.first {

border-left:none;

}

#header ul#logged-user li.first div.account {

padding-top:4px;

float:left;

}

#header ul#logged-user li.last {

border-right:none;

}

#header ul#logged-user li a {

font-weight:700;

text-decoration:none;

}

#header ul#logged-user li a:hover {

text-decoration:underline;

}

#header ul#logged-user li.highlight a {

color:#fff;

}

#header ul#logged-user li.highlight a:hover {

}

#header #header-inner {

height:40px;

clear:both;

position:relative;

background:#003367 url("../images/header_inner.png") repeat-x;

border-bottom:2px solid #fff;

margin:0;

padding:0;

}

#header #header-inner #home a {

height:40px;

width:46px;

display:block;

background:url("../images/button_home.png");

background-position:0 0;

margin:0;

padding:0;

}

#header #header-inner #home a:hover {

background-position:0 -40px;

}

#header #header-inner #logo h1 {

color:#FFF;

font-size:18px;

margin:10px 0 0 13px;

padding:0;

}

#header #header-inner #logo a {

color:#fff;

text-decoration:none;

}

#header #header-inner #logo a:hover {

color:#bfe3ff;

}

#header #header-inner #quick,#header #header-inner #quick ul {

position:relative;

float:right;

list-style-type:none;

list-style-position:outside;

margin:10px 5px 0 0;

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

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" id="mainhtml">

<head>

    <title>${next.title()}</title>

    <link rel="icon" href="/images/icons/database_gear.png" type="image/png" />

    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />

    <meta name="robots" content="index, nofollow"/>

    <!-- stylesheets -->

    ${self.css()}

    <!-- scripts -->

    ${self.js()}

</head>

<body>

    <!-- header -->

    <div id="header">

        <!-- user -->

        <ul id="logged-user">

	            <li class="first">

	                <div class="account">

	                </div>  

	            </li>

            <li class="last highlight">${h.link_to(u'Login',h.url('login_home'))}</li>

	        %else:

            %endif

        </ul>

        <!-- end user -->

        <div id="header-inner" class="title top-left-rounded-corner top-right-rounded-corner">

            <!-- logo -->

            <div id="logo">

                <h1><a href="${h.url('home')}">${c.rhodecode_name}</a></h1>

            </div>

            <!-- end logo -->

            <!-- menu -->

            ${self.page_nav()}

            <!-- quick -->

        </div>

    </div>     

    <!-- end header -->

	<!-- CONTENT -->

	<div id="content"> 

        <div class="flash_msg">

            <% messages = h.flash.pop_messages() %>

            % if messages:

            <ul id="flash-messages">

                % for message in messages:

                <li class="${message.category}_msg">${message}</li>

                % endfor

            </ul>

            % endif

        </div>	    

	    <div id="main"> 

	        ${next.main()}

	    </div>

	</div> 

    <!-- END CONTENT -->

	<!-- footer -->

	<div id="footer">

	   <div id="footer-inner" class="title bottom-left-rounded-corner bottom-right-rounded-corner">

	       <div>

	           <p class="footer-link">${h.link_to(_('Submit a bug'),h.url('bugtracker'))}</p>

		       <p class="footer-link">${h.link_to(_('GPL license'),h.url('gpl_license'))}</p>

		       <p>RhodeCode ${c.rhodecode_version} &copy; 2010 by Marcin Kuzminski</p>

	       </div>

	   </div>

        <script type="text/javascript">${h.tooltip.activate()}</script>

	</div>

	<!-- end footer -->

</body>

</html>