import pickle

from av.enum import EnumType, define_enum

from .common import TestCase


# This must be at the top-level.
PickleableFooBar = define_enum('PickleableFooBar', __name__, [('FOO', 1)])


class TestEnums(TestCase):

    def define_foobar(self, **kwargs):
        return define_enum('Foobar', __name__, (
            ('FOO', 1),
            ('BAR', 2),
        ), **kwargs)

    def test_basics(self):

        cls = self.define_foobar()

        self.assertIsInstance(cls, EnumType)

        foo = cls.FOO

        self.assertIsInstance(foo, cls)
        self.assertEqual(foo.name, 'FOO')
        self.assertEqual(foo.value, 1)

        self.assertNotIsInstance(foo, PickleableFooBar)

    def test_access(self):

        cls = self.define_foobar()
        foo1 = cls.FOO
        foo2 = cls['FOO']
        foo3 = cls[1]
        foo4 = cls[foo1]
        self.assertIs(foo1, foo2)
        self.assertIs(foo1, foo3)
        self.assertIs(foo1, foo4)

        self.assertIn(foo1, cls)
        self.assertIn('FOO', cls)
        self.assertIn(1, cls)

        self.assertRaises(KeyError, lambda: cls['not a foo'])
        self.assertRaises(KeyError, lambda: cls[10])
        self.assertRaises(TypeError, lambda: cls[()])

        self.assertEqual(cls.get('FOO'), foo1)
        self.assertIs(cls.get('not a foo'), None)

    def test_casting(self):

        cls = self.define_foobar()
        foo = cls.FOO

        self.assertEqual(repr(foo), '<tests.test_enums.Foobar:FOO(0x1)>')

        str_foo = str(foo)
        self.assertIsInstance(str_foo, str)
        self.assertEqual(str_foo, 'FOO')

        int_foo = int(foo)
        self.assertIsInstance(int_foo, int)
        self.assertEqual(int_foo, 1)

    def test_iteration(self):
        cls = self.define_foobar()
        self.assertEqual(list(cls), [cls.FOO, cls.BAR])

    def test_equality(self):

        cls = self.define_foobar()
        foo = cls.FOO
        bar = cls.BAR

        self.assertEqual(foo, 'FOO')
        self.assertEqual(foo, 1)
        self.assertEqual(foo, foo)
        self.assertNotEqual(foo, 'BAR')
        self.assertNotEqual(foo, 2)
        self.assertNotEqual(foo, bar)

        self.assertRaises(ValueError, lambda: foo == 'not a foo')
        self.assertRaises(ValueError, lambda: foo == 10)
        self.assertRaises(TypeError, lambda: foo == ())

    def test_as_key(self):

        cls = self.define_foobar()
        foo = cls.FOO

        d = {foo: 'value'}
        self.assertEqual(d[foo], 'value')
        self.assertIs(d.get('FOO'), None)
        self.assertIs(d.get(1), None)

    def test_pickleable(self):

        cls = PickleableFooBar
        foo = cls.FOO

        enc = pickle.dumps(foo)

        foo2 = pickle.loads(enc)

        self.assertIs(foo, foo2)

    def test_create_unknown(self):

        cls = self.define_foobar()
        baz = cls.get(3, create=True)

        self.assertEqual(baz.name, 'FOOBAR_3')
        self.assertEqual(baz.value, 3)

    def test_multiple_names(self):

        cls = define_enum('FFooBBar', __name__, (
            ('FOO', 1),
            ('F', 1),
            ('BAR', 2),
            ('B', 2),
        ))

        self.assertIs(cls.F, cls.FOO)

        self.assertEqual(cls.F.name, 'FOO')
        self.assertNotEqual(cls.F.name, 'F')  # This is actually the string.

        self.assertEqual(cls.F, 'FOO')
        self.assertEqual(cls.F, 'F')
        self.assertNotEqual(cls.F, 'BAR')
        self.assertNotEqual(cls.F, 'B')
        self.assertRaises(ValueError, lambda: cls.F == 'x')

    def test_flag_basics(self):

        cls = define_enum('FoobarAllFlags', __name__, dict(FOO=1, BAR=2, FOOBAR=3).items(), is_flags=True)
        foo = cls.FOO
        bar = cls.BAR

        foobar = foo | bar
        self.assertIs(foobar, cls.FOOBAR)

        foo2 = foobar & foo
        self.assertIs(foo2, foo)

        bar2 = foobar ^ foo
        self.assertIs(bar2, bar)

        bar3 = foobar & ~foo
        self.assertIs(bar3, bar)

        x = cls.FOO
        x |= cls.BAR
        self.assertIs(x, cls.FOOBAR)

        x = cls.FOOBAR
        x &= cls.FOO
        self.assertIs(x, cls.FOO)

    def test_multi_flags_basics(self):

        cls = self.define_foobar(is_flags=True)

        foo = cls.FOO
        bar = cls.BAR
        foobar = foo | bar
        self.assertEqual(foobar.name, 'FOO|BAR')
        self.assertEqual(foobar.value, 3)
        self.assertEqual(foobar.flags, (foo, bar))

        foobar2 = foo | bar
        foobar3 = cls[3]
        foobar4 = cls[foobar]

        self.assertIs(foobar, foobar2)
        self.assertIs(foobar, foobar3)
        self.assertIs(foobar, foobar4)

        self.assertRaises(KeyError, lambda: cls['FOO|BAR'])

        self.assertEqual(len(cls), 2)  # It didn't get bigger
        self.assertEqual(list(cls), [foo, bar])

    def test_multi_flags_create_missing(self):

        cls = self.define_foobar(is_flags=True)

        foobar = cls[3]
        self.assertIs(foobar, cls.FOO | cls.BAR)

        self.assertRaises(KeyError, lambda: cls[4])  # Not FOO or BAR
        self.assertRaises(KeyError, lambda: cls[7])  # FOO and BAR and missing flag.

    def test_properties(self):

        Flags = self.define_foobar(is_flags=True)
        foobar = Flags.FOO | Flags.BAR

        class Class(object):

            def __init__(self, value):
                self.value = Flags[value].value

            @Flags.property
            def flags(self):
                return self.value

            @flags.setter
            def flags(self, value):
                self.value = value

            foo = flags.flag_property('FOO')
            bar = flags.flag_property('BAR')

        obj = Class('FOO')

        self.assertIs(obj.flags, Flags.FOO)
        self.assertTrue(obj.foo)
        self.assertFalse(obj.bar)

        obj.bar = True
        self.assertIs(obj.flags, foobar)
        self.assertTrue(obj.foo)
        self.assertTrue(obj.bar)

        obj.foo = False
        self.assertIs(obj.flags, Flags.BAR)
        self.assertFalse(obj.foo)
        self.assertTrue(obj.bar)