import unittest
import psycopg
from psycopg.rows import dict_row
from ca_core import entity, group_member  # <-- your code package

class TestGroupMember(unittest.TestCase):
    """Unit tests for group_member functionality including cascade deletions."""

    def setUp(self):
        self.conn = psycopg.connect("dbname=ca")
        self.conn.autocommit = False
        self.cur = self.conn.cursor(row_factory=dict_row)

        # Create a creator
        self.creator_id = entity.insert_creator(self.cur, "Alice", "pubkeyA")

        # Create two persons
        self.person1_id = entity.enroll_person(self.cur, "Bob", "pubkeyB", self.creator_id)
        self.person2_id = entity.enroll_person(self.cur, "Charlie", "pubkeyC", self.creator_id)

        # Create a group
        self.group_id = entity.create_group(self.cur, "Admins", "gpub", self.creator_id)

    def tearDown(self):
        self.conn.rollback()
        self.cur.close()
        self.conn.close()

    # -------------------------
    # Add / remove members
    # -------------------------

    def test_add_member(self):
        group_member.add_group_member(self.cur, self.group_id, self.person1_id, "member")
        members = group_member.get_members_of_group(self.cur, self.group_id)

        self.assertEqual(len(members), 1)
        self.assertEqual(members[0]["person_id"], self.person1_id)
        self.assertEqual(members[0]["role"], "member")

    def test_remove_member(self):
        group_member.add_group_member(self.cur, self.group_id, self.person1_id, "member")
        group_member.remove_group_member(self.cur, self.group_id, self.person1_id)
        members = group_member.get_members_of_group(self.cur, self.group_id)
        self.assertEqual(len(members), 0)

    def test_get_groups_for_person(self):
        group_member.add_group_member(self.cur, self.group_id, self.person1_id, "admin")
        group_member.add_group_member(self.cur, self.group_id, self.person2_id, "member")

        groups = group_member.get_groups_for_person(self.cur, self.person2_id)
        self.assertEqual(len(groups), 1)
        self.assertEqual(groups[0]["group_id"], self.group_id)
        self.assertEqual(groups[0]["role"], "member")

    # -------------------------
    # Cascade deletion tests
    # -------------------------

    def test_cascade_delete_person(self):
        group_member.add_group_member(self.cur, self.group_id, self.person1_id, "admin")
        group_member.add_group_member(self.cur, self.group_id, self.person2_id, "member")

        # Delete person1
        entity.delete_person(self.cur, self.person1_id, self.creator_id)

        # Membership should be gone for person1
        members = group_member.get_members_of_group(self.cur, self.group_id)
        self.assertEqual(len(members), 1)
        self.assertEqual(members[0]["person_id"], self.person2_id)

    def test_cascade_delete_group(self):
        group_member.add_group_member(self.cur, self.group_id, self.person1_id, "admin")
        group_member.add_group_member(self.cur, self.group_id, self.person2_id, "member")

        # Delete the group
        entity.delete_group(self.cur, self.group_id, self.creator_id)

        # Persons should have no group membership
        groups_person1 = group_member.get_groups_for_person(self.cur, self.person1_id)
        groups_person2 = group_member.get_groups_for_person(self.cur, self.person2_id)

        self.assertEqual(len(groups_person1), 0)
        self.assertEqual(len(groups_person2), 0)


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