app.py

import sys
import random

from queue import Queue
from PySide6.QtGui import QFontDatabase, QFont
from PySide6.QtWidgets import QApplication, QMainWindow, QDialog
from PySide6.QtCore import QTimer, Qt
from loguru import logger

from window import Ui_MainWindow
from dialog import Ui_DialogWindow
from connections import DataBase
from barcode import SerialWorker
from nodered import NodeRedWorker

logger.remove()


class LogHandler:
    def __init__(self, stream):
        self.stream = stream

    def write(self, message):
        self.stream.appendPlainText(message.rstrip('\n'))
        self.stream.ensureCursorVisible()


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.database = DataBase()
        self.dialog = DialogWindow(self.database)
        self.dialog.setWindowModality(Qt.ApplicationModal)

        self.init_ui()
        self.setup_logging()
        self.setup_connections()
        self.refresh_devices()
        self.refresh_connection_list()

        self.serial_worker = None
        self.serial_queue = Queue()
        self.serial_timer = QTimer()
        self.is_serial_starting = False
        self.is_serial_stopping = False

        self.nodered_worker = NodeRedWorker()
        self.nodered_worker.start()
        self.nodered_timer = QTimer()

        self.random_timer = QTimer()

    def init_ui(self):
        font = QFontDatabase.addApplicationFont(":/resources/fonts/a_LCDNova.ttf")
        lcd_font = QFont(QFontDatabase.applicationFontFamilies(font)[0], 26, QFont.Bold)
        self.ui.labelCodeDisplay.setFont(lcd_font)
        self.ui.labelCodeDisplayManual.setFont(lcd_font)

    def setup_logging(self):
        logger.add(
            LogHandler(self.ui.plainTextEditLog), enqueue=True, diagnose=False, backtrace=True,
            format="{time:HH:mm:ss} | {level: <8} | {name}:{function: <20}:{line: <3} - {message}"
        )

    def setup_connections(self):
        self.ui.comboBoxListDevices.currentIndexChanged.connect(lambda: self.ui.checkBoxConnectDevice.setEnabled(True))
        self.ui.pushButtonRefreshDevices.clicked.connect(self.refresh_devices)
        self.ui.checkBoxConnectDevice.toggled.connect(self.toggle_serial_connection)
        self.ui.radioButtonManualMode.toggled.connect(self.toggle_input_mode)
        self.ui.checkBoxRandomGenerate.toggled.connect(self.toggle_random_generation)

        self.ui.pushButtonAdd.clicked.connect(self.add_connection)
        self.ui.pushButtonRefresh.clicked.connect(self.refresh_connection_list)
        self.ui.pushButtonEdit.clicked.connect(self.edit_connection)
        self.ui.pushButtonDelete.clicked.connect(self.delete_row)
        self.ui.listWidgetConnectManager.itemDoubleClicked.connect(self.select_connection_item)
        self.dialog.finished.connect(self.refresh_connection_list)

        self.ui.lineEditCodeManual.returnPressed.connect(self.manual_data_enter)
        self.ui.pushButtonNull.pressed.connect(lambda: self.ui.labelCodeDisplayManual.setText('0'))
        self.ui.checkBoxConnectNodeRed.toggled.connect(self.connect_nodered)

    def connect_nodered(self, state):
        self.ui.checkBoxConnectNodeRed.setEnabled(False)
        if state:
            # Блокируем элементы управления
            self.ui.lineEditIP.setDisabled(True)
            self.ui.lineEditAPI.setDisabled(True)
            self.ui.checkBoxOnOffHTTPS.setDisabled(True)
            self.ui.spinBoxRefreshInterval.setDisabled(True)

            # Формируем URL
            url = self.ui.lineEditIP.text()
            path = self.ui.lineEditAPI.text()
            if '://' not in url:
                scheme = "https" if self.ui.checkBoxOnOffHTTPS.isChecked() else "http"
                url = f"{scheme}://{url}{path if path.startswith('/') else f'/{path}'}"
            else:
                url = f"{url}{path if path.startswith('/') else f'/{path}'}"

            # Определяем код для отправки
            code = (
                self.ui.labelCodeDisplay.text()
                if self.ui.radioButtonDeviceMode.isChecked()
                else self.ui.labelCodeDisplayManual.text()
            )

            # Устанавливаем параметры для NodeRedWorker
            interval = int(self.ui.spinBoxRefreshInterval.value())
            self.nodered_worker.set_params(url, code, interval)

            self.nodered_timer.timeout.connect(lambda: self.nodered_worker.set_code(
                self.ui.labelCodeDisplay.text()
                if self.ui.radioButtonDeviceMode.isChecked()
                else self.ui.labelCodeDisplayManual.text()
            ))
            self.nodered_timer.start(100)  # Проверяем каждые 100 мс

        else:
            # Разблокируем элементы управления
            self.ui.lineEditIP.setEnabled(True)
            self.ui.lineEditAPI.setEnabled(True)
            self.ui.checkBoxOnOffHTTPS.setEnabled(True)
            self.ui.spinBoxRefreshInterval.setEnabled(True)

            # Очищаем параметры для NodeRedWorker
            self.nodered_worker.set_params(None, None, 5)

            if self.nodered_timer:
                self.nodered_timer.stop()

        QTimer.singleShot(500, lambda: self.ui.checkBoxConnectNodeRed.setEnabled(True))

    def refresh_devices(self):
        self.ui.comboBoxListDevices.clear()
        self.ui.checkBoxConnectDevice.setChecked(False)
        self.ui.checkBoxConnectDevice.setDisabled(True)
        ports = SerialWorker.get_ports_list()
        for name, port in ports.items():
            self.ui.comboBoxListDevices.addItem(name, port)
        logger.info(f"Обнаружено последовательных портов: {len(ports)}")

    def manual_data_enter(self):
        data = self.ui.lineEditCodeManual.text()
        try:
            # self.data_received.emit(data)
            integer_data = int(data)
            self.ui.labelCodeDisplayManual.setText(str(integer_data))
            logger.info(f"Код записан: {integer_data}")
        except ValueError:
            logger.info(f"Получен неверный тип данных: {type(data)}")

    def toggle_serial_connection(self, state):
        self.ui.checkBoxConnectDevice.setEnabled(False)
        if state:
            self.ui.radioButtonManualMode.setEnabled(False)
            if self.is_serial_starting or self.is_serial_stopping:
                return

            self.is_serial_starting = True
            # self.ui.checkBoxConnectDevice.setEnabled(False)

            port = self.ui.comboBoxListDevices.currentData()
            if not port:
                logger.error("Порт не выбран")
                self.ui.checkBoxConnectDevice.setChecked(False)
                self.is_serial_starting = False
                # self.ui.checkBoxConnectDevice.setEnabled(True)
                return

            self.serial_worker = SerialWorker(port, 9600, self.serial_queue)
            self.serial_worker.start()
            self.start_serial_polling()

            self.is_serial_starting = False
            # self.ui.checkBoxConnectDevice.setEnabled(True)
            QTimer.singleShot(500, lambda: (self.ui.checkBoxConnectDevice.setEnabled(True),
                                            self.ui.radioButtonManualMode.setEnabled(True)))
        else:
            if self.is_serial_stopping:
                return
            self.is_serial_stopping = True
            # self.ui.checkBoxConnectDevice.setEnabled(False)

            self.stop_serial_connection()

            self.ui.checkBoxConnectDevice.setEnabled(True)
            self.is_serial_stopping = False

    def start_serial_polling(self):
        self.serial_timer.timeout.connect(self.read_serial_data)
        self.serial_timer.start(100)

    def read_serial_data(self):
        try:
            while not self.serial_worker.queue.empty():
                data = self.serial_worker.queue.get_nowait()
                if data.startswith("Received:"):
                    self.ui.labelCodeDisplay.setText(data.split(":")[1].strip())
        except Exception as e:
            logger.error(f"Ошибка чтения данных: {e}")

    def stop_serial_connection(self):
        if self.serial_worker and self.serial_worker.is_alive():
            self.serial_worker.stop()
            self.serial_worker.join()
        if self.serial_timer:
            self.serial_timer.stop()

    def toggle_input_mode(self, manual_mode):
        if not manual_mode:
            self.ui.checkBoxRandomGenerate.setChecked(False)
            self.refresh_devices()
        else:
            self.ui.checkBoxConnectDevice.setChecked(False)
            self.ui.checkBoxConnectDevice.setDisabled(True)
        self.ui.checkBoxRandomGenerate.setEnabled(manual_mode)
        self.ui.comboBoxListDevices.setDisabled(manual_mode)
        self.ui.pushButtonNull.setEnabled(manual_mode)
        self.ui.lineEditCodeManual.setEnabled(manual_mode)
        logger.info(f"Режим ввода: {'ручной' if manual_mode else 'устройство'}")

    def toggle_random_generation(self, enabled):
        self.ui.checkBoxRandomGenerate.setEnabled(False)
        if enabled:
            self.random_timer.timeout.connect(self.generate_random)
            self.random_timer.start(2000)
            self.ui.lineEditCodeManual.setEnabled(False)
            self.ui.pushButtonNull.setEnabled(False)
            logger.info("Генерация случайных данных запущена")
        else:
            self.random_timer.stop()
            self.ui.lineEditCodeManual.setEnabled(True)
            self.ui.pushButtonNull.setEnabled(True)
            logger.info("Генерация случайных данных остановлена")
        QTimer.singleShot(500, lambda: self.ui.checkBoxRandomGenerate.setEnabled(True))

    def generate_random(self):
        self.ui.labelCodeDisplayManual.setText(str(random.randint(99, 999)))

    def refresh_connection_list(self):
        self.ui.listWidgetConnectManager.clear()
        connections = sorted(self.database.get_all_rows("Name"))
        self.ui.listWidgetConnectManager.addItems(connections)

    def select_connection_item(self):
        item = self.ui.listWidgetConnectManager.currentItem()
        if item and not self.ui.checkBoxConnectNodeRed.isChecked():
            connection_name = item.text()
            data = self.database.get_connection_by_name(connection_name)
            self.ui.lineEditIP.setText(str(data['ip']))
            self.ui.lineEditAPI.setText(str(data['api']))

    def add_connection(self):
        self.dialog = DialogWindow(self.database)  # Создаем новый экземпляр для добавления
        self.dialog.exec()
        self.refresh_connection_list()

    def edit_connection(self):
        item = self.ui.listWidgetConnectManager.currentItem()
        if item:
            connection_name = item.text()
            self.dialog = DialogWindow(self.database, connection_name)
            self.dialog.exec()
            self.refresh_connection_list()

    def delete_row(self):
        if self.ui.listWidgetConnectManager.currentItem() is None:
            logger.warning(f"Не выбран ни один из элементов списка менеджера подключений")
            return
        item = self.ui.listWidgetConnectManager.currentItem().text()
        self.database.delete_transaction_query(item)
        self.refresh_connection_list()

    def closeEvent(self, event):
        if self.nodered_timer:
            self.nodered_timer.stop()
        if self.nodered_worker:
            self.nodered_worker.stop()
            self.nodered_worker.join()
        if self.serial_worker:
            self.serial_worker.stop()
            self.serial_worker.join()
        if self.serial_timer:
            self.serial_timer.stop()
        if self.random_timer:
            self.random_timer.stop()
        super().closeEvent(event)


class DialogWindow(QDialog):
    def __init__(self, db, connection_name=None):
        super().__init__()
        self.ui = Ui_DialogWindow()
        self.ui.setupUi(self)
        self.db = db
        self.connection_name = connection_name  # Имя редактируемой записи
        self.is_edit_mode = connection_name is not None

        if self.is_edit_mode:
            self.load_connection_data()
            self.ui.lineEditName.setDisabled(True)
        else:
            self.ui.lineEditName.setEnabled(True)

        self.ui.pushButtonSave.clicked.connect(self.save_connection)
        self.setWindowTitle("Edit Connection" if self.is_edit_mode else "Add Connection")

    def load_connection_data(self):
        """Загружает данные существующей записи в поля"""
        data = self.db.get_connection_by_name(self.connection_name)
        if data:
            self.ui.lineEditName.setText(data['name'])
            self.ui.lineEditIP.setText(data['ip'])
            self.ui.lineEditAPI.setText(data['api'])

    def save_connection(self):
        """Сохраняет/обновляет данные в БД"""
        data = {
            'name': self.ui.lineEditName.text(),
            'ip': self.ui.lineEditIP.text(),
            'api': self.ui.lineEditAPI.text()
        }

        if self.is_edit_mode:
            self.db.update_transaction_query(**data)
            logger.info(f"Обновлены параметры: {self.connection_name}")
        else:
            self.db.add_new_transaction_query(**data)
            logger.info(f"Параметры сохранены под именем {data['name']}")

        self.accept()


if __name__ == "__main__":
    # logger.configure(
    #     handlers=[
    #         {
    #             "sink": sys.stdout,
    #             "format": "<lg>{time:YYYY-MM-DD HH:mm:ss}</> | <lvl>{level: <8}</> | "
    #                       "<lc>{name}</>:<lc>{function}</>:<lc>{line}</> - <lvl>{message}</>",
    #             "level": "INFO"
    #         }
    #     ]
    # )
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec())