# -*- coding: utf-8 -*-
import datetime
import json
import os
import shutil
from unittest.mock import patch
from django.core.exceptions import ImproperlyConfigured
from django.test import SimpleTestCase
from django.urls import URLResolver

from ..config.modules import ModuleMeta, ModuleConfig

from .utils import mkdtemp

TMP_BASE_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'tmp')


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')
        self.assertEqual(mm.root_url_name, 'dav_base_tests_fake_app1:root')
        pattern = mm.url_conf_pattern
        self.assertIsInstance(pattern, URLResolver)
        self.assertEqual('^test/', str(pattern.pattern))

    def test_module_not_exists(self):
        with self.assertRaises(ModuleNotFoundError):
            _ = ModuleMeta('dav_base.tests.non_existent_app')

    def test_init_without_load(self):
        app_name = 'dav_base.tests.non_existent_app'
        app_namespace = app_name.replace('.', '_')
        mm = ModuleMeta(app_name, load=False)
        self.assertEqual(mm.package, app_name)
        self.assertEqual(mm.app, app_name)
        self.assertEqual(mm.url_prefix, app_name)
        self.assertEqual(mm.url_namespace, app_namespace)
        self.assertEqual(mm.root_url_name, app_namespace + ':root')

    def test_url_config_not_exists(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_str(self):
        app_name = 'dav_base.tests.fake_app1'
        mm = ModuleMeta(app_name)
        self.assertEqual(str(mm), '- {}'.format(app_name))

    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',
              }
        expected_namespace = dd['package'].replace('.', '_')
        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, expected_namespace)
        self.assertEqual(mm.root_url_name, expected_namespace + ':root')

        dd = {'package': 'dav_base2.bar'}
        expected_namespace = dd['package'].replace('.', '_')
        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'])
        self.assertEqual(mm.url_namespace, expected_namespace)
        self.assertEqual(mm.root_url_name, expected_namespace + ':root')

    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 setUp(self):
        prefix = 'dav_base.tests.test_config_modules-{datetime}-'.format(
            datetime=datetime.datetime.now().strftime('%Y%m%d-%H%M')
        )
        self.temp_dir = mkdtemp(prefix=prefix, base_dir=TMP_BASE_DIR)

        self.config_dir = os.path.join(self.temp_dir, 'main')
        os.makedirs(self.config_dir)
        self.config_file = os.path.join(self.config_dir, 'module_config.json')

    def tearDown(self):
        shutil.rmtree(self.temp_dir)

    def test_default_config_file_not_exists(self):
        with patch('dav_base.config.modules.settings') as mock_settings:
            mock_settings.BASE_DIR = self.temp_dir
            mc = ModuleConfig()
            self.assertEqual(mc.modules, {})

    def test_default_config_file_exists(self):
        config_data = {
            'modules': [
                {'package': 'pkg1'},
                {'package': 'pkg2'},
            ]
        }

        with open(self.config_file, 'w', encoding='ascii') as f:
            json.dump(config_data, f)

        with patch('dav_base.config.modules.settings') as mock_settings:
            mock_settings.BASE_DIR = self.temp_dir
            mc = ModuleConfig()
            self.assertEqual(list(mc.modules.keys()), ['pkg1', 'pkg2'])

    def test_django_base_dir_parameter(self):
        config_data = {
            'modules': [
                {'package': 'pkgA'},
                {'package': 'pkgB'},
            ]
        }

        with open(self.config_file, 'w', encoding='ascii') as f:
            json.dump(config_data, f)

        with patch('dav_base.config.modules.settings') as mock_settings:
            mock_settings.BASE_DIR = self.config_dir  # No config file there

            mc = ModuleConfig()
            self.assertEqual(mc.modules, {})

            mc = ModuleConfig(django_base_dir=self.temp_dir)
            self.assertEqual(list(mc.modules.keys()), ['pkgA', 'pkgB'])

    def test_custom_config_file_path(self):
        config_data = {
            'modules': [
                {'package': 'pkgX'},
                {'package': 'pkgY'},
            ]
        }

        config_file = os.path.join(self.config_dir, 'test.json')
        with open(config_file, 'w', encoding='ascii') as f:
            json.dump(config_data, f)

        with patch('dav_base.config.modules.settings') as mock_settings:
            mock_settings.BASE_DIR = self.temp_dir
            mc = ModuleConfig(config_file_path=config_file)
            self.assertEqual(list(mc.modules.keys()), ['pkgX', 'pkgY'])

    def test_custom_config_file_path_and_django_base_dir(self):
        config_data = {
            'modules': [
                {'package': 'pkg11'},
                {'package': 'pkg22'},
            ]
        }

        config_file = os.path.join(self.config_dir, 'test.json')
        with open(config_file, 'w', encoding='ascii') as f:
            json.dump(config_data, f)

        with patch('dav_base.config.modules.settings') as mock_settings:
            mock_settings.BASE_DIR = self.temp_dir
            mc = ModuleConfig(config_file_path=config_file, django_base_dir=self.config_dir)
            self.assertEqual(list(mc.modules.keys()), ['pkg11', 'pkg22'])

    def test_save(self):
        config_data = {
            'modules': [
                {'package': 'pkg_foo'},
                {'package': 'pkg_bar'},
                {'package': 'pkg_baz'},
                {'package': 'pkg_quux', 'url_prefix': 'quux'},
            ]
        }
        copy_modules = ['pkg_bar', 'pkg_quux']
        expected_config_data = {'modules': [d for d in config_data['modules'] if d['package'] in copy_modules]}

        config_file = os.path.join(self.config_dir, 'test.json')
        with open(config_file, 'w', encoding='ascii') as f:
            json.dump(config_data, f)

        with patch('dav_base.config.modules.settings') as mock_settings:
            mock_settings.BASE_DIR = self.temp_dir
            mc1 = ModuleConfig()
            mc2 = ModuleConfig(config_file_path=config_file)
            for module_name in copy_modules:
                mc1.modules[module_name] = mc2.modules[module_name]
            mc1.save()

        with open(self.config_file, 'r', encoding='ascii') as f:
            config_data = json.load(f)

        self.assertEqual(config_data, expected_config_data)

    def test_save_empty(self):
        self.assertFalse(os.path.exists(self.config_file))
        with patch('dav_base.config.modules.settings') as mock_settings:
            mock_settings.BASE_DIR = self.temp_dir
            mc = ModuleConfig()
            mc.save()
        self.assertTrue(os.path.isfile(self.config_file))

        with open(self.config_file, 'r', encoding='ascii') as f:
            config_data = json.load(f)

        self.assertEqual(config_data, {'modules': []})

    def test_save_overwrite(self):
        with patch('dav_base.config.modules.settings') as mock_settings:
            mock_settings.BASE_DIR = self.temp_dir
            mc = ModuleConfig()
            mc.save()
            self.assertTrue(os.path.isfile(self.config_file))
            mc.modules['mod1'] = ModuleMeta('mod1', load=False)
            mc.save()

        with open(self.config_file, 'r', encoding='ascii') as f:
            config_data = json.load(f)

        self.assertEqual(config_data, {'modules': [{'package': 'mod1'}]})