#!/usr/bin/env python


__license__   = 'GPL v3'
__copyright__ = '2008, Kovid Goyal kovid@kovidgoyal.net'
__docformat__ = 'restructuredtext en'


import traceback
from functools import partial

from qt.core import (
    QAbstractItemView,
    QApplication,
    QCoreApplication,
    QDialog,
    QEvent,
    QIcon,
    QListWidgetItem,
    QMenu,
    QObject,
    QShortcut,
    QStyle,
    Qt,
    QTableWidgetItem,
    QTimer,
    pyqtSignal,
)

from calibre.customize.ui import find_plugin
from calibre.gui2 import error_dialog, gprefs
from calibre.gui2.dialogs.quickview_ui import Ui_Quickview
from calibre.utils.date import timestampfromdt
from calibre.utils.icu import sort_key
from calibre.utils.iso8601 import UNDEFINED_DATE


class TableItem(QTableWidgetItem):

    '''
    A QTableWidgetItem that sorts on a separate string and uses ICU rules
    '''

    def __init__(self, getter=None):
        self.val = ''
        self.sort = None
        self.sort_idx = 0
        self.getter = getter
        self.resolved = False
        QTableWidgetItem.__init__(self, '')
        self.setFlags(Qt.ItemFlag.ItemIsEnabled|Qt.ItemFlag.ItemIsSelectable)

    def __ge__(self, other):
        self.get_data()
        other.get_data()
        if self.sort is None:
            if other.sort is None:
                # None == None therefore >=
                return True
            # self is None, other is not None therefore self < other
            return False
        if other.sort is None:
            # self is not None and other is None therefore self >= other
            return True

        if isinstance(self.sort, (bytes, str)):
            l = sort_key(self.sort)
            r = sort_key(other.sort)
        else:
            l = self.sort
            r = other.sort
        if l > r:
            return 1
        if l == r:
            return self.sort_idx >= other.sort_idx
        return 0

    def __lt__(self, other):
        self.get_data()
        other.get_data()
        if self.sort is None:
            if other.sort is None:
                # None == None therefore not <
                return False
            # self is None, other is not None therefore self < other
            return True
        if other.sort is None:
            # self is not None therefore self > other
            return False

        if isinstance(self.sort, (bytes, str)):
            l = sort_key(self.sort)
            r = sort_key(other.sort)
        else:
            l = self.sort
            r = other.sort
        if l < r:
            return 1
        if l == r:
            return self.sort_idx < other.sort_idx
        return 0

    def get_data(self):
        if not self.resolved and self.getter:
            self.resolved = True
            self.val, self.sort, self.sort_idx = self.getter()

    def data(self, role):
        self.get_data()
        if role == Qt.ItemDataRole.DisplayRole:
            return self.val
        return QTableWidgetItem.data(self, role)


IN_WIDGET_ITEMS = 0
IN_WIDGET_BOOKS = 1
IN_WIDGET_LOCK = 2
IN_WIDGET_DOCK = 3
IN_WIDGET_SEARCH = 4
IN_WIDGET_CLOSE = 5


class BooksTableFilter(QObject):

    return_pressed_signal = pyqtSignal()

    def eventFilter(self, obj, event):
        if event.type() == QEvent.Type.KeyPress and event.key() == Qt.Key.Key_Return:
            self.return_pressed_signal.emit()
            return True
        return False


class WidgetFocusFilter(QObject):

    focus_entered_signal = pyqtSignal(object)

    def eventFilter(self, obj, event):
        if event.type() == QEvent.Type.FocusIn:
            self.focus_entered_signal.emit(obj)
        return False


class WidgetTabFilter(QObject):

    def __init__(self, attach_to_Class, which_widget, tab_signal):
        QObject.__init__(self, attach_to_Class)
        self.tab_signal = tab_signal
        self.which_widget = which_widget

    def eventFilter(self, obj, event):
        if event.type() == QEvent.Type.KeyPress:
            if event.key() == Qt.Key.Key_Tab:
                self.tab_signal.emit(self.which_widget, True)
                return True
            if event.key() == Qt.Key.Key_Backtab:
                self.tab_signal.emit(self.which_widget, False)
                return True
        return False


class Quickview(QDialog, Ui_Quickview):

    reopen_after_dock_change = pyqtSignal()
    tab_pressed_signal       = pyqtSignal(object, object)
    quickview_closed         = pyqtSignal()

    def __init__(self, gui, row, toggle_shortcut, focus_booklist_shortcut=None):
        self.is_pane = gprefs.get('quickview_is_pane', False)
        if not self.is_pane:
            QDialog.__init__(self, None, flags=Qt.WindowType.Window)
        else:
            QDialog.__init__(self, None, flags=Qt.WindowType.Dialog)
        Ui_Quickview.__init__(self)
        self.setupUi(self)
        self.isClosed = False
        self.current_book = None
        self.closed_by_button = False

        if self.is_pane:
            self.main_grid_layout.setContentsMargins(0, 0, 0, 0)
        else:
            self.setWindowIcon(self.windowIcon())

        self.books_table_column_widths = None
        try:
            self.books_table_column_widths = \
                        gprefs.get('quickview_dialog_books_table_widths', None)
            if not self.is_pane:
                self.restore_geometry(gprefs, 'quickview_dialog_geometry')
        except:
            pass

        self.view = gui.library_view
        self.db = self.view.model().db
        self.gui = gui
        self.is_closed = False
        self.current_book_id = None  # the db id of the book used to fill the lh pane
        self.current_column = None   # current logical column in books list
        self.current_key = None      # current lookup key in books list
        self.last_search = None
        self.no_valid_items = False
        self.follow_library_view = True

        self.apply_vls.setCheckState(Qt.CheckState.Checked if gprefs['qv_respects_vls']
                                        else Qt.CheckState.Unchecked)
        self.apply_vls.stateChanged.connect(self.vl_box_changed)

        self.fm = self.db.field_metadata

        self.items.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
        self.items.currentTextChanged.connect(self.item_selected)
        self.items.setProperty('highlight_current_item', 150)
        self.items.itemDoubleClicked.connect(self.item_doubleclicked)
        self.items.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
        self.items.customContextMenuRequested.connect(self.show_item_context_menu)

        focus_filter = WidgetFocusFilter(self.items)
        focus_filter.focus_entered_signal.connect(self.focus_entered)
        self.items.installEventFilter(focus_filter)

        self.tab_pressed_signal.connect(self.tab_pressed)
        return_filter = BooksTableFilter(self.books_table)
        return_filter.return_pressed_signal.connect(self.return_pressed)
        self.books_table.installEventFilter(return_filter)

        focus_filter = WidgetFocusFilter(self.books_table)
        focus_filter.focus_entered_signal.connect(self.focus_entered)
        self.books_table.installEventFilter(focus_filter)

        self.close_button.clicked.connect(self.close_button_clicked)
        self.refresh_button.clicked.connect(self.refill)

        self.tab_order_widgets = [self.items, self.books_table, self.lock_qv,
                          self.dock_button, self.refresh_button,
                          self.close_button]
        for idx,widget in enumerate(self.tab_order_widgets):
            widget.installEventFilter(WidgetTabFilter(widget, idx, self.tab_pressed_signal))

        self.books_table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
        self.books_table.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
        self.books_table.setProperty('highlight_current_item', 150)

        # Set up the books table columns
        self.add_columns_to_widget()

        self.books_table_header_height = self.books_table.height()
        self.books_table.cellDoubleClicked.connect(self.book_doubleclicked)
        self.books_table.currentCellChanged.connect(self.books_table_cell_changed)
        self.books_table.cellClicked.connect(self.books_table_set_search_string)
        self.books_table.cellActivated.connect(self.books_table_set_search_string)
        self.books_table.sortByColumn(0, Qt.SortOrder.AscendingOrder)

        # get the standard table row height. Do this here because calling
        # resizeRowsToContents can word wrap long cell contents, creating
        # double-high rows
        self.books_table.setRowCount(1)
        self.books_table.setItem(0, 0, TableItem())
        self.books_table.resizeRowsToContents()
        self.books_table_row_height = self.books_table.rowHeight(0)
        self.books_table.setRowCount(0)

        # Add the data
        self.refresh(row)

        self.slave_timers = [QTimer(self), QTimer(self), QTimer(self)]
        self.view.clicked.connect(partial(self.delayed_slave, func=self.slave, dex=0))
        self.view.selectionModel().currentColumnChanged.connect(
                        partial(self.delayed_slave, func=self.column_slave, dex=1))
        QCoreApplication.instance().aboutToQuit.connect(self.save_state)
        self.view.model().new_bookdisplay_data.connect(
                           partial(self.delayed_slave, func=self.book_was_changed, dex=2))

        self.close_button.setDefault(False)
        self.close_button_tooltip = _('The Quickview shortcut ({0}) shows/hides the Quickview panel')
        self.refresh_button.setIcon(QIcon.ic('view-refresh.png'))
        self.close_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_DialogCloseButton))
        if self.is_pane:
            self.dock_button.setText(_('Undock'))
            self.dock_button.setToolTip(_('Show the Quickview panel in its own floating window'))
            self.dock_button.setIcon(QIcon.ic('arrow-up.png'))
            # Remove the ampersands from the buttons because shortcuts exist.
            self.lock_qv.setText(_('Lock Quickview contents'))
            self.refresh_button.setText(_('Refresh'))
            self.gui.layout_container.set_widget('quick_view', self)
            self.close_button.setVisible(False)
        else:
            self.dock_button.setToolTip(_('Embed the Quickview panel into the main calibre window'))
            self.dock_button.setIcon(QIcon.ic('arrow-down.png'))
        self.set_focus()

        self.books_table.horizontalHeader().sectionResized.connect(self.section_resized)
        self.dock_button.clicked.connect(self.show_as_pane_changed)
        self.view.model().search_done.connect(self.check_for_no_items)

        # Enable the refresh button only when QV is locked
        self.refresh_button.setEnabled(False)
        self.lock_qv.stateChanged.connect(self.lock_qv_changed)

        self.view_icon = QIcon.ic('view.png')
        self.view_plugin = self.gui.iactions['View']
        self.show_details_plugin = self.gui.iactions['Show Book Details']
        self.edit_metadata_icon = QIcon.ic('edit_input.png')
        self.quickview_icon = QIcon.ic('quickview.png')
        self.select_book_icon = QIcon.ic('library.png')
        self.search_icon = QIcon.ic('search.png')
        self.books_table.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
        self.books_table.customContextMenuRequested.connect(self.show_context_menu)

        # Add the quickview toggle as a shortcut for the close button
        # Don't add it if it identical to the current &X shortcut because that
        # breaks &X. Also add the focus booklist shortcut
        if not self.is_pane:
            if toggle_shortcut and self.close_button.shortcut() != toggle_shortcut:
                toggle_sc = QShortcut(toggle_shortcut, self.close_button)
                toggle_sc.activated.connect(lambda: self.close_button_clicked())
                toggle_sc.setEnabled(True)
                self.close_button.setToolTip(_('Alternate shortcut: ') +
                                             toggle_shortcut.toString())
            if focus_booklist_shortcut is not None:
                toggle_sc = QShortcut(focus_booklist_shortcut, self)
                toggle_sc.activated.connect(self.focus_booklist)
                toggle_sc.setEnabled(True)

    def focus_booklist(self):
        from calibre.gui2.ui import get_gui
        gui = get_gui()
        gui.activateWindow()
        gui.focus_current_view()

    def delayed_slave(self, current, func=None, dex=None):
        self.slave_timers[dex].stop()
        t = self.slave_timers[dex] = QTimer(self)
        t.timeout.connect(partial(func, current))
        t.setSingleShot(True)
        t.setInterval(200)
        t.start()

    def item_doubleclicked(self, item):
        tb = self.gui.tb_widget
        tb.set_focus_to_find_box()
        tb.item_search.lineEdit().setText(self.current_key + ':=' + item.text())
        tb.do_find()

    def show_item_context_menu(self, point):
        item = self.items.currentItem()
        self.context_menu = QMenu(self)
        self.context_menu.addAction(self.search_icon, _('Find item in the Tag browser'),
                                partial(self.item_doubleclicked, item))
        self.context_menu.addAction(self.search_icon, _('Find item in the library'),
                                partial(self.do_search, follow_library_view=False))
        self.context_menu.popup(self.items.mapToGlobal(point))
        self.context_menu = QMenu(self)

    def show_context_menu(self, point):
        index = self.books_table.indexAt(point)
        row = index.row()
        column = index.column()
        item = self.books_table.item(index.row(), 0)
        if item is None:
            return False
        book_id = int(item.data(Qt.ItemDataRole.UserRole))
        book_displayed = self.book_displayed_in_library_view(book_id)
        m = self.context_menu = QMenu(self)
        a = m.addAction(self.select_book_icon, _('Select this book in the library'),
                                partial(self.select_book, book_id))
        a.setEnabled(book_displayed)
        m.addAction(_('Open a locked Book details window for this book'),
                    partial(self.show_book_details, book_id))
        m.addAction(self.search_icon, _('Find item in the library'),
                        partial(self.do_search, follow_library_view=False))
        a = m.addAction(self.edit_metadata_icon, _('Edit metadata'),
                        partial(self.edit_metadata, book_id, follow_library_view=False))
        a.setEnabled(book_displayed)
        a = m.addAction(self.quickview_icon, _('Quickview this cell'),
                        partial(self.quickview_item, row, column))
        key = self.column_order[column]
        a.setEnabled(self.is_category(key) and book_displayed and
                     key in self.view.visible_columns and
                     not self.lock_qv.isChecked())
        m.addSeparator()
        m.addAction(self.view_icon, _('Open book in the E-book viewer'),
                        partial(self.view_plugin._view_calibre_books, [book_id]))
        self.context_menu.popup(self.books_table.mapToGlobal(point))
        return True

    def lock_qv_changed(self, state):
        self.refresh_button.setEnabled(state)

    def add_columns_to_widget(self):
        '''
        Get the list of columns from the preferences. Clear the current table
        and add the current column set
        '''
        self.column_order = [x[0] for x in get_qv_field_list(self.fm) if x[1]]
        self.books_table.clear()
        self.books_table.setRowCount(0)
        self.books_table.setColumnCount(len(self.column_order))
        for idx,col in enumerate(self.column_order):
            t = QTableWidgetItem(self.fm[col]['name'])
            self.books_table.setHorizontalHeaderItem(idx, t)

    def refill(self):
        '''
            Refill the table in case the columns displayed changes
        '''
        self.add_columns_to_widget()
        self.refresh(self.view.currentIndex(), ignore_lock=True)

    def set_search_text(self, txt):
        self.last_search = txt

    def focus_entered(self, obj):
        if obj == self.books_table:
            self.books_table_set_search_string(self.books_table.currentRow(),
                                               self.books_table.currentColumn())
        elif obj.currentItem():
            self.item_selected(obj.currentItem().text())

    def books_table_cell_changed(self, cur_row, cur_col, prev_row, prev_col):
        self.books_table_set_search_string(cur_row, cur_col)

    def books_table_set_search_string(self, current_row, current_col):
        '''
        Given the contents of a cell, compute a search string that will find
        that book and any others with identical contents in the cell.
        '''
        current = self.books_table.item(current_row, current_col)
        if current is None:
            return
        book_id = current.data(Qt.ItemDataRole.UserRole)

        if current is None:
            return
        col = self.column_order[current.column()]
        if col == 'title':
            self.set_search_text('title:="' + current.text().replace('"', '\\"') + '"')
        elif col == 'authors':
            authors = []
            for aut in [t.strip() for t in current.text().split('&')]:
                authors.append('authors:="' + aut.replace('"', '\\"') + '"')
            self.set_search_text(' and '.join(authors))
        elif self.fm[col]['datatype'] == 'series':
            mi = self.db.get_metadata(book_id, index_is_id=True, get_user_categories=False)
            t = mi.get(col)
            if t:
                self.set_search_text(col+ ':="' + t + '"')
            else:
                self.set_search_text(None)
        else:
            if self.fm[col]['is_multiple']:
                items = [(col + ':"=' + v.strip() + '"') for v in
                         current.text().split(self.fm[col]['is_multiple']['ui_to_list'])]
                self.set_search_text(' and '.join(items))
            else:
                self.set_search_text(col + ':"=' + current.text() + '"')

    def tab_pressed(self, in_widget, isForward):
        if isForward:
            in_widget += 1
            if in_widget >= len(self.tab_order_widgets):
                in_widget = 0
        else:
            in_widget -= 1
            if in_widget < 0:
                in_widget = len(self.tab_order_widgets) - 1
        self.tab_order_widgets[in_widget].setFocus(Qt.FocusReason.TabFocusReason)

    def show(self):
        QDialog.show(self)
        if self.is_pane:
            self.gui.show_panel('quick_view')

    def show_as_pane_changed(self):
        gprefs['quickview_is_pane'] = not gprefs.get('quickview_is_pane', False)
        self.reopen_after_dock_change.emit()

    # search button
    def do_search(self, follow_library_view=True):
        if self.no_valid_items:
            return
        if self.last_search is not None:
            try:
                self.follow_library_view = follow_library_view
                self.gui.search.set_search_string(self.last_search)
            finally:
                self.follow_library_view = True

    def book_was_changed(self, mi):
        '''
        Called when book information is changed in the library view. Make that
        book info current. This means that prev and next in edit metadata will move
        the current book and change quickview
        '''
        if self.is_closed or self.current_column is None or not self.follow_library_view:
            return
        # There is an ordering problem when libraries are changed. The library
        # view is changed, triggering a book_was_changed signal. Unfortunately
        # this happens before the library_changed actions are run, meaning we
        # still have the old database. To avoid the problem we just ignore the
        # operation if we get an exception. The "close" will come
        # eventually.
        try:
            self.refresh(self.view.model().index(self.db.row(mi.id), self.current_column))
        except:
            pass

    # clicks on the items listWidget
    def item_selected(self, txt):
        if self.no_valid_items:
            return
        self.fill_in_books_box(str(txt))
        self.set_search_text(self.current_key + ':"=' + txt.replace('"', '\\"') + '"')

    def vl_box_changed(self):
        gprefs['qv_respects_vls'] = self.apply_vls.isChecked()
        self._refresh(self.current_book_id, self.current_key)

    def refresh(self, idx, ignore_lock=False):
        '''
        Given a cell in the library view, display the information. This method
        converts the index into the lookup key
        '''
        if (not ignore_lock and self.lock_qv.isChecked()):
            return
        if not idx.isValid():
            from calibre.constants import DEBUG
            if DEBUG:
                from calibre import prints
                prints('QuickView: current index is not valid')
            return

        try:
            self.current_column = (
                self.view.column_map.index('authors') if (
                    self.current_column is None and self.view.column_map[idx.column()] == 'title'
                ) else idx.column())
            key = self.view.column_map[self.current_column]
            book_id = self.view.model().id(idx.row())
            if self.current_book_id == book_id and self.current_key == key:
                return
            self._refresh(book_id, key)
        except:
            traceback.print_exc()
            self.indicate_no_items()

    def is_category(self, key):
        return key is not None and (
                     self.fm[key]['table'] is not None and
                     (self.fm[key]['is_category'] or
                                    (self.fm[key]['datatype'] == 'composite' and
                                     self.fm[key]['display'].get('make_category', False))))

    def _refresh(self, book_id, key):
        '''
        Actually fill in the left-hand panel from the information in the
        selected column of the selected book
        '''
        # Only show items for categories
        if not self.is_category(key):
            if self.current_key is None:
                self.indicate_no_items()
                return
            key = self.current_key
        label_text = _('&Item: {0} ({1})')
        if self.is_pane:
            label_text = label_text.replace('&', '')

        self.items.blockSignals(True)
        self.items.clear()
        self.books_table.setRowCount(0)

        mi = self.db.new_api.get_proxy_metadata(book_id)
        vals = self.db.new_api.split_if_is_multiple_composite(key, mi.get(key, None))
        try:
            # Check if we are in the GridView and there are no values for the
            # selected column. In this case switch the column to 'authors'
            # because there isn't an easy way to switch columns in GridView
            # when the QV box is empty.
            if not vals:
                is_grid_view = (self.gui.current_view().alternate_views.current_view !=
                                self.gui.current_view().alternate_views.main_view)
                if is_grid_view:
                    key = 'authors'
                    vals = mi.get(key, None)
        except:
            traceback.print_exc()

        self.current_book_id = book_id
        self.current_key = key
        self.items_label.setText(label_text.format(self.fm[key]['name'], key))

        if vals:
            self.no_valid_items = False
            if self.fm[key]['datatype'] == 'rating':
                if self.fm[key]['display'].get('allow_half_stars', False):
                    vals = str(vals/2.0)
                else:
                    vals = str(vals//2)
            if not isinstance(vals, list):
                vals = [vals]
            vals.sort(key=sort_key)

            for v in vals:
                a = QListWidgetItem(v)
                a.setToolTip(
                    '<p>' + _(
                        'Click to show only books with this item. '
                        'Double click to search for this item in the Tag browser') + '</p>')
                self.items.addItem(a)
            self.items.setCurrentRow(0)

            self.fill_in_books_box(vals[0])
        else:
            self.indicate_no_items()
        self.items.blockSignals(False)

    def check_for_no_items(self):
        if not self.is_closed and self.view.model().count() == 0:
            self.indicate_no_items()

    def indicate_no_items(self):
        self.no_valid_items = True
        self.items.clear()
        self.add_columns_to_widget()
        self.items.addItem(QListWidgetItem(_('**No items found**')))
        self.books_label.setText(_('Click in a column  in the library view '
                                   'to see the information for that book'))

    def fill_in_books_box(self, selected_item):
        '''
        Given the selected row in the left-hand box, fill in the grid with
        the books that contain that data.
        '''
        # Do a bit of fix-up on the items so that the search works.
        if selected_item.startswith('.'):
            sv = '.' + selected_item
        else:
            sv = selected_item
        sv = self.current_key + ':"=' + sv.replace('"', r'\"') + '"'
        if self.apply_vls.isChecked():
            books = self.db.search(sv, return_matches=True, sort_results=False)
        else:
            books = self.db.new_api.search(sv)

        self.books_table.setRowCount(len(books))
        label_text = _('&Books with selected item "{0}": {1}')
        if self.is_pane:
            label_text = label_text.replace('&', '')
        self.books_label.setText(label_text.format(selected_item, len(books)))

        select_item = None
        self.books_table.setSortingEnabled(False)
        self.books_table.blockSignals(True)
        tt = ('<p>' + _(
              'Double click on a book to change the selection in the library view or '
              'change the column shown in the left-hand panel. '
              'Shift- or Ctrl- double click to edit the metadata of a book, '
              'which also changes the selected book.'
              ) + '</p>')
        for row, b in enumerate(books):
            for col in self.column_order:
                a = TableItem(partial(self.get_item_data, b, col))
                if col == 'title':
                    if b == self.current_book_id:
                        select_item = a
                # The data is supplied on demand when the item is displayed
                a.setData(Qt.ItemDataRole.UserRole, b)
                a.setToolTip(tt)
                self.books_table.setItem(row, self.key_to_table_widget_column(col), a)
                self.books_table.setRowHeight(row, self.books_table_row_height)
        self.books_table.blockSignals(False)
        self.books_table.setSortingEnabled(True)
        if select_item is not None:
            self.books_table.setCurrentItem(select_item)
            self.books_table.scrollToItem(select_item, QAbstractItemView.ScrollHint.PositionAtCenter)
        self.set_search_text(sv)

    def get_item_data(self, book_id, col):
        mi = self.db.new_api.get_proxy_metadata(book_id)
        try:
            if col == 'title':
                return (mi.title, mi.title_sort, 0)
            elif col == 'authors':
                return (' & '.join(mi.authors), mi.author_sort, 0)
            elif col == 'series':
                series = mi.format_field('series')[1]
                if series is None:
                    return ('', None, 0)
                else:
                    return (series, mi.series, mi.series_index)
            elif col == 'size':
                v = mi.get('book_size')
                if v is not None:
                    return (f'{v:n}', v, 0)
                else:
                    return ('', None, 0)
            elif self.fm[col]['datatype'] == 'series':
                v = mi.format_field(col)[1]
                return (v, mi.get(col), mi.get(col+'_index'))
            elif self.fm[col]['datatype'] == 'datetime':
                v = mi.format_field(col)[1]
                d = mi.get(col)
                if d is None:
                    d = UNDEFINED_DATE
                return (v, timestampfromdt(d), 0)
            elif self.fm[col]['datatype'] in ('float', 'int'):
                v = mi.format_field(col)[1]
                sort_val = mi.get(col)
                return (v, sort_val, 0)
            else:
                v = mi.format_field(col)[1]
                return (v, v, 0)
        except:
            traceback.print_exc()
            return (_('Something went wrong while filling in the table'), '', 0)

    # Deal with sizing the table columns. Done here because the numbers are not
    # correct until the first paint.
    def resizeEvent(self, *args):
        QDialog.resizeEvent(self, *args)

        if self.books_table_column_widths is not None:
            for c,w in enumerate(self.books_table_column_widths):
                self.books_table.setColumnWidth(c, w)
        else:
            # the vertical scroll bar might not be rendered, so might not yet
            # have a width. Assume 25. Not a problem because user-changed column
            # widths will be remembered
            w = self.books_table.width() - 25 - self.books_table.verticalHeader().width()
            w //= self.books_table.columnCount()
            for c in range(0, self.books_table.columnCount()):
                self.books_table.setColumnWidth(c, w)
        self.save_state()

    def key_to_table_widget_column(self, key):
        return self.column_order.index(key)

    def return_pressed(self):
        row = self.books_table.currentRow()
        if gprefs['qv_retkey_changes_column']:
            self.select_book_and_qv(row, self.books_table.currentColumn())
        else:
            self.select_book_and_qv(row, self.key_to_table_widget_column(self.current_key))

    def book_not_in_view_error(self):
        error_dialog(self, _('Quickview: Book not in library view'),
                     _('The book you selected is not currently displayed in '
                       'the library view, perhaps because of a search or a '
                       'Virtual library, so Quickview cannot select it.'),
                     show=True,
                     show_copy_button=False)

    def book_displayed_in_library_view(self, book_id):
        try:
            self.db.data.index(book_id)
            return True
        except:
            return False

    def quickview_item(self, row, column):
        self.select_book_and_qv(row, column)

    def book_doubleclicked(self, row, column):
        if self.no_valid_items:
            return
        try:
            if gprefs['qv_dclick_changes_column']:
                self.quickview_item(row, column)
            else:
                self.quickview_item(row, self.key_to_table_widget_column(self.current_key))
        except:
            traceback.print_exc()
            self.book_not_in_view_error()

    def edit_metadata(self, book_id, follow_library_view=True):
        try:
            self.follow_library_view = follow_library_view
            self.view.select_rows([book_id])
            em = find_plugin('Edit Metadata')
            if em and em.actual_plugin_:
                em.actual_plugin_.edit_metadata(None)
        finally:
            self.follow_library_view = True

    def show_book_details(self, book_id):
        try:
            self.show_details_plugin.show_book_info(book_id=book_id, locked=True)
        finally:
            pass

    def select_book(self, book_id):
        '''
        Select a book in the library view without changing the QV lists
        '''
        try:
            self.follow_library_view = False
            self.view.select_cell(self.db.data.id_to_index(book_id),
                                  self.current_column)
        finally:
            self.follow_library_view = True

    def select_book_and_qv(self, row, column):
        '''
        row and column both refer the qv table. In particular, column is not
        the logical column in the book list.
        '''
        item = self.books_table.item(row, column)
        if item is None:
            return
        book_id = int(self.books_table.item(row, column).data(Qt.ItemDataRole.UserRole))
        if not self.book_displayed_in_library_view(book_id):
            self.book_not_in_view_error()
            return
        key = self.column_order[column]
        if QApplication.keyboardModifiers() in (Qt.KeyboardModifier.ControlModifier, Qt.KeyboardModifier.ShiftModifier):
            self.edit_metadata(book_id)
        else:
            if key not in self.view.visible_columns:
                error_dialog(self, _("Quickview: Column cannot be selected"),
                     _("The column you double-clicked, '{}', is not shown in the "
                       "library view. The book/column cannot be selected by Quickview.").format(key),
                     show=True,
                     show_copy_button=False)
                return
            self.view.select_cell(self.db.data.id_to_index(book_id),
                                  self.view.column_map.index(key))

    def set_focus(self):
        self.activateWindow()
        self.books_table.setFocus()

    def column_slave(self, current):
        '''
        called when the column is changed on the booklist
        '''
        if self.follow_library_view and gprefs['qv_follows_column']:
            self.slave(current)

    def slave(self, current):
        '''
        called when a book is clicked on the library view
        '''
        if self.is_closed or not self.follow_library_view:
            return
        self.refresh(current)
        self.view.activateWindow()

    def section_resized(self, logicalIndex, oldSize, newSize):
        self.save_state()

    def save_state(self):
        if self.is_closed:
            return
        self.books_table_column_widths = []
        for c in range(0, self.books_table.columnCount()):
            self.books_table_column_widths.append(self.books_table.columnWidth(c))
        gprefs['quickview_dialog_books_table_widths'] = self.books_table_column_widths
        if not self.is_pane:
            self.save_geometry(gprefs, 'quickview_dialog_geometry')

    def _close(self):
        self.save_state()
        # clean up to prevent memory leaks
        self.db = self.view = self.gui = None
        self.is_closed = True

    def close_button_clicked(self):
        self.closed_by_button = True
        self.quickview_closed.emit()

    def reject(self):
        if not self.closed_by_button:
            self.close_button_clicked()
        else:
            self._reject()

    def _reject(self):
        gui = self.gui
        if self.is_pane:
            gui.hide_panel('quick_view')
        gui.library_view.setFocus(Qt.FocusReason.ActiveWindowFocusReason)
        self._close()
        QDialog.reject(self)


def get_qv_field_list(fm, use_defaults=False):
    from calibre.gui2.ui import get_gui
    db = get_gui().current_db
    if use_defaults:
        src = db.prefs.defaults
    else:
        src = db.prefs
    fieldlist = list(src['qv_display_fields'])
    names = frozenset(x[0] for x in fieldlist)
    for field in fm.displayable_field_keys():
        if (field != 'comments' and fm[field]['datatype'] != 'comments' and field not in names):
            fieldlist.append((field, False))
    available = frozenset(fm.displayable_field_keys())
    return [(f, d) for f, d in fieldlist if f in available]
