Zordon/src/ui/settings_window.py

import humanize
import socket

from datetime import datetime
from PyQt6 import QtCore
from PyQt6.QtCore import Qt, QSettings
from PyQt6.QtGui import QIcon
from PyQt6.QtWidgets import QApplication, QMainWindow, QListWidget, QListWidgetItem, QStackedWidget, QVBoxLayout, \
    QWidget, QLabel, QCheckBox, QLineEdit, \
    QComboBox, QPushButton, QHBoxLayout, QGroupBox, QTableWidget, QAbstractItemView, QTableWidgetItem, QHeaderView

from api.server_proxy import RenderServerProxy
from engines.engine_manager import EngineManager
from utilities.misc_helper import launch_url
from version import APP_AUTHOR, APP_NAME

settings = QSettings(APP_AUTHOR, APP_NAME)


class SettingsWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        # declare objects we need to store settings
        self.check_for_engine_updates_checkbox = None
        # todo: add all here

        self.installed_engines_table = None

        self.setWindowTitle("Settings")

        # Create the main layout
        main_layout = QVBoxLayout()

        # Create the sidebar (QListWidget) for navigation
        self.sidebar = QListWidget()
        self.sidebar.setFixedWidth(150)

        # Set the icon size
        self.sidebar.setIconSize(QtCore.QSize(32, 32))  # Increase the icon size to 32x32 pixels

        # Adjust the font size for the sidebar items
        font = self.sidebar.font()
        font.setPointSize(12)  # Increase the font size
        self.sidebar.setFont(font)

        # Add items with icons to the sidebar
        self.add_sidebar_item("General", "../../resources/Gear.png")
        self.add_sidebar_item("Network", "../../resources/Server.png")
        self.add_sidebar_item("Engines", "../../resources/Blender.png")
        self.sidebar.setCurrentRow(0)

        # Create the stacked widget to hold different settings pages
        self.stacked_widget = QStackedWidget()

        # Create pages for each section
        general_page = self.create_general_page()
        network_page = self.create_network_page()
        engines_page = self.create_engines_page()

        # Add pages to the stacked widget
        self.stacked_widget.addWidget(general_page)
        self.stacked_widget.addWidget(network_page)
        self.stacked_widget.addWidget(engines_page)

        # Connect the sidebar to the stacked widget
        self.sidebar.currentRowChanged.connect(self.stacked_widget.setCurrentIndex)

        # Create a horizontal layout to hold the sidebar and stacked widget
        content_layout = QHBoxLayout()
        content_layout.addWidget(self.sidebar)
        content_layout.addWidget(self.stacked_widget)

        # Add the content layout to the main layout
        main_layout.addLayout(content_layout)

        # Add the "OK" button at the bottom
        ok_button = QPushButton("OK")
        ok_button.clicked.connect(self.close)
        ok_button.setFixedWidth(80)
        ok_button.setDefault(True)
        main_layout.addWidget(ok_button, alignment=Qt.AlignmentFlag.AlignRight)

        # Create a central widget and set the layout
        central_widget = QWidget()
        central_widget.setLayout(main_layout)
        self.setCentralWidget(central_widget)

        self.setMinimumSize(700, 400)

    def add_sidebar_item(self, name, icon_path):
        """Add an item with an icon to the sidebar."""
        item = QListWidgetItem(QIcon(icon_path), name)
        self.sidebar.addItem(item)

    def create_general_page(self):
        """Create the General settings page."""
        page = QWidget()
        layout = QVBoxLayout()

        # Startup Settings Group
        startup_group = QGroupBox("Startup Settings")
        startup_layout = QVBoxLayout()
        # startup_layout.addWidget(QCheckBox("Start application on system startup"))
        check_for_updates_checkbox = QCheckBox("Check for updates automatically")
        check_for_updates_checkbox.setChecked(settings.value("auto_check_for_updates", True))
        check_for_updates_checkbox.stateChanged.connect(lambda state: settings.setValue("auto_check_for_updates", bool(state)))
        startup_layout.addWidget(check_for_updates_checkbox)
        startup_group.setLayout(startup_layout)

        # Render Settings Group
        render_settings_group = QGroupBox("Render Settings")
        render_settings_layout = QVBoxLayout()
        render_settings_layout.addWidget(QLabel("Require same:"))
        require_same_engine_checkbox = QCheckBox("Renderer Version")
        require_same_engine_checkbox.setChecked(settings.value("render_require_same_engine_version"))
        require_same_engine_checkbox.stateChanged.connect(lambda state: settings.setValue("render_require_same_engine_version", bool(state)))
        render_settings_layout.addWidget(require_same_engine_checkbox)
        require_same_cpu_checkbox = QCheckBox("CPU Architecture")
        require_same_cpu_checkbox.setChecked(settings.value("render_require_same_cpu_type"))
        require_same_cpu_checkbox.stateChanged.connect(lambda state: settings.setValue("render_require_same_cpu_type", bool(state)))
        render_settings_layout.addWidget(require_same_cpu_checkbox)
        require_same_os_checkbox = QCheckBox("Operating System")
        require_same_os_checkbox.setChecked(settings.value("render_require_same_os"))
        require_same_os_checkbox.stateChanged.connect(lambda state: settings.setValue("render_require_same_os", bool(state)))
        render_settings_layout.addWidget(require_same_os_checkbox)
        render_settings_group.setLayout(render_settings_layout)

        layout.addWidget(startup_group)
        layout.addWidget(render_settings_group)

        layout.addStretch()  # Add a stretch to push content to the top
        page.setLayout(layout)
        return page

    def create_network_page(self):
        """Create the Network settings page."""
        page = QWidget()
        layout = QVBoxLayout()

        # Proxy Settings Group
        proxy_group = QGroupBox("Proxy Settings")
        proxy_layout = QVBoxLayout()
        proxy_layout.addWidget(QCheckBox("Use Proxy"))
        proxy_layout.addWidget(QLabel("Proxy Address"))
        proxy_layout.addWidget(QLineEdit())
        proxy_layout.addWidget(QLabel("Proxy Port"))
        proxy_layout.addWidget(QLineEdit())
        proxy_group.setLayout(proxy_layout)

        layout.addWidget(proxy_group)

        layout.addStretch()  # Add a stretch to push content to the top
        page.setLayout(layout)
        return page

    def create_engines_page(self):
        """Create the Engines settings page."""
        page = QWidget()
        layout = QVBoxLayout()

        # Installed Engines Group
        installed_group = QGroupBox("Installed Engines")
        installed_layout = QVBoxLayout()
        self.installed_engines_table = EngineTableWidget()
        installed_layout.addWidget(self.installed_engines_table)
        installed_buttons_layout = QHBoxLayout()
        launch_engine_button = QPushButton("Launch")
        launch_engine_button.clicked.connect(self.launch_selected_engine)
        delete_engine_button = QPushButton("Delete")
        delete_engine_button.clicked.connect(self.delete_selected_engine)

        installed_buttons_layout.addWidget(launch_engine_button)
        installed_buttons_layout.addWidget(delete_engine_button)
        installed_layout.addLayout(installed_buttons_layout)
        installed_group.setLayout(installed_layout)

        # Engine Updates Group
        engine_updates_group = QGroupBox("Auto-Install")
        engine_updates_layout = QVBoxLayout()

        engine_download_layout = QHBoxLayout()
        engine_download_layout.addWidget(QLabel("Enable Downloads for:"))

        at_least_one_downloadable = False
        for engine in EngineManager.downloadable_engines():
            engine_download_check = QCheckBox(engine.name())
            is_checked = settings.value(f"engine_download-{engine.name()}", False)
            at_least_one_downloadable |= is_checked
            engine_download_check.setChecked(is_checked)
            # Capture the checkbox correctly using a default argument in lambda
            engine_download_check.clicked.connect(
                lambda state, checkbox=engine_download_check: self.engine_download_settings_changed(state, checkbox.text())
            )
            engine_download_layout.addWidget(engine_download_check)

        engine_updates_layout.addLayout(engine_download_layout)

        self.check_for_engine_updates_checkbox = QCheckBox("Check for new versions on launch")
        self.check_for_engine_updates_checkbox.setChecked(settings.value('check_for_engine_updates_on_launch', True))
        self.check_for_engine_updates_checkbox.setEnabled(at_least_one_downloadable)
        self.check_for_engine_updates_checkbox.stateChanged.connect(
            lambda state: settings.setValue("check_for_engine_updates_on_launch", bool(state)))
        engine_updates_layout.addWidget(self.check_for_engine_updates_checkbox)
        self.engines_last_update_label = QLabel()
        self.update_last_checked_label()
        self.engines_last_update_label.setEnabled(at_least_one_downloadable)
        engine_updates_layout.addWidget(self.engines_last_update_label)
        self.check_for_new_engines_button = QPushButton("Check for New Versions")
        self.check_for_new_engines_button.setEnabled(at_least_one_downloadable)
        self.check_for_new_engines_button.clicked.connect(self.check_for_new_engines)
        engine_updates_layout.addWidget(self.check_for_new_engines_button)
        engine_updates_group.setLayout(engine_updates_layout)

        layout.addWidget(installed_group)
        layout.addWidget(engine_updates_group)

        layout.addStretch()  # Add a stretch to push content to the top
        page.setLayout(layout)
        return page

    def update_last_checked_label(self):
        """Retrieve the last check timestamp and return a human-friendly string."""
        last_checked_str = settings.value("engines_last_update_time", None)
        if not last_checked_str:
            time_string = "Never"
        else:
            last_checked_dt = datetime.fromisoformat(last_checked_str)
            now = datetime.now()
            time_string = humanize.naturaltime(now - last_checked_dt)
        self.engines_last_update_label.setText(f"Last Updated: {time_string}")

    def engine_download_settings_changed(self, state, engine_name):
        settings.setValue(f"engine_download-{engine_name}", state)

        at_least_one_downloadable = False
        for engine in EngineManager.downloadable_engines():
            at_least_one_downloadable |= settings.value(f"engine_download-{engine.name()}", False)
        self.check_for_new_engines_button.setEnabled(at_least_one_downloadable)
        self.check_for_engine_updates_checkbox.setEnabled(at_least_one_downloadable)
        self.engines_last_update_label.setEnabled(at_least_one_downloadable)

    def delete_selected_engine(self):
        pass

    def launch_selected_engine(self):
        engine_info = self.installed_engines_table.selected_engine_data()
        if engine_info:
            launch_url(engine_info['path'])

    def check_for_new_engines(self):
        settings.setValue("engines_last_update_time", datetime.now().isoformat())
        self.update_last_checked_label()

class EngineTableWidget(QWidget):
    def __init__(self):
        super().__init__()

        self.table = QTableWidget(0, 4)
        self.table.setHorizontalHeaderLabels(["Engine", "Version", "Type", "Path"])
        self.table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
        self.table.verticalHeader().setVisible(False)
        # self.table_widget.itemSelectionChanged.connect(self.engine_picked)
        self.table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)

        layout = QVBoxLayout(self)
        layout.addWidget(self.table)

    def showEvent(self, event):
        """Runs when the widget is about to be shown."""
        self.update_table()
        super().showEvent(event)  # Ensure normal event processing

    def update_table(self):
        raw_server_data = RenderServerProxy(socket.gethostname()).get_renderer_info()
        if not raw_server_data:
            return

        table_data = []  # convert the data into a flat list
        for _, engine_data in raw_server_data.items():
            table_data.extend(engine_data['versions'])

        self.table.clear()
        self.table.setRowCount(len(table_data))
        self.table.setColumnCount(4)

        self.table.setHorizontalHeaderLabels(['Engine', 'Version', 'Type', 'Path'])
        self.table.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeMode.Fixed)
        self.table.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeMode.Fixed)
        self.table.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeMode.Fixed)
        self.table.horizontalHeader().setSectionResizeMode(3, QHeaderView.ResizeMode.Stretch)

        for row, engine in enumerate(table_data):
            self.table.setItem(row, 0, QTableWidgetItem(engine['engine']))
            self.table.setItem(row, 1, QTableWidgetItem(engine['version']))
            self.table.setItem(row, 2, QTableWidgetItem(engine['type']))
            self.table.setItem(row, 3, QTableWidgetItem(engine['path']))

        self.table.selectRow(0)

    def selected_engine_data(self):
        """Returns the data from the selected row as a dictionary."""
        row = self.table.currentRow()  # Get the selected row index

        if row < 0:  # No row selected
            return None

        data = {
            "engine": self.table.item(row, 0).text(),
            "version": self.table.item(row, 1).text(),
            "type": self.table.item(row, 2).text(),
            "path": self.table.item(row, 3).text(),
        }

        return data


if __name__ == "__main__":
    app = QApplication([])
    window = SettingsWindow()
    window.show()
    app.exec()