from PySide6.QtCore import QTimer
from PySide6.QtWidgets import QTabWidget, QVBoxLayout, QWidget

from pypos.core.base_view import BaseView
from pypos.modules.penjualan.views.pembatalan_transaksi_view import PembatalanTransaksiView
from pypos.modules.penjualan.views.return_history_view import ReturnPembatalanHistoryView
from pypos.modules.penjualan.views.return_view import ReturnView


class PembatalanView(BaseView, QWidget):
    def __init__(
        self,
        parent=None,
        pembatalan_controller=None,
        return_controller=None,
        return_history_controller=None,
    ):
        super().__init__(parent)
        self.setWindowTitle("Pembatalan & Return Penjualan")
        self.pembatalan_controller = pembatalan_controller
        self.return_controller = return_controller
        self.return_history_controller = return_history_controller
        if (
            self.pembatalan_controller is None
            or self.return_controller is None
            or self.return_history_controller is None
        ):
            raise ValueError("PembatalanView membutuhkan controller instance lengkap")

        self.tab_pembatalan = None
        self.tab_return = None
        self.tab_history = None

        layout = QVBoxLayout(self)
        self.tab_widget = QTabWidget()
        layout.addWidget(self.tab_widget)
        # edited by glg
        # Lazy-init tab untuk menghindari burst query saat halaman pembatalan pertama kali dibuka.
        self._tab_containers = {}
        self._init_tab_placeholders()
        self.tab_widget.currentChanged.connect(self._on_tab_changed)
        self._ensure_tab_initialized(self.tab_widget.currentIndex())

    # edited by glg
    def _init_tab_placeholders(self):
        tab_defs = [
            (0, "Pembatalan Transaksi"),
            (1, "Return Penjualan"),
            (2, "History"),
        ]
        for index, label in tab_defs:
            container = QWidget(self)
            container_layout = QVBoxLayout(container)
            container_layout.setContentsMargins(0, 0, 0, 0)
            container_layout.setSpacing(0)
            self._tab_containers[index] = container
            self.tab_widget.addTab(container, label)

    # edited by glg
    def _mount_tab_widget(self, index, widget):
        container = self._tab_containers.get(index)
        if container is None or widget is None:
            return
        container_layout = container.layout()
        if container_layout is None:
            return
        if container_layout.indexOf(widget) >= 0:
            return
        container_layout.addWidget(widget)

    # edited by glg
    def _ensure_tab_initialized(self, index):
        if index == 0 and self.tab_pembatalan is None:
            self.tab_pembatalan = PembatalanTransaksiView(self.pembatalan_controller, self)
            self._mount_tab_widget(0, self.tab_pembatalan)
            return
        if index == 1 and self.tab_return is None:
            self.tab_return = ReturnView(self.return_controller, self)
            self._mount_tab_widget(1, self.tab_return)
            return
        if index == 2 and self.tab_history is None:
            self.tab_history = ReturnPembatalanHistoryView(self.return_history_controller, self, mode="both")
            self._mount_tab_widget(2, self.tab_history)
            return

    def _on_tab_changed(self, index):
        self._ensure_tab_initialized(index)
        if index == 0 and hasattr(self.tab_pembatalan, "refresh_data"):
            # edited by glg
            # Defer refresh agar perpindahan tab tidak menunggu query sinkron.
            QTimer.singleShot(0, self.tab_pembatalan.refresh_data)
        if index == 1 and hasattr(self.tab_return, "refresh_master"):
            # edited by glg
            # Defer refresh agar tab switch tetap responsif.
            QTimer.singleShot(0, self.tab_return.refresh_master)
        if index == 2 and hasattr(self.tab_history, "refresh_data"):
            # edited by glg
            # Defer refresh agar render tab terjadi sebelum query history berjalan.
            QTimer.singleShot(0, self.tab_history.refresh_data)

    def refresh_active_tab(self):
        self._on_tab_changed(self.tab_widget.currentIndex())

    # edited by glg
    def closeEvent(self, event):
        try:
            if self.return_controller and hasattr(self.return_controller, "dispose"):
                self.return_controller.dispose()
        except Exception as exc:
            self.log_warning(f"Gagal cleanup PembatalanView: {exc}")
        super().closeEvent(event)