import ast
import sys

from PyQt6 import QtWidgets

from src.transform import Transform
from src.ui.graph import Graph
from src.ui.Ui_diagram import Ui_MainWindow as MainWindow


class Application(QtWidgets.QMainWindow, MainWindow):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        # set Name to Diagram
        self.setWindowTitle("Zeitschriftennutzung")
        self.start_date.setEnabled(False)
        self.end_Date.setEnabled(False)
        self.load_data.clicked.connect(self.load_data_clicked)
        self.creatediagram.clicked.connect(self.create_diagram)
        self.removeLastGraph.clicked.connect(self.remove_last_graph)
        # if cursor drags something to data_source, add path to data_source
        self.data_source.setAcceptDrops(True)
        self.data_source.dropEvent = self.dropEvent
        self.data_source.dragEnterEvent = self.dragEnterEvent
        self.start_date.dateChanged.connect(self.load_data_clicked)
        self.end_Date.dateChanged.connect(self.load_data_clicked)
        self.widgetCount = 2
        if self.widgetCount == 2:
            self.removeLastGraph.setEnabled(False)
        self.sensor_data = None # activations and usage data for legend of graph

    def dragEnterEvent(self, event):
        if event.mimeData().hasUrls():
            event.accept()
        else:
            event.ignore()

    def dropEvent(self, event):
        for url in event.mimeData().urls():
            if url.isLocalFile():
                if url.toLocalFile().endswith(".json"):
                    self.data_source.setText(url.toLocalFile())
                else:
                    # Show error message in dialog
                    msg = QtWidgets.QMessageBox()
                    msg.setIcon(QtWidgets.QMessageBox.Icon.Warning)
                    msg.setText("Only JSON files are supported")
                    msg.setWindowTitle("Error")
                    msg.exec()

        event.accept()

    def load_data_clicked(self):
        print("Load data clicked")
        source = self.data_source.text()
        if source == "":
            # Show error message in dialog
            msg = QtWidgets.QMessageBox()
            msg.setIcon(QtWidgets.QMessageBox.Icon.Warning)
            msg.setText("Data source is empty")
            msg.setWindowTitle("Error")
            msg.exec()
        else:
            print("Data source:", source)
            if self.useSensorTimeData.isChecked():
                data, sensor_data = (
                    Transform(source)
                    .load_data()
                    .transform_data(addMissing=self.addMissingDays.isChecked())
                )
            else:
                start_date = self.start_date.text().replace(".", "-")
                end_date = self.end_Date.text().replace(".", "-")
                data,sensor_data = (
                    Transform(source)
                    .load_data()
                    .transform_data(
                        addMissing=self.addMissingDays.isChecked(),
                        start_date=start_date,
                        end_date=end_date,
                        split=True,
                    )
                )
            # add data to table
            self.sensor_data = sensor_data
            self.insertIntoTable(data)

    def insertIntoTable(self, data):
        #check if rows have set aliases
        sensor_alias = {}
        for row in range(self.dataTable.rowCount()):
            if self.dataTable.item(row, 1):
                sensor_alias[self.dataTable.item(row, 0).text()] = self.dataTable.item(
                    row, 1
                ).text()
        self.dataTable.setRowCount(0)
        for sensor in data:
            
            self.dataTable.insertRow(self.dataTable.rowCount())
            self.dataTable.setItem(
                self.dataTable.rowCount() - 1, 0, QtWidgets.QTableWidgetItem(sensor)
            )
            self.dataTable.setItem(
                self.dataTable.rowCount() - 1,
                2,
                QtWidgets.QTableWidgetItem(str((data[sensor]))),
            )
            if sensor in sensor_alias:
                self.dataTable.setItem(
                    self.dataTable.rowCount() - 1,
                    1,
                    QtWidgets.QTableWidgetItem(sensor_alias[sensor]),
                )

    def create_diagram(self):
        selectedRowCount = len(self.dataTable.selectionModel().selectedRows())
        labels = {}
        if selectedRowCount == 0:
            # Show error message in dialog
            msg = QtWidgets.QMessageBox()
            msg.setIcon(QtWidgets.QMessageBox.Icon.Warning)
            msg.setText("No sensor selected")
            msg.setWindowTitle("Error")
            msg.exec()
        else:
            if selectedRowCount == 1:
                # get selected sensor
                sensor = self.dataTable.item(self.dataTable.currentRow(), 0).text()
                try:
                    alias = self.dataTable.item(self.dataTable.currentRow(), 1).text()
                except AttributeError:
                    alias = None
                data = self.dataTable.item(self.dataTable.currentRow(), 2).text()
                # convert data to dict
                data = ast.literal_eval(data)
                labels[sensor] = alias
                graph_data = {
                    alias if alias else sensor: {"x": data["x"], "y": data["y"]}
                }
            else:
                graph_data = []
                for row in range(selectedRowCount):
                    sensor = self.dataTable.item(
                        self.dataTable.selectionModel().selectedRows()[row].row(), 0
                    ).text()
                    try:
                        alias = self.dataTable.item(
                            self.dataTable.selectionModel().selectedRows()[row].row(), 1
                        ).text()
                    except AttributeError:
                        alias = None
                    data = self.dataTable.item(
                        self.dataTable.selectionModel().selectedRows()[row].row(), 2
                    ).text()
                    # convert data to dict
                    data = ast.literal_eval(data)
                    row_data = {
                        alias if alias else sensor: {"x": data["x"], "y": data["y"]}
                    }
                    labels[sensor] = alias
                    graph_data.append(row_data)
            #replace the keys from self.sensor_data with the alias from labels
            print(labels)
            for key in labels:
                if key in self.sensor_data:
                    self.sensor_data[labels[key]] = self.sensor_data.pop(key)
            graph = Graph(graph_data, labels,self.sensor_data, )
            self.centralWidget().layout().addWidget(graph.graph)
            self.widgetCount += 1
            self.check_widget_count()
            # set heigth of frame / data table to be 150

    def check_widget_count(self):
        if self.widgetCount > 2:
            self.removeLastGraph.setEnabled(True)
        else:
            self.removeLastGraph.setEnabled(False)

    def remove_last_graph(self):
        print("Remove last graph")
        # remove last graph
        persistentItems = 2
        Item_count = self.centralWidget().layout().count()
        print(Item_count)
        if Item_count > persistentItems:
            self.centralWidget().layout().removeWidget(
                self.centralWidget().layout().itemAt(Item_count - 1).widget()
            )
            self.widgetCount -= 1
            self.check_widget_count()
        # self.dataTable.setMaximumHeight(300)


def launch():
    app = QtWidgets.QApplication(sys.argv)
    window = Application()
    window.show()
    sys.exit(app.exec())


if __name__ == "__main__":
    launch()