import logging

import os

import time

import formencode

import pytest

from paste.deploy import loadwsgi

from pytest_localserver.http import WSGIServer

from routes.util import URLGenerator

from tg.util.webtest import test_context

import kallithea.tests.base  # FIXME: needed for setting testapp instance!!!

from kallithea.controllers.root import RootController

from kallithea.lib import inifile

from kallithea.lib.utils import repo2db_mapper

from kallithea.model import db, meta

from kallithea.model.scm import ScmModel

from kallithea.model.user import UserModel

from kallithea.tests.base import TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS, TEST_USER_REGULAR_LOGIN, TESTS_TMP_PATH, invalidate_all_caches

from kallithea.tests.fixture import create_test_env, create_test_index

def pytest_configure():

    os.environ['TZ'] = 'UTC'

    if not kallithea.is_windows:

        time.tzset() # only available on Unix

    # Disable INFO logging of test database creation, restore with NOTSET

    logging.disable(logging.INFO)

    ini_settings = {

        '[server:main]': {

            'port': '4999',

        },

        '[app:main]': {

            'ssh_enabled': 'true',

            # Mainly to safeguard against accidentally overwriting the real one:

            'ssh_authorized_keys': os.path.join(TESTS_TMP_PATH, 'authorized_keys'),

            #'ssh_locale': 'C',

            'app_instance_uuid': 'test',

            'show_revision_number': 'true',

            'session.secret': '{74e0cd75-b339-478b-b129-07dd221def1f}',

            #'i18n.lang': '',

        },

        '[handler_console]': {

            'formatter': 'color_formatter',

        },

        # The 'handler_console_sql' block is very similar to the one in

        # development.ini, but without the explicit 'level=DEBUG' setting:

        # it causes duplicate sqlalchemy debug logs, one through

        # handler_console_sql and another through another path.

        '[handler_console_sql]': {

            'formatter': 'color_formatter_sql',

        },

    }

    create_database = os.environ.get('TEST_DB')  # TODO: rename to 'CREATE_TEST_DB'

    if create_database:

        ini_settings['[app:main]']['sqlalchemy.url'] = create_database

    reuse_database = os.environ.get('REUSE_TEST_DB')

    if reuse_database:

        ini_settings['[app:main]']['sqlalchemy.url'] = reuse_database

    test_ini_file = os.path.join(TESTS_TMP_PATH, 'test.ini')

    inifile.create(test_ini_file, None, ini_settings)

    context = loadwsgi.loadcontext(loadwsgi.APP, 'config:%s' % test_ini_file)

    # set KALLITHEA_NO_TMP_PATH=1 to disable re-creating the database and test repos

    if not int(os.environ.get('KALLITHEA_NO_TMP_PATH', 0)):

        create_test_env(TESTS_TMP_PATH, context.config(), reuse_database=bool(reuse_database))

    # set KALLITHEA_WHOOSH_TEST_DISABLE=1 to disable whoosh index during tests

    if not int(os.environ.get('KALLITHEA_WHOOSH_TEST_DISABLE', 0)):

        create_test_index(TESTS_TMP_PATH, context.config(), True)

    kallithea.tests.base.testapp = context.create()

    # do initial repo scan

    repo2db_mapper(ScmModel().repo_scan(TESTS_TMP_PATH))

    logging.disable(logging.NOTSET)

    kallithea.tests.base.url = URLGenerator(RootController().mapper, {'HTTP_HOST': 'example.com'})

    # set fixed language for form messages, regardless of environment settings

    formencode.api.set_stdtranslation(languages=[])

@pytest.fixture

def create_test_user():

    """Provide users that automatically disappear after test is over."""

    test_user_ids = []

    def _create_test_user(user_form):

        user = UserModel().create(user_form)

        test_user_ids.append(user.user_id)

        return user

    yield _create_test_user

    for user_id in test_user_ids:

        UserModel().delete(user_id)

    meta.Session().commit()

def _set_settings(*kvtseq):

    session = meta.Session()

    for kvt in kvtseq:

        assert len(kvt) in (2, 3)

        k = kvt[0]

        v = kvt[1]

        t = kvt[2] if len(kvt) == 3 else 'unicode'

        db.Setting.create_or_update(k, v, t)

    session.commit()

@pytest.fixture

def set_test_settings():

    """Restore settings after test is over."""

    # Save settings.

    settings_snapshot = [

        (s.app_settings_name, s.app_settings_value, s.app_settings_type)

        for s in db.Setting.query().all()]

    yield _set_settings

    # Restore settings.

    session = meta.Session()