class Node:
    def __init__(self, value):
        self.value = value
        self.children = []

def diameter_of_n_ary_tree_brute_force(root):
    if not root:
        return 0

    max_diameter = 0

    def height(node):
        if not node:
            return 0
        if not node.children:
            return 1

        maximum_height = 0
        for child in node.children:
            maximum_height = max(maximum_height, height(child))

        return maximum_height + 1

    def calculate_distance(start_node, end_node):
        if not start_node or not end_node:
            return 0

        if start_node == end_node:
            return 0

        # This list keeps track of visited nodes
        visited_nodes = set()
        queue = [(start_node, 0)]
        visited_nodes.add(start_node)

        while queue:
            current_node, current_distance = queue.pop(0)

            if current_node == end_node:
                return current_distance

            for child in current_node.children:
                if child not in visited_nodes:
                    queue.append((child, current_distance + 1))
                    visited_nodes.add(child)

        return float('inf')

    # Consider every node as a potential start
    all_nodes = []

    def traverse(node):
        if node:
            all_nodes.append(node)
            for child in node.children:
                traverse(child)

    traverse(root)

    for start_node in all_nodes:
        # Explore every possible path to every other node
        for end_node in all_nodes:
            path_length = calculate_distance(start_node, end_node)
            # Find the longest path
            max_diameter = max(max_diameter, path_length)

    return max_diameter

class Node:
    def __init__(self):
        self.children = []

def diameter_of_n_ary_tree(root):
    longest_path = 0

    def depth(node):
        nonlocal longest_path
        if not node:
            return 0

        # Store the depths of all child nodes
        child_depths = []
        for child in node.children:
            child_depths.append(depth(child))

        # Find the two largest depths
        child_depths.sort(reverse=True)

        first_longest_path = child_depths[0] if len(child_depths) > 0 else 0
        second_longest_path = child_depths[1] if len(child_depths) > 1 else 0

        # Update the longest path if needed
        longest_path = max(longest_path,
                           first_longest_path + second_longest_path)

        # Return the depth of the current node
        return first_longest_path + 1

    depth(root)
    return longest_path

def create_tree():
    root = Node()

    child1 = Node()
    child2 = Node()
    child3 = Node()
    root.children = [child1, child2, child3]

    grandchild1 = Node()
    grandchild2 = Node()
    child1.children = [grandchild1, grandchild2]

    grandchild3 = Node()
    child2.children = [grandchild3]

    return root

if __name__ == '__main__':
    root_node = create_tree()

    #Calculate tree diameter
    tree_diameter = diameter_of_n_ary_tree(root_node)

    print(f"Diameter of N-ary Tree: {tree_diameter}")