views

class AYViewEditor(QDialog):
    """Modal editor for the metadata fields of a :class:`View`.

    Args:
        view: The :class:`View` to edit.  Pass a fresh ``View()`` with
            an empty ``id`` to create a new view.
        current_user: User identifier of the editor.  Used to gate the
            studio scope when applicable.
        allow_studio_scope: Whether ``Scope.STUDIO`` is offered to the
            user.  Consumer apps gate this via their permission model.
        usernames_and_groups: Users and access groups offered in the
            "People with access" selector.
        allow_sharing: Whether the "People with access" section is
            shown.  When False the view's access is left unchanged.
        parent: Optional parent widget.
    """

    class Mode(IntEnum):
        """Dialog mode: create or edit."""

        CREATE = 0
        EDIT = 1

    def __init__(
        self,
        view: View,
        current_user: str = "",
        current_project: str = "",
        allow_studio_scope: bool = False,
        usernames_and_groups: dict[str, list] | None = None,
        allow_sharing: bool = True,
        parent: QWidget | None = None,
    ) -> None:
        self._dialog_mode = (
            AYViewEditor.Mode.EDIT if view.id else AYViewEditor.Mode.CREATE
        )

        super().__init__(parent)
        self.setStyle(get_ayon_style())
        self.setWindowTitle(
            "Edit View"
            if self._dialog_mode == AYViewEditor.Mode.EDIT
            else "Create New View"
        )
        self.setModal(True)
        self.setContentsMargins(0, 0, 0, 0)

        self._view = view
        self._current_user = current_user
        self.usernames_and_groups = usernames_and_groups or {
            "users": [],
            "groups": [],
        }
        self._current_project = current_project
        self._allow_studio_scope = bool(allow_studio_scope)
        self._allow_sharing = bool(allow_sharing)
        self._delete_requested = False

        # Access control state: {key: access_level}
        #   where key is "user:name" or "group:name"
        self._access_dict: dict[str, int] = {}
        # Stores row widgets by access key
        self._access_row_widgets: dict[str, QWidget] = {}

        self._build_ui()
        self._load_from_view(view)

    # ------------------------------------------------------------------
    # UI construction
    # ------------------------------------------------------------------

    def _build_ui(self) -> None:
        """Create the form and button row."""
        root = AYVBoxLayout(self, spacing=0, margin=0)

        static_layout = AYContainer(
            layout=AYContainer.Layout.VBox,
            layout_margin=20,
            layout_spacing=12,
        )

        static_layout.add_widget(AYLabel("View name"))

        # view name field — required.
        self._view_name_edit = AYLineEdit(placeholder="View name")
        static_layout.add_widget(self._view_name_edit)

        # Scope combo (project / all projects).
        self._scope_combo = AYComboBox()
        scope_items = [
            {
                "text": f"Project - {self._current_project}",
                "short_text": "Project",
            }
        ]
        if self._allow_studio_scope:
            scope_items.append(
                {"text": "All Projects", "short_text": "All Projects"}
            )
        self._scope_combo.update_items(scope_items)
        static_layout.add_widget(AYLabel("Scope"))
        static_layout.add_widget(self._scope_combo)

        # Everything about sharing lives in one section, so it can be
        # hidden as a whole when sharing is unavailable.
        access_section = AYContainer(
            layout=AYContainer.Layout.VBox,
            layout_margin=0,
            layout_spacing=12,
        )
        access_section.setVisible(self._allow_sharing)
        static_layout.add_widget(access_section)

        # User/group selector dropdown
        self._user_selector = AYSearchableComboBox(
            placeholder="Add people or access groups"
        )

        access_section.add_widget(AYLabel("People with access"))
        access_section.add_widget(self._user_selector)

        self._user_selector.item_selected.connect(self._on_user_selected)

        # Owner row
        self._owner_avatar = AYUserImage(
            name="",
            full_name="",
            size=24,
            outline=False,
        )
        self._owner_avatar.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        self._owner_label = AYLabel("-")

        owner_row = AYContainer(
            layout=AYContainer.Layout.HBox,
            layout_spacing=8,
            layout_margin=0,
        )
        owner_row.add_widget(self._owner_avatar, stretch=0)
        owner_row.add_widget(self._owner_label, stretch=0)
        owner_row.addStretch()
        owner_row.add_widget(AYLabel("Owner", dim=True))
        owner_row.layout().addSpacerItem(
            QSpacerItem(32, 0, QSizePolicy.Fixed, QSizePolicy.Minimum)
        )
        access_section.add_widget(owner_row)

        # Everyone row
        self._everyone_combo = AYComboBox()
        access_items = [
            {"text": ACCESS_LEVELS[level]} for level in ACCESS_LEVEL_VALUES
        ]
        self._everyone_combo.update_items(access_items)
        self._everyone_combo.setFixedWidth(120)

        def on_everyone_changed(idx: int) -> None:
            self._access_dict["__everyone__"] = ACCESS_LEVEL_VALUES[idx]

        self._everyone_combo.currentIndexChanged.connect(on_everyone_changed)

        everyone_row = AYContainer(
            layout=AYContainer.Layout.HBox,
            layout_spacing=8,
            layout_margin=0,
        )
        everyone_icon = AYLabel(icon="groups", icon_size=24)
        everyone_row.add_widget(everyone_icon, stretch=0)
        everyone_row.add_widget(AYLabel("Everyone"), stretch=0)
        everyone_row.addStretch()
        everyone_row.add_widget(self._everyone_combo)
        everyone_row.layout().addSpacerItem(
            QSpacerItem(32, 0, QSizePolicy.Fixed, QSizePolicy.Minimum)
        )
        access_section.add_widget(everyone_row)

        # Dynamic user/group access rows
        self._access_rows_container = AYContainer(
            layout=AYContainer.Layout.VBox,
            layout_spacing=4,
            layout_margin=0,
        )
        access_section.add_widget(self._access_rows_container)

        root.addWidget(static_layout)
        root.addStretch()

        # Button row - positioned at bottom with Delete on left, Save on right
        button_container = QWidget()
        button_layout = QHBoxLayout(button_container)
        button_layout.setContentsMargins(16, 16, 16, 16)
        button_layout.setSpacing(8)

        save_btn = AYButton(
            "Save"
            if self._dialog_mode == AYViewEditor.Mode.EDIT
            else "Create",
            variant=AYButton.Variants.Filled,
            icon="check",
        )
        delete_btn = AYButton(
            "Delete", variant=AYButton.Variants.Danger, icon="delete"
        )

        if self._dialog_mode == AYViewEditor.Mode.EDIT:
            # Delete on left, stretch, Save on right
            button_layout.addWidget(delete_btn)
            button_layout.addStretch()
            button_layout.addWidget(save_btn)
            delete_btn.clicked.connect(self._on_delete)
        else:
            # Just Save on right for create mode
            button_layout.addStretch()
            button_layout.addWidget(save_btn)

        save_btn.clicked.connect(self._on_accept)

        root.addWidget(button_container)

        self.setMinimumWidth(500)
        self.setContentsMargins(0, 0, 0, 0)

    # ------------------------------------------------------------------
    # Data loading
    # ------------------------------------------------------------------

    def _load_from_view(self, view: View) -> None:
        """Populate widgets from *view*.

        Args:
            view: The view to copy values from.
        """
        self._view_name_edit.setText(view.label)

        # Scope: select matching item, falling back to project when
        # studio is disallowed but the view is scoped studio.
        if view.scope == Scope.STUDIO and self._allow_studio_scope:
            self._scope_combo.setCurrentIndex(1)
        else:
            self._scope_combo.setCurrentIndex(0)

        # Load access data from view
        self._access_dict = dict(view.access) if view.access else {}

        # Update Owner
        owner_name = self._view.owner or self._current_user or "-"
        self._owner_label.setText(owner_name)

        # Recreate owner avatar with updated name
        self._owner_avatar._name = owner_name
        self._owner_avatar._full_name = owner_name
        self._owner_avatar.set_image()

        # Update Everyone
        everyone_level = self._access_dict.get("__everyone__", 0)
        if everyone_level not in ACCESS_LEVEL_VALUES:
            everyone_level = 0
        self._access_dict["__everyone__"] = everyone_level
        self._everyone_combo.setCurrentIndex(
            ACCESS_LEVEL_VALUES.index(everyone_level)
        )

        self._populate_access_rows()
        self._update_user_dropdown()

    def _update_user_dropdown(self) -> None:
        """Update dropdown to show only users/groups not yet added."""
        added_keys = set(self._access_dict.keys())

        items = []
        users = self.usernames_and_groups.get("users", [])
        groups = self.usernames_and_groups.get("groups", [])

        if users:
            for user in users:
                user_name = user.get("name", "")
                user_full_name = user.get("fullName", "") or user_name
                user_key = f"user:{user_name}"
                if user_key not in added_keys:
                    items.append({
                        "key": user_key,
                        "label": user_full_name,
                        "identifier": user_name,
                        "type": "user"
                    })

        for group in groups:
            group_key = f"group:{group}"
            if group_key not in added_keys:
                items.append({
                    "key": group_key,
                    "label": group.capitalize(),
                    "identifier": "group",
                    "type": "group"
                })

        # Set items
        self._user_selector.set_items_with_builder(
            items,
            row_builder=self._build_access_list_row
        )

    def _on_user_selected(self, access_key: str) -> None:
        """Handle user selection from dropdown."""
        if not access_key:
            return

        self._add_access_row(access_key, 10)  # Default to Viewer access
        self._update_user_dropdown()

    def _add_access_row(self, key: str, access_level: int) -> None:
        """Add an access control row for the given user/group.

        Args:
            key: The access key (e.g., "user:name" or "group:name").
            access_level: The access level (0, 10, 20, or 30).
        """
        if key in self._access_dict:
            return  # Already exists

        self._access_dict[key] = access_level
        self._populate_access_rows()

    def _remove_access_row(self, key: str) -> None:
        """Remove an access control row.

        Args:
            key: The access key to remove.
        """
        if key not in self._access_dict:
            return

        del self._access_dict[key]

        self._populate_access_rows()
        self._update_user_dropdown()

    def _render_access_row(self, key: str, access_level: int) -> None:
        """Render a single access row"""
        row = AYContainer(
            layout=AYContainer.Layout.HBox,
            layout_spacing=4,
            layout_margin=0,
        )

        access_combo = AYComboBox(show_chevron=True)
        access_combo.setFixedWidth(120)
        access_items = [
            {"text": ACCESS_LEVELS[level]}
            for level in ACCESS_LEVEL_VALUES
        ]
        access_combo.update_items(access_items)

        if access_level not in ACCESS_LEVEL_VALUES:
            access_level = 10
        access_combo.setCurrentIndex(ACCESS_LEVEL_VALUES.index(access_level))

        def on_access_changed(idx: int) -> None:
            self._access_dict[key] = ACCESS_LEVEL_VALUES[idx]

        access_combo.currentIndexChanged.connect(on_access_changed)

        remove_btn = AYButton("", icon="close", variant=AYButton.Variants.Nav)
        remove_btn.setFixedWidth(32)
        remove_btn.clicked.connect(lambda: self._remove_access_row(key))

        label_widget = self._build_access_row_label(key)
        row.add_widget(label_widget, stretch=1)
        row.addStretch()
        row.add_widget(access_combo)
        row.add_widget(remove_btn)

        self._access_rows_container.add_widget(row)
        self._access_row_widgets[key] = row

    def _populate_access_rows(self) -> None:
        """Populate access control rows from _access_dict."""
        # Clear existing rows
        for widget in self._access_row_widgets.values():
            widget.setVisible(False)
            widget.deleteLater()
        self._access_row_widgets.clear()

        self._access_rows_container.clear()

        # Add user/group rows
        for key in sorted(self._access_dict.keys()):
            if key == "__everyone__":
                continue
            self._render_access_row(key, int(self._access_dict[key]))

    def _build_access_list_row(self, row, entry: dict) -> None:
        """Build custom identifier widgets for a dropdown row.

        This row builder is used with :meth:`AYSearchableComboBox.set_items_with_builder`
        to add avatar and identifier labels to user/group rows.

        Args:
            row: The _ItemRow widget to customize.
            entry: The item dict containing metadata.
        """  # noqa: E501
        entry_type = entry.get("type", "")
        identifier = entry.get("identifier", "")
        label = entry.get("label", "")

        # Insert avatar/icon at the beginning for users and groups
        if entry_type == "user":
            avatar = AYUserImage(
                name=identifier,
                full_name=label,
                size=20,
                outline=False,
            )
            avatar.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
            row.layout().insertWidget(0, avatar)
        elif entry_type == "group":
            group_icon = AYLabel(
                icon="shield_person",
                icon_size=20,
            )
            row.layout().insertWidget(0, group_icon)

        if "identifier" in entry:
            # Add spacer item with stretch
            row.layout().addSpacerItem(
                QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Minimum)
            )
            # Add identifier label (dim)
            id_label = AYLabel(f"({identifier})", dim=True)
            row.add_custom_widget(id_label, stretch=0)

    def _build_access_row_label(self, key: str) -> AYContainer:
        """Build formatted label widget for access control row.

        For users: Shows avatar with "Full Name" and "(username)" in dim text
        For groups: Shows capitalized group name

        Args:
            key: The access key (e.g., "user:name" or "group:name")

        Returns:
            AYContainer with formatted widgets for the access row.
        """
        if key.startswith("user:"):
            # Extract username from key
            user_name = key.replace("user:", "")

            # Find the full name from usernames_and_groups
            user_full_name = user_name
            for user in self.usernames_and_groups["users"]:
                if user["name"] == user_name:
                    user_full_name = user["fullName"] or user_name
                    break

            # Create container with avatar and text
            user_row_container = AYContainer(
                layout=AYContainer.Layout.HBox,
                layout_spacing=8,
                layout_margin=0,
            )

            # Add Avatar
            avatar = AYUserImage(
                name=user_name,
                full_name=user_full_name,
                size=24,
                outline=False,
                parent=user_row_container,
            )
            avatar.setSizePolicy(
                QSizePolicy.Fixed,
                QSizePolicy.Fixed,
            )
            user_row_container.add_widget(avatar, stretch=0)

            # Add full name
            user_row_container.add_widget(
                AYLabel(user_full_name),
                stretch=0
            )
            user_row_container.add_widget(
                AYLabel(f"({user_name})", dim=True),
                stretch=0
            )
            user_row_container.layout().addSpacerItem(
                QSpacerItem(
                    0,
                    0,
                    QSizePolicy.Expanding,
                    QSizePolicy.Minimum,
                )
            )

            return user_row_container

        # Group access row
        group_name = key.replace("group:", "")

        # Create container with groups icon and name
        group_row_container = AYContainer(
            layout=AYContainer.Layout.HBox,
            layout_spacing=8,
            layout_margin=0,
        )

        # Add groups icon
        group_icon = AYLabel(
            icon="shield_person",
            icon_size=24,
        )
        group_row_container.add_widget(group_icon, stretch=0)

        # Add group name
        group_row_container.add_widget(
            AYLabel(group_name.capitalize()),
            stretch=0
        )
        group_row_container.layout().addSpacerItem(
            QSpacerItem(
                0,
                0,
                QSizePolicy.Expanding,
                QSizePolicy.Minimum,
            )
        )

        return group_row_container

    # ------------------------------------------------------------------
    # Accept handling
    # ------------------------------------------------------------------

    def _on_accept(self) -> None:
        """Validate inputs and accept the dialog.

        Labels must be non-empty; the dialog stays open otherwise.
        """
        label = self._view_name_edit.text().strip()
        if not label:
            self._view_name_edit.setFocus(Qt.FocusReason.OtherFocusReason)
            return

        self.accept()

    def _on_delete(self) -> None:
        """Delete the view and close the dialog."""
        self._delete_requested = True
        self.accept()

    # ------------------------------------------------------------------
    # Public API
    # ------------------------------------------------------------------

    def mode(self) -> AYViewEditor.Mode:
        """Return the dialog mode: create or edit."""
        return self._dialog_mode

    def delete_requested(self) -> bool:
        """Whether the user requested deletion of the view."""
        return self._delete_requested

    def get_view(self) -> View:
        """Return the edited :class:`View`.

        The original :attr:`View.settings`, :attr:`View.id`,
        :attr:`View.view_type`, :attr:`View.owner`, :attr:`View.access`,
        :attr:`View.position` and :attr:`View.extra` are kept intact;
        only the metadata edited in this dialog is mutated.

        Returns:
            The (mutated) original :class:`View` instance.
        """
        view = self._view
        view.label = self._view_name_edit.text().strip()

        if self._scope_combo.currentIndex() == 1 and self._allow_studio_scope:
            view.scope = Scope.STUDIO
        else:
            view.scope = Scope.PROJECT

        # The access editor is hidden without sharing; keep whatever
        # access the view already has rather than the editor defaults.
        if self._allow_sharing:
            view.access = dict(self._access_dict)

        if not view.owner and self._current_user:
            view.owner = self._current_user

        return view

class AYViewSelector(AYButtonMenu):
    """Icon button exposing the Views feature.

    Public API:

    - :meth:`set_view_type` — switch the view-type identifier and reload.
    - :meth:`refresh` — re-pull the view list from the manager.
    - :meth:`current_view` — return the active :class:`View` (or
      ``None``).

    Signals:
        view_applied(View): Emitted after a view has been applied to
            the bindings.
        view_saved(View): Emitted after a view has been persisted.
        view_deleted(str): Emitted with the view id after deletion.
        view_modified(str, bool): Emitted when the live UI no longer
            matches the loaded view settings, or when it returns to the
            saved state. Payload is ``(current_view_name, modified)``.
        binding_error(str, str): Emitted with ``(stage, message)`` when
            :class:`ViewBindings` reports a non-fatal failure while
            applying or capturing a view.
    """

    view_applied = Signal(object)
    view_saved = Signal(object)
    view_deleted = Signal(str)
    view_modified = Signal(str, bool)
    binding_error = Signal(str, str)
    default_view_message = Signal(str, bool)

    def __init__(
        self,
        bindings: ViewBindings,
        manager: ViewManager,
        view_type: str,
        current_user: str = "",
        user_access_level: int = _DEFAULT_USER_ACCESS,
        allow_studio_scope: bool = False,
        parent: QWidget | None = None,
    ) -> None:
        # Store state before super().__init__() because the base class
        # invokes ``populate_callback`` during construction.
        self._bindings = bindings
        self._manager = manager
        self._view_type = view_type
        self._current_user = current_user
        self._user_access = int(user_access_level)
        self._allow_studio_scope = bool(allow_studio_scope)
        # Dirty flag: set on any UI change, cleared on apply/save/reset.
        # just highlight as soon as the user makes any change.
        self._view_modified = False

        self._current_view: View | None = None
        self._views: list[View] = []
        # The view list is only needed to draw the dropdown, so it is
        # fetched the first time the menu opens rather than at startup.
        self._views_loaded: bool = False
        # When True, :meth:`refresh` skips its auto-apply-working-view
        # branch.  Toggled by :class:`_SuspendAutoApply` around save
        # operations so the manager-driven refresh during save_view
        # does not trigger a redundant page-0 refetch.
        self._suppress_auto_apply: bool = False
        self._ensuring_working_view: bool = False
        # True while :meth:`_apply_view` is pushing settings into the
        # widgets. Those widgets emit the same change signals a user edit
        # does, and echoing them back to the server would rewrite the
        # working view with what we just read from it.
        self._applying_view: bool = False

        # Per-section collapsed state for the dropdown headers ("My
        # views", "Shared views", "Default view"). Kept for the
        # lifetime of the selector, mirroring the frontend's
        # collapsible section headers.
        self._collapsed_sections: dict[str, bool] = {}

        self._dropdown_layout = None  # type: ignore[assignment]
        self._default_view_control = DefaultViewControl(self)

        super().__init__(
            populate_callback=self._populate_menu,
            icon="view_quilt",
            variant=AYButton.Variants.Surface,
            dropdown_variant=AYContainer.Variants.Popover,
            dropdown_margin=6,
            tooltip="Views",
            parent=parent,
        )
        self.setObjectName("AYViewSelector")
        self.setFixedSize(32, 32)

        # Applying a view, or a single user gesture, moves several widgets
        # at once. Coalesce the resulting saves into one round trip.
        # Built here rather than with the state above: parenting a QTimer
        # needs this object's base class to be initialised first.
        self._working_view_timer = QTimer(self)
        self._working_view_timer.setSingleShot(True)
        self._working_view_timer.setInterval(300)
        self._working_view_timer.timeout.connect(self._update_working_view)

        # Rebuild the menu contents each time it opens, since the view
        # list may change between openings.
        self.menu_opened.connect(self._rebuild_menu)

        # Refresh when the manager changes.
        self._manager.views_changed.connect(self._on_manager_changed)
        self._manager.project_changed.connect(self._on_project_changed)
        self._connect_modified_state_sources()

        # Forward binding errors via the public ``binding_error`` signal so
        # hosts can surface them.  Overrides any pre-existing
        # ``on_error`` hook (the caller can wrap it themselves to chain).
        if self._bindings.on_error is None:
            self._bindings.on_error = self._on_binding_error

        self.refresh()
        # After refresh(), since it may apply a working view and set
        # its own "View: ..." tooltip — this call must have the final
        # say when there's no project, overriding that.
        self._update_enabled_for_project()

    # ------------------------------------------------------------------
    # Menu population
    # ------------------------------------------------------------------

    def _populate_menu(self, container: QFrame) -> None:
        """Initial populate callback invoked by :class:`AYButtonMenu`.

        We only cache the container's layout here; actual contents are
        (re)built on every menu open via :meth:`_rebuild_menu`.

        Args:
            container: The dropdown ``QFrame`` provided by the base.
        """
        layout = container.layout()
        if layout is not None:
            layout.setContentsMargins(4, 4, 4, 4)
            layout.setSpacing(2)
        self._dropdown_layout = layout

    def _rebuild_menu(self) -> None:
        """Rebuild the dropdown contents from the current view list."""
        layout = self._dropdown_layout
        if layout is None:
            return

        # Wipe previous contents.
        while layout.count():
            item = layout.takeAt(0)
            if item and item.widget():
                item.widget().deleteLater()

        # First open of the menu is what pays for the view list.
        self._ensure_views_listed()

        # The working view + "My views" + "Shared views" portion lives
        # in its own scrollable area, capped at _VIEWS_LIST_MAX_HEIGHT,
        # so a long view list scrolls instead of growing the dropdown
        # indefinitely — "Default view" and "Create new view…" stay
        # outside it, always visible.
        layout.addWidget(self._make_views_list_scroll_area())

        layout.addWidget(
            self._make_section_header("Default view", "default_view")
        )
        if not self._collapsed_sections.get("default_view"):
            layout.addWidget(self._make_default_view_row())
        layout.addWidget(self._make_separator())

        layout.addWidget(self._make_create_view_row())

        self.refresh_dropdown_size()

    def _make_views_list_scroll_area(self) -> AYScrollArea:
        """Build the scrollable working-view + "My views" + "Shared
        views" portion of the dropdown, capped at
        ``_VIEWS_LIST_MAX_HEIGHT``.
        """
        # A real, opaquely-painted Popover frame — same variant as the
        # dropdown and its rows — rather than a bare QWidget stylesheet
        # "background: transparent". The dropdown is a translucent
        # popup: a bare widget's "transparent" paints nothing of its
        # own, and any pixel none of its rows happen to cover (the
        # inter-row spacing, in particular) has nothing to fall back
        # to, so it stayed see-through — a visible darker gap/border
        # around the whole list. Painting Popover here directly makes
        # every pixel in the list opaque and correct, regardless of
        # what any translucent ancestor does or doesn't cover.
        scroll_content = AYContainer(
            layout=AYContainer.Layout.VBox,
            variant=AYContainer.Variants.Popover_Square,
            layout_spacing=2,
            layout_margin=0,
        )

        # Current view row with inline reset button.
        scroll_content.add_widget(
            self._make_working_view_row(self._current_view)
        )
        scroll_content.add_widget(self._make_separator())

        # Exclude working view as it stored with private Visibility
        private_views = [
            v for v in self._views
            if v.visibility == Visibility.PRIVATE
               and not v.working
               and v.label != DEFAULT_VIEW_LABEL
        ]
        public_views = [
            v for v in self._views if v.visibility == Visibility.PUBLIC
        ]

        if private_views:
            scroll_content.add_widget(
                self._make_section_header("My views", "my_views")
            )
            if not self._collapsed_sections.get("my_views"):
                for view in private_views:
                    scroll_content.add_widget(self._make_row(view))

        if public_views and self._manager.supports_sharing():
            scroll_content.add_widget(
                self._make_section_header("Shared views", "shared_views")
            )
            if not self._collapsed_sections.get("shared_views"):
                for view in public_views:
                    scroll_content.add_widget(self._make_row(view))

        if not self._views:
            no_views_label = AYLabel("No saved views.", dim=True)
            # Match the left indent every row's own label gets from its
            # row's contents margins + the label's own inner margin
            # (2 + 6 = 8), since this one isn't wrapped in a row.
            no_views_label.setContentsMargins(8, 4, 8, 4)
            scroll_content.add_widget(no_views_label)

        scroll_area = AYScrollArea()
        scroll_area.setWidget(scroll_content)
        scroll_area.setWidgetResizable(True)
        scroll_area.setHorizontalScrollBarPolicy(
            Qt.ScrollBarPolicy.ScrollBarAlwaysOff
        )

        # Natural content height, capped — lets the scroll area shrink
        # to fit a short list instead of always reserving max height.
        scroll_content.adjustSize()
        content_height = scroll_content.sizeHint().height()
        scroll_area.setFixedHeight(
            min(content_height, _VIEWS_LIST_MAX_HEIGHT)
        )
        return scroll_area

    # ------------------------------------------------------------------
    # Row helpers
    # ------------------------------------------------------------------

    def _style_row(self, row: AYContainer) -> None:
        """Apply the shared row inset/height to a dropdown list row.

        Uses the row's *layout* contents margins rather than the row
        widget's own ``setContentsMargins`` — ``AYFrame`` paints its own
        background using ``frameRect()`` (== ``contentsRect()``), which
        is inset by the widget's own contents margins. Insetting the
        widget itself would shrink the row's background fill by the
        same amount as its children, leaving the fill and a trailing
        action button flush against each other with no visible gap.
        The layout's margins only affect child placement, so this
        keeps the row's fill full-bleed while still inserting real
        padding around its children.
        """
        row.layout().setContentsMargins(4, 4, 8, 4)
        row.setMinimumHeight(_ROW_MIN_HEIGHT)

    def _make_separator(self) -> QFrame:
        """Return a subtle 1px divider line (outline-variant color)."""
        sep = QFrame()
        sep.setFrameShape(QFrame.Shape.HLine)
        sep.setFrameShadow(QFrame.Shadow.Plain)
        sep.setFixedHeight(1)
        sep.setStyleSheet("QFrame { border-top: 1px solid #41474d; }")
        return sep

    def _make_section_header(
        self, title: str, section_key: str
    ) -> _SectionHeader:
        """Return a clickable, collapsible section header."""
        return _SectionHeader(
            title,
            collapsed=bool(self._collapsed_sections.get(section_key)),
            on_toggle=lambda key=section_key: self._on_section_toggle(key),
        )

    def _on_section_toggle(self, section_key: str) -> None:
        """Flip a section's collapsed state and redraw the dropdown."""
        self._collapsed_sections[section_key] = (
            not self._collapsed_sections.get(section_key)
        )
        self._rebuild_menu()

    def _make_working_view_row(self, view: View) -> AYContainer:
        """Build the current-view row with an inline reset button.

        The row itself is the click target and carries the selected
        highlight — the label is plain text, not a button — so the
        label and the reset button read as one merged control, and
        clicking anywhere in the row (including the margins around the
        reset button) selects the working view. Matches the frontend,
        where ``.selected`` is applied to the whole row element.
        """
        is_current_view_is_working_view = view is not None and view.working
        is_selected = self._view_modified or is_current_view_is_working_view

        row = AYClickableRow(
            layout=AYContainer.Layout.HBox,
            variant=AYContainer.Variants.Popover,
            layout_spacing=4,
            layout_margin=0,
            hover_enabled=True,
            on_click=self._on_working_view_clicked,
        )
        self._style_row(row)
        row.set_selected(is_selected)

        label = AYLabel("Working view")
        label.setContentsMargins(6, 0, 0, 0)
        row.add_widget(label, stretch=1)

        reset_btn = AYButton(
            icon="restart_alt",
            variant=AYButton.Variants.Row_Action,
            tooltip="Reset to default",
        )
        reset_btn.clicked.connect(self._on_reset_clicked)
        row.add_widget(reset_btn)

        RowHoverTracker(row).watch(reset_btn)

        return row

    def _make_view_label(self, view: View) -> AYLabel:
        label = AYLabel(view.label or "(unnamed view)")
        label.setContentsMargins(6, 0, 0, 0)
        return label

    def _make_save_btn(self, view: View, row: AYContainer) -> AYButton:
        """Build the save button — same size as any other row action.

        It's the plain ``Row_Action`` variant, not a bespoke bigger
        one: the "modified" highlight is just its ``checked`` state
        (like the filter chips and other checkable buttons elsewhere)
        turning it primary-blue, the same mechanism, not a special
        button.
        """
        is_modified = bool(
            self._current_view
            and view.id == self._current_view.id
            and self._view_modified
        )
        btn = AYButton(
            icon="save",
            variant=AYButton.Variants.Row_Action,
            checkable=True,
            tooltip="Save view settings from current view",
        )
        btn.setChecked(is_modified)
        btn.clicked.connect(
            lambda _checked=False, v=view: self._on_view_save_clicked(v)
        )

        if not is_modified:
            sp = btn.sizePolicy()
            sp.setRetainSizeWhenHidden(True)
            btn.setSizePolicy(sp)
            btn.setVisible(False)
            row.installEventFilter(HoverReveal(btn, row))

        return btn

    def _make_edit_btn(self, view: View) -> AYButton:
        btn = AYButton(
            icon="more_horiz",
            variant=AYButton.Variants.Row_Action,
            tooltip="Edit view",
        )
        btn.clicked.connect(
            lambda _checked=False, v=view: self._on_edit_clicked(v)
        )
        return btn

    def _make_row(self, view: View) -> AYContainer:
        """Build one selectable row for *view*."""
        modified = not (
            self._current_view
            and view.id == self._current_view.id
            and not self._view_modified
        )

        row = AYClickableRow(
            layout=AYContainer.Layout.HBox,
            variant=AYContainer.Variants.Popover,
            layout_spacing=4,
            layout_margin=0,
            hover_enabled=True,
            on_click=lambda v=view: self._on_view_selected(v),
        )
        self._style_row(row)
        row.set_selected(not modified)

        row.add_widget(self._make_view_label(view), stretch=1)
        hover_watched = []

        if view.can_edit(self._current_user, self._user_access):
            if modified:
                save_btn = self._make_save_btn(view, row)
                row.add_widget(save_btn)
                hover_watched.append(save_btn)
            edit_btn = self._make_edit_btn(view)
            row.add_widget(edit_btn)
            hover_watched.append(edit_btn)

        RowHoverTracker(row).watch(*hover_watched)

        return row

    def _make_default_view_row(self) -> AYContainer:
        """Build a row for the default view."""
        return self._default_view_control.build_row()

    def _make_create_view_row(self) -> AYContainer:
        """Build the "Create new view…" row.

        Wrapped the same way as every other row (a hover-enabled
        Popover frame whose click and hover the row itself owns) so
        its look matches the rest of the dropdown instead of the plain
        Text-button gray. No :class:`RowHoverTracker` here: unlike the
        other rows, this one has no interactive child button to steal
        Enter/Leave events, so the frame drawer's own ``underMouse()``
        fallback (see ``hover_enabled``) already keeps it highlighted.
        """
        row = AYClickableRow(
            layout=AYContainer.Layout.HBox,
            variant=AYContainer.Variants.Popover,
            layout_spacing=4,
            layout_margin=0,
            hover_enabled=True,
            on_click=self._on_create_clicked,
        )
        self._style_row(row)

        label = AYLabel("Create new view…", icon="add")
        label.setContentsMargins(6, 0, 0, 0)
        row.add_widget(label, stretch=1)
        return row

    def _on_binding_error(self, stage: str, exc: BaseException) -> None:
        """Forward a :class:`ViewBindings` error via :attr:`binding_error`."""
        self.binding_error.emit(stage, str(exc) or exc.__class__.__name__)

    def _connect_modified_state_sources(self) -> None:
        """Wire widget signals that mark the view as dirty."""
        self._bindings.filter_bar.filters_changed.connect(self._mark_modified)
        self._bindings.table_view.column_state_changed.connect(self._mark_modified)
        self._bindings.table_view.header().sortIndicatorChanged.connect(
            self._mark_modified
        )

    # ------------------------------------------------------------------
    # Public API
    # ------------------------------------------------------------------

    def set_view_type(self, view_type: str) -> None:
        """Switch to a new view-type identifier."""
        if view_type == self._view_type:
            return
        self._view_type = view_type
        self._current_view = None
        self.refresh()

    def refresh(self) -> None:
        """Re-resolve the working view and drop the cached view list.

        Restoring the user's last state only needs the working view,
        which has its own endpoint. The dropdown is not on screen yet, so
        listing the rest - and each one's settings - waits until the menu
        is opened; see :meth:`_ensure_views_listed`.
        """
        self._views = []
        self._views_loaded = False

        working_view = self._ensure_working_view_exists()
        if (
            working_view is not None
            and self._current_view is None
            and not self._suppress_auto_apply
        ):
            self._apply_view(working_view, emit=True)
            return

    def _ensure_views_listed(self) -> None:
        """Fetch the view list on first use, then keep it until refresh."""
        if self._views_loaded:
            return
        try:
            self._views = list(self._manager.list_views(self._view_type))
        except Exception:
            log.exception("Failed to list views for %r", self._view_type)
            self._views = []
        self._views_loaded = True

    def current_view(self) -> View | None:
        """Return the currently active view, or ``None``."""
        return self._current_view

    def notify_view_modified(self, *_args) -> None:
        """Mark the view as modified after a UI settings change.

        Consumer code may connect custom widgets here when they affect
        :meth:`ViewBindings.capture` but are not part of the built-in
        table/filter stack.
        """
        self._mark_modified()

    def apply_default_settings(self) -> None:
        """Reset every tracked setting to the built-in AYON defaults.

        Used when neither a project nor a studio default view is
        configured, so "reset" has to fall back to what the consumer
        declared as its defaults.  Applying an empty
        :class:`ViewSettings` makes :class:`ViewBindings` fill in every
        slice from ``default_settings`` - columns, sort, filter,
        grouping, row height and the consumer's extras alike - so
        nothing carries over from the view that was active before.

        The reset lands on the *working* view: it is emitted through
        :attr:`view_applied` (so consumers can sync widgets the
        bindings do not own, such as the Group By menu) and then
        persisted, which is what makes it survive a restart.
        """
        defaults = (
            self._bindings.default_settings()
            if self._bindings.default_settings is not None
            else ViewSettings()
        )

        self._applying_view = True
        try:
            self._bindings.apply(ViewSettings())
        except Exception:
            log.exception("Failed to apply default view settings")
            return
        finally:
            self._applying_view = False
            # Nothing the user did is pending; this method saves the
            # working view itself once the widgets have settled.
            self._working_view_timer.stop()

        try:
            working_view = self._manager.get_working_view(self._view_type)
        except Exception:
            log.exception(
                "Failed to resolve working view for %r", self._view_type
            )
            working_view = None
        if working_view is None:
            working_view = View(
                label="Working",
                working=True,
                visibility=Visibility.PRIVATE,
                view_type=self._view_type,
                owner=self._current_user,
                scope=Scope.PROJECT,
            )
        working_view.settings = defaults
        working_view.loaded = True
        self._current_view = working_view
        self.setToolTip(f"View: {working_view.label}")

        # Consumers apply the slices the bindings do not own (grouping,
        # toolbar widgets) from this signal, so it has to fire before
        # the working view is captured back below.  Clearing the dirty
        # flag afterwards discards the changes those handlers report -
        # they are this reset's own writes, not the user's edits.
        self.view_applied.emit(working_view)
        self._working_view_timer.stop()
        self._clear_modified()
        self._update_working_view()

    def _capture_into(self, view: View) -> None:
        """Store the live widget state as *view*'s settings.

        Also flags the view as loaded.  Rows built from the listing
        endpoint arrive with ``loaded=False`` and empty settings, and a
        manager that fetches settings lazily reads that flag as "this
        view's settings still need fetching" - which would make it
        refetch the stored settings on save and silently discard the
        capture we just made (see ``ServerViewManager.save_view``).

        Args:
            view: The view to write the captured settings onto.
        """
        view.settings = self._bindings.capture()
        view.loaded = True

    # ------------------------------------------------------------------
    # Actions
    # ------------------------------------------------------------------

    def _on_view_selected(self, view: View) -> None:
        """Handle a view-row click in the dropdown."""
        self._apply_view(view, emit=True)
        self._close_menu()

    def _on_edit_clicked(self, view: View) -> None:
        """Open the editor for an existing view."""
        self._close_menu()
        # A row from the listing lacks the view's access grants; the
        # editor must start from the stored ones or saving wipes them.
        loaded_view = self._manager.load_view(view)
        if not loaded_view.loaded:
            # On failure to load, just stop here. Manager would've already
            # emitted the error
            return
        view_copy = View.from_payload(loaded_view.to_payload())
        self._capture_into(view_copy)
        editor = self._create_editor(view_copy)
        if editor.exec() != QDialog.DialogCode.Accepted:
            return
        with self._suspend_auto_apply():
            if editor.delete_requested():
                self._delete_view(editor.get_view())
                return
            saved = self._save_view(editor.get_view())
        if saved is not None and (
            self._current_view is not None
            and self._current_view.id == saved.id
        ):
            self._apply_view(saved, emit=True)

    def _on_create_clicked(self) -> None:
        """Open the editor for a new view, then save it."""
        self._close_menu()
        new_view = View(view_type=self._view_type)
        self._capture_into(new_view)
        editor = self._create_editor(new_view)
        if editor.exec() != QDialog.DialogCode.Accepted:
            return
        with self._suspend_auto_apply():
            if editor.delete_requested():
                self._delete_view(editor.get_view())
                return
            saved = self._save_view(editor.get_view())
        if saved is not None:
            self._apply_view(saved, emit=True)

    def _create_editor(self, view: View) -> AYViewEditor:
        """Build the metadata editor dialog for *view*."""
        allow_sharing = self._manager.supports_sharing()
        usernames_and_groups = (
            self._get_usernames_and_groups() if allow_sharing else None
        )
        return AYViewEditor(
            view,
            current_user=self._current_user,
            allow_studio_scope=self._allow_studio_scope,
            current_project=self._current_project_name(),
            usernames_and_groups=usernames_and_groups,
            allow_sharing=allow_sharing,
            parent=self,
        )

    def _delete_view(self, view: View) -> None:
        if not view.id:
            return
        if self._current_view is not None and self._current_view.id == view.id:
            self._current_view = None
            working = self._manager.get_working_view(self._view_type)
            if working:
                self._current_view = working
        try:
            self._manager.delete_view(view.id)
        except Exception:
            log.exception("Failed to delete view %r", view.id)
            return
        self.view_deleted.emit(view.id)
        self._apply_view(self._current_view, emit=True)

    def _on_reset_clicked(self) -> None:
        """Reset the current view to the default view for the current scope."""
        ctrl = self._default_view_control

        if ctrl.project_default_view:
            ctrl.load_project_default_view()
            return

        if ctrl.studio_default_view:
            ctrl.load_studio_default_view()
            return

        if ctrl.make_default_view_settings:
            ctrl.make_default_view_settings()
            return

        self.emit_default_view_message(
            "No default view configured.",
            False,
        )

    def _on_manager_changed(self, view_type: str) -> None:
        """Refresh when the manager signals a change for our type."""
        if view_type == self._view_type:
            self.refresh()

    def _on_project_changed(self, project_name: str) -> None:
        """Reset state and refresh when the manager switches project.
        clear active view belongs to the old project so the new
        project's working view can be auto-applied.
        """
        self._current_view = None
        self._clear_modified()
        self.refresh()
        self._update_enabled_for_project()

    def _update_enabled_for_project(self) -> None:
        """Enable the Views button only while a project is active.

        With no project there is nothing sensible for a view to apply
        to, so opening the dropdown wouldn't do anything useful — keep
        it disabled instead. Called after :meth:`refresh`, since that
        may apply a working view and set its own "View: ..." tooltip;
        this must have the final say when there's no project.
        """
        has_project = bool(self._current_project_name())
        self.setEnabled(has_project)
        if not has_project:
            self.setToolTip("Views (select a project first)")

    def _get_usernames_and_groups(self) -> dict[str, list]:
        """Fetch active project users and return unique usernames."""
        project_name = getattr(self._manager, "project_name", "")
        if not project_name:
            return {"users": [], "groups": []}
        users = []
        groups = []
        try:
            users = ayon_api.get_users(project_name=project_name) or []
        except Exception:  # noqa: BLE001
            log.exception("Failed to fetch users for project %r",
                          project_name)

        try:
            group_data = ayon_api.get(f"/accessGroups/{project_name}").data
            groups = [group.get('name') for group in group_data]
        except Exception:
            log.exception("Failed to fetch project groups")

        users_data: list[dict[str, str]] = []
        seen: set[str] = set()
        for user in users:
            if not isinstance(user, dict):
                continue
            if not bool(user.get("active", False)):
                continue
            name = str(user.get("name") or "").strip()
            if not name or name in seen or name == self._current_user:
                continue

            full_name = user["attrib"].get("fullName") or name

            seen.add(name)
            users_data.append({"name": name, "fullName": full_name})
        return {"users": users_data, "groups": groups}

    # ------------------------------------------------------------------
    # Helpers
    # ------------------------------------------------------------------

    def _close_menu(self) -> None:
        """Close the dropdown popup if currently open."""
        try:
            self._dropdown.close()
        except Exception:
            pass

    def refresh_dropdown_size(self) -> None:
        """Resize the dropdown popup to fit its current content.

        Call after any change to the dropdown's contents (a full
        rebuild, or swapping a single row/pill's children in place):
        rebuilding a widget's children leaves stale cached size hints
        on its ancestors, so a plain ``adjustSize()`` alone can settle
        on a size that no longer fits — e.g. clipping the label text on
        a default-view pill after it switches between its "unset" and
        "active" (wider) look. Invalidating the layout chain first
        forces every ancestor to recompute before the popup resizes.
        """
        layout = self._dropdown_layout
        if layout is not None:
            layout.invalidate()
            layout.activate()
        self._dropdown.updateGeometry()
        self._dropdown.adjustSize()

    def emit_default_view_message(self, message: str, success: bool) -> None:
        """Emit default-view feedback for host UIs.

        Hosts can map this to the same toast presentation used by loader
        action results.
        """
        self.default_view_message.emit(message, success)

    def _current_project_name(self) -> str:
        """Return the manager's current project name when available."""
        project_name = getattr(self._manager, "project_name", "")
        return str(project_name or "")

    def _ensure_working_view_exists(self) -> View | None:
        """Return the current working view, creating one when missing."""
        if self._ensuring_working_view or self._current_view is not None:
            return None

        try:
            existing = self._manager.get_working_view(self._view_type)
        except Exception:
            log.exception(
                "Failed to resolve working view for %r", self._view_type
            )
            existing = None
        if existing is not None:
            return existing

        project_name = getattr(self._manager, "project_name", None)
        if project_name is not None and not str(project_name or ""):
            return None

        working_view = View(
            label="Working",
            settings=self._bindings.capture(),
            working=True,
            visibility=Visibility.PRIVATE,
            view_type=self._view_type,
            owner=self._current_user,
            scope=Scope.PROJECT
        )

        self._ensuring_working_view = True
        try:
            with self._suspend_auto_apply():
                self._manager.set_working_view(working_view)
        except Exception:
            log.exception(
                "Failed to create initial working view for %r",
                self._view_type,
            )
            return None
        finally:
            self._ensuring_working_view = False

        refreshed_working = self._manager.get_working_view(self._view_type)
        if refreshed_working is not None:
            return refreshed_working
        return working_view

    def _mark_modified(self, *_args) -> None:
        """Set the dirty flag on the first UI change after a view is applied.
            and cleared by applying, saving, or resetting a view.
        """
        if self._applying_view:
            # Our own writes bouncing back off the widgets.
            return

        self._working_view_timer.start()

        if self._view_modified:
            return

        self._view_modified = True

        if self._current_view and not self._current_view.working:
            self.set_variant(AYButton.Variants.Filled)

        if self._current_view:
            view_name = self._current_view.label or self._current_view.id
            self.view_modified.emit(view_name, True)

    def _apply_view(self, view: View, emit: bool) -> None:
        """Apply *view* to the bindings and clear the dirty flag.

        Default views are applied onto the working-view context, so edits
        continue against the working view.
        """
        is_default_view = (
            not view.working
            and view.label == DEFAULT_VIEW_LABEL
        )

        target_view = view
        if is_default_view:
            try:
                working_view = self._manager.get_working_view(self._view_type)
            except Exception:
                log.exception(
                    "Failed to resolve working view for %r", self._view_type
                )
                return
            target_view = working_view
            self._close_menu()

        # A view picked from the dropdown carries only listing metadata;
        # this is where its settings are actually needed.
        view = self._manager.load_view(view)
        if target_view is not None and target_view.id == view.id:
            target_view = view
        self._current_view = target_view

        self._applying_view = True
        try:
            self._bindings.apply(view.settings)
        except Exception:
            log.exception("Failed to apply view %r", view.id)
            return
        finally:
            self._applying_view = False
            # Nothing was modified, so drop any save this apply queued.
            self._working_view_timer.stop()

        self.setToolTip(f"View: {self._current_view.label}")
        self._clear_modified()

        if emit:
            self.view_applied.emit(view)

    def _on_view_save_clicked(self, view: View) -> None:
        self._close_menu()
        self._capture_into(view)
        with self._suspend_auto_apply():
            saved = self._save_view(view)
        if saved is not None:
            self._apply_view(saved, emit=True)

    def _clear_modified(self) -> None:
        """Clear the dirty flag and restore the default button variant."""
        if not self._view_modified:
            return
        self._view_modified = False
        self.set_variant(AYButton.Variants.Surface)
        if self._current_view:
            view_name = self._current_view.label or self._current_view.id
            self.view_modified.emit(view_name, False)

    def _save_view(self, view: View) -> View | None:
        """
        This called when new view is created or existing view is updated.
        Persist *view* and return the manager's response."""
        try:
            saved = self._manager.save_view(view)
        except Exception:
            log.exception("Failed to save view %r", view.label)
            return None
        self.view_saved.emit(saved)
        return saved

    def _on_working_view_clicked(self, _checked: bool = False) -> None:
        try:
            working_view = self._manager.get_working_view(self._view_type)
        except Exception:
            log.exception(
                "Failed to resolve working view for %r", self._view_type
            )
            return

        if not working_view:
            return

        self._apply_view(working_view, emit=True)

        # Change views icon state to normal
        self.set_variant(AYButton.Variants.Surface)
        self._close_menu()

    def hideEvent(self, event) -> None:
        """Flush a pending working-view save before going away.

        The debounce would otherwise drop the last few hundred
        milliseconds of edits when the window closes.
        """
        if self._working_view_timer.isActive():
            self._working_view_timer.stop()
            self._update_working_view()
        super().hideEvent(event)

    def _update_working_view(self) -> None:
        """Persist the live widget state onto the working view."""
        # The applied view is normally the working view already, so going
        # back to the server for it would just re-read what we hold.
        working_view = self._current_view
        if working_view is None or not working_view.working:
            try:
                working_view = self._manager.get_working_view(self._view_type)
            except Exception:
                log.exception(
                    "Failed to resolve working view for %r", self._view_type
                )
                return
        if working_view is None:
            return
        self._capture_into(working_view)
        with self._suspend_auto_apply():
            self._manager.set_working_view(working_view)

    def get_default_views(self):
        """Return the current default views from the default view control."""
        return (
            self._default_view_control.studio_default_view,
            self._default_view_control.project_default_view,
        )

    def _suspend_auto_apply(self) -> "_SuspendAutoApply":
        """Return a context manager that suppresses the auto-apply branch
        of :meth:`refresh` while a save is in flight.
        """
        return _SuspendAutoApply(self)