import json
from typing import cast

import requests
from PyQt6.QtCore import QPoint, QRect, Qt, QTimer, pyqtSlot
from PyQt6.QtGui import (
    QBrush,
    QColor,
    QFont,
    QMouseEvent,
    QPainter,
    QPainterPath,
    QPaintEvent,
    QTextCharFormat,
    QTextCursor,
    QTextDocument,
    QTextListFormat,
)
from PyQt6.QtSql import QSqlDatabase, QSqlQuery, QSqlQueryModel
from PyQt6.QtWidgets import QDialog, QPushButton

from main import query_error
from ui.EditDialog import Ui_Dialog


class EditDialog(QDialog, Ui_Dialog):
    block: int

    def __init__(self, person_id: int) -> None:
        super(EditDialog, self).__init__()
        self.person_id = person_id
        self.setupUi(self)
        #
        # Override UI
        #
        font = QFont()
        font.setFamily("OpenDyslexic")
        font.setPointSize(14)
        self.paraEdit.setFont(font)
        #
        # End overrides
        #
        self.load_book(self.person_id)
        blockNumber = self.block
        self.paraEdit.setReadOnly(True)
        self.defEdit.setReadOnly(True)
        self.show_section(self.section_id)
        self.block = blockNumber
        self.savePosition()
        self.stackedWidget.setCurrentIndex(0)
        self.addBtn.clicked.connect(self.defineAction)
        self.showBtn.clicked.connect(self.showAction)
        self.nextBtn.clicked.connect(self.nextAction)
        self.prevBtn.clicked.connect(self.prevAction)
        self.nextParaBtn.clicked.connect(self.nextParaAction)
        # self.prevParaBtn.clicked.connect(self.prevParaAction)
        self.paraEdit.verticalScrollBar().valueChanged.connect(self.scrollSlot)
        self.scrollBtn.clicked.connect(self.scrollAction)
        return

    @pyqtSlot()
    def scrollAction(self) -> None:
        position = (
            self.paraEdit.document().findBlockByNumber(self.block).position()
        )
        cursor = self.paraEdit.textCursor()
        cursor.setPosition(position)
        pos = self.paraEdit.mapTo(
            self, self.paraEdit.cursorRect(cursor).topLeft()
        )
        top = self.paraEdit.mapTo(self, QPoint(0, 0))
        value = self.paraEdit.verticalScrollBar().value()
        #
        # XXX - Where does "4" come from?
        #
        delta = pos.y() - top.y() - 4
        self.pxPerTick = int(1000 / delta)
        if self.pxPerTick < 1:
            if delta < 0:
                self.pxPerTick = -1
            else:
                self.pxPerTick = 1
        steps = abs(delta / self.pxPerTick)
        msPerTick = int(1000 / steps)
        if msPerTick < 3:
            msPerTick = 3
        self.target = value + delta
        print(f"delta: {delta}, pixels: {self.pxPerTick}, ms: {msPerTick}")
        timer = QTimer(self)
        timer.timeout.connect(self.softTick)
        timer.start(msPerTick)
        return

    @pyqtSlot()
    def softTick(self) -> None:
        value = self.paraEdit.verticalScrollBar().value()
        sender: QTimer = cast(QTimer, self.sender())
        if self.pxPerTick < 0:  # moving content up
            if value < self.target:
                sender.stop()
                return
        else:
            if value > self.target:
                sender.stop()
                return
        value += self.pxPerTick
        self.paraEdit.verticalScrollBar().setValue(value)
        self.update()
        return

    @pyqtSlot(int)
    def scrollSlot(self, value: int) -> None:
        self.update()
        return

    def load_book(self, person_id: int) -> None:
        query = QSqlQuery()
        query.prepare(
            "SELECT pb.* FROM people p "
            "LEFT JOIN person_book pb "
            "ON (p.book_id = pb.book_id "
            "AND p.person_id = pb.person_id) "
            "WHERE p.person_id = :person_id"
        )
        query.bindValue(":person_id", person_id)
        if not query.exec():
            query_error(query)
        if not query.next():
            self.done(0)
        self.book_id = query.value("book_id")
        self.section_id = query.value("section_id")
        self.block = query.value("block")
        self.sections = []
        self.section_map = {}
        self.sequence_map = {}
        query.prepare(
            "SELECT * FROM sections "
            "WHERE book_id = :book_id "
            "ORDER BY sequence"
        )
        query.bindValue(":book_id", self.book_id)
        if not query.exec():
            query_error(query)
        while query.next():
            self.sections.append(query.value("content"))
            self.section_map[query.value("section_id")] = query.value(
                "sequence"
            )
            self.sequence_map[query.value("sequence")] = query.value(
                "section_id"
            )
        return

    def show_section(self, section_id: int, start: bool = True) -> None:
        sequence = self.section_map[section_id]
        self.setWindowTitle(f"Section {sequence}")
        self.paraEdit.clear()
        cursor = self.paraEdit.textCursor()
        cursor.insertHtml(self.sections[sequence])
        if start:
            self.block = 0
        else:
            self.block = self.paraEdit.document().blockCount() - 1
        textBlock = self.paraEdit.document().findBlockByNumber(self.block)
        cursor.setPosition(textBlock.position())
        self.paraEdit.setTextCursor(cursor)
        self.paraEdit.ensureCursorVisible()
        #
        # Mark all the defined words with underlines
        #
        def_format = QTextCharFormat()
        def_format.setFontUnderline(True)
        cursor = QTextCursor(self.paraEdit.document())
        query = QSqlQuery()
        query.prepare(
            "SELECT * FROM word_block " "WHERE section_id = :section_id"
        )
        query.bindValue(":section_id", section_id)
        if not query.exec():
            query_error(query)
        while query.next():
            #
            # Define these variables so that the code matches
            # the defining action
            #
            blockNum = query.value("block")
            start = query.value("start")
            end = query.value("end")
            textBlock = self.paraEdit.document().findBlockByNumber(blockNum)
            cursor.setPosition(
                start + textBlock.position(), QTextCursor.MoveMode.MoveAnchor
            )
            cursor.setPosition(
                end + textBlock.position(), QTextCursor.MoveMode.KeepAnchor
            )
            cursor.setCharFormat(def_format)

        return

    def mousePressEvent(self, event: QMouseEvent | None) -> None:
        return

    def paintEvent(self, e: QPaintEvent | None) -> None:
        position = (
            self.paraEdit.document().findBlockByNumber(self.block).position()
        )
        cursor = self.paraEdit.textCursor()
        cursor.setPosition(position)
        #
        # rect is position in viewport coordenates.
        rect = self.paraEdit.cursorRect(cursor)
        c_pt = self.paraEdit.mapTo(self, rect.bottomLeft())
        painter = QPainter(self)
        brush = QBrush()
        brush.setColor(QColor("green"))
        brush.setStyle(Qt.BrushStyle.SolidPattern)
        path = QPainterPath()
        path.moveTo(0, 0)
        path.lineTo(18, -rect.height() / 2.0)
        path.lineTo(0, -rect.height())
        path.lineTo(0, 0)
        painter.translate(1.0, c_pt.y())
        painter.fillPath(path, brush)
        return
    
    @pyqtSlot()
    def nextParaAction(self) -> None:
        self.block += 1
        if self.block >= self.paraEdit.document().blockCount():
            self.nextAction()
            return
        self.savePosition()
        return

    @pyqtSlot()
    def defineAction(self) -> None:
        #
        # Find the word
        #
        cursor = self.paraEdit.textCursor()
        word = cursor.selectedText()
        start = cursor.selectionStart()
        end = cursor.selectionEnd()
        if start != end:
            word = word.strip()
        if len(word) == 0 or word.find(" ") >= 0:
            return
        if start > end:
            tmp = start
            start = end
            end = tmp
        #
        # Find the block
        #
        textBlock = self.paraEdit.document().findBlock(cursor.position())
        blockNum = textBlock.blockNumber()
        query = QSqlQuery()
        query.prepare("SELECT * FROM words WHERE word = :word")
        query.bindValue(":word", word)
        if not query.exec():
            query_error(query)
        if query.next():  # we have something
            self.defined(query.value("word_id"), blockNum, start, end)
            return
        #
        # Get the defintion
        #
        response = requests.get(
            f"https://api.dictionaryapi.dev/api/v2/entries/en/{word}"
        )
        if response.status_code != 200:
            print(response.content)
            return
        definitions = json.loads(response.content.decode("utf-8"))
        definition = definitions[0]
        query.prepare(
            "INSERT INTO words (word, definition) "
            "VALUES (:word, :definition)"
        )
        query.bindValue(":word", word)
        query.bindValue(":definition", json.dumps(definition))
        if not query.exec():
            query_error(query)
        start = start - textBlock.position()
        end = end - textBlock.position()
        self.defined(query.lastInsertId(), blockNum, start, end)
        return

    def defined(
        self, word_id: int, blockNum: int, start: int, end: int
    ) -> None:
        query = QSqlQuery()
        query.prepare(
            "SELECT * FROM word_block "
            "WHERE section_id = :section_id "
            "AND block = :block "
            "AND start = :start "
            "AND end = :end"
        )
        query.bindValue(":word_id", word_id)
        query.bindValue(":section_id", self.section_id)
        query.bindValue(":block", blockNum)
        query.bindValue(":start", start)
        query.bindValue(":end", end)
        if not query.exec():
            query_error(query)
        if query.next():
            return
        query.prepare(
            "INSERT INTO word_block VALUES "
            "( :word_id, :section_id, :block, :start, :end)"
        )
        query.bindValue(":word_id", word_id)
        query.bindValue(":section_id", self.section_id)
        query.bindValue(":block", blockNum)
        query.bindValue(":start", start)
        query.bindValue(":end", end)
        if not query.exec():
            query_error(query)
        def_format = QTextCharFormat()
        def_format.setFontUnderline(True)
        cursor = QTextCursor(self.paraEdit.document())
        textBlock = self.paraEdit.document().findBlockByNumber(blockNum)
        cursor.setPosition(
            start + textBlock.position(), QTextCursor.MoveMode.MoveAnchor
        )
        cursor.setPosition(
            end + textBlock.position(), QTextCursor.MoveMode.KeepAnchor
        )
        cursor.setCharFormat(def_format)
        return

    def display_definition(self) -> None:
        cursor = self.paraEdit.textCursor()
        textBlock = self.paraEdit.document().findBlock(cursor.position())
        blockNum = textBlock.blockNumber()
        query = QSqlQuery()
        query.prepare(
            "SELECT w.* FROM word_block wb "
            "LEFT JOIN words w "
            "ON (w.word_id = wb.word_id) "
            "WHERE :position BETWEEN wb.start AND wb.end "
            "AND wb.block = :block AND wb.section_id = :section_id"
        )
        query.bindValue(":position", cursor.position() - textBlock.position())
        query.bindValue(":block", blockNum)
        query.bindValue(":section_id", self.section_id)
        if not query.exec():
            query_error(query)
        if not query.next():
            return
        word = query.value("word")
        definition = json.loads(query.value("definition"))
        self.defEdit.document().clear()
        cursor = self.defEdit.textCursor()
        word_format = QTextCharFormat()
        word_format.setFontPointSize(48)
        word_format.setFontWeight(QFont.Weight.Bold)
        cursor.insertText(word, word_format)
        typeFormat = QTextListFormat()
        typeFormat.setStyle(QTextListFormat.Style.ListDisc)
        typeFormat.setIndent(1)
        defFormat = QTextListFormat()
        defFormat.setStyle(QTextListFormat.Style.ListCircle)
        defFormat.setIndent(2)
        word_format.setFontWeight(QFont.Weight.Normal)
        word_format.setFontPointSize(16)
        cursor.setCharFormat(word_format)
        try:
            cursor.insertBlock()
            cursor.insertText(definition["phonetic"])
        except Exception:
            pass
        for meaning in definition["meanings"]:
            cursor.insertList(typeFormat)
            cursor.insertText(meaning["partOfSpeech"])
            cursor.insertList(defFormat)
            first = True
            for a_def in meaning["definitions"]:
                if not first:
                    cursor.insertBlock()
                cursor.insertText(a_def["definition"])
                # TODO: synonyms
                # TODO: antonyms
                first = False
        return

    @pyqtSlot()
    def showAction(self) -> None:
        idx = self.stackedWidget.currentIndex()
        if idx == 0:
            self.display_definition()
        self.stackedWidget.setCurrentIndex(1 - idx)
        return

    def nextDefinition(self) -> None:
        cursor = self.paraEdit.textCursor()
        position = cursor.position()
        block = cursor.block()
        found = None
        while block and not found:
            formats = block.textFormats()
            for f in formats:
                wc = QTextCursor(cursor)
                wc.setPosition(f.start)
                wc.movePosition(
                    QTextCursor.MoveOperation.Right,
                    QTextCursor.MoveMode.KeepAnchor,
                    f.length,
                )
                word = wc.selectedText()
                cf = wc.charFormat()
                if f.start <= position:
                    continue
                if not cf.fontUnderline():
                    continue
                if not found:
                    found = f
                elif f.start < found.start:
                    found = f
                    if found:
                        cursor.setPosition(found.start)
                        self.paraEdit.setTextCursor(cursor)
            block = block.next()
        self.display_definition()
        return

    def scrollTo(self, position: int) -> None:
        cursor = self.paraEdit.textCursor()
        cursor.setPosition(position)
        rect = self.paraEdit.cursorRect(cursor)
        return

    def savePosition(self) -> None:
        cursor = self.paraEdit.textCursor()
        cursor.setPosition(
            self.paraEdit.document().findBlockByNumber(self.block).position()
        )
        self.paraEdit.setTextCursor(cursor)
        self.scrollTo(cursor.position())
        self.paraEdit.ensureCursorVisible()
        self.update()
        query = QSqlQuery()
        query.prepare(
            "UPDATE person_book SET section_id = :section_id, "
            "block = :block "
            "WHERE book_id = :book_id "
            "AND person_id = :person_id"
        )
        query.bindValue(":section_id", self.section_id)
        query.bindValue(":block", self.block)
        query.bindValue(":book_id", self.book_id)
        query.bindValue(":person_id", self.person_id)
        if not query.exec():
            query_error(query)
        return

    @pyqtSlot()
    def nextAction(self) -> None:
        if self.stackedWidget.currentIndex() == 1:
            self.nextDefinition()
            return
        sequence = self.section_map[self.section_id]
        sequence += 1
        self.section_id = self.sequence_map[sequence]
        self.show_section(self.section_id)
        self.savePosition()
        return

    @pyqtSlot()
    def prevAction(self) -> None:
        if self.stackedWidget.currentIndex() == 1:
            return
        sequence = self.section_map[self.section_id]
        if sequence < 1:
            return
        sequence -= 1
        self.section_id = self.sequence_map[sequence]
        self.show_section(self.section_id, False)
        self.savePosition()
        return