Display¶

def print_projects(
    projects: Sequence[Union[ProjectInfo, Project]], max_items: Optional[int] = None, file: Optional[TextIO] = None
) -> None:
    """
    Print a list of projects.

    Accepts either ProjectInfo (DTO) or Project (wrapper) objects.
    Both have .name and .id attributes, so duck typing works.
    """
    console = create_console(file=file)

    if console:
        primary_color = get_rich_style("primary")
        muted_color = get_rich_style("muted")
        count = len(projects)
        console.print(f"[bold]Found {count} project{'s' if count != 1 else ''}[/bold]")
        if projects:
            console.print("[bold]Projects:[/bold]")
            display_items = projects[:max_items] if max_items is not None else projects
            for project in display_items:
                console.print(
                    f"  [{primary_color}]{project.name}[/{primary_color}] "
                    f"[{muted_color}]({project.id})[/{muted_color}]"
                )
            if max_items is not None and len(projects) > max_items:
                console.print(
                    f"  [{muted_color}]... (showing first {max_items} of {len(projects)} projects)[/{muted_color}]"
                )
    else:
        # Fallback to plain text
        if file is None:
            file = sys.stdout
        print(_format_projects(projects, max_items=max_items), file=file)

def print_collections(
    collections: Sequence[Union[CollectionInfo, Collection]],
    max_items: Optional[int] = None,
    file: Optional[TextIO] = None,
) -> None:
    """
    Print a list of collections.

    Accepts either CollectionInfo (DTO) or Collection (wrapper) objects.
    Both have .name and .id attributes, so duck typing works.
    """
    console = create_console(file=file)

    if console:
        primary_color = get_rich_style("primary")
        muted_color = get_rich_style("muted")
        count = len(collections)
        console.print(f"[bold]Found {count} collection{'s' if count != 1 else ''}[/bold]")
        if collections:
            console.print("[bold]Collections:[/bold]")
            display_items = collections[:max_items] if max_items is not None else collections
            for collection in display_items:
                console.print(
                    f"  [{primary_color}]{collection.name}[/{primary_color}] "
                    f"[{muted_color}]({collection.id})[/{muted_color}]"
                )
            if max_items is not None and len(collections) > max_items:
                console.print(
                    f"  [{muted_color}]... (showing first {max_items} of "
                    f"{len(collections)} collections)[/{muted_color}]"
                )
    else:
        # Fallback to plain text
        if file is None:
            file = sys.stdout
        print(_format_collections(collections, max_items=max_items), file=file)

def print_items(
    items: Sequence[CollectionItemInfo] | Iterable[CollectionItemInfo],
    style: Literal["list", "table"] = "list",
    max_items: Optional[int] = None,
    show_attributes: bool = False,
    file: Optional[TextIO] = None,
) -> None:
    """
    Print flat items for display.

    Use this for items from `list_items()` or `iter_items()`.

    For items with depth information from `walk_items()`, use `print_walk_items()` instead.

    Examples:
        # From list_items()
        items = collection.list_items()
        print_items(items)

        # From iter_items()
        print_items(collection.iter_items(), max_items=50)

        # Include split/labels/annotations from item attributes
        print_items(items, show_attributes=True)
    """
    console = create_console(file=file)

    # Convert to list for counting and slicing
    items_list = list(items)
    total_count = len(items_list)
    display_items = items_list[:max_items] if max_items is not None else items_list

    # Count files and folders separately
    file_count = sum(1 for item in items_list if not item.is_folder)
    folder_count = sum(1 for item in items_list if item.is_folder)

    # Build count message with proper singular/plural
    if file_count == 0 and folder_count == 0:
        count_msg = "Found 0 items"
    elif file_count == 0:
        count_msg = f"Found {folder_count} folder{'s' if folder_count != 1 else ''}"
    elif folder_count == 0:
        count_msg = f"Found {file_count} file{'s' if file_count != 1 else ''}"
    else:
        count_msg = (
            f"Found {file_count} file{'s' if file_count != 1 else ''}, "
            f"{folder_count} folder{'s' if folder_count != 1 else ''}"
        )

    if console:
        console.print(f"[bold]{count_msg}[/bold]")
        if display_items:
            if style == "table":
                # Use rich Table for table style
                primary_color = get_rich_style("primary")
                warning_color = get_rich_style("warning")
                success_color = get_rich_style("success")
                muted_color = get_rich_style("muted")
                show_type_column = any(item.is_folder for item in display_items)
                table = Table(show_header=True, header_style="bold", box=box.ROUNDED)
                table.add_column("Name", style=primary_color)
                if show_type_column:
                    table.add_column("Type", style=warning_color)
                table.add_column("Size", style=success_color, justify="right")
                if show_attributes:
                    table.add_column("Split", style=warning_color)
                    table.add_column("Labels", style=muted_color)
                    table.add_column("Annotations", style=muted_color)
                for item in display_items:
                    item_type = "Folder" if item.is_folder else "File"
                    size_str = human_bytes(item.file_size) if item.file_size else "-"
                    uri = item.item_uri.rstrip("/") + "/" if item.is_folder else item.item_uri
                    row = [uri]
                    if show_type_column:
                        row.append(item_type)
                    row.append(size_str)
                    if show_attributes:
                        split, labels, annotations = _item_attribute_summary_rich(_item_raw_attributes(item))
                        row.extend([split, labels, annotations])
                    table.add_row(*row)
                console.print(table)
            else:
                # Use rich list style
                folder_color = get_rich_style("folder")
                file_color = get_rich_style("file")
                muted_color = get_rich_style("muted")
                for item in display_items:
                    if item.is_folder:
                        uri = item.item_uri.rstrip("/") + "/"
                        console.print(f"  [{folder_color}]{uri}[/{folder_color}]")
                    else:
                        size_str = (
                            f" [{muted_color}]({human_bytes(item.file_size)})[/{muted_color}]" if item.file_size else ""
                        )
                        console.print(f"  [{file_color}]{item.item_uri}[/{file_color}]{size_str}")
                    if show_attributes:
                        split, labels, annotations = _item_attribute_summary_rich(_item_raw_attributes(item))
                        if split != "-":
                            line = Text("    ")
                            line.append("split", style=muted_color)
                            line.append(": ")
                            line.append(split)
                            console.print(line)
                        if labels != "-":
                            line = Text("    ")
                            line.append("labels", style=muted_color)
                            line.append(": ")
                            line.append(labels)
                            console.print(line)
                        if annotations != "-":
                            line = Text("    ")
                            line.append("annotations", style=muted_color)
                            line.append(": ")
                            line.append(annotations)
                            console.print(line)
            if max_items is not None and total_count > max_items:
                muted_color = get_rich_style("muted")
                console.print(
                    f"  [{muted_color}]... (showing first {max_items} of {total_count} items)[/{muted_color}]"
                )
    else:
        # Fallback to plain text
        if file is None:
            file = sys.stdout
        print(_format_items(items, style=style, max_items=max_items), file=file)
        if show_attributes and display_items:
            for item in display_items:
                split, labels, annotations = _item_attribute_summary(_item_raw_attributes(item))
                if split != "-" or labels != "-" or annotations != "-":
                    print(f"  {item.item_uri}", file=file)
                    if split != "-":
                        print(f"    split: {split}", file=file)
                    if labels != "-":
                        print(f"    labels: {labels}", file=file)
                    if annotations != "-":
                        print(f"    annotations: {annotations}", file=file)

def print_walk_items(
    items: Union[Iterable[tuple[CollectionItemInfo, int]], AsyncIterable[tuple[Any, int]]],
    max_items: Optional[int] = None,
    file: Optional[TextIO] = None,
    collection_name: str | None = None,
) -> None:
    """
    Print items from walk_items() with depth-aware formatting.

    This function accepts both sync and async iterators from walk_items().
    For async iterators, items are collected first, then processed.

    Args:
        items: Iterable or AsyncIterable of (item, depth) tuples from walk_items()
        max_items: Maximum number of items to display (None = no limit)
        file: File to write to (default: stdout)
        collection_name: Optional collection name to use as root node (default: "Collection")

    Examples:
        # From walk_items() (sync) - no limits
        print_walk_items(collection.walk_items())

        # From walk_items() (async) - accepts async iterator directly
        print_walk_items(collection.walk_items(), collection_name=collection.name)

        # With optional limits
        print_walk_items(collection.walk_items(max_depth=3), max_items=50)
    """
    # Handle async iterators by collecting them first
    if hasattr(items, "__aiter__"):
        # It's an async iterator - collect items first
        async def _collect_async_items():
            collected = []
            async for item, depth in items:  # type: ignore
                collected.append((item, depth))
            return collected

        # Check if we're in a running event loop
        try:
            loop = asyncio.get_running_loop()
            # We're in an async context - use nest_asyncio to allow nested event loops
            import nest_asyncio

            nest_asyncio.apply(loop)
            # Now we can use run_until_complete even though loop is running
            items_list: list[tuple[CollectionItemInfo, int]] = loop.run_until_complete(_collect_async_items())
        except RuntimeError:
            # No running event loop - we can use asyncio.run()
            items_list = asyncio.run(_collect_async_items())
    else:
        # It's a sync iterable - convert to list for processing
        items_list = list(items)  # type: ignore[arg-type]

    console = create_console(file=file)

    if console:
        # Create a single root tree node for the collection
        root_label = collection_name if collection_name else "Collection"
        root_tree = Tree(f"[bold]{root_label}[/bold]")

        # Use rich Tree for hierarchical display
        count = 0
        file_count = 0
        folder_count = 0
        parent_paths: dict[int, str] = {}
        tree_nodes: dict[int, Tree] = {}  # Track tree nodes at each depth (relative to root)

        for item, depth in items_list:
            # Count files and folders during iteration
            if item.is_folder:
                folder_count += 1
            else:
                file_count += 1

            if item.is_folder:
                # Compute relative path
                if depth == 0:
                    uri = item.item_uri.rstrip("/") + "/"
                    display_path = uri
                else:
                    parent_uri = parent_paths.get(depth - 1, "")
                    if parent_uri and item.item_uri.startswith(parent_uri):
                        relative_path = item.item_uri[len(parent_uri) :].lstrip("/")
                        display_path = relative_path.rstrip("/") + "/"
                    else:
                        display_path = item.item_uri.rstrip("/") + "/"

                # Create or get tree node (all items are children of root_tree)
                folder_color = get_rich_style("folder")
                if depth == 0:
                    # Root level item - add directly to root tree
                    new_node = root_tree.add(f"[{folder_color}]{display_path}[/{folder_color}]")
                    tree_nodes[depth] = new_node
                else:
                    # Child level - add to parent tree node
                    parent_node = tree_nodes.get(depth - 1)
                    if parent_node:
                        new_node = parent_node.add(f"[{folder_color}]{display_path}[/{folder_color}]")
                        tree_nodes[depth] = new_node
                    else:
                        # Fallback: add to root if parent not found
                        new_node = root_tree.add(f"[{folder_color}]{display_path}[/{folder_color}]")
                        tree_nodes[depth] = new_node

                parent_paths[depth] = item.item_uri.rstrip("/") + "/"
            else:
                # File item
                file_color = get_rich_style("file")
                muted_color = get_rich_style("muted")
                if depth == 0:
                    # Root level file - add directly to root tree
                    size_str = (
                        f" [{muted_color}]({human_bytes(item.file_size)})[/{muted_color}]" if item.file_size else ""
                    )
                    display_path = item.item_uri
                    root_tree.add(f"[{file_color}]{display_path}[/{file_color}]{size_str}")
                else:
                    # Child file: show relative path
                    parent_uri = parent_paths.get(depth - 1, "")
                    if parent_uri and item.item_uri.startswith(parent_uri):
                        relative_path = item.item_uri[len(parent_uri) :].lstrip("/")
                    else:
                        relative_path = item.item_uri

                    size_str = (
                        f" [{muted_color}]({human_bytes(item.file_size)})[/{muted_color}]" if item.file_size else ""
                    )
                    parent_node = tree_nodes.get(depth - 1)
                    if parent_node:
                        parent_node.add(f"[{file_color}]{relative_path}[/{file_color}]{size_str}")
                    else:
                        # Fallback: add to root if parent not found
                        root_tree.add(f"[{file_color}]{relative_path}[/{file_color}]{size_str}")

            count += 1
            if max_items is not None and count >= max_items:
                break

        # Build count message with proper singular/plural
        if file_count == 0 and folder_count == 0:
            count_msg = "Found 0 items"
        elif file_count == 0:
            count_msg = f"Found {folder_count} folder{'s' if folder_count != 1 else ''}"
        elif folder_count == 0:
            count_msg = f"Found {file_count} file{'s' if file_count != 1 else ''}"
        else:
            count_msg = (
                f"Found {file_count} file{'s' if file_count != 1 else ''}, "
                f"{folder_count} folder{'s' if folder_count != 1 else ''}"
            )

        # Print header and tree
        console.print(f"[bold]{count_msg}[/bold]")
        if count > 0:
            console.print(root_tree)
            if max_items is not None and count >= max_items:
                muted_color = get_rich_style("muted")
                console.print(f"  [{muted_color}]... (showing first {max_items} items)[/{muted_color}]")
    else:
        # Fallback to plain text
        if file is None:
            file = sys.stdout
        print(_format_walk_items(items_list, max_items=max_items), file=file)

def print_collection_schema(schema: List[Dict[str, Any]], file: Optional[TextIO] = None) -> None:
    """
    Print a collection schema with standard JSON formatting and raw strings for patterns.

    Args:
        schema: List of schema node dictionaries
        file: Optional file to write to (defaults to stdout)
    """
    console = create_console(file=file)

    def format_node(node: Dict[str, Any], indent: int = 0, use_rich: bool = False) -> str:
        """Format a single schema node with standard JSON formatting."""
        indent_str = " " * indent
        field_indent = " " * (indent + 4)  # Fields are indented 4 more than the object
        items = []
        for key, value in node.items():
            if key == "pattern" and isinstance(value, str):
                # Use raw string for patterns
                if use_rich:
                    pattern_color = get_rich_style("primary")
                    items.append(f'{field_indent}"{key}": [{pattern_color}]r"{value}"[/{pattern_color}]')
                else:
                    items.append(f'{field_indent}"{key}": r"{value}"')
            elif key == "name" and isinstance(value, str):
                if use_rich:
                    name_color = get_rich_style("file")
                    items.append(f'{field_indent}"{key}": [{name_color}]"{value}"[/{name_color}]')
                else:
                    items.append(f'{field_indent}"{key}": "{value}"')
            elif key == "children" and isinstance(value, list):
                children_str = format_children(value, indent + 4, use_rich)
                items.append(f'{field_indent}"{key}": {children_str}')
            else:
                if use_rich:
                    muted_color = get_rich_style("muted")
                    items.append(f'{field_indent}"{key}": [{muted_color}]{value}[/{muted_color}]')
                else:
                    items.append(f'{field_indent}"{key}": {value}')
        return indent_str + "{\n" + ",\n".join(items) + "\n" + indent_str + "}"

    def format_children(children: List[Dict[str, Any]], indent: int = 0, use_rich: bool = False) -> str:
        """Format children list with standard JSON formatting."""
        if not children:
            return "[]"
        indent_str = " " * indent
        formatted_nodes = []
        for child in children:
            # Format node with proper indentation (indent + 4 for array content)
            node_str = format_node(child, indent + 4, use_rich)
            formatted_nodes.append(node_str)
        # Standard JSON format: each object on its own line, properly indented
        return "[\n" + ",\n".join(formatted_nodes) + "\n" + indent_str + "]"

    if console:
        # Use Rich formatting
        if not schema:
            console.print("[bold]Schema:[/bold] []")
            return

        console.print("[bold]Schema:[/bold]")
        formatted_schema = format_children(schema, indent=0, use_rich=True)
        console.print(formatted_schema)
    else:
        # Fallback to plain text
        if file is None:
            file = sys.stdout
        if not schema:
            print("Schema: []", file=file)
            return
        print("Schema:", file=file)
        formatted_schema = format_children(schema, indent=0, use_rich=False)
        print(formatted_schema, file=file)

def print_recipes(
    recipes: Sequence["RecipeResponse"],
    max_items: Optional[int] = None,
    file: Optional[TextIO] = None,
) -> None:
    """
    Print a list of recipes.

    Args:
        recipes: Sequence of RecipeResponse objects
        max_items: Optional maximum number of items to display
        file: Optional file to write to (defaults to stdout)
    """
    # Lazy import to avoid circular dependency
    from miura.nexus.recipe.recipe_models import RecipeResponse  # noqa: F401

    console = create_console(file=file)

    if console:
        primary_color = get_rich_style("primary")
        muted_color = get_rich_style("muted")
        count = len(recipes)
        console.print(f"[bold]Found {count} recipe{'s' if count != 1 else ''}[/bold]")
        if recipes:
            console.print("[bold]Recipes:[/bold]")
            display_items = recipes[:max_items] if max_items is not None else recipes
            for recipe in display_items:
                # Try to get source/target info, handle ValidationError gracefully
                try:
                    source = f"{recipe.source_collection}:{recipe.source_group}"
                    try:
                        target = f"{recipe.target_collection}:{recipe.target_group}"
                    except Exception:
                        target = "[dim]<omitted>[/dim]"
                    console.print(
                        f"  [{primary_color}]{recipe.name}[/{primary_color}] "
                        f"[{muted_color}]({recipe.id})[/{muted_color}]"
                    )
                    console.print(f"    Source: {source}, Target: {target}")
                except Exception:
                    # Fallback if convenience properties fail
                    console.print(
                        f"  [{primary_color}]{recipe.name}[/{primary_color}] "
                        f"[{muted_color}]({recipe.id})[/{muted_color}]"
                    )
            if max_items is not None and len(recipes) > max_items:
                console.print(
                    f"  [{muted_color}]... (showing first {max_items} of " f"{len(recipes)} recipes)[/{muted_color}]"
                )
    else:
        # Fallback to plain text
        if file is None:
            file = sys.stdout
        print(_format_recipes(recipes, max_items=max_items), file=file)

def print_project_info(
    project: ProjectInfo,
    collections: Optional[list[CollectionInfo]] = None,
    recipes: Optional[list["RecipeResponse"]] = None,
    file: Optional[TextIO] = None,
) -> None:
    """
    Print comprehensive information about a project, its collections, and recipes.

    Args:
        project: ProjectInfo object with project details
        collections: Optional list of CollectionInfo objects (if None, will show message)
        recipes: Optional list of RecipeResponse objects (if None, will show message)
        file: Optional file to write to (defaults to stdout)
    """
    console = create_console(file=file)
    primary_color = get_rich_style("primary")
    muted_color = get_rich_style("muted")
    error_color = get_rich_style("error")

    if console:
        console.print("[bold]PROJECT INFORMATION[/bold]")
        console.print("[dim]" + "=" * 60 + "[/dim]")
        console.print()
        console.print("[bold]Project Details:[/bold]")
        console.print(f"   Name: [{primary_color}]{project.name}[/{primary_color}]")
        console.print(f"   UUID: [{muted_color}]{project.id}[/{muted_color}]")
        project_metadata = _normalized_metadata(project.metadata)
        owner_line = format_project_owner_line(
            project.owner_id,
            owner_profile=project.owner_profile,
            metadata=project_metadata,
        )
        if owner_line:
            console.print(f"   Owner: [{muted_color}]{owner_line}[/{muted_color}]")
        project_created, project_updated = _display_timestamps(project.created_at, project.updated_at, project_metadata)
        if project_created:
            console.print(f"   Created: [{muted_color}]{project_created}[/{muted_color}]")
        if project_updated:
            console.print(f"   Updated: [{muted_color}]{project_updated}[/{muted_color}]")

        # Handle metadata
        project_metadata_display = _metadata_for_display(project_metadata)
        if project_metadata_display:
            console.print("   Metadata:")
            _print_metadata_value(
                project_metadata_display,
                indent="     ",
                console=console,
                primary_color=primary_color,
                muted_color=muted_color,
            )

        # Collections information
        console.print()
        console.print("[bold]COLLECTIONS INFORMATION[/bold]")
        console.print("[dim]" + "=" * 60 + "[/dim]")
        console.print()

        if collections is None:
            console.print(f"[{error_color}]Error: Could not list collections[/{error_color}]")
        elif not collections:
            console.print(f"[{muted_color}]No collections found in this project[/{muted_color}]")
        else:
            console.print(f"Found {len(collections)} collection{'s' if len(collections) != 1 else ''}:")
            console.print("[dim]" + "-" * 60 + "[/dim]")
            console.print()

            for i, collection in enumerate(collections, 1):
                console.print(f"{i}. [{primary_color}]{collection.name}[/{primary_color}]")
                console.print(f"   UUID: [{muted_color}]{collection.uuid}[/{muted_color}]")

                # Handle collection attributes + remaining metadata
                collection_metadata = _normalized_metadata(collection.metadata)
                collection_created, collection_updated = _display_timestamps(
                    collection.created_at, collection.updated_at, collection_metadata
                )
                collection_attributes_display, collection_metadata_display = _collection_fields_for_display(
                    collection_metadata
                )
                if collection_attributes_display:
                    console.print("   Attributes:")
                    _print_metadata_value(
                        collection_attributes_display,
                        indent="     ",
                        console=console,
                        primary_color=primary_color,
                        muted_color=muted_color,
                    )
                if collection_metadata_display:
                    console.print("   Metadata:")
                    _print_metadata_value(
                        collection_metadata_display,
                        indent="     ",
                        console=console,
                        primary_color=primary_color,
                        muted_color=muted_color,
                    )

                # Handle timestamps
                if collection_created:
                    console.print(f"   Created: [{muted_color}]{collection_created}[/{muted_color}]")
                if collection_updated:
                    console.print(f"   Updated: [{muted_color}]{collection_updated}[/{muted_color}]")

                console.print("[dim]" + "-" * 40 + "[/dim]")
                console.print()

        # Recipes information
        console.print()
        console.print("[bold]RECIPES INFORMATION[/bold]")
        console.print("[dim]" + "=" * 60 + "[/dim]")
        console.print()
        if recipes is None:
            console.print(f"[{error_color}]Error: Could not list recipes[/{error_color}]")
        elif not recipes:
            console.print(f"[{muted_color}]No recipes found in this project[/{muted_color}]")
        else:
            console.print(f"Found {len(recipes)} recipe{'s' if len(recipes) != 1 else ''}:")
            console.print("[dim]" + "-" * 60 + "[/dim]")
            console.print()
            for i, recipe in enumerate(recipes, 1):
                console.print(f"{i}. [{primary_color}]{recipe.name}[/{primary_color}]")
                console.print(f"   UUID: [{muted_color}]{recipe.id}[/{muted_color}]")
                console.print(f"   Created by: [{muted_color}]{recipe.created_by}[/{muted_color}]")
                console.print(f"   Created at: [{muted_color}]{recipe.created_at}[/{muted_color}]")
                if recipe.description:
                    console.print(f"   description: [{muted_color}]{recipe.description}[/{muted_color}]")

                # Sources information
                console.print("   [bold]Sources:[/bold]")
                if recipe.sources:
                    for i, source in enumerate(recipe.sources, 1):
                        console.print(
                            f"      {i}. [{primary_color}]{source.collection_name}[/{primary_color}] "
                            f"(group: [{muted_color}]{source.group_name}[/{muted_color}])"
                        )
                else:
                    console.print(f"      [{muted_color}]No sources (data integrity issue)[/{muted_color}]")

                # Targets information
                console.print("   [bold]Targets:[/bold]")
                if recipe.targets:
                    for i, target in enumerate(recipe.targets, 1):
                        console.print(
                            f"      {i}. [{primary_color}]{target.collection_name}[/{primary_color}] "
                            f"(group: [{muted_color}]{target.group_name}[/{muted_color}])"
                        )
                else:
                    console.print(f"      [{muted_color}]Omitted (will be created during execution)[/{muted_color}]")

                console.print("[dim]" + "-" * 40 + "[/dim]")
                console.print()
    else:
        # Plain text fallback
        if file is None:
            file = sys.stdout
        print("PROJECT INFORMATION", file=file)
        print("=" * 60, file=file)
        print("Project Details:", file=file)
        print(f"   Name: {project.name}", file=file)
        print(f"   UUID: {project.id}", file=file)
        project_metadata = _normalized_metadata(project.metadata)
        owner_line = format_project_owner_line(
            project.owner_id,
            owner_profile=project.owner_profile,
            metadata=project_metadata,
        )
        if owner_line:
            print(f"   Owner: {owner_line}", file=file)
        project_created, project_updated = _display_timestamps(project.created_at, project.updated_at, project_metadata)
        if project_created:
            print(f"   Created: {project_created}", file=file)
        if project_updated:
            print(f"   Updated: {project_updated}", file=file)
        project_metadata_display = _metadata_for_display(project_metadata)
        if project_metadata_display:
            print("   Metadata:", file=file)
            _print_metadata_value(project_metadata_display, indent="     ", file=file)
        print("\nCOLLECTIONS INFORMATION", file=file)
        print("=" * 60, file=file)
        if collections is None:
            print("Error: Could not list collections", file=file)
        elif not collections:
            print("No collections found in this project", file=file)
        else:
            print(f"Found {len(collections)} collection(s):", file=file)
            print("-" * 60, file=file)
            for i, collection in enumerate(collections, 1):
                print(f"{i}. {collection.name}", file=file)
                print(f"   UUID: {collection.uuid}", file=file)
                collection_metadata = _normalized_metadata(collection.metadata)
                collection_created, collection_updated = _display_timestamps(
                    collection.created_at, collection.updated_at, collection_metadata
                )
                collection_attributes_display, collection_metadata_display = _collection_fields_for_display(
                    collection_metadata
                )
                if collection_attributes_display:
                    print("   Attributes:", file=file)
                    _print_metadata_value(collection_attributes_display, indent="     ", file=file)
                if collection_metadata_display:
                    print("   Metadata:", file=file)
                    _print_metadata_value(collection_metadata_display, indent="     ", file=file)
                if collection_created:
                    print(f"   Created: {collection_created}", file=file)
                if collection_updated:
                    print(f"   Updated: {collection_updated}", file=file)
                print("-" * 40, file=file)

        print("\nRECIPES INFORMATION", file=file)
        print("=" * 60, file=file)
        if recipes is None:
            print("Error: Could not list recipes", file=file)
        elif not recipes:
            print("No recipes found in this project", file=file)
        else:
            print(f"Found {len(recipes)} recipe(s):", file=file)
            print("-" * 60, file=file)
            for i, recipe in enumerate(recipes, 1):
                print(f"{i}. {recipe.name}", file=file)
                print(f"   UUID: {recipe.id}", file=file)
                print("-" * 40, file=file)