from typing import Any, cast

from PySide6.QtCore import (
    QDate,
    QModelIndex,
    QPersistentModelIndex,
    QPoint,
    Qt,
    Signal,
    Slot,
)
from PySide6.QtGui import (
    QCloseEvent,
    QColor,
)
from PySide6.QtSql import QSqlQuery, QSqlTableModel
from PySide6.QtWidgets import (
    QAbstractItemView,
    QHBoxLayout,
    QHeaderView,
    QLabel,
    QMainWindow,
    QProgressBar,
    QPushButton,
    QSizePolicy,
    QStyledItemDelegate,
    QStyleOptionViewItem,
    QWidget,
)

from docketModel import docketModel
from lib.utils import (
    QStyleOptionViewItemInit,
    query_error,
    readGeometry,
    writeGeometry,
)
from ui.MainWindow import Ui_MainWindow
from workers import loadCases, updateThread


class dateDelegate(QStyledItemDelegate):
    def displayText(self, value: QDate, _: Any) -> str:
        return value.toString("MMMM d, yyyy")

    def initStyleOption(
        self,
        option: QStyleOptionViewItem,
        index: QModelIndex | QPersistentModelIndex,
        /,
    ) -> None:
        options = cast(QStyleOptionViewItemInit, option)
        super().initStyleOption(options, index)
        assert isinstance(index, QModelIndex)
        if (
            index.siblingAtColumn(5).data(Qt.ItemDataRole.CheckStateRole)
            == Qt.CheckState.Unchecked
        ):
            options.backgroundBrush = QColor(0x444444)
        return


class activeDelegate(QStyledItemDelegate):
    def initStyleOption(
        self,
        option: QStyleOptionViewItem,
        index: QModelIndex | QPersistentModelIndex,
        /,
    ) -> None:
        options = cast(QStyleOptionViewItemInit, option)
        super().initStyleOption(options, index)
        assert isinstance(index, QModelIndex)
        if (
            index.siblingAtColumn(5).data(Qt.ItemDataRole.CheckStateRole)
            == Qt.CheckState.Unchecked
        ):
            options.backgroundBrush = QColor(0x444444)
        return


class casesModel(QSqlTableModel):
    def flags(self, index: QModelIndex | QPersistentModelIndex) -> Qt.ItemFlag:
        if not index.isValid():
            return Qt.ItemFlag.NoItemFlags
        flags = super(casesModel, self).flags(index)
        if index.column() == 5:
            flags = (
                Qt.ItemFlag.ItemIsEnabled
                | Qt.ItemFlag.ItemIsEditable
                | Qt.ItemFlag.ItemIsUserCheckable
            )
        return flags

    def data(
        self,
        index: QModelIndex | QPersistentModelIndex,
        role: int = Qt.ItemDataRole.DisplayRole,
    ) -> Any:
        if not index.isValid():
            return None
        if index.column() == 5:
            if role == Qt.ItemDataRole.CheckStateRole:
                value = super(casesModel, self).data(index)
                return (
                    Qt.CheckState.Checked
                    if value == 1
                    else Qt.CheckState.Unchecked
                )
            elif role == Qt.ItemDataRole.DisplayRole:
                return ""
        return super().data(index, role)

    def setData(
        self,
        index: QModelIndex | QPersistentModelIndex,
        value: Any,
        role: int = Qt.ItemDataRole.DisplayRole,
    ) -> bool:
        if role == Qt.ItemDataRole.CheckStateRole and index.column() == 5:
            super(casesModel, self).setData(index, 1 if value else 0)
            return True
        return super().setData(index, value, role)


class MainWindow(QMainWindow, Ui_MainWindow):
    show_entries = Signal(int)
    update_status = Signal()

    loadThread = None

    def __init__(self) -> None:
        super(MainWindow, self).__init__()
        self.setupUi(self)
        readGeometry(self)

        model = casesModel()
        model.setTable("cases")
        model.setFilter(
            "1=1 ORDER BY SUBSTRING(docket_id, 1, 3), CAST(SUBSTRING(docket_id,4) AS INTEGER)"
        )
        model.select()
        model.setHeaderData(1, Qt.Orientation.Horizontal, "Docket")
        model.setHeaderData(2, Qt.Orientation.Horizontal, "Petitioners")
        model.setHeaderData(3, Qt.Orientation.Horizontal, "Respondents")
        model.setHeaderData(4, Qt.Orientation.Horizontal, "Date")
        model.setHeaderData(5, Qt.Orientation.Horizontal, "Active")
        self.casesView.setModel(model)

        self.casesView.setSelectionMode(
            QAbstractItemView.SelectionMode.SingleSelection
        )
        self.casesView.setSelectionBehavior(
            QAbstractItemView.SelectionBehavior.SelectRows
        )
        self.casesView.hideColumn(0)
        self.casesView.setItemDelegate(activeDelegate())
        self.casesView.setItemDelegateForColumn(4, dateDelegate())
        self.casesView.resizeColumnToContents(1)
        self.casesView.resizeColumnToContents(4)
        header = self.casesView.horizontalHeader()
        header.setSectionResizeMode(2, QHeaderView.ResizeMode.Fixed)
        header.setSectionResizeMode(3, QHeaderView.ResizeMode.Fixed)
        self.show()
        remaining = (
            self.casesView.width()
            - header.sectionSize(1)
            - header.sectionSize(4)
            - 5
        )
        self.casesView.setColumnWidth(2, int(remaining * 0.5))
        self.casesView.setColumnWidth(3, int(remaining * 0.5))
        self.casesView.verticalHeader().hide()
        self.casesView.resizeRowsToContents()
        self.casesView.doubleClicked.connect(self.rowClicked)
        self.casesView.clicked.connect(self.rowClicked)

        self.docketView.clickedEvent.connect(self.clickedEvent)
        self.docketView.setModel(docketModel())
        self.docketView.horizontalHeader().setSectionResizeMode(
            1, QHeaderView.ResizeMode.Stretch
        )

        widget = QWidget()
        layout = QHBoxLayout(widget)
        self.status = QLabel("Status")
        layout.addWidget(self.status)
        layout.addStretch()
        self.progress = QProgressBar()
        self.progress.setRange(0, 100)
        self.progress.setValue(0)
        self.progress.setMinimumWidth(150)
        self.progress.setMaximumWidth(150)
        self.progress.setSizePolicy(
            QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Preferred
        )
        layout.addWidget(self.progress)
        self.loadButton = QPushButton()
        self.loadButton.setObjectName("loadButton")
        self.loadButton.setText("Load Cases")
        layout.addWidget(self.loadButton)
        self.statusbar.addWidget(widget, 10)

        self.loadButton.clicked.connect(self.loadCases)
        self.update_status.connect(self.statusBarUpdate)
        self.update_status.emit()
        return

    def closeEvent(self, event: QCloseEvent) -> None:
        writeGeometry(self)
        super().closeEvent(event)
        return

    @Slot()
    def loadCases(self) -> None:
        if self.loadThread is None:
            self.loadThread = loadCases()
            self.loadThread.caseLoaded.connect(self.progress.setValue)
            self.loadThread.finished.connect(self.loadCasesDone)
        self.loadButton.setEnabled(False)
        self.loadThread.start()
        return

    @Slot()
    def loadCasesDone(self) -> None:
        self.loadButton.setEnabled(True)
        self.update_status.emit()
        return

    @Slot()
    def statusBarUpdate(self) -> None:
        if self.loadThread is None:
            year = ""
            max = "unknown"
        else:
            year = self.loadThread.year
            max = str(self.loadThread.number)
        query = QSqlQuery()
        query.prepare(
            "SELECT COUNT(*) AS number_active FROM cases WHERE active=1"
        )
        if not query.exec():
            query_error(query)
        if query.next():
            active = query.value("number_active")
        query.prepare(
            "select SUBSTRING(docket_id,1,2) AS year, "
            "SUBSTRING(docket_id,3,1) AS type, "
            "MAX(CAST(SUBSTRING(docket_id,4) AS INTEGER)) AS number "
            "FROM cases "
            "GROUP BY year, type "
            "ORDER BY type, year, number"
            "LIMIT 2"
        )
        # if not query.exec():
        #    query_error(query)
        msg = f"Oldest: {year}, Active: {active}, Max. Case: {max}"
        self.status.setText(msg)
        return

    @Slot(QModelIndex)  # type: ignore
    def rowClicked(self, index: QModelIndex) -> None:
        if not index.isValid():
            raise Exception("Bad index")
        docket = index.siblingAtColumn(1).data()
        self.docketLabel.setText(docket)
        self.show_entries.emit(index.siblingAtColumn(0).data())
        model = cast(docketModel, self.docketView.model())
        model.newCase(index.siblingAtColumn(0).data())
        self.docketView.resizeColumnToContents(0)
        self.docketView.resizeRowsToContents()
        return

    updateThread = None

    @Slot()
    def on_updateButton_clicked(self) -> None:
        text = self.docketInput.toPlainText()
        print(f"on_updateButton_clicked(): {text}")
        if not self.updateThread:
            self.updateThread = updateThread()
            assert isinstance(self.updateThread, updateThread)
            self.updateThread.finished.connect(self.updateDone)
        self.updateThread.setDocketId(text)
        self.updateThread.setDocketId(text)
        self.updateThread.start()
        return

    @Slot(QPoint)  # type: ignore
    def clickedEvent(self, pos: QPoint) -> None:
        print(pos)
        viewport = self.docketView.viewport()
        print(viewport, viewport.children())
        return

    @Slot()
    def updateDone(self) -> None:
        self.updateThread = None
        print("Done updating")
        model: QSqlTableModel = cast(QSqlTableModel, self.casesView.model())
        query = model.query()
        query.exec()
        model.setQuery(query)
        return