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

# 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/>.

"""WSGI middleware initialization for the Kallithea application."""

import logging.config

from kallithea.config.app_cfg import base_config

from kallithea.config.environment import load_environment

__all__ = ['make_app']

# Use base_config to setup the necessary PasteDeploy application factory.

# make_base_app will wrap the TurboGears2 app with all the middleware it needs.

make_base_app = base_config.setup_tg_wsgi_app(load_environment)

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

    """

    Set up Kallithea with the settings found in the PasteDeploy configuration

    file used.

    :param global_conf: The global settings for Kallithea (those

        defined under the ``[DEFAULT]`` section).

    :type global_conf: dict

    :param full_stack: Should the whole TurboGears2 stack be set up?

    :type full_stack: str or bool

    :return: The Kallithea application with all the relevant middleware

        loaded.

    This is the PasteDeploy factory for the Kallithea application.

    ``app_conf`` contains all the application-specific settings (those defined

    under ``[app:main]``.

    """

    logging.config.fileConfig(global_conf['__file__'])

"""

import os

import sys

import logging.config

import paste.deploy

import gearbox.command

from tg import config

import kallithea.config.middleware

import kallithea.model.base

import kallithea.lib.utils2

import kallithea.lib.utils

def ask_ok(prompt, retries=4, complaint='Yes or no please!'):

    while True:

        ok = raw_input(prompt)

        if ok in ('y', 'ye', 'yes'):

            return True

        if ok in ('n', 'no', 'nop', 'nope'):

            return False

        retries = retries - 1

        if retries < 0:

            raise IOError

        print complaint

class BasePasterCommand(gearbox.command.Command):

    """

    Abstract Base Class for gearbox commands.

    """

    # override to control how much get_parser and run should do:

    takes_config_file = True

    requires_db_session = True

    def run(self, args):

        """

        Overrides Command.run

        If needed by the command, read config file and initialize database before running.

        """

        if self.takes_config_file:

            path_to_ini_file = os.path.realpath(args.config_file)

            conf = paste.deploy.appconfig('config:' + path_to_ini_file)

            logging.config.fileConfig(path_to_ini_file)

            if self.requires_db_session:

                kallithea.lib.utils.setup_cache_regions(config)

                engine = kallithea.lib.utils2.engine_from_config(config, 'sqlalchemy.')

                kallithea.model.base.init_model(engine)

        return super(BasePasterCommand, self).run(args)

    def get_parser(self, prog_name):

        parser = super(BasePasterCommand, self).get_parser(prog_name)

        if self.takes_config_file:

            parser.add_argument("-c", "--config",

                help='Kallithea .ini file with configuration of database etc',

                dest='config_file', required=True)

        return parser

    def error(self, msg, exitcode=1):

        """Write error message and exit"""

        sys.stderr.write('%s\n' % msg)

        raise SystemExit(exitcode)