# -*- coding: utf-8 -*-
"""WSGI middleware initialization for the {{project}} application."""

import tempfile
import warnings

import tg
from repoze.retry import Retry
import MySQLdb
import sqlalchemy.exc

from bazjunk.middleware.email import EmailErrors
from bazjunk.middleware.mako import CatchMakoErrors
from bazjunk.middleware.raw import PrintRawErrors
from bazjunk.middleware.cgitb import CgitbMiddleware
from bazjunk.middleware.rewrite import UnrewriteMiddleware
from bazjunk.middleware.environ import SaveEnviron
from bazjunk.middleware.profiler import OptionalProfileMiddleware
from bazki.turbogears import wrap_app, render_html_error
from bazki import util

from {{package}}.config.app_cfg import base_config
from {{package}}.config.environment import load_environment


__all__ = ['make_app']

def make_app(global_conf, full_stack=True, **app_conf):
    """
    Set {{project}} up with the settings found in the PasteDeploy configuration
    file used.
    
    :param global_conf: The global settings for {{project}} (those
        defined under the ``[DEFAULT]`` section).
    :type global_conf: dict
    :param full_stack: Should the whole TG2 stack be set up?
    :type full_stack: str or bool
    :return: The {{project}} application with all the relevant middleware
        loaded.
    
    This is the PasteDeploy factory for the {{project}} application.
    
    ``app_conf`` contains all the application-specific settings (those defined
    under ``[app:main]``.
    """

    # This probably shouldn't properly be here, but it works as well here
    # as anywhere.
    warnings.showwarning = util.showwarning
    util.filterwarnings()

    # Use base_config to setup the necessary PasteDeploy application factory. 
    # make_base_app will wrap the TG2 app with all the middleware it needs. 
    make_base_app = base_config.setup_tg_wsgi_app(load_environment)

    # Turn off full_stack because default debug middleware in some versions
    # breaks with fastcgi, and we want mako and latex errors handled 
    # specifically, and generally errors shown for Admins but mailed for 
    # others.
    app = make_base_app(global_conf, full_stack=False, 
                        wrap_app=lambda a:wrap_app(a,base_config),
                        **app_conf)
    
    # Retry failed transactions.
    app = Retry(app, tries=3, retryable=(MySQLdb.OperationalError,
                                         sqlalchemy.exc.OperationalError))

    # This tempfile actually gets cleaned up by the middleware at __del__ time.
    app = OptionalProfileMiddleware(
        app,
        log_filename=tempfile.mkstemp('.bazki.profile')[1],
        discard_first_request=True,
        flush_at_shutdown=True,
        path='/profile')

    # Take the effects of our mod_rewrite rules, if we're running under Apache
    app = UnrewriteMiddleware(app, {'dispatch.fcgi':'',
                                    'dispatch.cgi':'dev'})

    # Send email on errors.
    app = EmailErrors(app, from_addr=global_conf['error_email_from'],
                      to_addr=global_conf['email_to'],
                      subject_prefix=global_conf['error_subject_prefix'],
                      smtp_server=global_conf['smtp_server'])
    # Handle mako errors specially
    # (bazki.auth disables these first two for non-omnicients by only setting
    #  'bazjunk.catch_errors' to true in the wsgi environ for omniscients.)
    app = CatchMakoErrors(app)
    # And TeXFailedErrors
    from bazki.latex import TeXFailedError
    app = PrintRawErrors(app, TeXFailedError)
    # And handle other errors with cgitb for omniscients or an html page
    # for others.
    app = CgitbMiddleware(app, gen_html=render_html_error)
    
    return app