# -*- coding: utf-8 -*-
from django.apps import apps
from django.core.exceptions import ImproperlyConfigured
from django.test import SimpleTestCase
from django.urls import URLResolver

from ..config.apps import DefaultSetting, AppSettings, AppConfig
from ..config.modules import ModuleMeta
from ..apps import AppConfig as RealAppConfig

TEST_SETTING_VALUE = 'do not change this value'


class DefaultSettingTestCase(SimpleTestCase):
    def test_key_name(self):
        name = 'somename'
        key_name = 'SoMeKeY'

        setting = DefaultSetting(name, None)
        self.assertEqual(setting.key_name, name.upper())

        setting = DefaultSetting(name, None, key_name=key_name)
        self.assertEqual(setting.key_name, key_name)

    def test_validate(self):
        name = 'somename'

        setting = DefaultSetting(name, None, validator=None)
        try:
            setting.validate(False)
        except ImproperlyConfigured:  # pragma: no cover
            self.fail('Disabled validation validated invalid :(')

        def callable_validator(value):
            return (value % 2) == 0

        valid_values = (2, 4)
        invalid_values = (3, 5)

        setting = DefaultSetting(name, None, validator=callable_validator)
        for val in valid_values:
            try:
                setting.validate(val)
            except ImproperlyConfigured:  # pragma: no cover
                self.fail('Callable validated valid value invalid :(')

        for val in invalid_values:
            with self.assertRaises(ImproperlyConfigured):
                setting.validate(val)

        re_validator = r'[a-z]'

        valid_values = 'aocd'
        invalid_values = 'Aö1.'

        setting = DefaultSetting(name, None, validator=re_validator)
        for val in valid_values:
            try:
                setting.validate(val)
            except ImproperlyConfigured:  # pragma: no cover
                self.fail('Regular Expression validated valid value invalid :(')

        for val in invalid_values:
            with self.assertRaises(ImproperlyConfigured):
                setting.validate(val)


class AppSettingsTestCase(SimpleTestCase):
    def setUp(self):
        self.app_name = 'dav_base'
        self.test_setting_value = TEST_SETTING_VALUE

    def test_no_settings_file(self):
        """Test that nothing bad happens if no settings file can be read"""
        app_settings = AppSettings('', ())
        self.assertIsInstance(app_settings, AppSettings)

    def test_defaults(self):
        """Test the default value for optional and unset settings"""
        default_settings = (
            DefaultSetting('no_test_setting', 1),
            DefaultSetting('no_test_setting_2', 2),
        )
        app_settings = AppSettings(self.app_name, default_settings)
        self.assertEqual(app_settings.no_test_setting, 1)
        self.assertEqual(app_settings.no_test_setting_2, 2)

    def test_improperlyconfigured_by_class(self):
        """Test if mandatory but unset setting raise correct exception"""
        default_settings = (
            DefaultSetting('no_test_setting', ImproperlyConfigured),
        )
        with self.assertRaisesRegex(ImproperlyConfigured, 'NO_TEST_SETTING must be defined in main.settings-dav_base'):
            _ = AppSettings(self.app_name, default_settings)

    def test_improperlyconfigured_by_instance(self):
        """Test if mandatory but unset setting raise correct exception"""
        default_settings = (
            DefaultSetting('no_test_setting', ImproperlyConfigured('Some Error Message')),
        )
        with self.assertRaisesRegex(ImproperlyConfigured, 'Some Error Message'):
            _ = AppSettings(self.app_name, default_settings)

    def test_improperlyconfigured_by_func(self):
        """Test if invalid setting raise correct exception"""
        def validator(value):  # pylint: disable=unused-argument
            return False
        default_settings = (
            DefaultSetting('test_setting', 1, validator=validator),
        )
        with self.assertRaises(ImproperlyConfigured):
            _ = AppSettings(self.app_name, default_settings)

    def test_improperlyconfigured_by_regex(self):
        """Test if invalid setting raise correct exception"""
        default_settings = (
            DefaultSetting('test_setting', 1, validator=r'^[01]$'),
        )
        with self.assertRaises(ImproperlyConfigured):
            _ = AppSettings(self.app_name, default_settings)

    def test_settings_from_file(self):
        """Test if value from settings file eliminate exception"""
        default_settings = (
            DefaultSetting('test_setting', ImproperlyConfigured),
        )
        app_settings = AppSettings(self.app_name, default_settings)
        self.assertEqual(app_settings.test_setting, self.test_setting_value)

        # Test if value from settings file overwrites default value
        default_settings = (
            DefaultSetting('test_setting', 1),
        )
        app_settings = AppSettings(self.app_name, default_settings)
        self.assertEqual(app_settings.test_setting, self.test_setting_value)

    def test_key_name(self):
        default_settings = (
            DefaultSetting('test_setting', 1, key_name='NO_TEST_SETTING'),
            DefaultSetting('no_test_setting', ImproperlyConfigured, key_name='TEST_SETTING'),
        )
        app_settings = AppSettings(self.app_name, default_settings)
        self.assertEqual(app_settings.test_setting, 1)
        self.assertEqual(app_settings.no_test_setting, self.test_setting_value)


class AppConfigTestCase(SimpleTestCase):
    def test_init(self):
        app_name = 'dav_base'
        import dav_base as app_module  # pylint: disable=import-outside-toplevel

        test_default_settings = (
            DefaultSetting('test_setting', ImproperlyConfigured),
            DefaultSetting('no_test_setting', 1),
        )

        class TestAppConfig(AppConfig):
            name = 'not_dav_base'
            verbose_name = 'DAV Base App'
            default_settings = test_default_settings

        app_config = TestAppConfig(app_name, app_module)
        app_settings = app_config.settings

        self.assertEqual(app_config.name, app_name)
        self.assertEqual(app_settings.test_setting, TEST_SETTING_VALUE)
        self.assertEqual(app_settings.no_test_setting, 1)

    def test_integrated(self):
        app_config = apps.get_containing_app_config(__package__)
        self.assertEqual(app_config.__class__, RealAppConfig)
        self.assertIsInstance(app_config, AppConfig)
        self.assertEqual(app_config.settings.__class__, AppSettings)


class ModuleMetaTestCase(SimpleTestCase):
    def test_init(self):
        mm = ModuleMeta('dav_base.tests.fake_app1')
        self.assertEqual(mm.package, 'dav_base.tests.fake_app1')
        self.assertEqual(mm.app, 'dav_base.tests.fake_app1.apps.AppConfig')
        self.assertEqual(mm.additional_apps, [])
        self.assertEqual(mm.url_prefix, 'test')
        self.assertEqual(mm.url_namespace, 'dav_base_tests_fake_app1')
        pattern = mm.url_conf_pattern
        self.assertIsInstance(pattern, URLResolver)
        self.assertEqual('^test/', str(pattern.pattern))

    def test_cannot_include_urls(self):
        mm = ModuleMeta('dav_base.tests.fake_app1')
        dd = {'package': 'dav_base'}
        mm.load_from_dict(dd)
        with self.assertRaises(ImproperlyConfigured):
            _ = mm.url_conf_pattern

    def test_load_from_dict(self):
        mm = ModuleMeta('dav_base.tests.fake_app1')
        dd = {'package': 'dav_base2.foo',
              'app_config': 'MyApp.MyAppConfig',
              'additional_apps': ['test1', 'test2.subtest'],
              'url_prefix': 'test_url_prefix',
              }
        mm.load_from_dict(dd)
        self.assertEqual(mm.package, dd['package'])
        self.assertEqual(mm.app, dd['app_config'])
        self.assertEqual(mm.additional_apps, dd['additional_apps'])
        self.assertEqual(mm.url_prefix, dd['url_prefix'])
        self.assertEqual(mm.url_namespace, dd['package'].replace('.', '_'))

        dd = {'package': 'dav_base2.bar'}
        mm.load_from_dict(dd)
        self.assertEqual(mm.url_prefix, dd['package'])
        self.assertEqual(mm.app, dd['package'])
        self.assertEqual(mm.additional_apps, [])
        self.assertEqual(mm.url_prefix, dd['package'])

    def test_dump_as_dict(self):
        mm = ModuleMeta('dav_base.tests.fake_app1')
        dd_in = {'package': 'dav_base2.foo',
              'app_config': '.mymod.MyAppConfig',
              'additional_apps': ['test1'],
              'url_prefix': 'test_url_prefix',
              }
        mm.load_from_dict(dd_in)
        dd_out = mm.dump_as_dict()
        self.assertEqual(dd_in, dd_out)


class ModuleConfigTestCase(SimpleTestCase):
    def test_some(self):
        # TODO
        pass