# Copyright 2021 (c) Anna Schumaker.
import unittest
from gi.repository import GObject
from gi.repository import Gio
from . import sql
from . import table

class FakeRow(GObject.GObject):
    def __init__(self, data):
        GObject.GObject.__init__(self)
        self.rowid = data["fakeid"]
        self.name = data["name"]

class FakeTable(table.Table):
    def __init__(self):
        table.Table.__init__(self, "fake_table")
        self.reset()

    def do_create(self):
        sql.execute("CREATE TABLE IF NOT EXISTS fake_table "
                        "(fakeid INTEGER PRIMARY KEY, name TEXT UNIQUE)")

    def do_factory(self, row):
        return FakeRow(row)

    def do_insert(self, name):
        return sql.execute("INSERT INTO fake_table (name) VALUES (?)", [ name ])

    def do_lookup(self, name):
        return sql.execute("SELECT * FROM fake_table WHERE name=?", [ name ])

class FakeModel(table.Model, FakeTable):
    def __init__(self):
        table.Model.__init__(self, "fake_table", "lower(name)")
        self.reset()

class FakeChild(table.Child):
    def __init__(self):
        table.Child.__init__(self, "fake_child", "parentid", "lower(name)")
        self.reset()

    def do_create(self):
        sql.execute("CREATE TABLE IF NOT EXISTS fake_child "
                        "(fakeid INTEGER PRIMARY KEY, "
                         "parentid INTEGER, "
                         "name TEXT UNIQUE, "
                         "FOREIGN KEY(parentid) REFERENCES fake_table(fakeid))")

    def do_factory(self, row):
        return FakeRow(row)

    def do_insert(self, parent, name):
        return sql.execute("INSERT INTO fake_child (parentid, name) "
                           "VALUES (?,?)", [ parent.rowid, name ])


class TestTable(unittest.TestCase):
    def test_init(self):
        fake = FakeTable()
        self.assertIsInstance(fake.cache, dict)
        self.assertEqual(fake.table, "fake_table")

    def test_interface(self):
        with self.assertRaises(NotImplementedError):
            table.Table.do_create(None)
        with self.assertRaises(NotImplementedError):
            table.Table.do_factory(None, None)
        with self.assertRaises(NotImplementedError):
            table.Table.do_insert(None, "Text")
        with self.assertRaises(NotImplementedError):
            table.Table.do_lookup(None, "Text")

    def test_insert_delete(self):
        fake = FakeTable()
        row = fake.insert("Test Name")
        self.assertIsInstance(row, FakeRow)
        self.assertEqual(fake.cache[1], row)
        self.assertEqual(fake.get(1), row)

        fake.delete(row)
        self.assertEqual(fake.cache, { })

    def test_find(self):
        fake = FakeTable()
        row = fake.find("Test Name")
        self.assertIsInstance(row, FakeRow)
        self.assertEqual(fake.cache[1], row)
        self.assertEqual(fake.find("Test Name"), row)

    def test_lookup(self):
        fake = FakeTable()
        row = fake.insert("Test Name")
        fake.cache.clear()

        row = fake.lookup("Test Name")
        self.assertEqual(row.name, "Test Name")
        self.assertEqual(fake.cache, { 1 : row })
        self.assertEqual(fake.lookup("Test Name"), row)

    def test_reset(self):
        fake = FakeTable()
        sql.execute("SELECT fakeid,name FROM fake_table")
        fake.insert("Test Name")

        fake.reset()
        self.assertEqual(fake.cache, { })


class TestModel(unittest.TestCase):
    def items_changed(self, table, pos, rm, add):
        self.changed = (pos, rm, add)

    def setUp(self):
        self.changed = None

    def test_init(self):
        fake = FakeModel()
        self.assertIsInstance(fake, GObject.GObject)
        self.assertIsInstance(fake, Gio.ListModel)
        self.assertIsInstance(fake, table.Table)
        self.assertEqual(fake.order, "lower(name)")

    def test_insert_delete(self):
        fake = FakeModel()
        fake.connect("items-changed", self.items_changed)

        row = fake.insert("Test Row")
        self.assertEqual(self.changed, (0, 0, 1))

        fake.delete(row)
        self.assertEqual(self.changed, (0, 1, 0))

    def test_model(self):
        fake = FakeModel()
        self.assertEqual(fake.get_item_type(), GObject.TYPE_PYOBJECT)
        self.assertEqual(fake.get_n_items(), 0)

        c = fake.insert("C")
        self.assertEqual(fake.get_n_items(), 1)
        self.assertEqual(fake.get_item(0), c)

        b = fake.insert("B")
        self.assertEqual(fake.get_n_items(), 2)
        self.assertEqual(fake.get_item(0), b)
        self.assertEqual(fake.get_item(1), c)

        a = fake.insert("A")
        self.assertEqual(fake.get_n_items(), 3)
        self.assertEqual(fake.get_item(0), a)
        self.assertEqual(fake.get_item(1), b)
        self.assertEqual(fake.get_item(2), c)

    def test_reset(self):
        fake = FakeModel()
        fake.insert("Test Row")
        fake.insert("Test Row 2")
        fake.connect("items-changed", self.items_changed)
        fake.reset()
        self.assertEqual(self.changed, (0, 2, 0))


class TestChild(unittest.TestCase):
    def test_init(self):
        child = FakeChild()

        self.assertIsInstance(child, table.Table)
        self.assertEqual(child.parent, "parentid")
        self.assertEqual(child.order, "lower(name)")

    def test_children(self):
        model = FakeModel()
        child = FakeChild()
        parent = model.insert("Fake Parent")

        self.assertEqual(child.get_n_children(parent), 0)

        c = child.insert(parent, "C")
        b = child.insert(parent, "B")
        a = child.insert(parent, "A")

        self.assertEqual(child.get_n_children(parent), 3)

        self.assertEqual(child.get_child(parent, 0), a)
        self.assertEqual(child.get_child(parent, 1), b)
        self.assertEqual(child.get_child(parent, 2), c)

        self.assertEqual(child.get_child_index(parent, a), 0)
        self.assertEqual(child.get_child_index(parent, b), 1)
        self.assertEqual(child.get_child_index(parent, c), 2)