lintunes/lintunes/gui/identify_dialog.py

"""Confirmation dialog for a track identification (Identify Track…).

Shows the proposed tag changes for one track — current value vs an editable
proposed value per field, with a checkbox to opt out of any row — and a
dropdown of alternate candidates (other albums/releases the recording appears
on). Passive like AlbumArtDialog: candidates arrive pre-parsed, nothing is
written until the user accepts, and the caller applies ``result_fields()``
through LibraryManager afterwards.
"""
from PyQt6.QtWidgets import (
    QCheckBox, QComboBox, QDialog, QDialogButtonBox, QGridLayout, QLabel,
    QLineEdit, QPushButton, QSpinBox, QVBoxLayout,
)

# (field, label, is_number, spinbox max)
_FIELDS = [
    ("name", "Name", False, 0),
    ("artist", "Artist", False, 0),
    ("album_artist", "Album Artist", False, 0),
    ("album", "Album", False, 0),
    ("year", "Year", True, 9999),
    ("track_number", "Track #", True, 999),
    ("track_count", "Track Count", True, 999),
    ("disc_number", "Disc #", True, 99),
]


class IdentifyDialog(QDialog):
    def __init__(self, track, candidates, remaining: int = 0, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Identify Track")
        self._track = track
        self._candidates = candidates
        # True when the user pressed "Stop Identifying" on a queued batch.
        self.cancel_all = False

        layout = QVBoxLayout(self)
        best = candidates[0]
        header = QLabel(f"Identified “{track.name or '(untitled)'}” — "
                        f"match confidence {round(best.score * 100)}%")
        header.setWordWrap(True)
        layout.addWidget(header)

        # All alternates at a glance — a candidate summarizes to one line, so
        # a dropdown beats AlbumArtDialog's blind Next-clicking.
        self._combo = QComboBox()
        for c in candidates:
            year = f" ({c.year})" if c.year else ""
            self._combo.addItem(" — ".join(
                p for p in (c.name, c.artist, c.album) if p) + year)
        layout.addWidget(self._combo)

        grid = QGridLayout()
        grid.setColumnStretch(1, 1)
        grid.setColumnStretch(3, 1)
        self._checks: dict[str, QCheckBox] = {}
        self._current_labels: dict[str, QLabel] = {}
        self._editors: dict[str, QLineEdit | QSpinBox] = {}
        for row, (field, label, is_number, maximum) in enumerate(_FIELDS):
            check = QCheckBox(label)
            current = QLabel()
            current.setEnabled(False)  # the greyed-hint idiom
            arrow = QLabel("→")
            if is_number:
                editor = QSpinBox()
                editor.setRange(0, maximum)
                editor.setSpecialValueText(" ")
            else:
                editor = QLineEdit()
            check.toggled.connect(editor.setEnabled)
            self._checks[field] = check
            self._current_labels[field] = current
            self._editors[field] = editor
            grid.addWidget(check, row, 0)
            grid.addWidget(current, row, 1)
            grid.addWidget(arrow, row, 2)
            grid.addWidget(editor, row, 3)
        layout.addLayout(grid)

        buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok
                                   | QDialogButtonBox.StandardButton.Cancel)
        buttons.button(QDialogButtonBox.StandardButton.Ok).setText(
            "Apply Tags")
        if remaining > 0:
            noun = "track" if remaining == 1 else "tracks"
            stop_btn = QPushButton(f"Stop Identifying ({remaining} {noun} left)")
            buttons.addButton(stop_btn,
                              QDialogButtonBox.ButtonRole.ActionRole)
            stop_btn.clicked.connect(self._stop_all)
        buttons.accepted.connect(self.accept)
        buttons.rejected.connect(self.reject)
        layout.addWidget(buttons)

        self._combo.currentIndexChanged.connect(self._fill_from_candidate)
        self._fill_from_candidate(0)

    # ---- candidate switching ----

    def _current_value(self, field):
        return getattr(self._track, field, None)

    def _fill_from_candidate(self, index: int):
        """Re-fill the grid from a candidate (hand edits are discarded on a
        switch, like AlbumArtDialog cycling). A row is checked and editable
        iff the candidate proposes a value that differs from the current one;
        rows with nothing proposed are unchecked and disabled."""
        candidate = self._candidates[index]
        for field, _label, is_number, _max in _FIELDS:
            current = self._current_value(field)
            proposed = getattr(candidate, field)
            label = self._current_labels[field]
            editor = self._editors[field]
            check = self._checks[field]
            label.setText(str(current) if current else "—")
            if is_number:
                editor.setValue(proposed or 0)
            else:
                editor.setText(proposed or "")
            has_proposal = proposed is not None
            differs = has_proposal and proposed != (current or None)
            check.setEnabled(has_proposal)
            check.setChecked(differs)
            editor.setEnabled(differs)

    def _stop_all(self):
        self.cancel_all = True
        self.reject()

    # ---- result ----

    def result_fields(self) -> dict:
        """Checked rows only, keyed by LinTunes field names — ready for
        ``LibraryManager.edit_track_fields``. Blank editors are dropped (a
        checked row the user then emptied proposes nothing)."""
        fields = {}
        for field, _label, is_number, _max in _FIELDS:
            if not self._checks[field].isChecked():
                continue
            editor = self._editors[field]
            value = editor.value() if is_number else editor.text().strip()
            if value:
                fields[field] = value
        return fields