# -*- coding: utf-8 -*-
"""Main Controller"""
import os

from tg import expose, flash, require, url, request, redirect
from pylons.i18n import ugettext as _, lazy_ugettext as l_
from repoze.what import predicates

import bazki
{{if bazkitype != 'bazki'}}
import {{bazkitype}}
{{endif}}
{{for ei in extra_imports.split(';')}}
{{ei}}
{{endfor}}

from {{package}}.lib.base import BaseController
from {{package}}.model import DBSession, metadata
from {{package}}.controllers.error import ErrorController
from {{package}} import model
from {{package}}.controllers.secure import SecureController

__all__ = ['RootController']


class RootController(BaseController):
    """
    The root controller for the {{project}} application.
    
    All the other controllers and WSGI applications should be mounted on this
    controller. For example::
    
        panel = ControlPanelController()
        another_app = AnotherWSGIApplication()
    
    Keep in mind that WSGI applications shouldn't be mounted directly: They
    must be wrapped around with :class:`tg.controllers.WSGIAppController`.
    
    """
    secc = SecureController()
    
    edit = bazki.Edit()
    edit.allow_only = bazki.custom.OMNISCIENT_PRED

    @expose(content_type='text/plain')
    @require(bazki.custom.EDITOR_PRED)
    def restart(self):
        fcgi = os.path.join(
            os.path.dirname(os.path.dirname(os.path.dirname(__file__))),
            'webroot', 'dispatch.fcgi')
        os.utime(fcgi, None)
        return "Restarting."

    _default = {{bazkitype}}.Getter()
    bazki = bazki.Static()
    {{for ec in extra_controllers.split(';')}}
    {{ec}}
    {{endfor}}
    
    # These shouldn't be necessary, but TG2 doesn't allow default to be a
    # controller, but only a method, so this is necessary.  We also use this
    # lookup method to allow for methods like 'print_', since it's hard to
    # have a print method since it's a keyword.
    @expose()
    def _lookup(self, *remainder):
        if hasattr(self, remainder[0]+'_'):
            return getattr(self, remainder[0]+'_'), list(remainder[1:])
        else:
            return self._default, list(remainder)
    @expose()
    def index(self):
        return self._default._default()

    error = ErrorController()

    @expose('mako:{{package}}.templates.login')
    def login(self, came_from='/'):
        """Start the user login."""
        login_counter = request.environ['repoze.who.logins']
        if login_counter > 0:
            flash(_('Wrong credentials'), 'warning')
        return dict(page='login', login_counter=str(login_counter),
                    came_from=came_from)
    
    @expose()
    def post_login(self, came_from='/'):
        """
        Redirect the user to the initially requested page on successful
        authentication or redirect her back to the login page if login failed.
        
        """
        if not request.identity:
            login_counter = request.environ['repoze.who.logins'] + 1
            redirect('/login', dict(came_from=came_from, 
                                    __logins=login_counter))
        userid = request.identity['repoze.who.userid']
        flash(_('Welcome back, %s!') % userid)
        redirect(came_from)

    @expose()
    def post_logout(self, came_from='/'):
        """
        Redirect the user to the initially requested page on logout and say
        goodbye as well.
        
        """
        flash(_('We hope to see you soon!'))
        redirect(came_from)