"""

Part of the tagit test suite.
A copy of the license is provided with the project.
Author: Matthias Baumgartner, 2022
"""
# imports
import unittest

# objects to test
from tagit.utils.frame import Frame


## code ##

class EntityStub(object):
    def __init__(self, guid):
        self.guid = guid
    def __eq__(self, other):
        return self.guid == other.guid

class LibraryStub(object):
    def __init__(self, guids):
        self.guids = guids
    def entity(self, guid):
        if guid in self.guids:
            return EntityStub(guid)
        else:
            raise KeyError(guid)

class TestFrame(unittest.TestCase):
    def setUp(self):
        self.ent0 = EntityStub('ent0')
        self.ent1 = EntityStub('ent1')
        self.ent2 = EntityStub('ent2')
        self.ent3 = EntityStub('ent3')
        self.ent4 = EntityStub('ent4')
        self.ent5 = EntityStub('ent5')
        self.lib = LibraryStub(['ent0', 'ent1', 'ent2', 'ent3'])

    def test_properties(self):
        # plain test
        frame = Frame(self.ent0, [self.ent1, self.ent2], 123)
        self.assertEqual(frame, {
            'cursor': self.ent0,
            'selection': [self.ent1, self.ent2],
            'offset': 123,
            })
        self.assertEqual(frame.cursor, self.ent0)
        self.assertEqual(frame.selection, [self.ent1, self.ent2])
        self.assertEqual(frame.offset, 123)

        # empty selection
        frame = Frame(self.ent0, [], 123)
        self.assertEqual(frame, {
            'cursor': self.ent0,
            'selection': [],
            'offset': 123,
            })
        self.assertEqual(frame.cursor, self.ent0)
        self.assertEqual(frame.selection, [])
        self.assertEqual(frame.offset, 123)

        # no cursor
        frame = Frame(None, [self.ent0], 123)
        self.assertEqual(frame, {
            'cursor': None,
            'selection': [self.ent0],
            'offset': 123,
            })
        self.assertEqual(frame.cursor, None)
        self.assertEqual(frame.selection, [self.ent0])
        self.assertEqual(frame.offset, 123)

        # no selection
        frame = Frame(self.ent0, None, 123)
        self.assertEqual(frame, {
            'cursor': self.ent0,
            'selection': [],
            'offset': 123
            })
        self.assertEqual(frame.cursor, self.ent0)
        self.assertEqual(frame.selection, [])
        self.assertEqual(frame.offset, 123)

        # Not tested: different list-like selection formats (tuple, list)
        # This seems ok since such formats would be admissible.

    def test_copy(self):
        frameA = Frame(self.ent0, [self.ent1, self.ent2], 123)
        self.assertEqual(frameA, {
            'cursor': self.ent0,
            'selection': [self.ent1, self.ent2],
            'offset': 123
            })

        frameB = frameA.copy()
        self.assertEqual(frameB, {
            'cursor': self.ent0,
            'selection': [self.ent1, self.ent2],
            'offset': 123
            })

        # robust against frame changes
        frameA['cursor'] = self.ent3
        self.assertEqual(frameB.cursor, self.ent0)
        frameA['selection'].append(self.ent3)
        self.assertEqual(frameB.selection, [self.ent1, self.ent2, self.ent3])
        frameA['selection'] = [self.ent4, self.ent5]
        self.assertEqual(frameB.selection, [self.ent1, self.ent2, self.ent3])
        frameA['offset'] = 321
        self.assertEqual(frameB.offset, 123)

        # ignorant to object changes
        self.ent0.guid = 'abc'
        self.assertEqual(frameA.cursor.guid, 'ent3')
        self.assertEqual(frameB.cursor.guid, 'abc')

    def test_serialization(self):
        # empty frame
        frame = Frame()
        self.assertEqual(frame,
            Frame.from_serialized(self.lib, frame.serialize(), ignore_errors=False))
        # with cursor
        frame = Frame(self.ent1)
        self.assertEqual(frame,
            Frame.from_serialized(self.lib, frame.serialize(), ignore_errors=False))

        # with selection
        frame = Frame(selection=[self.ent0, self.ent3])
        self.assertEqual(frame,
            Frame.from_serialized(self.lib, frame.serialize(), ignore_errors=False))

        # with offset
        frame = Frame(offset=554)
        self.assertEqual(frame,
            Frame.from_serialized(self.lib, frame.serialize(), ignore_errors=False))

        # full frame
        frame = Frame(self.ent1, [self.ent0, self.ent2], 482)
        self.assertEqual(frame,
            Frame.from_serialized(self.lib, frame.serialize(), ignore_errors=False))

        # with invalid values
        frame = Frame(self.ent5, [self.ent0, self.ent2], 482)
        self.assertRaises(KeyError,
            Frame.from_serialized, self.lib, frame.serialize(), ignore_errors=False)
        frame = Frame(self.ent1, [self.ent5, self.ent2], 482)
        self.assertRaises(KeyError,
            Frame.from_serialized, self.lib, frame.serialize(), ignore_errors=False)

        # ignoring invalid values
        frame = Frame(self.ent5, [self.ent0, self.ent2], 482)
        self.assertEqual(
            Frame(None, [self.ent0, self.ent2], 482),
            Frame.from_serialized(self.lib, frame.serialize(), ignore_errors=True))
        frame = Frame(self.ent1, [self.ent5, self.ent2], 482)
        self.assertEqual(
            Frame(self.ent1, [self.ent2], 482),
            Frame.from_serialized(self.lib, frame.serialize(), ignore_errors=True))


## main ##

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

## EOF ##