import importlib
import os
import types
import unittest

from _colorize import ANSIColors, get_theme
from _pyrepl.completing_reader import stripcolor
from _pyrepl.fancycompleter import Completer, commonprefix
from test.support.import_helper import ready_to_import

class MockPatch:
    def __init__(self):
        self.original_values = {}

    def setattr(self, obj, name, value):
        if obj not in self.original_values:
            self.original_values[obj] = {}
        if name not in self.original_values[obj]:
            self.original_values[obj][name] = getattr(obj, name)
        setattr(obj, name, value)

    def restore_all(self):
        for obj, attrs in self.original_values.items():
            for name, value in attrs.items():
                setattr(obj, name, value)

class FancyCompleterTests(unittest.TestCase):
    def setUp(self):
        self.mock_patch = MockPatch()

    def tearDown(self):
        self.mock_patch.restore_all()

    def test_commonprefix(self):
        self.assertEqual(commonprefix(['isalpha', 'isdigit', 'foo']), '')
        self.assertEqual(commonprefix(['isalpha', 'isdigit']), 'is')
        self.assertEqual(commonprefix([]), '')

    def test_complete_attribute(self):
        compl = Completer({'a': None}, use_colors=False)
        self.assertEqual(compl.attr_matches('a.'), ['a.__'])
        matches = compl.attr_matches('a.__')
        self.assertNotIn('__class__', matches)
        self.assertIn('a.__class__', matches)
        match = compl.attr_matches('a.__class')
        self.assertEqual(len(match), 1)
        self.assertTrue(match[0].startswith('a.__class__'))

    def test_complete_attribute_prefix(self):
        class C(object):
            attr = 1
            _attr = 2
            __attr__attr = 3
        compl = Completer({'a': C}, use_colors=False)
        self.assertEqual(compl.attr_matches('a.'), ['a.attr', 'a.mro'])
        self.assertEqual(
            compl.attr_matches('a._'),
            ['a._C__attr__attr', 'a._attr'],
        )
        matches = compl.attr_matches('a.__')
        self.assertNotIn('__class__', matches)
        self.assertIn('a.__class__', matches)
        match = compl.attr_matches('a.__class')
        self.assertEqual(len(match), 1)
        self.assertTrue(match[0].startswith('a.__class__'))

        compl = Completer({'a': None}, use_colors=False)
        self.assertEqual(compl.attr_matches('a._'), ['a.__'])

    def test_complete_attribute_colored(self):
        theme = get_theme()
        compl = Completer({'a': 42}, use_colors=True)
        matches = compl.attr_matches('a.__')
        self.assertGreater(len(matches), 2)
        expected_color = theme.fancycompleter.type
        expected_part = f'{expected_color}a.__class__{ANSIColors.RESET}'
        for match in matches:
            if expected_part in match:
                break
        else:
            self.assertFalse(True, matches)
        self.assertNotIn(' ', matches)

    def test_preserves_callable_postfix_for_single_attribute_match(self):
        compl = Completer({'os': os}, use_colors=False)
        self.assertEqual(compl.attr_matches('os.getpid'), ['os.getpid()'])

    def test_property_method_not_called(self):
        class Foo:
            property_called = False

            @property
            def bar(self):
                self.property_called = True
                return 1

        foo = Foo()
        compl = Completer({'foo': foo}, use_colors=False)
        self.assertEqual(compl.attr_matches('foo.b'), ['foo.bar'])
        self.assertFalse(foo.property_called)

    def test_excessive_getattr(self):
        class Foo:
            calls = 0
            bar = ''

            def __getattribute__(self, name):
                if name == 'bar':
                    self.calls += 1
                    return None
                return super().__getattribute__(name)

        foo = Foo()
        compl = Completer({'foo': foo}, use_colors=False)
        self.assertEqual(compl.complete('foo.b', 0), 'foo.bar')
        self.assertEqual(foo.calls, 1)

    def test_uncreated_attr(self):
        class Foo:
            __slots__ = ('bar',)

        compl = Completer({'foo': Foo()}, use_colors=False)
        self.assertEqual(compl.complete('foo.', 0), 'foo.bar')

    def test_module_attributes_do_not_reify_lazy_imports(self):
        with ready_to_import("test_pyrepl_lazy_mod", "lazy import json\n") as (name, _):
            module = importlib.import_module(name)
            self.assertIs(type(module.__dict__["json"]), types.LazyImportType)

            compl = Completer({name: module}, use_colors=False)
            self.assertEqual(compl.attr_matches(f"{name}.j"), [f"{name}.json"])
            self.assertIs(type(module.__dict__["json"]), types.LazyImportType)

    def test_complete_colored_single_match(self):
        """No coloring, via commonprefix."""
        compl = Completer({'foobar': 42}, use_colors=True)
        matches = compl.global_matches('foob')
        self.assertEqual(matches, ['foobar'])

    def test_does_not_color_single_match(self):
        class obj:
            msgs = []

        compl = Completer({'obj': obj}, use_colors=True)
        matches = compl.attr_matches('obj.msgs')
        self.assertEqual(matches, ['obj.msgs'])

    def test_complete_global(self):
        compl = Completer({'foobar': 1, 'foobazzz': 2}, use_colors=False)
        self.assertEqual(compl.global_matches('foo'), ['fooba'])
        matches = compl.global_matches('fooba')
        self.assertEqual(set(matches), set(['foobar', 'foobazzz']))
        self.assertEqual(compl.global_matches('foobaz'), ['foobazzz'])
        self.assertEqual(compl.global_matches('nothing'), [])

    def test_complete_global_colored(self):
        theme = get_theme()
        compl = Completer({'foobar': 1, 'foobazzz': 2}, use_colors=True)
        self.assertEqual(compl.global_matches('foo'), ['fooba'])
        matches = compl.global_matches('fooba')

        int_color = theme.fancycompleter.int
        self.assertEqual(matches, [
            f'{int_color}foobar{ANSIColors.RESET}',
            f'{int_color}foobazzz{ANSIColors.RESET}',
        ])
        self.assertEqual(compl.global_matches('foobaz'), ['foobazzz'])
        self.assertEqual(compl.global_matches('nothing'), [])

    def test_colorized_match_is_stripped(self):
        compl = Completer({'a': 42}, use_colors=True)
        match = compl._color_for_obj('spam', 1)
        self.assertEqual(stripcolor(match), 'spam')

    def test_complete_with_indexer(self):
        compl = Completer({'lst': [None, 2, 3]}, use_colors=False)
        self.assertEqual(compl.attr_matches('lst[0].'), ['lst[0].__'])
        matches = compl.attr_matches('lst[0].__')
        self.assertNotIn('__class__', matches)
        self.assertIn('lst[0].__class__', matches)
        match = compl.attr_matches('lst[0].__class')
        self.assertEqual(len(match), 1)
        self.assertTrue(match[0].startswith('lst[0].__class__'))

    def test_autocomplete(self):
        class A:
            aaa = None
            abc_1 = None
            abc_2 = None
            abc_3 = None
            bbb = None
        compl = Completer({'A': A}, use_colors=False)
        #
        # In this case, we want to display all attributes which start with
        # 'a'.
        matches = compl.attr_matches('A.a')
        self.assertEqual(
            sorted(matches),
            ['A.aaa', 'A.abc_1', 'A.abc_2', 'A.abc_3'],
        )
        #
        # If there is an actual common prefix, we return just it, so that readline
        # will insert it into place
        matches = compl.attr_matches('A.ab')
        self.assertEqual(matches, ['A.abc_'])
        #
        # Finally, at the next tab, we display again all the completions
        # available for this common prefix.
        matches = compl.attr_matches('A.abc_')
        self.assertEqual(
            sorted(matches),
            ['A.abc_1', 'A.abc_2', 'A.abc_3'],
        )

    def test_complete_exception(self):
        compl = Completer({}, use_colors=False)
        self.assertEqual(compl.attr_matches('xxx.'), [])

    def test_complete_invalid_attr(self):
        compl = Completer({'str': str}, use_colors=False)
        self.assertEqual(compl.attr_matches('str.xx'), [])

    def test_complete_function_skipped(self):
        compl = Completer({'str': str}, use_colors=False)
        self.assertEqual(compl.attr_matches('str.split().'), [])

    def test_unicode_in___dir__(self):
        class Foo(object):
            def __dir__(self):
                return ['hello', 'world']

        compl = Completer({'a': Foo()}, use_colors=False)
        matches = compl.attr_matches('a.')
        self.assertEqual(matches, ['a.hello', 'a.world'])
        self.assertIs(type(matches[0]), str)


if __name__ == "__main__":
    unittest.main()