app.py

import sys
import os
import time
import platform
import psutil
import logging
import subprocess
from datetime import datetime
from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
                           QHBoxLayout, QPushButton, QLabel, QFileDialog, 
                           QTabWidget, QLineEdit, QSpinBox, QComboBox, 
                           QCheckBox, QGroupBox, QScrollArea, QTextEdit,
                           QProgressBar, QMessageBox, QSplitter, QFrame,
                           QStackedWidget, QToolButton, QMenu, QSystemTrayIcon)
from PyQt6.QtCore import (Qt, QPropertyAnimation, QEasingCurve, QPoint, 
                         QTimer, QThread, pyqtSignal, QSize, QRect, QSettings)
from PyQt6.QtGui import (QFont, QIcon, QPalette, QColor, QFontDatabase, 
                        QPixmap, QAction, QGradient, QLinearGradient, QPainter, QPen)
import PyInstaller.__main__
import shutil
from pathlib import Path
import qtawesome as qta

# Translation dictionaries
TRANSLATIONS = {
    "en": {
        "window_title": "PyExe Builder Professional",
        "main_tab": "Main",
        "metadata_tab": "Metadata",
        "dependencies_tab": "Dependencies",
        "advanced_tab": "Advanced",
        "settings_tab": "Settings",
        "build_console": "Build Console",
        "system_info": "System Information",
        "python_script": "Python Script",
        "browse": "Browse",
        "output_options": "Output Options",
        "app_name": "Application Name:",
        "output_dir": "Output Directory:",
        "icon": "Icon:",
        "build_options": "Build Options",
        "one_file": "One File",
        "no_console": "No Console",
        "admin_access": "Request Admin Access",
        "auto_deps": "Auto-install from requirements.txt",
        "build_exe": "Build Executable",
        "company_details": "Company Details",
        "company_name": "Company Name",
        "version": "Version (e.g., 1.0.0)",
        "copyright": "Copyright Information",
        "trademark": "Trademark Information",
        "product_details": "Product Details",
        "product_name": "Product Name",
        "product_desc": "Product Description",
        "hidden_imports": "Hidden Imports",
        "binary_deps": "Binary Dependencies",
        "data_files": "Data Files",
        "debug_mode": "Debug Mode",
        "strip": "Strip Binaries",
        "upx": "Use UPX Compression",
        "clean": "Clean Build",
        "runtime_options": "Runtime Options",
        "disable_windowed": "Disable Windowed Traceback",
        "key": "Encryption Key (optional)",
        "theme": "Theme:",
        "language": "Language:",
        "font_size": "Font Size:",
        "animations": "Enable Animations",
        "anti_aliasing": "Enable Anti-Aliasing",
        "ready": "Ready",
        "starting_build": "Starting build process...",
        "build_success": "Build completed successfully!",
        "build_failed": "Build failed: {}",
        "no_script": "Please select a Python script!",
    },
    "ja": {
        "window_title": "PyExeビルダープロフェッショナル",
        "main_tab": "メイン",
        "metadata_tab": "メタデータ",
        "dependencies_tab": "依存関係",
        "advanced_tab": "高度",
        "settings_tab": "設定",
        "build_console": "ビルドコンソール",
        "system_info": "システム情報",
        "python_script": "Pythonスクリプト",
        "browse": "参照",
        "output_options": "出力オプション",
        "app_name": "アプリケーション名:",
        "output_dir": "出力ディレクトリ:",
        "icon": "アイコン:",
        "build_options": "ビルドオプション",
        "one_file": "単一ファイル",
        "no_console": "コンソールなし",
        "admin_access": "管理者アクセスを要求",
        "auto_deps": "requirements.txtから自動インストール",
        "build_exe": "実行可能ファイルをビルド",
        "company_details": "会社詳細",
        "company_name": "会社名",
        "version": "バージョン (例: 1.0.0)",
        "copyright": "著作権情報",
        "trademark": "商標情報",
        "product_details": "製品詳細",
        "product_name": "製品名",
        "product_desc": "製品説明",
        "hidden_imports": "隠しインポート",
        "binary_deps": "バイナリ依存関係",
        "data_files": "データファイル",
        "debug_mode": "デバッグモード",
        "strip": "バイナリを剥がす",
        "upx": "UPX圧縮を使用",
        "clean": "クリーンビルド",
        "runtime_options": "ランタイムオプション",
        "disable_windowed": "ウィンドウ付きトレースバックを無効化",
        "key": "暗号化キー (任意)",
        "theme": "テーマ:",
        "language": "言語:",
        "font_size": "フォントサイズ:",
        "animations": "アニメーションを有効化",
        "anti_aliasing": "アンチエイリアシングを有効化",
        "ready": "準備完了",
        "starting_build": "ビルドプロセスを開始...",
        "build_success": "ビルドが正常に完了しました！",
        "build_failed": "ビルドに失敗しました: {}",
        "no_script": "Pythonスクリプトを選択してください！",
    },
    "ko": {
        "window_title": "PyExe 빌더 프로페셔널",
        "main_tab": "메인",
        "metadata_tab": "메타데이터",
        "dependencies_tab": "종속성",
        "advanced_tab": "고급",
        "settings_tab": "설정",
        "build_console": "빌드 콘솔",
        "system_info": "시스템 정보",
        "python_script": "파이썬 스크립트",
        "browse": "찾아보기",
        "output_options": "출력 옵션",
        "app_name": "애플리케이션 이름:",
        "output_dir": "출력 디렉토리:",
        "icon": "아이콘:",
        "build_options": "빌드 옵션",
        "one_file": "단일 파일",
        "no_console": "콘솔 없음",
        "admin_access": "관리자 권한 요청",
        "auto_deps": "requirements.txt에서 자동 설치",
        "build_exe": "실행 파일 빌드",
        "company_details": "회사 세부사항",
        "company_name": "회사 이름",
        "version": "버전 (예: 1.0.0)",
        "copyright": "저작권 정보",
        "trademark": "상표 정보",
        "product_details": "제품 세부사항",
        "product_name": "제품 이름",
        "product_desc": "제품 설명",
        "hidden_imports": "숨겨진 가져오기",
        "binary_deps": "바이너리 종속성",
        "data_files": "데이터 파일",
        "debug_mode": "디버그 모드",
        "strip": "바이너리 제거",
        "upx": "UPX 압축 사용",
        "clean": "클린 빌드",
        "runtime_options": "런타임 옵션",
        "disable_windowed": "창 추적 비활성화",
        "key": "암호화 키 (선택 사항)",
        "theme": "테마:",
        "language": "언어:",
        "font_size": "글꼴 크기:",
        "animations": "애니메이션 활성화",
        "anti_aliasing": "안티 앨리어싱 활성화",
        "ready": "준비 완료",
        "starting_build": "빌드 프로세스 시작...",
        "build_success": "빌드가 성공적으로 완료되었습니다!",
        "build_failed": "빌드 실패: {}",
        "no_script": "파이썬 스크립트를 선택하세요!",
    },
    "fil": {
        "window_title": "PyExe Builder Propesyonal",
        "main_tab": "Pangunahin",
        "metadata_tab": "Metadata",
        "dependencies_tab": "Mga Depende",
        "advanced_tab": "Advanced",
        "settings_tab": "Mga Setting",
        "build_console": "Build Console",
        "system_info": "Impormasyon ng Sistema",
        "python_script": "Python Script",
        "browse": "Mag-browse",
        "output_options": "Mga Opsyon sa Output",
        "app_name": "Pangalan ng Aplikasyon:",
        "output_dir": "Direktoryo ng Output:",
        "icon": "Icon:",
        "build_options": "Mga Opsyon sa Build",
        "one_file": "Isang File",
        "no_console": "Walang Console",
        "admin_access": "Humiling ng Access ng Admin",
        "auto_deps": "Auto-install mula sa requirements.txt",
        "build_exe": "I-build ang Executable",
        "company_details": "Mga Detalye ng Kompanya",
        "company_name": "Pangalan ng Kompanya",
        "version": "Bersyon (hal. 1.0.0)",
        "copyright": "Impormasyon sa Copyright",
        "trademark": "Impormasyon sa Trademark",
        "product_details": "Mga Detalye ng Produkto",
        "product_name": "Pangalan ng Produkto",
        "product_desc": "Deskripsyon ng Produkto",
        "hidden_imports": "Mga Hidden Imports",
        "binary_deps": "Mga Binary Dependencies",
        "data_files": "Mga Data File",
        "debug_mode": "Debug Mode",
        "strip": "Hubarin ang mga Binary",
        "upx": "Gumamit ng UPX Compression",
        "clean": "Malinis na Build",
        "runtime_options": "Mga Opsyon sa Runtime",
        "disable_windowed": "Huwag Paganahin ang Windowed Traceback",
        "key": "Encryption Key (opsyonal)",
        "theme": "Tema:",
        "language": "Wika:",
        "font_size": "Laki ng Font:",
        "animations": "Paganahin ang mga Animation",
        "anti_aliasing": "Paganahin ang Anti-Aliasing",
        "ready": "Handa na",
        "starting_build": "Sinimulan ang proseso ng build...",
        "build_success": "Matagumpay na natapos ang build!",
        "build_failed": "Nabigo ang build: {}",
        "no_script": "Pumili ng Python script!",
    }
}

# Theme definitions (unchanged)
THEMES = {
    "Dark Soft": {
        "background": "#1E2A44",
        "gradient_start": "#1E2A44",
        "gradient_end": "#2E3B55",
        "text": "#D9E1E8",
        "border": "#3A4971",
        "button": "#4A5A88",
        "button_hover": "#5A6A98",
        "button_pressed": "#3A4971",
        "console_bg": "#1A1A1A",
        "console_border": "#2A2A2A",
    },
    "Midnight Blue": {
        "background": "#0A192F",
        "gradient_start": "#0A192F",
        "gradient_end": "#172A45",
        "text": "#FFFFFF",
        "border": "#1A237E",
        "button": "#1A237E",
        "button_hover": "#283593",
        "button_pressed": "#0D1752",
        "console_bg": "#1A1A1A",
        "console_border": "#2A2A2A",
    },
    "Slate Gray": {
        "background": "#2F3E46",
        "gradient_start": "#2F3E46",
        "gradient_end": "#354F52",
        "text": "#CAD2C5",
        "border": "#52796F",
        "button": "#52796F",
        "button_hover": "#84A98C",
        "button_pressed": "#354F52",
        "console_bg": "#1A1A1A",
        "console_border": "#2A2A2A",
    },
    "Deep Forest": {
        "background": "#1F2A33",
        "gradient_start": "#1F2A33",
        "gradient_end": "#2A3B44",
        "text": "#E0E7D7",
        "border": "#3E5A61",
        "button": "#4A7066",
        "button_hover": "#5A8377",
        "button_pressed": "#3E5A61",
        "console_bg": "#1A1A1A",
        "console_border": "#2A2A2A",
    },
    "Velvet Night": {
        "background": "#2A1E3B",
        "gradient_start": "#2A1E3B",
        "gradient_end": "#3B2A4F",
        "text": "#E8D9F0",
        "border": "#5A3E71",
        "button": "#6A4A88",
        "button_hover": "#7A5A98",
        "button_pressed": "#5A3E71",
        "console_bg": "#1A1A1A",
        "console_border": "#2A2A2A",
    },
    "Charcoal Glow": {
        "background": "#2D2D2D",
        "gradient_start": "#2D2D2D",
        "gradient_end": "#3D3D3D",
        "text": "#E0E0E0",
        "border": "#4A4A4A",
        "button": "#5A5A5A",
        "button_hover": "#6A6A6A",
        "button_pressed": "#4A4A4A",
        "console_bg": "#1A1A1A",
        "console_border": "#2A2A2A",
    }
}

class ConsoleOutput(QTextEdit):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setReadOnly(True)
        
    def append_message(self, msg, level="INFO"):
        colors = {"INFO": "#00ff00", "WARNING": "#ffff00", "ERROR": "#ff0000", "DEBUG": "#00ffff"}
        timestamp = datetime.now().strftime("%H:%M:%S")
        formatted_msg = f'<span style="color: {colors[level]}">[{timestamp}] [{level}] {msg}</span>'
        self.append(formatted_msg)
        self.verticalScrollBar().setValue(self.verticalScrollBar().maximum())

class MetadataTab(QWidget):
    def __init__(self, lang="en"):
        super().__init__()
        self.lang = lang
        layout = QVBoxLayout(self)
        
        self.company_group = QGroupBox(TRANSLATIONS[lang]["company_details"])
        company_layout = QVBoxLayout()
        
        self.company_name = QLineEdit()
        self.company_name.setPlaceholderText(TRANSLATIONS[lang]["company_name"])
        company_layout.addWidget(self.company_name)
        
        self.company_version = QLineEdit()
        self.company_version.setPlaceholderText(TRANSLATIONS[lang]["version"])
        company_layout.addWidget(self.company_version)
        
        self.copyright = QLineEdit()
        self.copyright.setPlaceholderText(TRANSLATIONS[lang]["copyright"])
        company_layout.addWidget(self.copyright)
        
        self.trademark = QLineEdit()
        self.trademark.setPlaceholderText(TRANSLATIONS[lang]["trademark"])
        company_layout.addWidget(self.trademark)
        
        self.company_group.setLayout(company_layout)
        layout.addWidget(self.company_group)
        
        self.product_group = QGroupBox(TRANSLATIONS[lang]["product_details"])
        product_layout = QVBoxLayout()
        
        self.product_name = QLineEdit()
        self.product_name.setPlaceholderText(TRANSLATIONS[lang]["product_name"])
        product_layout.addWidget(self.product_name)
        
        self.product_desc = QTextEdit()
        self.product_desc.setPlaceholderText(TRANSLATIONS[lang]["product_desc"])
        self.product_desc.setMaximumHeight(100)
        product_layout.addWidget(self.product_desc)
        
        self.product_group.setLayout(product_layout)
        layout.addWidget(self.product_group)

class DependenciesTab(QWidget):
    def __init__(self, lang="en"):
        super().__init__()
        self.lang = lang
        layout = QVBoxLayout(self)
        
        self.imports_group = QGroupBox(TRANSLATIONS[lang]["hidden_imports"])
        imports_layout = QVBoxLayout()
        self.hidden_imports = QTextEdit()
        self.hidden_imports.setPlaceholderText(TRANSLATIONS[lang]["hidden_imports"])
        imports_layout.addWidget(self.hidden_imports)
        self.imports_group.setLayout(imports_layout)
        layout.addWidget(self.imports_group)
        
        self.binary_group = QGroupBox(TRANSLATIONS[lang]["binary_deps"])
        binary_layout = QVBoxLayout()
        self.binary_files = QTextEdit()
        self.binary_files.setPlaceholderText(TRANSLATIONS[lang]["binary_deps"])
        binary_layout.addWidget(self.binary_files)
        self.binary_group.setLayout(binary_layout)
        layout.addWidget(self.binary_group)
        
        self.data_group = QGroupBox(TRANSLATIONS[lang]["data_files"])
        data_layout = QVBoxLayout()
        self.data_files = QTextEdit()
        self.data_files.setPlaceholderText(TRANSLATIONS[lang]["data_files"])
        data_layout.addWidget(self.data_files)
        self.data_group.setLayout(data_layout)
        layout.addWidget(self.data_group)

class AdvancedOptionsTab(QWidget):
    def __init__(self, lang="en"):
        super().__init__()
        self.lang = lang
        layout = QVBoxLayout(self)
        
        self.build_group = QGroupBox(TRANSLATIONS[lang]["build_options"])
        build_layout = QVBoxLayout()
        
        self.debug_mode = QCheckBox(TRANSLATIONS[lang]["debug_mode"])
        build_layout.addWidget(self.debug_mode)
        
        self.strip = QCheckBox(TRANSLATIONS[lang]["strip"])
        build_layout.addWidget(self.strip)
        
        self.upx = QCheckBox(TRANSLATIONS[lang]["upx"])
        build_layout.addWidget(self.upx)
        
        self.clean = QCheckBox(TRANSLATIONS[lang]["clean"])
        build_layout.addWidget(self.clean)
        
        self.build_group.setLayout(build_layout)
        layout.addWidget(self.build_group)
        
        self.runtime_group = QGroupBox(TRANSLATIONS[lang]["runtime_options"])
        runtime_layout = QVBoxLayout()
        
        self.disable_windowed = QCheckBox(TRANSLATIONS[lang]["disable_windowed"])
        runtime_layout.addWidget(self.disable_windowed)
        
        self.key = QLineEdit()
        self.key.setPlaceholderText(TRANSLATIONS[lang]["key"])
        runtime_layout.addWidget(self.key)
        
        self.runtime_group.setLayout(runtime_layout)
        layout.addWidget(self.runtime_group)

class SettingsTab(QWidget):
    def __init__(self, lang="en", update_callback=None):
        super().__init__()
        self.lang = lang
        self.update_callback = update_callback
        layout = QVBoxLayout(self)
        
        self.theme_group = QGroupBox("Appearance")
        theme_layout = QVBoxLayout()
        self.theme_label = QLabel(TRANSLATIONS[lang]["theme"])
        self.theme_combo = QComboBox()
        self.theme_combo.addItems(THEMES.keys())
        self.theme_combo.currentTextChanged.connect(self.update_callback)
        theme_layout.addWidget(self.theme_label)
        theme_layout.addWidget(self.theme_combo)
        self.theme_group.setLayout(theme_layout)
        layout.addWidget(self.theme_group)
        
        self.lang_group = QGroupBox("Localization")
        lang_layout = QVBoxLayout()
        self.lang_label = QLabel(TRANSLATIONS[lang]["language"])
        self.lang_combo = QComboBox()
        self.lang_combo.addItems(["English", "Japanese", "Korean", "Filipino"])
        self.lang_combo.currentTextChanged.connect(self.update_callback)
        lang_layout.addWidget(self.lang_label)
        lang_layout.addWidget(self.lang_combo)
        self.lang_group.setLayout(lang_layout)
        layout.addWidget(self.lang_group)
        
        self.font_group = QGroupBox("Typography")
        font_layout = QHBoxLayout()
        self.font_label = QLabel(TRANSLATIONS[lang]["font_size"])
        self.font_size = QSpinBox()
        self.font_size.setRange(8, 24)
        self.font_size.setValue(12)
        self.font_size.valueChanged.connect(self.update_callback)
        font_layout.addWidget(self.font_label)
        font_layout.addWidget(self.font_size)
        self.font_group.setLayout(font_layout)
        layout.addWidget(self.font_group)
        
        self.misc_group = QGroupBox("Miscellaneous")
        misc_layout = QVBoxLayout()
        self.animations = QCheckBox(TRANSLATIONS[lang]["animations"])
        self.animations.setChecked(True)
        self.animations.stateChanged.connect(self.update_callback)
        self.anti_aliasing = QCheckBox(TRANSLATIONS[lang]["anti_aliasing"])
        self.anti_aliasing.setChecked(True)
        self.anti_aliasing.stateChanged.connect(self.update_callback)
        misc_layout.addWidget(self.animations)
        misc_layout.addWidget(self.anti_aliasing)
        self.misc_group.setLayout(misc_layout)
        layout.addWidget(self.misc_group)

class SystemInfoWidget(QWidget):
    def __init__(self, lang="en"):
        super().__init__()
        layout = QVBoxLayout(self)
        
        info_text = f"""
        {TRANSLATIONS[lang]["system_info"]}:
        OS: {platform.system()} {platform.release()}
        Python: {platform.python_version()}
        CPU: {platform.processor()}
        Memory: {psutil.virtual_memory().total / (1024**3):.1f} GB
        """
        
        self.info_label = QLabel(info_text)
        self.info_label.setStyleSheet("color: #a0a0a0; font-size: 10px;")
        layout.addWidget(self.info_label)

class RequirementsScanner(QThread):
    progress = pyqtSignal(int)
    message = pyqtSignal(str, str)
    finished = pyqtSignal(list)
    
    def __init__(self, script_path):
        super().__init__()
        self.script_dir = os.path.dirname(script_path)
        
    def run(self):
        requirements_file = os.path.join(self.script_dir, "requirements.txt")
        dependencies = []
        
        if os.path.exists(requirements_file):
            self.message.emit(TRANSLATIONS["en"]["starting_build"], "INFO")
            try:
                with open(requirements_file, 'r') as f:
                    lines = f.readlines()
                    total_lines = len(lines)
                    for i, line in enumerate(lines):
                        dep = line.strip()
                        if dep and not dep.startswith('#'):
                            dependencies.append(dep)
                        self.progress.emit(int((i + 1) / total_lines * 100))
                self.message.emit(f"Found {len(dependencies)} dependencies in requirements.txt", "INFO")
            except Exception as e:
                self.message.emit(f"Failed to read requirements.txt: {str(e)}", "ERROR")
        else:
            self.message.emit("No requirements.txt found in script directory", "WARNING")
        
        self.finished.emit(dependencies)

def resource_path(relative_path):
    if hasattr(sys, '_MEIPASS'):
        return os.path.join(sys._MEIPASS, relative_path)
    else:
        return os.path.join(os.path.dirname(__file__), relative_path)

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.settings = QSettings("VoxDroid", "PyExeBuilder")
        self.load_settings()
        self.setWindowTitle(TRANSLATIONS[self.lang]["window_title"])
        self.setMinimumSize(1200, 800)
        self.setup_ui()
        self.apply_theme()
        self.setup_tray()
        self.setWindowIcon(QIcon(resource_path("icon.ico")))
        
        logging.basicConfig(level=logging.DEBUG)
        self.logger = logging.getLogger(__name__)

    def load_settings(self):
        self.lang = self.settings.value("lang", "en", str)
        self.theme = self.settings.value("theme", "Dark Soft", str)
        self.font_size = self.settings.value("font_size", 12, int)
        self.animations_enabled = self.settings.value("animations", True, bool)
        self.anti_aliasing_enabled = self.settings.value("anti_aliasing", True, bool)
        self.is_building = False

    def save_settings(self):
        self.settings.setValue("lang", self.lang)
        self.settings.setValue("theme", self.theme)
        self.settings.setValue("font_size", self.font_size)
        self.settings.setValue("animations", self.animations_enabled)
        self.settings.setValue("anti_aliasing", self.anti_aliasing_enabled)
        self.settings.sync()

    def closeEvent(self, event):
        self.save_settings()
        super().closeEvent(event)

    def setup_tray(self):
        self.tray_icon = QSystemTrayIcon(self)
        self.tray_icon.setIcon(qta.icon("fa5s.cogs"))
        tray_menu = QMenu()
        show_action = QAction("Show", self)
        quit_action = QAction("Exit", self)
        show_action.triggered.connect(self.show)
        quit_action.triggered.connect(QApplication.quit)
        tray_menu.addAction(show_action)
        tray_menu.addAction(quit_action)
        self.tray_icon.setContextMenu(tray_menu)
        self.tray_icon.show()

    def apply_theme(self):
        theme = THEMES[self.theme]
        gradient = QLinearGradient(0, 0, 0, self.height())
        gradient.setColorAt(0, QColor(theme["gradient_start"]))
        gradient.setColorAt(1, QColor(theme["gradient_end"]))
        palette = self.palette()
        palette.setBrush(QPalette.ColorRole.Window, gradient)
        self.setPalette(palette)
        
        stylesheet = f"""
            QMainWindow {{
                background-color: {theme["background"]};
            }}
            QTabWidget::pane {{
                border: none;
                background-color: transparent;
            }}
            QTabBar::tab {{
                background-color: {theme["border"]};
                color: {theme["text"]};
                padding: 12px 24px;
                border-top-left-radius: 8px;
                border-top-right-radius: 8px;
                margin: 2px;
                font-family: 'Poppins';
                font-size: {self.font_size}px;
            }}
            QTabBar::tab:selected {{
                background-color: {theme["button"]};
            }}
            QLabel {{
                color: {theme["text"]};
                font-family: 'Poppins';
                font-size: {self.font_size}px;
            }}
            QLineEdit, QTextEdit, QSpinBox, QComboBox {{
                background-color: {theme["border"]};
                color: {theme["text"]};
                border: 1px solid {theme["button"]};
                border-radius: 6px;
                padding: 6px;
                font-family: 'Poppins';
                font-size: {self.font_size}px;
            }}
            QGroupBox {{
                color: {theme["text"]};
                font-family: 'Poppins';
                border: 1px solid {theme["button"]};
                border-radius: 6px;
                margin-top: 12px;
                font-size: {self.font_size}px;
            }}
            QCheckBox {{
                color: {theme["text"]};
                font-family: 'Poppins';
                font-size: {self.font_size}px;
            }}
            QProgressBar {{
                border: 2px solid {theme["button"]};
                border-radius: 6px;
                text-align: center;
                color: {theme["text"]};
                font-family: 'Poppins';
                font-size: {self.font_size}px;
            }}
            QProgressBar::chunk {{
                background-color: {theme["button"]};
            }}
            QPushButton {{
                background-color: {theme["button"]};
                color: {theme["text"]};
                border: none;
                border-radius: 6px;
                padding: 15px;
                font-family: 'Poppins';
                font-size: {self.font_size}px;
                min-width: 100px;
                min-height: 40px;
            }}
            QPushButton:hover {{
                background-color: {theme["button_hover"]};
            }}
            QPushButton:pressed {{
                background-color: {theme["button_pressed"]};
            }}
            QPushButton:disabled {{
                background-color: #666666;
                color: #aaaaaa;
            }}
            QTextEdit {{
                background-color: {theme["console_bg"]};
                border: 1px solid {theme["console_border"]};
                border-radius: 6px;
            }}
            #footer {{
                background-color: {theme["border"]};
                border-top: 1px solid {theme["button"]};
            }}
        """
        self.setStyleSheet(stylesheet)
        if self.animations_enabled:
            self.animate_tabs()

    def animate_tabs(self):
        for i in range(self.tabs.count()):
            tab = self.tabs.widget(i)
            anim = QPropertyAnimation(tab, b"pos")
            anim.setDuration(300)
            anim.setStartValue(QPoint(0, -20))
            anim.setEndValue(QPoint(0, 0))
            anim.setEasingCurve(QEasingCurve.Type.OutCubic)
            anim.start()

    def setup_ui(self):
        QFontDatabase.addApplicationFont("assets/fonts/Poppins-Regular.ttf")
        
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        main_layout = QVBoxLayout(central_widget)
        main_layout.setContentsMargins(0, 0, 0, 0)
        main_layout.setSpacing(0)
        
        # Navigation bar (top, horizontal, stretched)
        self.tabs = QTabWidget()
        self.tabs.setTabPosition(QTabWidget.TabPosition.North)
        self.tabs.setMovable(False)
        self.tabs.setDocumentMode(True)
        
        main_tab = self.create_main_tab()
        self.tabs.addTab(main_tab, qta.icon("fa5s.home"), TRANSLATIONS[self.lang]["main_tab"])
        
        self.metadata_tab = MetadataTab(self.lang)
        self.tabs.addTab(self.metadata_tab, qta.icon("fa5s.info-circle"), TRANSLATIONS[self.lang]["metadata_tab"])
        
        self.dependencies_tab = DependenciesTab(self.lang)
        self.tabs.addTab(self.dependencies_tab, qta.icon("fa5s.link"), TRANSLATIONS[self.lang]["dependencies_tab"])
        
        self.advanced_tab = AdvancedOptionsTab(self.lang)
        self.tabs.addTab(self.advanced_tab, qta.icon("fa5s.cog"), TRANSLATIONS[self.lang]["advanced_tab"])
        
        self.settings_tab = SettingsTab(self.lang, self.update_settings)
        self.settings_tab.theme_combo.setCurrentText(self.theme)
        self.settings_tab.lang_combo.setCurrentText({"en": "English", "ja": "Japanese", "ko": "Korean", "fil": "Filipino"}[self.lang])
        self.settings_tab.font_size.setValue(self.font_size)
        self.settings_tab.animations.setChecked(self.animations_enabled)
        self.settings_tab.anti_aliasing.setChecked(self.anti_aliasing_enabled)
        self.tabs.addTab(self.settings_tab, qta.icon("fa5s.sliders-h"), TRANSLATIONS[self.lang]["settings_tab"])
        
        main_layout.addWidget(self.tabs)
        
        # Content area (splitter)
        content_widget = QWidget()
        content_layout = QHBoxLayout(content_widget)
        
        # Left side (tab content)
        self.left_widget = QWidget()
        left_layout = QVBoxLayout(self.left_widget)
        left_layout.addWidget(self.tabs)
        
        # Right side (build console and system info)
        self.right_widget = QWidget()
        right_layout = QVBoxLayout(self.right_widget)
        
        self.console_group = QGroupBox(TRANSLATIONS[self.lang]["build_console"])
        console_layout = QVBoxLayout()
        self.console = ConsoleOutput()
        console_layout.addWidget(self.console)
        self.console_group.setLayout(console_layout)
        right_layout.addWidget(self.console_group)
        
        self.system_info = SystemInfoWidget(self.lang)
        right_layout.addWidget(self.system_info)
        
        content_layout.addWidget(self.left_widget, 2)
        content_layout.addWidget(self.right_widget, 1)
        
        main_layout.addWidget(content_widget)
        
        # Footer (single-line)
        self.footer_widget = QWidget()
        self.footer_widget.setObjectName("footer")
        footer_layout = QHBoxLayout(self.footer_widget)
        footer_layout.setContentsMargins(10, 5, 10, 5)
        
        self.status_label = QLabel(TRANSLATIONS[self.lang]["ready"])
        self.status_label.setStyleSheet("color: #a0a0a0; font-size: 12px;")
        footer_layout.addWidget(self.status_label)
        
        footer_layout.addStretch()
        
        self.dev_info = QLabel("PyExe Builder v1.0.0 by VoxDroid - github.com/VoxDroid")
        self.dev_info.setStyleSheet("color: #a0a0a0; font-size: 12px;")
        footer_layout.addWidget(self.dev_info)
        
        main_layout.addWidget(self.footer_widget)

    def create_main_tab(self):
        main_tab = QWidget()
        main_layout = QVBoxLayout(main_tab)
        
        self.script_group = QGroupBox(TRANSLATIONS[self.lang]["python_script"])
        script_layout = QHBoxLayout()
        self.script_path = QLineEdit()
        self.browse_script = QPushButton(qta.icon("fa5s.folder-open"), TRANSLATIONS[self.lang]["browse"])
        self.browse_script.clicked.connect(lambda: self.browse_file(self.script_path, "Python Files (*.py)"))
        script_layout.addWidget(self.script_path)
        script_layout.addWidget(self.browse_script)
        self.script_group.setLayout(script_layout)
        main_layout.addWidget(self.script_group)
        
        self.output_group = QGroupBox(TRANSLATIONS[self.lang]["output_options"])
        output_layout = QVBoxLayout()
        
        name_layout = QHBoxLayout()
        self.name_label = QLabel(TRANSLATIONS[self.lang]["app_name"])
        self.app_name = QLineEdit()
        name_layout.addWidget(self.name_label)
        name_layout.addWidget(self.app_name)
        output_layout.addLayout(name_layout)
        
        dir_layout = QHBoxLayout()
        self.dir_label = QLabel(TRANSLATIONS[self.lang]["output_dir"])
        self.output_dir = QLineEdit()
        self.browse_dir = QPushButton(qta.icon("fa5s.folder"), TRANSLATIONS[self.lang]["browse"])
        self.browse_dir.clicked.connect(self.browse_output_dir)
        dir_layout.addWidget(self.dir_label)
        dir_layout.addWidget(self.output_dir)
        dir_layout.addWidget(self.browse_dir)
        output_layout.addLayout(dir_layout)
        
        icon_layout = QHBoxLayout()
        self.icon_label = QLabel(TRANSLATIONS[self.lang]["icon"])
        self.icon_path = QLineEdit()
        self.browse_icon = QPushButton(qta.icon("fa5s.image"), TRANSLATIONS[self.lang]["browse"])
        self.browse_icon.clicked.connect(lambda: self.browse_file(self.icon_path, "Icon Files (*.ico)"))
        icon_layout.addWidget(self.icon_label)
        icon_layout.addWidget(self.icon_path)
        icon_layout.addWidget(self.browse_icon)
        output_layout.addLayout(icon_layout)
        
        self.output_group.setLayout(output_layout)
        main_layout.addWidget(self.output_group)
        
        self.build_group = QGroupBox(TRANSLATIONS[self.lang]["build_options"])
        build_layout = QVBoxLayout()
        
        self.one_file = QCheckBox(TRANSLATIONS[self.lang]["one_file"])
        self.one_file.setChecked(True)
        self.no_console = QCheckBox(TRANSLATIONS[self.lang]["no_console"])
        self.admin_access = QCheckBox(TRANSLATIONS[self.lang]["admin_access"])
        self.auto_deps = QCheckBox(TRANSLATIONS[self.lang]["auto_deps"])
        self.auto_deps.setChecked(True)
        
        build_layout.addWidget(self.one_file)
        build_layout.addWidget(self.no_console)
        build_layout.addWidget(self.admin_access)
        build_layout.addWidget(self.auto_deps)
        
        self.build_group.setLayout(build_layout)
        main_layout.addWidget(self.build_group)
        
        self.progress_bar = QProgressBar()
        main_layout.addWidget(self.progress_bar)
        
        self.build_button = QPushButton(qta.icon("fa5s.play"), TRANSLATIONS[self.lang]["build_exe"])
        self.build_button.setMinimumHeight(50)
        self.build_button.clicked.connect(self.build_executable)
        main_layout.addWidget(self.build_button)
        
        main_layout.addStretch()
        
        return main_tab

    def browse_file(self, line_edit, file_filter):
        file_path, _ = QFileDialog.getOpenFileName(self, "Select File", "", file_filter)
        if file_path:
            line_edit.setText(file_path)

    def browse_output_dir(self):
        dir_path = QFileDialog.getExistingDirectory(self, "Select Output Directory")
        if dir_path:
            self.output_dir.setText(dir_path)

    def update_settings(self):
        current_tab = self.tabs.currentIndex()
        self.theme = self.settings_tab.theme_combo.currentText()
        lang_map = {"English": "en", "Japanese": "ja", "Korean": "ko", "Filipino": "fil"}
        self.lang = lang_map[self.settings_tab.lang_combo.currentText()]
        self.font_size = self.settings_tab.font_size.value()
        self.animations_enabled = self.settings_tab.animations.isChecked()
        self.anti_aliasing_enabled = self.settings_tab.anti_aliasing.isChecked()
        
        self.apply_theme()
        self.update_ui_text()
        self.save_settings()
        self.tabs.setCurrentIndex(current_tab)

    def update_ui_text(self):
        self.setWindowTitle(TRANSLATIONS[self.lang]["window_title"])
        self.tabs.setTabText(0, TRANSLATIONS[self.lang]["main_tab"])
        self.tabs.setTabText(1, TRANSLATIONS[self.lang]["metadata_tab"])
        self.tabs.setTabText(2, TRANSLATIONS[self.lang]["dependencies_tab"])
        self.tabs.setTabText(3, TRANSLATIONS[self.lang]["advanced_tab"])
        self.tabs.setTabText(4, TRANSLATIONS[self.lang]["settings_tab"])
        
        if hasattr(self, 'status_label'):
            self.status_label.setText(TRANSLATIONS[self.lang]["ready"])
        if hasattr(self, 'dev_info'):
            self.dev_info.setText("PyExe Builder v1.0.0 by VoxDroid - github.com/VoxDroid")
        
        # Update Main Tab
        widget = self.tabs.widget(0)
        if widget:
            self.script_group.setTitle(TRANSLATIONS[self.lang]["python_script"])
            self.output_group.setTitle(TRANSLATIONS[self.lang]["output_options"])
            self.build_group.setTitle(TRANSLATIONS[self.lang]["build_options"])
            self.name_label.setText(TRANSLATIONS[self.lang]["app_name"])
            self.dir_label.setText(TRANSLATIONS[self.lang]["output_dir"])
            self.icon_label.setText(TRANSLATIONS[self.lang]["icon"])
            self.one_file.setText(TRANSLATIONS[self.lang]["one_file"])
            self.no_console.setText(TRANSLATIONS[self.lang]["no_console"])
            self.admin_access.setText(TRANSLATIONS[self.lang]["admin_access"])
            self.auto_deps.setText(TRANSLATIONS[self.lang]["auto_deps"])
            self.build_button.setText(TRANSLATIONS[self.lang]["build_exe"])
            # Explicitly update all Browse buttons
            self.browse_script.setText(TRANSLATIONS[self.lang]["browse"])
            self.browse_dir.setText(TRANSLATIONS[self.lang]["browse"])
            self.browse_icon.setText(TRANSLATIONS[self.lang]["browse"])

        # Update Metadata Tab
        if hasattr(self, 'metadata_tab'):
            self.metadata_tab.lang = self.lang
            self.metadata_tab.company_group.setTitle(TRANSLATIONS[self.lang]["company_details"])
            self.metadata_tab.product_group.setTitle(TRANSLATIONS[self.lang]["product_details"])
            self.metadata_tab.company_name.setPlaceholderText(TRANSLATIONS[self.lang]["company_name"])
            self.metadata_tab.company_version.setPlaceholderText(TRANSLATIONS[self.lang]["version"])
            self.metadata_tab.copyright.setPlaceholderText(TRANSLATIONS[self.lang]["copyright"])
            self.metadata_tab.trademark.setPlaceholderText(TRANSLATIONS[self.lang]["trademark"])
            self.metadata_tab.product_name.setPlaceholderText(TRANSLATIONS[self.lang]["product_name"])
            self.metadata_tab.product_desc.setPlaceholderText(TRANSLATIONS[self.lang]["product_desc"])

        # Update Dependencies Tab
        if hasattr(self, 'dependencies_tab'):
            self.dependencies_tab.lang = self.lang
            self.dependencies_tab.imports_group.setTitle(TRANSLATIONS[self.lang]["hidden_imports"])
            self.dependencies_tab.binary_group.setTitle(TRANSLATIONS[self.lang]["binary_deps"])
            self.dependencies_tab.data_group.setTitle(TRANSLATIONS[self.lang]["data_files"])
            self.dependencies_tab.hidden_imports.setPlaceholderText(TRANSLATIONS[self.lang]["hidden_imports"])
            self.dependencies_tab.binary_files.setPlaceholderText(TRANSLATIONS[self.lang]["binary_deps"])
            self.dependencies_tab.data_files.setPlaceholderText(TRANSLATIONS[self.lang]["data_files"])

        # Update Advanced Tab
        if hasattr(self, 'advanced_tab'):
            self.advanced_tab.lang = self.lang
            self.advanced_tab.build_group.setTitle(TRANSLATIONS[self.lang]["build_options"])
            self.advanced_tab.runtime_group.setTitle(TRANSLATIONS[self.lang]["runtime_options"])
            self.advanced_tab.debug_mode.setText(TRANSLATIONS[self.lang]["debug_mode"])
            self.advanced_tab.strip.setText(TRANSLATIONS[self.lang]["strip"])
            self.advanced_tab.upx.setText(TRANSLATIONS[self.lang]["upx"])
            self.advanced_tab.clean.setText(TRANSLATIONS[self.lang]["clean"])
            self.advanced_tab.disable_windowed.setText(TRANSLATIONS[self.lang]["disable_windowed"])
            self.advanced_tab.key.setPlaceholderText(TRANSLATIONS[self.lang]["key"])

        # Update Settings Tab
        if hasattr(self, 'settings_tab'):
            self.settings_tab.lang = self.lang
            self.settings_tab.theme_label.setText(TRANSLATIONS[self.lang]["theme"])
            self.settings_tab.lang_label.setText(TRANSLATIONS[self.lang]["language"])
            self.settings_tab.font_label.setText(TRANSLATIONS[self.lang]["font_size"])
            self.settings_tab.animations.setText(TRANSLATIONS[self.lang]["animations"])
            self.settings_tab.anti_aliasing.setText(TRANSLATIONS[self.lang]["anti_aliasing"])

        # Update Console and System Info
        if hasattr(self, 'console_group'):
            self.console_group.setTitle(TRANSLATIONS[self.lang]["build_console"])
        if hasattr(self, 'system_info'):
            self.system_info.info_label.setText(f"""
                {TRANSLATIONS[self.lang]["system_info"]}:
                OS: {platform.system()} {platform.release()}
                Python: {platform.python_version()}
                CPU: {platform.processor()}
                Memory: {psutil.virtual_memory().total / (1024**3):.1f} GB
            """)

    def create_version_file(self, config):
        version_file_content = """
# UTF-8
#
# For more details about fixed file info 'ffi' see:
# http://msdn.microsoft.com/en-us/library/ms646997.aspx
VSVersionInfo(
  ffi=FixedFileInfo(
    filevers=({version_tuple}),
    prodvers=({version_tuple}),
    mask=0x3f,
    flags=0x0,
    OS=0x40004,
    fileType=0x1,
    subtype=0x0,
    date=(0, 0)
    ),
  kids=[
    StringFileInfo(
      [
      StringTable(
        u'040904B0',
        [StringStruct(u'CompanyName', u'{company_name}'),
        StringStruct(u'FileDescription', u'{product_desc}'),
        StringStruct(u'FileVersion', u'{company_version}'),
        StringStruct(u'LegalCopyright', u'{copyright}'),
        StringStruct(u'LegalTrademarks', u'{trademark}'),
        StringStruct(u'ProductName', u'{product_name}'),
        StringStruct(u'ProductVersion', u'{company_version}')])
      ]), 
    VarFileInfo([VarStruct(u'Translation', [0x0409, 1200])])
  ]
)
"""
        version = config['company_version'] or "1.0.0.0"
        version_parts = version.split('.')
        while len(version_parts) < 4:
            version_parts.append('0')
        version_tuple = ', '.join(version_parts[:4])
        
        content = version_file_content.format(
            version_tuple=version_tuple,
            company_name=config['company_name'] or "Unknown Company",
            product_desc=config['product_desc'] or "Application",
            company_version=version or "1.0.0.0",
            copyright=config['copyright'] or "",
            trademark=config['trademark'] or "",
            product_name=config['product_name'] or config['app_name']
        )
        
        build_dir = os.path.join(os.getcwd(), "build", config['app_name'])
        os.makedirs(build_dir, exist_ok=True)
        version_file_path = os.path.join(build_dir, "version_info.txt")
        with open(version_file_path, 'w', encoding='utf-8') as f:
            f.write(content)
        
        return version_file_path

    def install_requirements(self, dependencies):
        if not dependencies:
            return
        
        self.console.append_message(TRANSLATIONS[self.lang]["starting_build"], "INFO")
        env_dir = os.path.join(os.getcwd(), ".builder_env")
        
        if sys.platform == "win32":
            pip_path = os.path.join(env_dir, "Scripts", "pip.exe")
        else:
            pip_path = os.path.join(env_dir, "bin", "pip")
            
        total = len(dependencies)
        for i, dep in enumerate(dependencies):
            try:
                subprocess.check_call([pip_path, "install", dep])
                self.console.append_message(f"Installed {dep}", "INFO")
                self.progress_bar.setValue(int((i + 1) / total * 50))
            except subprocess.CalledProcessError as e:
                self.console.append_message(f"Failed to install {dep}: {str(e)}", "WARNING")

    def on_requirements_scan_finished(self, dependencies):
        if dependencies and self.auto_deps.isChecked():
            self.install_requirements(dependencies)
        self.detected_deps = [dep.split('==')[0].split('>=')[0].split('<=')[0].strip() for dep in dependencies]
        self.continue_build()

    def build_executable(self):
        if self.is_building:
            return
            
        if not self.script_path.text():
            QMessageBox.warning(self, "Error", TRANSLATIONS[self.lang]["no_script"])
            return
            
        self.is_building = True
        self.build_button.setEnabled(False)
        self.console.append_message(TRANSLATIONS[self.lang]["starting_build"], "INFO")
        self.status_label.setText(TRANSLATIONS[self.lang]["starting_build"])
        self.progress_bar.setValue(0)
        
        config = {
            'script_path': self.script_path.text(),
            'app_name': self.app_name.text() or "app",
            'output_dir': self.output_dir.text(),
            'icon_path': self.icon_path.text(),
            'one_file': self.one_file.isChecked(),
            'no_console': self.no_console.isChecked(),
            'admin_access': self.admin_access.isChecked(),
            'auto_deps': self.auto_deps.isChecked(),
            'company_name': self.metadata_tab.company_name.text(),
            'company_version': self.metadata_tab.company_version.text(),
            'copyright': self.metadata_tab.copyright.text(),
            'trademark': self.metadata_tab.trademark.text(),
            'product_name': self.metadata_tab.product_name.text(),
            'product_desc': self.metadata_tab.product_desc.toPlainText(),
            'hidden_imports': self.dependencies_tab.hidden_imports.toPlainText().split('\n'),
            'binary_files': self.dependencies_tab.binary_files.toPlainText().split('\n'),
            'data_files': self.dependencies_tab.data_files.toPlainText().split('\n'),
            'debug_mode': self.advanced_tab.debug_mode.isChecked(),
            'strip': self.advanced_tab.strip.isChecked(),
            'upx': self.advanced_tab.upx.isChecked(),
            'clean': self.advanced_tab.clean.isChecked(),
            'disable_windowed': self.advanced_tab.disable_windowed.isChecked(),
            'key': self.advanced_tab.key.text(),
        }
        
        if config['auto_deps']:
            self.scanner = RequirementsScanner(config['script_path'])
            self.scanner.progress.connect(self.progress_bar.setValue)
            self.scanner.message.connect(self.console.append_message)
            self.scanner.finished.connect(self.on_requirements_scan_finished)
            self.scanner.start()
            self.current_config = config
        else:
            self.detected_deps = []
            self.continue_build(config)

    def continue_build(self, config=None):
        if config is None:
            config = self.current_config
            
        try:
            version_file_path = self.create_version_file(config)
            spec_dir = os.path.join(os.getcwd(), "build", config['app_name'])
            cmd = [
                config['script_path'],
                '--noconfirm',
                f"--name={config['app_name']}",
                f"--specpath={spec_dir}",
                f"--version-file={version_file_path}"
            ]
            
            if config['one_file']:
                cmd.append('--onefile')
            if config['no_console']:
                cmd.append('--windowed')
            else:
                cmd.append('--console')
            if config['icon_path']:
                icon_path = config['icon_path']
                if not os.path.isabs(icon_path):
                    icon_path = os.path.join(os.path.dirname(config['script_path']), icon_path)
                if os.path.exists(icon_path):
                    cmd.append(f"--icon={icon_path}")
                    self.console.append_message(f"Set icon: {icon_path}", "DEBUG")
                else:
                    self.console.append_message(f"Icon file not found: {icon_path}", "WARNING")
            if config['output_dir']:
                cmd.append(f"--distpath={config['output_dir']}")
            if config['admin_access']:
                cmd.append('--uac-admin')
            if config['debug_mode']:
                cmd.append('--debug')
            if config['strip']:
                cmd.append('--strip')
            if config['upx']:
                cmd.append('--upx-dir=upx')
            if config['clean']:
                cmd.append('--clean')
            if config['disable_windowed']:
                cmd.append('--disable-windowed-traceback')
            if config['key']:
                cmd.append(f"--key={config['key']}")
                
            all_imports = set(config['hidden_imports'] + self.detected_deps)
            for imp in all_imports:
                if imp.strip():
                    cmd.append(f"--hidden-import={imp.strip()}")
                    
            for binary in config['binary_files']:
                if binary.strip():
                    cmd.append(f"--add-binary={binary.strip()}")
                    
            # Handle data files: Source from script directory, normalize paths
            separator = ';' if sys.platform == "win32" else ':'
            script_dir = os.path.dirname(config['script_path'])
            for data in config['data_files']:
                if data.strip():
                    parts = data.strip().split(separator)
                    if len(parts) == 1:
                        source = parts[0].strip()
                        if not os.path.isabs(source):
                            source = os.path.join(script_dir, source)
                        source = os.path.normpath(source)  # Normalize to avoid mixed slashes
                        if source and os.path.exists(source):
                            data_entry = f"{source}{separator}."
                            cmd.append(f"--add-data={data_entry}")
                            self.console.append_message(f"Added data file: {data_entry}", "DEBUG")
                        else:
                            self.console.append_message(f"Data file not found: {source}", "WARNING")
                    elif len(parts) >= 2:
                        source, dest = parts[0].strip(), parts[1].strip()
                        if not os.path.isabs(source):
                            source = os.path.join(script_dir, source)
                        source = os.path.normpath(source)  # Normalize to avoid mixed slashes
                        if source and dest and os.path.exists(source):
                            data_entry = f"{source}{separator}{dest}"
                            cmd.append(f"--add-data={data_entry}")
                            self.console.append_message(f"Added data file: {data_entry}", "DEBUG")
                        else:
                            self.console.append_message(f"Invalid data file entry: {data}", "WARNING")
                    else:
                        self.console.append_message(f"Malformed data file entry: {data}", "WARNING")
                    
            self.console.append_message("Running PyInstaller with command:", "INFO")
            self.console.append_message(" ".join(cmd), "DEBUG")
            
            PyInstaller.__main__.run(cmd)
            
            self.console.append_message(TRANSLATIONS[self.lang]["build_success"], "INFO")
            self.status_label.setText(TRANSLATIONS[self.lang]["build_success"])
            self.progress_bar.setValue(100)
            QMessageBox.information(self, "Success", TRANSLATIONS[self.lang]["build_success"])
            
            if os.path.exists(version_file_path):
                os.remove(version_file_path)
                
        except Exception as e:
            self.console.append_message(TRANSLATIONS[self.lang]["build_failed"].format(str(e)), "ERROR")
            self.status_label.setText(TRANSLATIONS[self.lang]["build_failed"].format(str(e)))
            self.progress_bar.setValue(0)
            QMessageBox.critical(self, "Error", TRANSLATIONS[self.lang]["build_failed"].format(str(e)))
            if os.path.exists(version_file_path):
                os.remove(version_file_path)
                
        finally:
            self.is_building = False
            self.build_button.setEnabled(True)
            if not self.is_building:
                self.status_label.setText(TRANSLATIONS[self.lang]["ready"])

    def paintEvent(self, event):
        if self.anti_aliasing_enabled:
            painter = QPainter(self)
            painter.setRenderHint(QPainter.RenderHint.Antialiasing)
            super().paintEvent(event)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    app.setStyle("Fusion")
    
    font = QFont("Poppins", 12)
    app.setFont(font)
    
    window = MainWindow()
    window.show()
    sys.exit(app.exec())