#  Copyright (c) 2021-2022, Manfred Moitzi
#  License: MIT License
from __future__ import annotations
from typing import Optional, Set
from functools import partial
from pathlib import Path
import subprocess
import shlex

from ezdxf.addons.xqt import (
    QtWidgets,
    QtGui,
    QAction,
    QMessageBox,
    QFileDialog,
    QInputDialog,
    Qt,
    QModelIndex,
    QSettings,
    QFileSystemWatcher,
    QSize,
)

import ezdxf
from ezdxf.lldxf.const import DXFStructureError, DXFValueError
from ezdxf.lldxf.types import DXFTag, is_pointer_code
from ezdxf.lldxf.tags import Tags
from ezdxf.pp.reflinks import get_reference_link

from .model import (
    DXFStructureModel,
    DXFTagsModel,
    DXFTagsRole,
)
from .data import (
    DXFDocument,
    get_row_from_line_number,
    dxfstr,
    EntityHistory,
    SearchIndex,
)
from .views import StructureTree, DXFTagsTable
from .find_dialog import Ui_FindDialog
from .bookmarks import Bookmarks

__all__ = ["DXFStructureBrowser"]

APP_NAME = "DXF Structure Browser"
BROWSE_COMMAND = ezdxf.options.BROWSE_COMMAND
TEXT_EDITOR = ezdxf.options.get(BROWSE_COMMAND, "TEXT_EDITOR")
ICON_SIZE = max(16, ezdxf.options.get_int(BROWSE_COMMAND, "ICON_SIZE"))

SearchSections = Set[str]


def searchable_entities(
    doc: DXFDocument, search_sections: SearchSections
) -> list[Tags]:
    entities: list[Tags] = []
    for name, section_entities in doc.sections.items():
        if name in search_sections:
            entities.extend(section_entities)  # type: ignore
    return entities


BROWSER_WIDTH = 1024
BROWSER_HEIGHT = 768
TREE_WIDTH_FACTOR = 0.33


class DXFStructureBrowser(QtWidgets.QMainWindow):
    def __init__(
        self,
        filename: str = "",
        line: Optional[int] = None,
        handle: Optional[str] = None,
        resource_path: Path = Path("."),
    ):
        super().__init__()
        self.doc = DXFDocument()
        self.resource_path = resource_path
        self._structure_tree = StructureTree()
        self._dxf_tags_table = DXFTagsTable()
        self._current_entity: Optional[Tags] = None
        self._active_search: Optional[SearchIndex] = None
        self._search_sections: set[str] = set()
        self._find_dialog: FindDialog = self.create_find_dialog()
        self._file_watcher = QFileSystemWatcher()
        self._exclusive_reload_dialog = True  # see ask_for_reloading() method
        self.history = EntityHistory()
        self.bookmarks = Bookmarks()
        self.setup_actions()
        self.setup_menu()
        self.setup_toolbar()

        if filename:
            self.load_dxf(filename)
        else:
            self.setWindowTitle(APP_NAME)

        self.setCentralWidget(self.build_central_widget())
        self.resize(BROWSER_WIDTH, BROWSER_HEIGHT)
        self.connect_slots()
        if line is not None:
            try:
                line = int(line)
            except ValueError:
                print(f"Invalid line number: {line}")
            else:
                self.goto_line(line)
        if handle is not None:
            try:
                int(handle, 16)
            except ValueError:
                print(f"Given handle is not a hex value: {handle}")
            else:
                if not self.goto_handle(handle):
                    print(f"Handle {handle} not found.")

    def build_central_widget(self):
        container = QtWidgets.QSplitter(Qt.Horizontal)
        container.addWidget(self._structure_tree)
        container.addWidget(self._dxf_tags_table)
        tree_width = int(BROWSER_WIDTH * TREE_WIDTH_FACTOR)
        table_width = BROWSER_WIDTH - tree_width
        container.setSizes([tree_width, table_width])
        container.setCollapsible(0, False)
        container.setCollapsible(1, False)
        return container

    def connect_slots(self):
        self._structure_tree.activated.connect(self.entity_activated)
        self._dxf_tags_table.activated.connect(self.tag_activated)
        # noinspection PyUnresolvedReferences
        self._file_watcher.fileChanged.connect(self.ask_for_reloading)

    # noinspection PyAttributeOutsideInit
    def setup_actions(self):

        self._open_action = self.make_action(
            "&Open DXF File...", self.open_dxf, shortcut="Ctrl+O"
        )
        self._export_entity_action = self.make_action(
            "&Export DXF Entity...", self.export_entity, shortcut="Ctrl+E"
        )
        self._copy_entity_action = self.make_action(
            "&Copy DXF Entity to Clipboard",
            self.copy_entity,
            shortcut="Shift+Ctrl+C",
            icon_name="icon-copy-64px.png",
        )
        self._copy_selected_tags_action = self.make_action(
            "&Copy selected DXF Tags to Clipboard",
            self.copy_selected_tags,
            shortcut="Ctrl+C",
            icon_name="icon-copy-64px.png",
        )
        self._quit_action = self.make_action(
            "&Quit", self.close, shortcut="Ctrl+Q"
        )
        self._goto_handle_action = self.make_action(
            "&Go to Handle...",
            self.ask_for_handle,
            shortcut="Ctrl+G",
            icon_name="icon-goto-handle-64px.png",
            tip="Go to Entity Handle",
        )
        self._goto_line_action = self.make_action(
            "Go to &Line...",
            self.ask_for_line_number,
            shortcut="Ctrl+L",
            icon_name="icon-goto-line-64px.png",
            tip="Go to Line Number",
        )

        self._find_text_action = self.make_action(
            "Find &Text...",
            self.find_text,
            shortcut="Ctrl+F",
            icon_name="icon-find-64px.png",
            tip="Find Text in Entities",
        )
        self._goto_predecessor_entity_action = self.make_action(
            "&Previous Entity",
            self.goto_previous_entity,
            shortcut="Ctrl+Left",
            icon_name="icon-prev-entity-64px.png",
            tip="Go to Previous Entity in File Order",
        )

        self._goto_next_entity_action = self.make_action(
            "&Next Entity",
            self.goto_next_entity,
            shortcut="Ctrl+Right",
            icon_name="icon-next-entity-64px.png",
            tip="Go to Next Entity in File Order",
        )
        self._entity_history_back_action = self.make_action(
            "Entity History &Back",
            self.go_back_entity_history,
            shortcut="Alt+Left",
            icon_name="icon-left-arrow-64px.png",
            tip="Go to Previous Entity in Browser History",
        )
        self._entity_history_forward_action = self.make_action(
            "Entity History &Forward",
            self.go_forward_entity_history,
            shortcut="Alt+Right",
            icon_name="icon-right-arrow-64px.png",
            tip="Go to Next Entity in Browser History",
        )
        self._open_entity_in_text_editor_action = self.make_action(
            "&Open in Text Editor",
            self.open_entity_in_text_editor,
            shortcut="Ctrl+T",
        )
        self._show_entity_in_tree_view_action = self.make_action(
            "Show Entity in Structure &Tree",
            self.show_current_entity_in_tree_view,
            shortcut="Ctrl+Down",
            icon_name="icon-show-in-tree-64px.png",
            tip="Show Current Entity in Structure Tree",
        )
        self._goto_header_action = self.make_action(
            "Go to HEADER Section",
            partial(self.go_to_section, name="HEADER"),
            shortcut="Shift+H",
        )
        self._goto_blocks_action = self.make_action(
            "Go to BLOCKS Section",
            partial(self.go_to_section, name="BLOCKS"),
            shortcut="Shift+B",
        )
        self._goto_entities_action = self.make_action(
            "Go to ENTITIES Section",
            partial(self.go_to_section, name="ENTITIES"),
            shortcut="Shift+E",
        )
        self._goto_objects_action = self.make_action(
            "Go to OBJECTS Section",
            partial(self.go_to_section, name="OBJECTS"),
            shortcut="Shift+O",
        )
        self._store_bookmark = self.make_action(
            "Store Bookmark...",
            self.store_bookmark,
            shortcut="Shift+Ctrl+B",
            icon_name="icon-store-bookmark-64px.png",
        )
        self._go_to_bookmark = self.make_action(
            "Go to Bookmark...",
            self.go_to_bookmark,
            shortcut="Ctrl+B",
            icon_name="icon-goto-bookmark-64px.png",
        )
        self._reload_action = self.make_action(
            "Reload DXF File",
            self.reload_dxf,
            shortcut="Ctrl+R",
        )

    def make_action(
        self,
        name,
        slot,
        *,
        shortcut: str = "",
        icon_name: str = "",
        tip: str = "",
    ) -> QAction:
        action = QAction(name, self)
        if shortcut:
            action.setShortcut(shortcut)
        if icon_name:
            icon = QtGui.QIcon(str(self.resource_path / icon_name))
            action.setIcon(icon)
        if tip:
            action.setToolTip(tip)
        action.triggered.connect(slot)  # type: ignore
        return action

    def setup_menu(self):
        menu = self.menuBar()
        file_menu = menu.addMenu("&File")
        file_menu.addAction(self._open_action)
        file_menu.addAction(self._reload_action)
        file_menu.addAction(self._open_entity_in_text_editor_action)
        file_menu.addSeparator()
        file_menu.addAction(self._copy_selected_tags_action)
        file_menu.addAction(self._copy_entity_action)
        file_menu.addAction(self._export_entity_action)
        file_menu.addSeparator()
        file_menu.addAction(self._quit_action)

        navigate_menu = menu.addMenu("&Navigate")
        navigate_menu.addAction(self._goto_handle_action)
        navigate_menu.addAction(self._goto_line_action)
        navigate_menu.addAction(self._find_text_action)
        navigate_menu.addSeparator()
        navigate_menu.addAction(self._goto_next_entity_action)
        navigate_menu.addAction(self._goto_predecessor_entity_action)
        navigate_menu.addAction(self._show_entity_in_tree_view_action)
        navigate_menu.addSeparator()
        navigate_menu.addAction(self._entity_history_back_action)
        navigate_menu.addAction(self._entity_history_forward_action)
        navigate_menu.addSeparator()
        navigate_menu.addAction(self._goto_header_action)
        navigate_menu.addAction(self._goto_blocks_action)
        navigate_menu.addAction(self._goto_entities_action)
        navigate_menu.addAction(self._goto_objects_action)

        bookmarks_menu = menu.addMenu("&Bookmarks")
        bookmarks_menu.addAction(self._store_bookmark)
        bookmarks_menu.addAction(self._go_to_bookmark)

    def setup_toolbar(self) -> None:
        toolbar = QtWidgets.QToolBar("MainToolbar")
        toolbar.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
        toolbar.addAction(self._entity_history_back_action)
        toolbar.addAction(self._entity_history_forward_action)
        toolbar.addAction(self._goto_predecessor_entity_action)
        toolbar.addAction(self._goto_next_entity_action)
        toolbar.addAction(self._show_entity_in_tree_view_action)
        toolbar.addAction(self._find_text_action)
        toolbar.addAction(self._goto_line_action)
        toolbar.addAction(self._goto_handle_action)
        toolbar.addAction(self._store_bookmark)
        toolbar.addAction(self._go_to_bookmark)
        toolbar.addAction(self._copy_selected_tags_action)
        self.addToolBar(toolbar)

    def create_find_dialog(self) -> "FindDialog":
        dialog = FindDialog(self)
        dialog.setModal(True)
        dialog.find_forward_button.clicked.connect(self.find_forward)
        dialog.find_backwards_button.clicked.connect(self.find_backwards)
        dialog.find_forward_button.setShortcut("F3")
        dialog.find_backwards_button.setShortcut("F4")
        return dialog

    def open_dxf(self):
        path, _ = QtWidgets.QFileDialog.getOpenFileName(
            self,
            caption="Select DXF file",
            filter="DXF Documents (*.dxf *.DXF)",
        )
        if path:
            self.load_dxf(path)

    def load_dxf(self, path: str):
        try:
            self._load(path)
        except IOError as e:
            QMessageBox.critical(self, "Loading Error", str(e))
        except DXFStructureError as e:
            QMessageBox.critical(
                self,
                "DXF Structure Error",
                f'Invalid DXF file "{path}": {str(e)}',
            )
        else:
            self.history.clear()
            self.view_header_section()
            self.update_title()

    def reload_dxf(self):
        if self._current_entity is not None:
            entity = self.get_current_entity()
            handle = self.get_current_entity_handle()
            first_row = self._dxf_tags_table.first_selected_row()
            line_number = self.doc.get_line_number(entity, first_row)

            self._load(self.doc.filename)
            if handle is not None:
                entity = self.doc.get_entity(handle)
                if entity is not None:  # select entity with same handle
                    self.set_current_entity_and_row_index(entity, first_row)
                    self._structure_tree.expand_to_entity(entity)
                    return
            # select entity at the same line number
            entity = self.doc.get_entity_at_line(line_number)
            self.set_current_entity_and_row_index(entity, first_row)
            self._structure_tree.expand_to_entity(entity)

    def ask_for_reloading(self):
        if self.doc.filename and self._exclusive_reload_dialog:
            # Ignore further reload signals until first signal is processed.
            # Saving files by ezdxf triggers two "fileChanged" signals!?
            self._exclusive_reload_dialog = False
            ok = QMessageBox.question(
                self,
                "Reload",
                f'"{self.doc.absolute_filepath()}"\n\nThis file has been '
                f"modified by another program, reload file?",
                buttons=QMessageBox.Yes | QMessageBox.No,
                defaultButton=QMessageBox.Yes,
            )
            if ok == QMessageBox.Yes:
                self.reload_dxf()
            self._exclusive_reload_dialog = True

    def _load(self, filename: str):
        if self.doc.filename:
            self._file_watcher.removePath(self.doc.filename)
        self.doc.load(filename)
        model = DXFStructureModel(self.doc.filepath.name, self.doc)
        self._structure_tree.set_structure(model)
        self.history.clear()
        self._file_watcher.addPath(self.doc.filename)

    def export_entity(self):
        if self._dxf_tags_table is None:
            return
        path, _ = QFileDialog.getSaveFileName(
            self,
            caption="Export DXF Entity",
            filter="Text Files (*.txt *.TXT)",
        )
        if path:
            model = self._dxf_tags_table.model()
            tags = model.compiled_tags()
            self.export_tags(path, tags)

    def copy_entity(self):
        if self._dxf_tags_table is None:
            return
        model = self._dxf_tags_table.model()
        tags = model.compiled_tags()
        copy_dxf_to_clipboard(tags)

    def copy_selected_tags(self):
        if self._current_entity is None:
            return
        rows = self._dxf_tags_table.selected_rows()
        model = self._dxf_tags_table.model()
        tags = model.compiled_tags()
        try:
            export_tags = Tags(tags[row] for row in rows)
        except IndexError:
            return
        copy_dxf_to_clipboard(export_tags)

    def view_header_section(self):
        header = self.doc.get_section("HEADER")
        if header:
            self.set_current_entity_with_history(header[0])
        else:  # DXF R12 with only a ENTITIES section
            entities = self.doc.get_section("ENTITIES")
            if entities:
                self.set_current_entity_with_history(entities[1])

    def update_title(self):
        self.setWindowTitle(f"{APP_NAME} - {self.doc.absolute_filepath()}")

    def get_current_entity_handle(self) -> Optional[str]:
        active_entity = self.get_current_entity()
        if active_entity:
            try:
                return active_entity.get_handle()
            except DXFValueError:
                pass
        return None

    def get_current_entity(self) -> Optional[Tags]:
        return self._current_entity

    def set_current_entity_by_handle(self, handle: str):
        entity = self.doc.get_entity(handle)
        if entity:
            self.set_current_entity(entity)

    def set_current_entity(
        self, entity: Tags, select_line_number: Optional[int] = None
    ):
        if entity:
            self._current_entity = entity
            start_line_number = self.doc.get_line_number(entity)
            model = DXFTagsModel(
                entity, start_line_number, self.doc.entity_index
            )
            self._dxf_tags_table.setModel(model)
            if select_line_number is not None:
                row = get_row_from_line_number(
                    model.compiled_tags(), start_line_number, select_line_number
                )
                self._dxf_tags_table.selectRow(row)
                index = self._dxf_tags_table.model().index(row, 0)
                self._dxf_tags_table.scrollTo(index)

    def set_current_entity_with_history(self, entity: Tags):
        self.set_current_entity(entity)
        self.history.append(entity)

    def set_current_entity_and_row_index(self, entity: Tags, index: int):
        line = self.doc.get_line_number(entity, index)
        self.set_current_entity(entity, select_line_number=line)
        self.history.append(entity)

    def entity_activated(self, index: QModelIndex):
        tags = index.data(role=DXFTagsRole)
        # PySide6: Tags() are converted to type list by PySide6?
        # print(type(tags))
        if isinstance(tags, (Tags, list)):
            self.set_current_entity_with_history(Tags(tags))

    def tag_activated(self, index: QModelIndex):
        tag = index.data(role=DXFTagsRole)
        if isinstance(tag, DXFTag):
            code, value = tag
            if is_pointer_code(code):
                if not self.goto_handle(value):
                    self.show_error_handle_not_found(value)
            elif code == 0:
                self.open_web_browser(get_reference_link(value))

    def ask_for_handle(self):
        handle, ok = QInputDialog.getText(
            self,
            "Go to",
            "Go to entity handle:",
        )
        if ok:
            if not self.goto_handle(handle):
                self.show_error_handle_not_found(handle)

    def goto_handle(self, handle: str) -> bool:
        entity = self.doc.get_entity(handle)
        if entity:
            self.set_current_entity_with_history(entity)
            return True
        return False

    def show_error_handle_not_found(self, handle: str):
        QMessageBox.critical(self, "Error", f"Handle {handle} not found!")

    def ask_for_line_number(self):
        max_line_number = self.doc.max_line_number
        number, ok = QInputDialog.getInt(
            self,
            "Go to",
            f"Go to line number: (max. {max_line_number})",
            1,  # value
            1,  # PyQt5: min, PySide6: minValue
            max_line_number,  # PyQt5: max, PySide6: maxValue
        )
        if ok:
            self.goto_line(number)

    def goto_line(self, number: int) -> bool:
        entity = self.doc.get_entity_at_line(int(number))
        if entity:
            self.set_current_entity(entity, number)
            return True
        return False

    def find_text(self):
        self._active_search = None
        dialog = self._find_dialog
        dialog.restore_geometry()
        dialog.show_message("F3 searches forward, F4 searches backwards")
        dialog.find_text_edit.setFocus()
        dialog.show()

    def update_search(self):
        def setup_search():
            self._search_sections = dialog.search_sections()
            entities = searchable_entities(self.doc, self._search_sections)
            self._active_search = SearchIndex(entities)

        dialog = self._find_dialog
        if self._active_search is None:
            setup_search()
            # noinspection PyUnresolvedReferences
            self._active_search.set_current_entity(self._current_entity)
        else:
            search_sections = dialog.search_sections()
            if search_sections != self._search_sections:
                setup_search()
        dialog.update_options(self._active_search)

    def find_forward(self):
        self._find(backward=False)

    def find_backwards(self):
        self._find(backward=True)

    def _find(self, backward=False):
        if self._find_dialog.isVisible():
            self.update_search()
            search = self._active_search
            if search.is_end_of_index:
                search.reset_cursor(backward=backward)

            entity, index = (
                search.find_backwards() if backward else search.find_forward()
            )

            if entity:
                self.set_current_entity_and_row_index(entity, index)
                self.show_entity_found_message(entity, index)
            else:
                if search.is_end_of_index:
                    self.show_message("Not found and end of file!")
                else:
                    self.show_message("Not found!")

    def show_message(self, msg: str):
        self._find_dialog.show_message(msg)

    def show_entity_found_message(self, entity: Tags, index: int):
        dxftype = entity.dxftype()
        if dxftype == "SECTION":
            tail = " @ {0} Section".format(entity.get_first_value(2))  # type: ignore
        else:
            try:
                handle = entity.get_handle()
                tail = f" @ {dxftype}(#{handle})"
            except ValueError:
                tail = ""
        line = self.doc.get_line_number(entity, index)
        self.show_message(f"Found in Line: {line}{tail}")

    def export_tags(self, filename: str, tags: Tags):
        try:
            with open(filename, "wt", encoding="utf8") as fp:
                fp.write(dxfstr(tags))
        except IOError as e:
            QMessageBox.critical(self, "IOError", str(e))

    def goto_next_entity(self):
        if self._dxf_tags_table:
            current_entity = self.get_current_entity()
            if current_entity is not None:
                next_entity = self.doc.next_entity(current_entity)
                if next_entity is not None:
                    self.set_current_entity_with_history(next_entity)

    def goto_previous_entity(self):
        if self._dxf_tags_table:
            current_entity = self.get_current_entity()
            if current_entity is not None:
                prev_entity = self.doc.previous_entity(current_entity)
                if prev_entity is not None:
                    self.set_current_entity_with_history(prev_entity)

    def go_back_entity_history(self):
        entity = self.history.back()
        if entity is not None:
            self.set_current_entity(entity)  # do not change history

    def go_forward_entity_history(self):
        entity = self.history.forward()
        if entity is not None:
            self.set_current_entity(entity)  # do not change history

    def go_to_section(self, name: str):
        section = self.doc.get_section(name)
        if section:
            index = 0 if name == "HEADER" else 1
            self.set_current_entity_with_history(section[index])

    def open_entity_in_text_editor(self):
        current_entity = self.get_current_entity()
        line_number = self.doc.get_line_number(current_entity)
        if self._dxf_tags_table:
            indices = self._dxf_tags_table.selectedIndexes()
            if indices:
                model = self._dxf_tags_table.model()
                row = indices[0].row()
                line_number = model.line_number(row)
            self._open_text_editor(
                str(self.doc.absolute_filepath()), line_number
            )

    def _open_text_editor(self, filename: str, line_number: int) -> None:
        cmd = TEXT_EDITOR.format(
            filename=filename,
            num=line_number,
        )
        args = shlex.split(cmd)
        try:
            subprocess.Popen(args)
        except FileNotFoundError:
            QMessageBox.critical(
                self, "Text Editor", "Error calling text editor:\n" + cmd
            )

    def open_web_browser(self, url: str):
        import webbrowser

        webbrowser.open(url)

    def show_current_entity_in_tree_view(self):
        entity = self.get_current_entity()
        if entity:
            self._structure_tree.expand_to_entity(entity)

    def store_bookmark(self):
        if self._current_entity is not None:
            bookmarks = self.bookmarks.names()
            if len(bookmarks) == 0:
                bookmarks = ["0"]
            name, ok = QInputDialog.getItem(
                self,
                "Store Bookmark",
                "Bookmark:",
                bookmarks,
                editable=True,
            )
            if ok:
                entity = self._current_entity
                rows = self._dxf_tags_table.selectedIndexes()
                if rows:
                    offset = rows[0].row()
                else:
                    offset = 0
                handle = self.doc.get_handle(entity)
                self.bookmarks.add(name, handle, offset)

    def go_to_bookmark(self):
        bookmarks = self.bookmarks.names()
        if len(bookmarks) == 0:
            QMessageBox.information(self, "Info", "No Bookmarks defined!")
            return

        name, ok = QInputDialog.getItem(
            self,
            "Go to Bookmark",
            "Bookmark:",
            self.bookmarks.names(),
            editable=False,
        )
        if ok:
            bookmark = self.bookmarks.get(name)
            if bookmark is not None:
                self.set_current_entity_by_handle(bookmark.handle)
                self._dxf_tags_table.selectRow(bookmark.offset)
                model = self._dxf_tags_table.model()
                index = QModelIndex(model.index(bookmark.offset, 0))
                self._dxf_tags_table.scrollTo(index)

            else:
                QtWidgets.QMessageBox.critical(
                    self, "Bookmark not found!", str(name)
                )


def copy_dxf_to_clipboard(tags: Tags):
    clipboard = QtWidgets.QApplication.clipboard()
    try:
        mode = clipboard.Mode.Clipboard
    except AttributeError:
        mode = clipboard.Clipboard  # type: ignore  # legacy location
    clipboard.setText(dxfstr(tags), mode=mode)


class FindDialog(QtWidgets.QDialog, Ui_FindDialog):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setupUi(self)
        self.close_button.clicked.connect(lambda: self.close())
        self.settings = QSettings("ezdxf", "DXFBrowser")

    def restore_geometry(self):
        geometry = self.settings.value("find.dialog.geometry")
        if geometry is not None:
            self.restoreGeometry(geometry)

    def search_sections(self) -> SearchSections:
        sections = set()
        if self.header_check_box.isChecked():
            sections.add("HEADER")
        if self.classes_check_box.isChecked():
            sections.add("CLASSES")
        if self.tables_check_box.isChecked():
            sections.add("TABLES")
        if self.blocks_check_box.isChecked():
            sections.add("BLOCKS")
        if self.entities_check_box.isChecked():
            sections.add("ENTITIES")
        if self.objects_check_box.isChecked():
            sections.add("OBJECTS")
        return sections

    def update_options(self, search: SearchIndex) -> None:
        search.reset_search_term(self.find_text_edit.text())
        search.case_insensitive = not self.match_case_check_box.isChecked()
        search.whole_words = self.whole_words_check_box.isChecked()
        search.numbers = self.number_tags_check_box.isChecked()

    def closeEvent(self, event):
        self.settings.setValue("find.dialog.geometry", self.saveGeometry())
        super().closeEvent(event)

    def show_message(self, msg: str):
        self.message.setText(msg)
