from PyQt5 import QtWidgets
from PyQt5.QtGui import QStandardItemModel, QStandardItem
from PyQt5.QtCore import Qt

from ArtNet.gui.dialogs.tag_modify_dialog.tag_modify_dialog import Ui_TagModify


class TagModifyDialog(QtWidgets.QDialog):

    def __init__(self, parent=None, create_tag: bool = True):
        super().__init__(parent)
        self.parent = parent
        self.ui = Ui_TagModify()
        self.ui.setupUi(self)

        self.data = dict()
        self.original_tag_name: str = None
        self.create_tag = create_tag

        self.alias_selection: list = None
        self.implication_selection: list = None
        self.tag_alias_search_result: list = None
        self.tag_implication_search_result: list = None
        self.category_selection: str = None

        if create_tag:
            self.ui.dialog_topic.setText("Create Tag")
        else:
            self.ui.dialog_topic.setText("Edit Tag")
            self.ui.tag_name_line.setReadOnly(False)

        self.ui.buttonBox.accepted.connect(self.getTagDetails)

        self.ui.tag_alias_search_line.textChanged.connect(self.on_tag_alias_search_line_changed)
        self.ui.tag_implication_search_line.textChanged.connect(self.on_tag_implication_search_line_changed)
        self.set_all_categories()

    def set_search_alias_tags(self, aliases: list, set_checked: bool = False):
        """
        Set the tags in the search result list to tags
        :param aliases:
        :param set_checked:
        :return:
        """
        if aliases is None:
            return
        item_model = QStandardItemModel(self.ui.tag_alias_search_list)

        for tag in aliases:
            tag = tag[0].strip()
            if tag == self.ui.tag_name_line.text():
                continue
            item = QStandardItem(tag)
            item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
            item.setData(Qt.Unchecked, Qt.CheckStateRole)

            if set_checked:
                item.setCheckState(Qt.Checked)

            item_model.appendRow(item)

        item_model.itemChanged.connect(self.on_search_alias_tag_item_changed)
        self.ui.tag_alias_search_list.setModel(item_model)

    def set_search_implicated_tags(self, implications: list, set_checked: bool=False):
        """
        Set the tags in the search result list to tags
        :param implications:
        :param set_checked:
        :return:
        """
        item_model = QStandardItemModel(self.ui.tag_implication_search_list)

        for tag in implications:
            tag = tag[0].strip()
            if tag == self.ui.tag_name_line.text():
                continue
            item = QStandardItem(tag)
            item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
            item.setData(Qt.Unchecked, Qt.CheckStateRole)
            if set_checked:
                item.setCheckState(Qt.Checked)

            item_model.appendRow(item)

        item_model.itemChanged.connect(self.on_search_implicated_tag_item_changed)
        self.ui.tag_implication_search_list.setModel(item_model)

    def set_all_categories(self):
        """
        Populate the categories list and only check the one selection
        :return:
        """
        categories = self.parent.get_categories("", all_if_empty=True)
        item_model = QStandardItemModel(self.ui.category_list)

        for category in categories:
            category = category.strip()

            item = QStandardItem(category)
            item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
            item.setData(Qt.Unchecked, Qt.CheckStateRole)

            if category == self.category_selection:
                item.setCheckState(Qt.Checked)

            item_model.appendRow(item)

        item_model.itemChanged.connect(self.on_category_item_changed)
        self.ui.category_list.setModel(item_model)

    def set_selected_alias_tags(self, aliases: list, set_checked: bool=False):
        """
        Set the tags in the search result list to tags
        :param aliases:
        :param set_checked:
        :return:
        """
        item_model = QStandardItemModel(self.ui.tag_alias_selection_list)

        for tag in aliases:
            tag = tag.strip()
            if tag == self.ui.tag_name_line.text():
                continue
            item = QStandardItem(tag)
            item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
            item.setData(Qt.Unchecked, Qt.CheckStateRole)

            if set_checked:
                item.setCheckState(Qt.Checked)

            item_model.appendRow(item)

        item_model.itemChanged.connect(self.on_selected_alias_tag_item_changed)
        self.ui.tag_alias_selection_list.setModel(item_model)

    def set_selected_implicated_tags(self, implications: list, set_checked: bool=False):
        """
        Set the tags in the search result list to tags
        :param implications:
        :param set_checked:
        :return:
        """
        item_model = QStandardItemModel(self.ui.tag_implication_search_list)

        for tag in implications:
            tag = tag.strip()
            if tag == self.ui.tag_name_line.text():
                continue
            item = QStandardItem(tag)
            item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
            item.setData(Qt.Unchecked, Qt.CheckStateRole)
            if set_checked:
                item.setCheckState(Qt.Checked)

            item_model.appendRow(item)

        item_model.itemChanged.connect(self.on_selected_implicated_tag_item_changed)
        self.ui.tag_implication_selection_list.setModel(item_model)

    def on_tag_alias_search_line_changed(self):
        search_text = self.ui.tag_alias_search_line.text()
        if len(search_text) == 0:
            tags = []
        else:
            tags = self.parent.get_tag_search_result(search_text)

        if tags is None:
            return

        self.tag_alias_search_result = tags
        self.set_search_alias_tags(tags)

    def on_tag_implication_search_line_changed(self):
        search_text = self.ui.tag_implication_search_line.text()
        if len(search_text) == 0:
            tags = []
        else:
            tags = self.parent.get_tag_search_result(search_text)

        if tags is None:
            return
        self.tag_implication_search_result = tags
        self.set_search_implicated_tags(tags)

    def on_search_implicated_tag_item_changed(self, item: QStandardItem):
        if item.checkState() == Qt.Checked:
            if self.implication_selection is None:
                self.implication_selection = []
            self.implication_selection.append(item.text())
        elif item.checkState() == Qt.Unchecked:
            if item.text() in self.implication_selection:
                self.implication_selection.remove(item.text())

        self.set_selected_implicated_tags(self.implication_selection, set_checked=True)

    def on_search_alias_tag_item_changed(self, item: QStandardItem):
        if item.checkState() == Qt.Checked:
            if self.alias_selection is None:
                self.alias_selection = []
            self.alias_selection.append(item.text())
        elif item.checkState() == Qt.Unchecked:
            if item.text() in self.alias_selection:
                self.alias_selection.remove(item.text())

        self.set_selected_alias_tags(self.alias_selection, set_checked=True)

    def on_selected_implicated_tag_item_changed(self, item: QStandardItem):
        if self.implication_selection is None:
            self.implication_selection = []
        self.implication_selection.remove(item.text())
        self.set_selected_implicated_tags(self.implication_selection, set_checked=True)

        if self.tag_implication_search_result is not None:
            self.set_search_implicated_tags(self.tag_implication_search_result)

    def on_selected_alias_tag_item_changed(self, item: QStandardItem):
        if self.alias_selection is None:
            self.alias_selection = []
        self.alias_selection.remove(item.text())
        self.set_selected_alias_tags(self.alias_selection, set_checked=True)

        self.set_search_alias_tags(self.tag_alias_search_result)

    def on_category_item_changed(self, item: QStandardItem):
        if self.category_selection is None:
            self.category_selection = []

        if item.checkState() == Qt.Checked:
            self.category_selection = item.text()
        elif item.checkState() == Qt.Unchecked:
            self.category_selection = None

        self.set_all_categories()

    def has_critical_info(self) -> bool:
        """
        Checks if all required fields are filled
        :return:
        """
        ok = True
        if len(self.ui.tag_name_line.text()) == 0:
            ok = False
        if self.category_selection is None:
            ok = False

        if not ok:
            msg = QtWidgets.QMessageBox()
            msg.setWindowTitle("Missing Fields")
            msg.setIcon(QtWidgets.QMessageBox.Critical)
            msg.setInformativeText(
                "Either the tag name or the category selection is empty! Can't save the tag this way!")

            msg.exec_()
        return ok

    def getTagDetails(self):
        self.data = dict()

        self.data["name"] = self.ui.tag_name_line.text()
        self.data["description"] = self.ui.tag_description_area.toPlainText()

        self.data["aliases"] = self.alias_selection
        self.data["implications"] = self.implication_selection

        self.data["category"] = self.category_selection

        if not self.has_critical_info():
            self.data = None
            self.reject()
            return

        self.accept()

    def exec_(self) -> dict:
        self.original_tag_name = self.ui.tag_name_line.text()

        if super(TagModifyDialog, self).exec_() == QtWidgets.QDialog.Rejected:
            return None

        if not self.create_tag:
            if self.data["name"] != self.original_tag_name:
                self.data["old_tag_name"] = self.original_tag_name

        return self.data