# -*- coding: utf-8 -*-
import os
import unittest
import tempfile
import codecs
try:  # pragma: no cover
    from collections import OrderedDict  # NOQA
except ImportError:  # pragma: no cover
    from ordereddict import OrderedDict  # NOQA

import six

import mock


class parse_configTest(unittest.TestCase):

    def call_FUT(self, configname='example.ini'):
        import mrbob
        from ..parsing import parse_config

        if not configname.startswith('http'):
            f = os.path.abspath(
                os.path.join(
                    os.path.dirname(mrbob.__file__), 'tests', configname)
            )
        else:
            f = configname
        return parse_config(f)

    def test_parse_variable(self):
        c = self.call_FUT()
        self.assertEqual(c['variables']['name'], 'Bob')

    def test_parse_nested_variable(self):
        c = self.call_FUT()
        self.assertEqual(c['variables']['host.ip_addr'], '10.0.10.120')

    def test_parse_2nd_level_nested_variable(self):
        c = self.call_FUT()
        self.assertEqual(c['variables']['webserver.foo.bar'], 'barf')

    def test_parse_nested_variable_out_of_order(self):
        c = self.call_FUT('example2.ini')
        self.assertEqual(c['variables']['webserver.foo.bar'], 'barf2')
        self.assertEqual(c['variables']['webserver.ip_addr'], '127.0.0.3')

    def test_ignored_files(self):
        c = self.call_FUT('ignored.ini')
        self.assertTrue('ignored' in c['mr.bob']['ignored_files'])
        self.assertTrue('*.txt' in c['mr.bob']['ignored_files'])

    def test_ignored_directories(self):
        c = self.call_FUT('ignored_dirs.ini')
        self.assertTrue('ignored' in c['mr.bob']['ignored_directories'])
        self.assertTrue('*_stuff' in c['mr.bob']['ignored_directories'])

    def test_parse_deeply_nested_variables(self):
        c = self.call_FUT('example5.ini')
        expected_config = {
            'mr.bob': {},
            'variables': {'a.b.c.d': 'foo', 'a.b.c.f': 'bar', 'name': 'Bob'},
            'questions': {'a': {'b': {'c': {'d': 'foo', 'f': 'bar'}}}, 'name': 'Bob'},
            'template': {},
            'defaults': {},
            'questions_order': [],
        }
        self.assertEqual(c, expected_config)

    def test_parse_config_utf8(self):
        from ..parsing import pretty_format_config
        c = self.call_FUT('example6.ini')
        output_variables = pretty_format_config(c['variables'])
        output_questions = pretty_format_config(c['questions'])
        if six.PY3:  # pragma: no cover
            expected_output = [
                'name = Čebula',
            ]
        else:  # pragma: no cover
            expected_output = [
                'name = Čebula'.decode('utf-8'),
            ]

        self.assertEqual(output_variables, expected_output)
        self.assertEqual(output_questions, expected_output)

    def test_parse_config(self):
        from ..parsing import pretty_format_config
        c = self.call_FUT()
        output = pretty_format_config(c['variables'])
        expected_output = [
            'host.ip_addr = 10.0.10.120',
            'name = Bob',
            'webserver.foo.bar = barf',
            'webserver.fqdn = mrbob.10.0.10.120.xip.io',
            'webserver.ip_addr = 127.0.0.2',
        ]
        self.assertEqual(output, expected_output)

    def test_question_order(self):
        c = self.call_FUT('question_order.ini')
        self.assertEqual(c['questions_order'], ['foo'])

    @mock.patch('mrbob.parsing.urlretrieve')
    def test_parse_remote_config(self, urlretrieve):

        def write(url, filename):
            f = open(filename, 'w')
            f.write(
                "[variables]\n"
                "foo = bar\n"
            )
            f.close()

        urlretrieve.side_effect = write

        c = self.call_FUT(configname='http://nohost/mrbob.ini')
        self.assertEqual(c['variables']['foo'], 'bar')


class update_configTest(unittest.TestCase):

    def call_FUT(self, config, newconfig):
        from ..parsing import update_config
        return update_config(config, newconfig)

    def test_update_config_override_one_option(self):
        config = {
            'foo': 'bar',
            'foo1': 'mar'
        }
        new_config = {
            'foo1': 'bar'
        }
        self.call_FUT(config, new_config)

        expected_config = {
            'foo': 'bar',
            'foo1': 'bar'
        }

        self.assertEqual(config, expected_config)

    def test_update_config_override_nested(self):
        config = {
            'foo': 'bar',
            'bar': {
                'foo': 'bar',
                'foo1': 'foo',
            }
        }
        new_config = {
            'foo1': 'bar',
            'bar': {
                'foo1': 'moo',
                'moo': 'moo',
            }
        }
        self.call_FUT(config, new_config)

        expected_config = {
            'foo': 'bar',
            'foo1': 'bar',
            'bar': {
                'foo': 'bar',
                'foo1': 'moo',
                'moo': 'moo',
            }
        }

        self.assertEqual(config, expected_config)


class write_configTest(unittest.TestCase):

    def setUp(self):
        self.tmpfile = tempfile.mkstemp()[1]

    def tearDown(self):
        os.remove(self.tmpfile)

    def call_FUT(self, section, data):
        from ..parsing import write_config
        return write_config(self.tmpfile, section, data)

    def test_multiple_options(self):
        self.call_FUT(
            'variables',
            {'foo.bar': 'a',
             'foo.bar.moo': 'b'},
        )

        with open(self.tmpfile) as f:
            output = f.read()
            self.assertTrue('\nfoo.bar = a\n' in output)
            self.assertTrue('\nfoo.bar.moo = b\n' in output)

    def test_empty(self):
        self.call_FUT(
            'variables',
            {},
        )

        with open(self.tmpfile) as f:
            self.assertEqual(f.read(), """[variables]\n\n""")

    def test_utf8(self):
        if six.PY3:  # pragma: nocover
            var_ = 'č'
        else:  # pragma: nocover
            var_ = 'č'.decode('utf-8')

        self.call_FUT(
            'variables',
            {'foo.bar': var_},
        )

        with codecs.open(self.tmpfile, 'r', 'utf-8') as f:
            self.assertEqual(f.read(), six.u("[variables]\nfoo.bar = %s\n\n") % var_)

    def test_non_str(self):
        self.call_FUT(
            'variables',
            {'foo': True},
        )

        with open(self.tmpfile) as f:
            output = f.read()
            self.assertTrue('\nfoo = True\n' in output)


class pretty_format_configTest(unittest.TestCase):

    def call_FUT(self, config):
        from ..parsing import pretty_format_config
        return pretty_format_config(config)

    def test_complex(self):
        c = self.call_FUT({
            'foo': 'bar',
            'bar': {'moo': '1', 'ma': '2'},
            'z': 'z',
            'a': 'b',
        })
        self.assertEqual(c, [
            'a = b',
            'bar.ma = 2',
            'bar.moo = 1',
            'foo = bar',
            'z = z'],
        )


class nest_variablesTest(unittest.TestCase):

    def call_FUT(self, d):
        from ..parsing import nest_variables
        return nest_variables(d)

    def test_overwrite_dict_with_value(self):
        """ providing a value for a key that already contains a
        dictionary raises a ConfigurationError """
        from ..bobexceptions import ConfigurationError
        d = OrderedDict([('foo.bar', '1'), ('foo', '2')])
        self.assertRaises(ConfigurationError, self.call_FUT, d)

    def test_overwrite_value_with_dict(self):
        """ providing a dict for a key that already contains a
        string raises a ConfigurationError """
        from ..bobexceptions import ConfigurationError
        d = OrderedDict([('foo', '2'), ('foo.bar', '1')])
        self.assertRaises(ConfigurationError, self.call_FUT, d)
