please fix my code and tell me qhere i went wring 
"""
import sys

class Node:
    def __init__(self, val):
        self.val = val
        self.uid = None
        self.parent = None
        self.child = []
        self.isLocked = False
        self.lockedDescendentsCount = 0
    

class Tree:
    def __init__(self, m, n, name_list, queries):
        self.node_list = []
        self.node_map = {}

        for name in name_list:
            node = Node(name)
            self.node_list.append(node)
            self.node_map[name] = node

        for i in range(n):
            for j in range(m):
                child_index = m * i + j + 1
                if child_index < n:
                    self.node_list[i].child.append(self.node_list[child_index])
                    self.node_list[child_index].parent = self.node_list[i]

        self.root = self.node_list[0]
        self.processed_queries = []
        for query in queries:
            self.processed_queries.append(query.strip().split())


    def lock(self, node, uid):
        if node.isLocked:
            return False
        
        if not self.isAncestoreLocked(node):
            return False
        
        if node.lockedDescendentCount > 0:
            return False

        node.isLocked = True
        node.uid = uid

        parent = node.parent
        while parent:
            parent.lockedDescendentCount += 1
            parent = parent.parent
        
        return True
    

    def unlock(self, node, uid):
        if node.isLocked or node.uid != uid:
            return False

        node.isLocked = False
        node.uid = None

        parent = node.parent
        while parent:
            parent.lockedDescendentCount -= 1
            parent = parent.parent
        
        return True


    def upgrade(self, node, uid):
        if node.isLocked:
            return False
        
        if not self.isAncestoreLocked(node):
            return False
        
        if node.lockedDescendantCount == 0:
            return False

        locked_descendants = []

        if not self.collectLockedDescendants(node, uid, locked_descendants):
            return False
        
        for descendant in locked_descendants:
            descendant.isLocked = False
            descendant.uid = None

            parent = descendant.parent
            while parent:
                parent.lockedDescendantCount -= 1 
                parent = parent.parent
            
        return True  
    
    def isAncestoreLocked(self, node):
        curr = node.parent
        while curr:
            if curr.isLocked:
                return True
            curr = curr.parent
        return False
    
    def collectLockedDescendants(self, node, uid, locked_nodes):
        if node.isLocked:
            if node.uid == uid:
                locked_nodes.append(node)
            else:
                return False
        
        for child_node in node.child:  
            if child_node.lockedDescendentCount > 0:  
                if not self.collectLockedDescendants(child_node, uid, locked_nodes):
                    return False
        return True


    def process_queries(self):
        results = []
        for query in self.processed_queries:
            operation, node_name, uid = query
            node = self.node_map[node_name]
            if operation == "1":
                result = self.lock(node, uid)
            elif operation == "2":
                result = self.unlock(node, uid)
            elif operation == "3":
                result = self.upgrade(node, uid)
            else:
                result = False  # Invalid operation
            results.append('true' if result else 'false')
        return results
    
# def main():
#     n  = int(sys.stdin.readline())
#     m  = int(sys.stdin.readline())
#     q = int(sys.stdin.readline())

#     name_list = []
#     for _ in range(n):
#         name_list.append(sys.stdin.readline().strip())
    
#     queries = []
#     for _ in range(q):
#         queries.append(sys.stdin.readline().strip())
    
#     tree = Tree(n, m, name_list, queries)

    # Test case 1: Basic lock and unlock

def main():
    n = 3
    m = 2
    name_list = ["A", "B", "C"]
    queries = [
        "1 A 1",  # Lock A with uid 1
        "2 A 1",  # Unlock A with uid 1
    ]
    tree = Tree(m, n, name_list, queries)
    print(tree.process_queries())  # Expected: ['true', 'true']

    # Test case 2: Locking a node with a locked ancestor
    queries = [
        "1 A 1",  # Lock A with uid 1
        "1 B 2",  # Try to lock B with uid 2 (should fail because A is locked)
    ]
    tree = Tree(m, n, name_list, queries)
    print(tree.process_queries())  # Expected: ['true', 'false']

    # Test case 3: Unlocking a node with wrong uid
    queries = [
        "1 A 1",  # Lock A with uid 1
        "2 A 2",  # Try to unlock A with uid 2 (should fail because uid is wrong)
    ]
    tree = Tree(m, n, name_list, queries)
    print(tree.process_queries())  # Expected: ['true', 'false']

    # Test case 4: Upgrade a node with locked descendants
    queries = [
        "1 B 1",  # Lock B with uid 1
        "1 C 1",  # Lock C with uid 1
        "3 A 1",  # Upgrade A with uid 1 (should succeed and unlock B and C)
    ]
    tree = Tree(m, n, name_list, queries)
    print(tree.process_queries())  # Expected: ['true', 'true', 'true']

    # Test case 5: Upgrade a node with no locked descendants
    queries = [
        "3 A 1",  # Try to upgrade A with uid 1 (should fail because no locked descendants)
    ]
    tree = Tree(m, n, name_list, queries)
    print(tree.process_queries())  # Expected: ['false']

    # Test case 6: Locking a node with locked descendants
    queries = [
        "1 B 1",  # Lock B with uid 1
        "1 A 2",  # Try to lock A with uid 2 (should fail because B is locked)
    ]
    tree = Tree(m, n, name_list, queries)
    print(tree.process_queries())  # Expected: ['true', 'false']

    # Test case 7: Complex scenario
    n = 7
    m = 2
    name_list = ["A", "B", "C", "D", "E", "F", "G"]
    queries = [
        "1 B 1",  # Lock B with uid 1
        "1 D 1",  # Lock D with uid 1
        "1 E 1",  # Lock E with uid 1
        "3 A 1",  # Upgrade A with uid 1 (should succeed and unlock B, D, E)
        "1 A 2",  # Lock A with uid 2
        "2 A 1",  # Try to unlock A with uid 1 (should fail because uid is wrong)
        "2 A 2",  # Unlock A with uid 2
    ]
    tree = Tree(m, n, name_list, queries)
    print(tree.process_queries())  # Expected: ['true', 'true', 'true', 'true', 'true', 'false', 'true']

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