import sys
from PySide6.QtWidgets import (QApplication, QTableView, QStyledItemDelegate, 
                             QLineEdit, QVBoxLayout, QWidget)
from PySide6.QtCore import Qt, Signal, QModelIndex, QAbstractTableModel

class TimeLineEdit(QLineEdit):
    nextRowRequested = Signal()

    def keyPressEvent(self, event):
        if event.key() in (Qt.Key_Return, Qt.Key_Enter):
            print("Enter pressed in editor")
            self.nextRowRequested.emit()
        else:
            super().keyPressEvent(event)

    def normalize(self):
        # Dummy normalization
        pass

class JourneyModel(QAbstractTableModel):
    def __init__(self, rows=10, cols=5):
        super().__init__()
        self._data = [["" for _ in range(cols)] for _ in range(rows)]

    def rowCount(self, parent=QModelIndex()):
        return len(self._data)

    def columnCount(self, parent=QModelIndex()):
        return len(self._data[0])

    def data(self, index, role=Qt.DisplayRole):
        if not index.isValid():
            return None
        if role in (Qt.DisplayRole, Qt.EditRole):
            return self._data[index.row()][index.column()]
        return None

    def setData(self, index, value, role=Qt.EditRole):
        if role == Qt.EditRole:
            print(f"Setting data at {index.row()},{index.column()} to {value}")
            self._data[index.row()][index.column()] = value
            self.dataChanged.emit(index, index, [Qt.EditRole])
            return True
        return False

    def flags(self, index):
        return Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable

class JourneyDelegate(QStyledItemDelegate):
    def createEditor(self, parent, option, index):
        print(f"Creating editor for {index.row()},{index.column()}")
        editor = TimeLineEdit(parent)
        # Use the same logic as in main_sovjet.py
        editor.nextRowRequested.connect(lambda: self._go_to_next(editor))
        return editor

    def _go_to_next(self, editor):
        # logic from main_sovjet.py: editor -> container -> table
        # In a standard QTableView, editor parent is the viewport.
        # viewport parent is the table.
        try:
            viewport = editor.parent()
            table = viewport.parent()
            
            if isinstance(table, QTableView):
                idx = table.currentIndex()
                print(f"Next requested from current index: {idx.row()},{idx.column()}")
                if idx.isValid():
                    new_idx = table.model().index(idx.row() + 1, idx.column())
                    if new_idx.isValid():
                        print(f"Moving to next row: {new_idx.row()}")
                        # This direct call is likely the source of the warning
                        table.setCurrentIndex(new_idx)
                        table.edit(new_idx)
            else:
                print(f"Parent is not QTableView: {type(table)}")
        except Exception as e:
            print(f"Error in _go_to_next: {e}")

    def setEditorData(self, editor, index):
        val = index.data(Qt.EditRole) or ""
        editor.setText(str(val))

    def setModelData(self, editor, model, index):
        print(f"Setting model data for {index.row()},{index.column()}")
        editor.normalize()
        model.setData(index, editor.text(), Qt.EditRole)

class MainWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Delegate Commit MRE")
        layout = QVBoxLayout(self)
        self.table = QTableView()
        self.model = JourneyModel()
        self.table.setModel(self.model)
        self.delegate = JourneyDelegate(self)
        self.table.setItemDelegate(self.delegate)
        layout.addWidget(self.table)
        self.resize(600, 400)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec())