import sys
import os
import time
import subprocess
import psutil
from datetime import datetime
import shutil
from dotenv import load_dotenv, set_key

from PyQt5.QtCore import Qt, QThread, pyqtSignal, QTimer, QPoint
from PyQt5.QtGui import QIntValidator, QFont, QTextCursor, QMouseEvent
from PyQt5.QtWidgets import (
    QApplication, QMainWindow, QTabWidget, QWidget, QVBoxLayout, QHBoxLayout,
    QPushButton, QLabel, QLineEdit, QTextEdit, QComboBox, QTableWidget,
    QTableWidgetItem, QMessageBox, QFileDialog, QCheckBox, QProgressBar, QSlider, QSizePolicy, QDialog
)

class ResizableTextEdit(QTextEdit):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setMouseTracking(True)
        self.dragging = False
        self.start_pos = QPoint()
        self.start_height = 0

    def mousePressEvent(self, event: QMouseEvent):
        if event.button() == Qt.LeftButton and event.pos().y() >= self.height() - 10:
            self.dragging = True
            self.start_pos = event.globalPos()
            self.start_height = self.height()

    def mouseMoveEvent(self, event: QMouseEvent):
        if self.dragging:
            delta = event.globalPos() - self.start_pos
            new_height = self.start_height + delta.y()
            self.setFixedHeight(max(100, new_height))
            self.parent().update_log_area_height(new_height)

    def mouseReleaseEvent(self, event: QMouseEvent):
        if event.button() == Qt.LeftButton:
            self.dragging = False

class ScriptRunner(QThread):
    log_signal = pyqtSignal(str)
    finished_signal = pyqtSignal(str)
    progress_signal = pyqtSignal(int)

    def __init__(self, scripts, python_path="python", delay_between_scripts=0, start_index=1, parent=None):
        super().__init__(parent)
        self.scripts = scripts
        self.python_path = python_path.strip()
        self.delay_between_scripts = delay_between_scripts
        self.start_index = start_index
        self.stop_flag = False
        self.current_process = None
        self.max_retries = 20

    def run(self):
        total_scripts = len(self.scripts)
        self.start_time = time.time()

        for i, (name, path) in enumerate(self.scripts, start=1):
            if self.stop_flag:
                self.log_signal.emit(self.format_log("⚠️ تم إيقاف التشغيل قبل تشغيل سكربت: " + name, "yellow"))
                break

            self.progress_signal.emit(int((i / total_scripts) * 100))
            self.log_signal.emit(self.format_log(f"📌 تشغيل السكربت رقم {i}: {name}\n📁 المسار: {path}", "blue"))

            start_time_all_attempts = time.time()
            success = False
            attempt_num = 0

            while attempt_num < self.max_retries and not self.stop_flag:
                attempt_num += 1
                if attempt_num > 1:
                    self.log_signal.emit(
                        self.format_log(f"🔁 إعادة المحاولة رقم {attempt_num} للسكربت: {name}", "orange")
                    )

                start_time = time.time()
                return_code = None

                try:
                    self.current_process = subprocess.Popen(
                        [self.python_path, path],
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                        text=True,
                        encoding='utf-8',
                        shell=False
                    )

                    while True:
                        if self.stop_flag:
                            if self.current_process:
                                self.current_process.terminate()
                                self.log_signal.emit(self.format_log("❌ تم إنهاء عملية السكربت بالقوة.", "red"))
                            break

                        line = self.current_process.stdout.readline()
                        if not line and self.current_process.poll() is not None:
                            break
                        if line:
                            self.log_signal.emit(self.format_log(line.rstrip(), "black"))

                    if self.stop_flag:
                        break

                    return_code = self.current_process.returncode
                    if return_code == 0:
                        end_time = time.time()
                        elapsed = end_time - start_time
                        self.log_signal.emit(
                            self.format_log(
                                f"✅ انتهى السكربت: {name} بنجاح في {elapsed:.1f} ثانية. (المحاولة {attempt_num})",
                                "green"
                            )
                        )
                        success = True
                        break
                    else:
                        self.log_signal.emit(
                            self.format_log(
                                f"⚠️ السكربت {name} انتهى برمز خطأ: {return_code} (المحاولة {attempt_num})",
                                "red"
                            )
                        )

                except Exception as e:
                    self.log_signal.emit(
                        self.format_log(f"❗️ خطأ أثناء تشغيل {name} (المحاولة {attempt_num}): {str(e)}", "red")
                    )

            end_time_all_attempts = time.time()
            total_elapsed = end_time_all_attempts - start_time_all_attempts

            if not success:
                self.log_signal.emit(
                    self.format_log(
                        f"👀 انتهت جميع المحاولات ({self.max_retries}) للسكربت: {name} دون نجاح. سيتم الانتقال للسكربت التالي.",
                        "purple"
                    )
                )
            else:
                self.log_signal.emit(
                    self.format_log(
                        f"✅ تم التنفيذ النهائي للسكربت: {name} في {total_elapsed:.1f} ثانية (بما يشمل المحاولات).",
                        "green"
                    )
                )

            if i == total_scripts:
                self.finished_signal.emit(name)
            else:
                if not self.stop_flag and self.delay_between_scripts > 0 and i < total_scripts:
                    self.log_signal.emit(
                        self.format_log(
                            f"⏳ انتظار {self.delay_between_scripts} ثانية قبل تشغيل السكربت التالي...",
                            "grey"
                        )
                    )
                    time.sleep(self.delay_between_scripts)

    def stop(self):
        self.stop_flag = True
        if self.current_process:
            self.current_process.terminate()

    def format_log(self, message, color="black"):
        return f'<span style="color:{color};">{message}</span>'

class SingleScriptRunner(QThread):
    log_signal = pyqtSignal(str)
    finished_signal = pyqtSignal()

    def __init__(self, script_name, script_path, python_path="python", parent=None):
        super().__init__(parent)
        self.script_name = script_name
        self.script_path = script_path
        self.python_path = python_path.strip()
        self.stop_flag = False
        self.current_process = None

    def run(self):
        self.log_signal.emit(
            self.format_log(f"🔍 تشغيل السكربت: {self.script_name}\n📁 المسار: {self.script_path}", "blue")
        )
        start_time = time.time()
        try:
            self.current_process = subprocess.Popen(
                [self.python_path, self.script_path],
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                encoding='utf-8',
                shell=False
            )
            while True:
                if self.stop_flag:
                    if self.current_process:
                        self.current_process.terminate()
                        self.log_signal.emit(self.format_log("❌ تم إنهاء عملية السكربت بالقوة.", "red"))
                    break

                line = self.current_process.stdout.readline()
                if not line and self.current_process.poll() is not None:
                    break
                if line:
                    self.log_signal.emit(self.format_log(line.rstrip(), "black"))

            if not self.stop_flag:
                if self.current_process.returncode == 0:
                    end_time = time.time()
                    elapsed = end_time - start_time
                    self.log_signal.emit(
                        self.format_log(
                            f"✅ انتهى السكربت: {self.script_name} بنجاح في {elapsed:.1f} ثانية.",
                            "green"
                        )
                    )
                else:
                    self.log_signal.emit(self.format_log(
                        f"⚠️ السكربت {self.script_name} انتهى برمز خطأ: {self.current_process.returncode}",
                        "red"
                    ))

        except Exception as e:
            self.log_signal.emit(self.format_log(f"❗️ خطأ أثناء تشغيل {self.script_name}: {str(e)}", "red"))

        self.finished_signal.emit()

    def stop(self):
        self.stop_flag = True
        if self.current_process:
            self.current_process.terminate()

    def format_log(self, message, color="black"):
        return f'<span style="color:{color};">{message}</span>'

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

        # إعدادات الواجهة الرئيسية
        self.setWindowFlags(Qt.Window | Qt.WindowMinimizeButtonHint | Qt.WindowMaximizeButtonHint | Qt.WindowCloseButtonHint)
        self.env_path = "D:\\YouTubeGen Pro 3\\config\\.env"
        load_dotenv(self.env_path)

        self.setWindowTitle("واجهة YouTubeGen Pro")
        self.setGeometry(100, 100, 1400, 800)

        self.script_thread = None
        self.single_script_threads = {}

        self.restart_timer = QTimer()
        self.restart_timer.setInterval(1000)
        self.restart_timer.timeout.connect(self.update_countdown)
        self.restart_remaining = 0

        self.countdown_label = QLabel("")
        self.countdown_label.setAlignment(Qt.AlignLeft)
        self.countdown_label.setStyleSheet("font-size: 16px; color: red;")

        self.operation_timer = QTimer()
        self.operation_timer.setInterval(1000)
        self.operation_timer.timeout.connect(self.update_operation_time)
        self.operation_time = 0

        self.operation_time_label = QLabel("⏰ وقت العملية المستغرق: 00:00:00")
        self.operation_time_label.setAlignment(Qt.AlignRight)
        self.operation_time_label.setStyleSheet("font-size: 16px; color: green;")

        self.tabs = QTabWidget()
        self.setCentralWidget(self.tabs)

        self.tabs.addTab(self.combined_settings_tab(), "النصوص والإعدادات المرئية")
        self.tabs.addTab(self.script_control_tab(), "التحكم بالسكربتات")
        self.tabs.addTab(self.api_management_tab(), "مفاتيح API")
        self.tabs.addTab(self.advanced_settings_tab(), "الإعدادات المتقدمة")
        self.tabs.addTab(self.env_settings_tab(), "إعدادات البيئة")

        self.log_area = ResizableTextEdit()
        self.log_area.setReadOnly(True)
        self.log_area.setStyleSheet("background-color: #f4f4f4; font-family: monospace;")
        self.log_area.setFont(QFont("Courier", 10))

        self.log_area.installEventFilter(self)

        log_layout = QVBoxLayout()
        log_layout.addWidget(QLabel("📝 سجل العمليات الجارية:"))
        log_layout.addWidget(self.log_area)

        self.progress_bar = QProgressBar()
        self.progress_bar.setValue(0)
        self.progress_bar.setFixedHeight(20)
        self.progress_bar.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
        log_layout.addWidget(self.progress_bar)

        countdown_operation_layout = QHBoxLayout()
        countdown_operation_layout.addWidget(self.countdown_label, alignment=Qt.AlignLeft)
        countdown_operation_layout.addWidget(self.operation_time_label, alignment=Qt.AlignRight)
        log_layout.addLayout(countdown_operation_layout)

        main_layout = QVBoxLayout()
        main_layout.addWidget(self.tabs)
        main_layout.addLayout(log_layout)

        container = QWidget()
        container.setLayout(main_layout)
        self.setCentralWidget(container)

        self.start_button = QPushButton("🚀 تشغيل السكربتات المحددة")
        self.start_button.clicked.connect(self.start_main_script)

        self.stop_button = QPushButton("⏹️ إيقاف")
        self.stop_button.clicked.connect(self.stop_execution)

        self.clear_log_button = QPushButton("🧹 مسح شاشة الترمينال")
        self.clear_log_button.clicked.connect(self.clear_log_area)

        self.quit_button = QPushButton("❌ إغلاق التطبيق")
        self.quit_button.clicked.connect(self.close_application)

        self.open_topic_button = QPushButton("📂 فتح موضوع الفيديو في نافذة منفصلة")
        self.open_topic_button.clicked.connect(self.open_topic_window)

        self.open_log_button = QPushButton("📂 فتح سجل العمليات في نافذة منفصلة")
        self.open_log_button.clicked.connect(self.open_log_window)

        button_layout = QHBoxLayout()
        button_layout.addWidget(self.start_button)
        button_layout.addWidget(self.stop_button)
        button_layout.addWidget(self.clear_log_button)
        button_layout.addWidget(self.quit_button)
        button_layout.addWidget(self.open_topic_button)
        button_layout.addWidget(self.open_log_button)

        main_layout.addLayout(button_layout)

    def open_topic_window(self):
        self.topic_window = QDialog(self)
        self.topic_window.setWindowTitle("موضوع الفيديو")
        self.topic_window.setWindowFlags(Qt.Window | Qt.WindowMinimizeButtonHint | Qt.WindowMaximizeButtonHint | Qt.WindowCloseButtonHint)
        layout = QVBoxLayout()
        topic_text = QTextEdit(self.topic_input.toPlainText())
        layout.addWidget(topic_text)
        self.topic_window.setLayout(layout)
        self.topic_window.exec_()

    def open_log_window(self):
        self.log_window = QDialog(self)
        self.log_window.setWindowTitle("سجل العمليات")
        self.log_window.setWindowFlags(Qt.Window | Qt.WindowMinimizeButtonHint | Qt.WindowMaximizeButtonHint | Qt.WindowCloseButtonHint)
        layout = QVBoxLayout()
        log_text = QTextEdit(self.log_area.toPlainText())
        log_text.setReadOnly(True)
        layout.addWidget(log_text)
        self.log_window.setLayout(layout)
        self.log_window.exec_()

    def combined_settings_tab(self):
        # إنشاء التبويب الرئيسي وتخطيطه
        tab = QWidget()
        layout = QVBoxLayout()
        tab.setLayoutDirection(Qt.RightToLeft)  # تعيين اتجاه التخطيط من اليمين إلى اليسار

        # مجموعة الإعدادات العامة
        general_group = QWidget()
        general_group.setLayoutDirection(Qt.RightToLeft)  # تعيين اتجاه التخطيط من اليمين إلى اليسار
        general_layout = QVBoxLayout()

        # إدخال موضوع الفيديو
        # إدخال موضوع الفيديو
        topic_layout = QVBoxLayout()  # استخدام QVBoxLayout لجعل كل عنصر في سطر منفصل
        topic_label = QLabel("📝 موضوع الفيديو:")
        topic_label.setAlignment(Qt.AlignRight)  # محاذاة التسمية إلى اليمين
        topic_layout.addWidget(topic_label)
        self.topic_input = QTextEdit(os.getenv("TOPIC", "").strip())
        self.topic_input.setFixedHeight(100)  # زيادة ارتفاع حقل موضوع الفيديو
        topic_layout.addWidget(self.topic_input)
        general_layout.addLayout(topic_layout)
        general_layout.addSpacing(10)  # إضافة مسافة ثابتة

        # إدخال عدد الكلمات
        word_count_layout = QHBoxLayout()
        word_count_label = QLabel("🔢 عدد الكلمات:")
        word_count_label.setAlignment(Qt.AlignRight)  # محاذاة التسمية إلى اليمين
        word_count_layout.addWidget(word_count_label)
        self.word_count_input = QLineEdit(os.getenv("WORD_COUNT", "").strip())
        self.word_count_input.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)  # توسيع الحقل
        word_count_layout.addWidget(self.word_count_input)
        general_layout.addLayout(word_count_layout)
        general_layout.addSpacing(10)  # إضافة مسافة ثابتة

        # اختيار نوع النص
        text_type_layout = QHBoxLayout()
        text_type_label = QLabel("🖋️ نوع النص:")
        text_type_label.setAlignment(Qt.AlignRight)  # محاذاة التسمية إلى اليمين
        text_type_layout.addWidget(text_type_label)
        self.text_type_selector = QComboBox()
        text_types = ["حكاية", "مقال", "وصف", "قصة", "أفكار", "تحليل"]
        env_text_type = os.getenv("TEXT_TYPE", "حكاية").strip()
        if env_text_type not in text_types:
            text_types.append(env_text_type)
        self.text_type_selector.addItems(text_types)
        self.text_type_selector.setCurrentText(env_text_type)
        self.text_type_selector.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)  # توسيع الحقل
        text_type_layout.addWidget(self.text_type_selector)
        general_layout.addLayout(text_type_layout)
        general_layout.addSpacing(10)  # إضافة مسافة ثابتة

        # اختيار لغة النص
        language_layout = QHBoxLayout()
        language_label = QLabel("🌐 لغة النص:")
        language_label.setAlignment(Qt.AlignRight)  # محاذاة التسمية إلى اليمين
        language_layout.addWidget(language_label)
        self.language_selector = QComboBox()
        languages = ["ar", "en", "fr"]
        env_lang = os.getenv("language_type", "ar").strip()
        if env_lang not in languages:
            languages.append(env_lang)
        self.language_selector.addItems(languages)
        self.language_selector.setCurrentText(env_lang)
        self.language_selector.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)  # توسيع الحقل
        language_layout.addWidget(self.language_selector)
        general_layout.addLayout(language_layout)
        general_layout.addSpacing(10)  # إضافة مسافة ثابتة

        general_group.setLayout(general_layout)

        # مجموعة الإعدادات المرئية
        visual_group = QWidget()
        visual_group.setLayoutDirection(Qt.RightToLeft)  # تعيين اتجاه التخطيط من اليمين إلى اليسار
        visual_layout = QVBoxLayout()

        # اختيار الاستايل
        style_layout = QHBoxLayout()
        style_label = QLabel("🎨 اختر الاستايل:")
        style_label.setAlignment(Qt.AlignRight)  # محاذاة التسمية إلى اليمين
        style_layout.addWidget(style_label)
        self.style_selector = QComboBox()
        styles = [
            "1 - 3D Render with High Detail",
            "2 - Cyberpunk with Neon Lights",
            "3 - Realistic Photo",
            "4 - 3D Cartoon",
            "5 - Vintage Watercolor Art",
            "6 - Dark Fantasy with Dramatic Lighting",
            "7 - Sci-Fi with Futuristic Technology",
            "8 - Steampunk with Victorian Aesthetic",
            "9 - Minimalist with Clean Lines",
            "10 - Nature Photography with Soft Lighting",
            "11 - Fantasy Creature Design",
            "12 - Retro 80s Neon Art"
        ]
        self.style_selector.addItems(styles)
        try:
            current_style = int(os.getenv("STYLE_NUMBER", "1")) - 1
            if 0 <= current_style < len(styles):
                self.style_selector.setCurrentIndex(current_style)
            else:
                self.style_selector.setCurrentIndex(0)
        except ValueError:
            self.style_selector.setCurrentIndex(0)
        self.style_selector.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)  # توسيع الحقل
        style_layout.addWidget(self.style_selector)
        visual_layout.addLayout(style_layout)
        visual_layout.addSpacing(10)  # إضافة مسافة ثابتة

        # اختيار حجم الفيديو
        size_layout = QHBoxLayout()
        size_label = QLabel("📏 اختر حجم الفيديو:")
        size_label.setAlignment(Qt.AlignRight)  # محاذاة التسمية إلى اليمين
        size_layout.addWidget(size_label)
        self.size_selector = QComboBox()
        size_options = [
            "1 - العرض الأفقي (1920x1080) - ستاندرد",
            "2 - العرض الرأسي (1080x1920) - شورت"
        ]
        self.size_selector.addItems(size_options)
        try:
            current_size = int(os.getenv("SIZE_NUMBER", "1")) - 1
            if 0 <= current_size < 2:
                self.size_selector.setCurrentIndex(current_size)
            else:
                self.size_selector.setCurrentIndex(0)
        except ValueError:
            self.size_selector.setCurrentIndex(0)
        self.size_selector.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)  # توسيع الحقل
        size_layout.addWidget(self.size_selector)
        visual_layout.addLayout(size_layout)
        visual_layout.addSpacing(10)  # إضافة مسافة ثابتة

        # إدخال رقم الصوت
        voice_layout = QHBoxLayout()
        voice_label = QLabel("🔊 رقم الصوت:")
        voice_label.setAlignment(Qt.AlignRight)  # محاذاة التسمية إلى اليمين
        voice_layout.addWidget(voice_label)
        self.voice_number_input = QLineEdit(os.getenv("VOICE_NUMBER", "1").strip())
        self.voice_number_input.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)  # توسيع الحقل
        voice_layout.addWidget(self.voice_number_input)
        visual_layout.addLayout(voice_layout)
        visual_layout.addSpacing(10)  # إضافة مسافة ثابتة

        # اختيار سرعة الصوت
        speed_layout = QHBoxLayout()
        speed_label = QLabel("⚡️ سرعة الصوت:")
        speed_label.setAlignment(Qt.AlignRight)  # محاذاة التسمية إلى اليمين
        speed_layout.addWidget(speed_label)
        self.speed_slider = QSlider(Qt.Horizontal)
        self.speed_slider.setMinimum(50)
        self.speed_slider.setMaximum(200)
        self.speed_slider.setValue(100)
        self.speed_slider.setTickPosition(QSlider.TicksBelow)
        self.speed_slider.setTickInterval(10)

        self.speed_label = QLabel("1.0")

        env_speed = os.getenv("SPEED", "1.0").strip()
        try:
            float_speed = float(env_speed)
            slider_value = int(float_speed * 100)
            if slider_value < 50:
                slider_value = 50
            elif slider_value > 200:
                slider_value = 200
            self.speed_slider.setValue(slider_value)
            self.speed_label.setText(f"{float_speed:.2f}")
        except:
            pass

        self.speed_slider.valueChanged.connect(self.on_speed_slider_changed)

        speed_layout.addWidget(self.speed_slider)
        speed_layout.addWidget(self.speed_label)
        visual_layout.addLayout(speed_layout)

        visual_group.setLayout(visual_layout)

        # إضافة الأقسام إلى التخطيط الرئيسي
        layout.addWidget(general_group)
        layout.addWidget(visual_group)

        # زر حفظ الإعدادات
        save_button = QPushButton("💾 حفظ الإعدادات النصية والمرئية")
        save_button.clicked.connect(self.save_combined_settings)
        layout.addWidget(save_button)

        tab.setLayout(layout)
        return tab
    def save_combined_settings(self):
        self.modify_env_file("TOPIC", self.topic_input.toPlainText().strip())
        self.modify_env_file("WORD_COUNT", self.word_count_input.text().strip())
        self.modify_env_file("TEXT_TYPE", self.text_type_selector.currentText().strip())
        self.modify_env_file("language_type", self.language_selector.currentText().strip())

        style_index = self.style_selector.currentIndex() + 1
        self.modify_env_file("STYLE_NUMBER", str(style_index))

        size_index = self.size_selector.currentIndex() + 1
        self.modify_env_file("SIZE_NUMBER", str(size_index))

        self.modify_env_file("VOICE_NUMBER", self.voice_number_input.text().strip())

        speed_value = self.speed_slider.value() / 100.0
        self.modify_env_file("SPEED", f"{speed_value:.2f}")

        self.log(self.format_log("✅ تم حفظ الإعدادات النصية والمرئية.", "green"))

    def on_speed_slider_changed(self, value):
        float_speed = value / 100.0
        self.speed_label.setText(f"{float_speed:.2f}")

    def script_control_tab(self):
        tab = QWidget()
        layout = QVBoxLayout()

        self.script_table = QTableWidget()
        self.script_table.setRowCount(9)
        self.script_table.setColumnCount(4)
        self.script_table.setHorizontalHeaderLabels(["✅ تشغيل", "📝 اسم السكربت", "📁 مسار السكربت", "▶️ تشغيل منفرد"])
        self.script_table.horizontalHeader().setStretchLastSection(True)

        self.script_table.setColumnWidth(2, 450)

        for i in range(1, 10):
            checkbox = QCheckBox()
            checkbox.setChecked(True)
            self.script_table.setCellWidget(i - 1, 0, checkbox)

            name = os.getenv(f"SCRIPT_{i}_NAME", "").strip()
            path = os.getenv(f"SCRIPT_{i}_PATH", "").strip()
            self.script_table.setItem(i - 1, 1, QTableWidgetItem(name))
            self.script_table.setItem(i - 1, 2, QTableWidgetItem(path))

            btn_run_single = QPushButton("▶️ تشغيل")
            btn_run_single.clicked.connect(lambda _, row=i - 1: self.run_single_script(row))
            self.script_table.setCellWidget(i - 1, 3, btn_run_single)

        layout.addWidget(self.script_table)

        layout.addWidget(QLabel("🛫 ابدأ التشغيل من السكربت رقم:"))
        self.start_script_selector = QComboBox()
        for i in range(1, 10):
            self.start_script_selector.addItem(str(i))
        layout.addWidget(self.start_script_selector)

        save_button = QPushButton("💾 حفظ إعدادات السكربتات")
        save_button.clicked.connect(self.save_script_settings)
        layout.addWidget(save_button)

        tab.setLayout(layout)
        return tab

    def save_script_settings(self):
        for row in range(self.script_table.rowCount()):
            name_item = self.script_table.item(row, 1)
            path_item = self.script_table.item(row, 2)
            if name_item and path_item:
                set_key(self.env_path, f"SCRIPT_{row + 1}_NAME", name_item.text().strip())
                set_key(self.env_path, f"SCRIPT_{row + 1}_PATH", path_item.text().strip())
        self.log(self.format_log("✅ تم حفظ إعدادات السكربتات.", "green"))

    def run_single_script(self, row_index):
        if row_index in self.single_script_threads:
            existing_thread = self.single_script_threads[row_index]
            if existing_thread.isRunning():
                QMessageBox.warning(self, "🔔 تنبيه", "🚫 هذا السكربت يعمل حاليًا.")
                return
            else:
                del self.single_script_threads[row_index]

        name_item = self.script_table.item(row_index, 1)
        path_item = self.script_table.item(row_index, 2)

        if not name_item or not path_item:
            self.log(self.format_log("❗️ اسم أو مسار السكربت فارغ.", "red"))
            return

        script_name = name_item.text().strip()
        script_path = path_item.text().strip()
        if not script_name or not script_path:
            self.log(self.format_log("❗️ اسم أو مسار السكربت فارغ.", "red"))
            return

        try:
            load_dotenv(self.env_path, override=True)
            self.log(self.format_log("🔄 تم إعادة تحميل ملف البيئة قبل التشغيل المنفرد.", "blue"))
        except Exception as e:
            self.log(self.format_log(f"⚠️ فشل إعادة تحميل ملف البيئة: {e}", "red"))

        python_path = os.getenv("PYTHON_ENV_PATH", "python").strip()

        runner = SingleScriptRunner(script_name, script_path, python_path=python_path)
        runner.log_signal.connect(self.log)
        runner.finished_signal.connect(lambda: self.on_single_script_finished(row_index, script_name))

        self.single_script_threads[row_index] = runner

        runner.start()
        self.log(self.format_log(f"🔄 تم تشغيل السكربت الفردي: {script_name}", "blue"))

    def on_single_script_finished(self, row_index, script_name):
        self.log(self.format_log(f"✅ تم الانتهاء من تشغيل السكربت: {script_name}", "green"))

        if row_index in self.single_script_threads:
            del self.single_script_threads[row_index]

    def api_management_tab(self):
        tab = QWidget()
        layout = QVBoxLayout()

        self.api_table = QTableWidget()
        self.api_table.setRowCount(0)
        self.api_table.setColumnCount(2)
        self.api_table.setHorizontalHeaderLabels(["🛠️ اسم الخدمة", "🔑 مفتاح API"])
        self.api_table.horizontalHeader().setStretchLastSection(True)

        self.load_api_keys()
        layout.addWidget(self.api_table)

        button_layout = QHBoxLayout()
        add_button = QPushButton("➕ إضافة مفتاح")
        add_button.clicked.connect(self.add_api_key)
        save_button = QPushButton("💾 حفظ المفاتيح")
        save_button.clicked.connect(self.save_api_keys)
        delete_button = QPushButton("🗑️ حذف مفتاح")
        delete_button.clicked.connect(self.delete_api_key)

        button_layout.addWidget(add_button)
        button_layout.addWidget(save_button)
        button_layout.addWidget(delete_button)
        layout.addLayout(button_layout)

        tab.setLayout(layout)
        return tab

    def load_api_keys(self):
        g_keys = os.getenv("GOOGLE_API_KEYS", "").split(",")
        for key in g_keys:
            key = key.strip()
            if key:
                row = self.api_table.rowCount()
                self.api_table.insertRow(row)
                self.api_table.setItem(row, 0, QTableWidgetItem("Google"))
                self.api_table.setItem(row, 1, QTableWidgetItem(key))

        h_keys = os.getenv("HUGGINGFACE_API_KEYS", "").split(",")
        for key in h_keys:
            key = key.strip()
            if key:
                row = self.api_table.rowCount()
                self.api_table.insertRow(row)
                self.api_table.setItem(row, 0, QTableWidgetItem("HuggingFace"))
                self.api_table.setItem(row, 1, QTableWidgetItem(key))

    def add_api_key(self):
        row = self.api_table.rowCount()
        self.api_table.insertRow(row)
        self.api_table.setItem(row, 0, QTableWidgetItem(""))
        self.api_table.setItem(row, 1, QTableWidgetItem(""))
        self.log(self.format_log("✅ تمت إضافة مفتاح API جديد.", "green"))

    def delete_api_key(self):
        selected_items = self.api_table.selectedItems()
        if selected_items:
            rows = set()
            for item in selected_items:
                rows.add(item.row())
            for row in sorted(rows, reverse=True):
                self.api_table.removeRow(row)
            self.log(self.format_log("✅ تم حذف مفاتيح API المحددة.", "green"))
        else:
            self.log(self.format_log("❗️ لم يتم تحديد أي مفتاح للحذف.", "red"))

    def save_api_keys(self):
        google_keys = []
        huggingface_keys = []

        for row in range(self.api_table.rowCount()):
            service_item = self.api_table.item(row, 0)
            key_item = self.api_table.item(row, 1)
            if service_item and key_item:
                service = service_item.text().strip()
                apikey = key_item.text().strip()
                if service.lower() == "google":
                    google_keys.append(apikey)
                elif service.lower() == "huggingface":
                    huggingface_keys.append(apikey)

        set_key(self.env_path, "GOOGLE_API_KEYS", ",".join(google_keys))
        set_key(self.env_path, "HUGGINGFACE_API_KEYS", ",".join(huggingface_keys))
        self.log(self.format_log("✅ تم حفظ مفاتيح API.", "green"))

    def advanced_settings_tab(self):
        tab = QWidget()
        layout = QVBoxLayout()

        self.chrome_label = QLabel("🔧 مسار ChromeDriver:")
        hl_chrome = QHBoxLayout()
        self.chromedriver_path_input = QLineEdit(os.getenv("CHROMEDRIVER_PATH", "").strip())
        btn_chrome = QPushButton("📂")
        btn_chrome.clicked.connect(lambda: self.browse_path(self.chromedriver_path_input, file_or_dir="file"))
        hl_chrome.addWidget(self.chrome_label)
        hl_chrome.addWidget(self.chromedriver_path_input)
        hl_chrome.addWidget(btn_chrome)
        layout.addLayout(hl_chrome)

        self.canary_label = QLabel("🔧 مسار Canary Browser:")
        hl_canary = QHBoxLayout()
        self.canary_path_input = QLineEdit(os.getenv("CANARY_BINARY_PATH", "").strip())
        btn_canary = QPushButton("📂")
        btn_canary.clicked.connect(lambda: self.browse_path(self.canary_path_input, file_or_dir="file"))
        hl_canary.addWidget(self.canary_label)
        hl_canary.addWidget(self.canary_path_input)
        hl_canary.addWidget(btn_canary)
        layout.addLayout(hl_canary)

        self.user_data_label = QLabel("👤 مجلد بيانات المستخدم (USER_DATA_DIR):")
        hl_user_data = QHBoxLayout()
        self.user_data_dir_input = QLineEdit(os.getenv("USER_DATA_DIR", "").strip())
        btn_user_data = QPushButton("📂")
        btn_user_data.clicked.connect(lambda: self.browse_path(self.user_data_dir_input, file_or_dir="dir"))
        hl_user_data.addWidget(self.user_data_label)
        hl_user_data.addWidget(self.user_data_dir_input)
        hl_user_data.addWidget(btn_user_data)
        layout.addLayout(hl_user_data)

        self.profile_name_label = QLabel("👤 اسم الملف الشخصي:")
        hl_profile = QHBoxLayout()
        self.profile_name_input = QComboBox()
        profiles = ["Default"] + [f"Profile{i}" for i in range(1, 11)]
        env_profile = os.getenv("PROFILE_NAME", "Default").strip()
        if env_profile not in profiles:
            profiles.append(env_profile)
        self.profile_name_input.addItems(profiles)
        self.profile_name_input.setCurrentText(env_profile)
        hl_profile.addWidget(self.profile_name_label)
        hl_profile.addWidget(self.profile_name_input)
        layout.addLayout(hl_profile)
        self.upload_profile_label = QLabel("📤 بروفيلات الرفع:")
        hl_upload_profile = QHBoxLayout()
        self.upload_profile_selector = QComboBox()
        upload_profiles = ["Default", "Profile1", "Profile2", "Profile3"]
        env_upload_profile = os.getenv("UPLOAD_PROFILE", "Default").strip()
        if env_upload_profile not in upload_profiles:
            upload_profiles.append(env_upload_profile)
        self.upload_profile_selector.addItems(upload_profiles)
        self.upload_profile_selector.setCurrentText(env_upload_profile)
        hl_upload_profile.addWidget(self.upload_profile_label)
        hl_upload_profile.addWidget(self.upload_profile_selector)
        layout.addLayout(hl_upload_profile)

        self.video_label = QLabel("🎬 مسار إخراج الفيديو النهائي:")
        hl_video = QHBoxLayout()
        self.video_path_input = QLineEdit(os.getenv("VIDEO_PATH", "").strip())
        btn_video = QPushButton("📂")
        btn_video.clicked.connect(lambda: self.browse_path(self.video_path_input, file_or_dir="file"))
        hl_video.addWidget(self.video_label)
        hl_video.addWidget(self.video_path_input)
        hl_video.addWidget(btn_video)
        layout.addLayout(hl_video)

        self.title_label = QLabel("📄 مسار ملف العنوان:")
        hl_title = QHBoxLayout()
        self.title_path_input = QLineEdit(os.getenv("TITLE_PATH", "").strip())
        btn_title = QPushButton("📂")
        btn_title.clicked.connect(lambda: self.browse_path(self.title_path_input, file_or_dir="file"))
        hl_title.addWidget(self.title_label)
        hl_title.addWidget(self.title_path_input)
        hl_title.addWidget(btn_title)
        layout.addLayout(hl_title)

        self.desc_label = QLabel("📄 مسار ملف الوصف:")
        hl_desc = QHBoxLayout()
        self.description_path_input = QLineEdit(os.getenv("DESCRIPTION_PATH", "").strip())
        btn_desc = QPushButton("📂")
        btn_desc.clicked.connect(lambda: self.browse_path(self.description_path_input, file_or_dir="file"))
        hl_desc.addWidget(self.desc_label)
        hl_desc.addWidget(self.description_path_input)
        hl_desc.addWidget(btn_desc)
        layout.addLayout(hl_desc)

        self.keywords_label = QLabel("🔑 مسار ملف الكلمات المفتاحية:")
        hl_keywords = QHBoxLayout()
        self.keywords_path_input = QLineEdit(os.getenv("KEYWORDS_PATH", "").strip())
        btn_keywords = QPushButton("📂")
        btn_keywords.clicked.connect(lambda: self.browse_path(self.keywords_path_input, file_or_dir="file"))
        hl_keywords.addWidget(self.keywords_label)
        hl_keywords.addWidget(self.keywords_path_input)
        hl_keywords.addWidget(btn_keywords)
        layout.addLayout(hl_keywords)

        self.delay_label = QLabel("⏱️ الانتظار بين السكربتات (ثواني):")
        hl_delay = QHBoxLayout()
        self.delay_input = QLineEdit(os.getenv("DELAY_BETWEEN_SCRIPTS", "5").strip())
        self.delay_input.setValidator(QIntValidator(0, 9999))
        hl_delay.addWidget(self.delay_label)
        hl_delay.addWidget(self.delay_input)
        layout.addLayout(hl_delay)

        self.restart_min_label = QLabel("⏲️ الحد الأدنى لإعادة التشغيل (ثواني):")
        hl_restart_min = QHBoxLayout()
        self.restart_wait_min_input = QLineEdit(os.getenv("RESTART_WAIT_MIN", "1300").strip())
        self.restart_wait_min_input.setValidator(QIntValidator(0, 999999))
        hl_restart_min.addWidget(self.restart_min_label)
        hl_restart_min.addWidget(self.restart_wait_min_input)
        layout.addLayout(hl_restart_min)

        self.restart_max_label = QLabel("⏲️ الحد الأقصى لإعادة التشغيل (ثواني):")
        hl_restart_max = QHBoxLayout()
        self.restart_wait_max_input = QLineEdit(os.getenv("RESTART_WAIT_MAX", "6000").strip())
        self.restart_wait_max_input.setValidator(QIntValidator(0, 999999))
        hl_restart_max.addWidget(self.restart_max_label)
        hl_restart_max.addWidget(self.restart_wait_max_input)
        layout.addLayout(hl_restart_max)

        self.restart_delay_label = QLabel("⏲️ الانتظار لإعادة التشغيل بعد الانتهاء (ثواني):")
        hl_restart_delay = QHBoxLayout()
        self.restart_delay_input = QLineEdit(os.getenv("RESTART_DELAY_AFTER_COMPLETE", "3600").strip())
        self.restart_delay_input.setValidator(QIntValidator(0, 999999))
        hl_restart_delay.addWidget(self.restart_delay_label)
        hl_restart_delay.addWidget(self.restart_delay_input)
        layout.addLayout(hl_restart_delay)

        self.close_processes_label = QLabel("🔒 العمليات التي يجب إغلاقها بعد Script9 (أسماء العمليات مفصولة بفواصل):")
        hl_close_processes = QHBoxLayout()
        self.close_processes_input = QLineEdit(os.getenv("CLOSE_PROCESSES", "").strip())
        hl_close_processes.addWidget(self.close_processes_label)
        hl_close_processes.addWidget(self.close_processes_input)
        layout.addLayout(hl_close_processes)

        save_button = QPushButton("💾 حفظ الإعدادات المتقدمة")
        save_button.clicked.connect(self.save_advanced_settings)
        layout.addWidget(save_button)

        kill_canary_button = QPushButton("🔴 إغلاق Canary فقط")
        kill_canary_button.clicked.connect(self.kill_chrome_canary_only)
        layout.addWidget(kill_canary_button)

        tab.setLayout(layout)
        return tab

    def browse_path(self, line_edit: QLineEdit, file_or_dir="file"):
        if file_or_dir == "file":
            filepath, _ = QFileDialog.getOpenFileName(self, "📂 اختر ملفًا", "", "All Files (*)")
            if filepath:
                line_edit.setText(filepath)
        else:
            folderpath = QFileDialog.getExistingDirectory(self, "📂 اختر مجلدًا")
            if folderpath:
                line_edit.setText(folderpath)

    def save_advanced_settings(self):
        set_key(self.env_path, "CHROMEDRIVER_PATH", self.chromedriver_path_input.text().strip())
        set_key(self.env_path, "CANARY_BINARY_PATH", self.canary_path_input.text().strip())
        set_key(self.env_path, "USER_DATA_DIR", self.user_data_dir_input.text().strip())
        set_key(self.env_path, "PROFILE_NAME", self.profile_name_input.currentText().strip())
        set_key(self.env_path, "UPLOAD_PROFILE", self.upload_profile_selector.currentText().strip())
        set_key(self.env_path, "VIDEO_PATH", self.video_path_input.text().strip())
        set_key(self.env_path, "TITLE_PATH", self.title_path_input.text().strip())
        set_key(self.env_path, "DESCRIPTION_PATH", self.description_path_input.text().strip())
        set_key(self.env_path, "KEYWORDS_PATH", self.keywords_path_input.text().strip())
        set_key(self.env_path, "DELAY_BETWEEN_SCRIPTS", self.delay_input.text().strip())
        set_key(self.env_path, "RESTART_WAIT_MIN", self.restart_wait_min_input.text().strip())
        set_key(self.env_path, "RESTART_WAIT_MAX", self.restart_wait_max_input.text().strip())
        set_key(self.env_path, "RESTART_DELAY_AFTER_COMPLETE", self.restart_delay_input.text().strip())
        set_key(self.env_path, "CLOSE_PROCESSES", self.close_processes_input.text().strip())
        self.log(self.format_log("✅ تم حفظ الإعدادات المتقدمة.", "green"))

    def kill_chrome_canary_only(self):
        try:
            canary_executable = os.path.abspath(self.canary_path_input.text().strip())
            if not canary_executable:
                self.log(self.format_log("❗️ لم يتم تحديد مسار Canary في الإعدادات.", "red"))
                return

            self.log(self.format_log("🔴 محاولة إغلاق Chrome Canary فقط...", "blue"))
            found_any = False

            for proc in psutil.process_iter(['pid', 'name', 'exe']):
                try:
                    exe_path = proc.info['exe']
                    if exe_path and exe_path.lower() == canary_executable.lower():
                        proc.kill()
                        found_any = True
                        self.log(self.format_log(f"✅ تم إغلاق عملية Chrome Canary ذات PID={proc.pid}.", "green"))
                except (psutil.NoSuchProcess, psutil.AccessDenied):
                    pass

            if not found_any:
                self.log(self.format_log("ℹ️ لا توجد أي عملية لـ Chrome Canary قيد التشغيل حاليًا.", "grey"))
            else:
                self.log(self.format_log("🔴 انتهت محاولة إغلاق Chrome Canary.", "blue"))
        except Exception as e:
            self.log(self.format_log(f"❗️ حدث خطأ أثناء محاولة إغلاق Chrome Canary: {e}", "red"))

    def env_settings_tab(self):
        tab = QWidget()
        layout = QVBoxLayout()

        layout.addWidget(QLabel("🐍 مسار Python في البيئة الافتراضية:"))
        hl_python = QHBoxLayout()
        self.python_env_input = QLineEdit(os.getenv("PYTHON_ENV_PATH", "python").strip())
        hl_python.addWidget(self.python_env_input)
        layout.addLayout(hl_python)

        save_button = QPushButton("💾 حفظ مسار البيئة")
        save_button.clicked.connect(self.save_env_settings)
        layout.addWidget(save_button)

        tab.setLayout(layout)
        return tab

    def save_env_settings(self):
        path = self.python_env_input.text().strip()
        set_key(self.env_path, "PYTHON_ENV_PATH", path)
        self.log(self.format_log(f"✅ تم حفظ مسار البيئة: {path}", "green"))

    def start_main_script(self):
        self.clear_log_area()
        try:
            if not os.path.isfile(self.env_path):
                self.log(self.format_log(f"⚠️ تعذر العثور على ملف البيئة: {self.env_path}. قد يؤثر ذلك على الإعدادات.", "red"))
            else:
                load_dotenv(self.env_path, override=True)
                self.log(self.format_log("🗂️ تم إعادة قراءة ملف البيئة قبل تشغيل السكربتات.", "blue"))
        except Exception as e:
            self.log(self.format_log(f"⚠️ فشل في إعادة تحميل ملف البيئة: {e}", "red"))

        if self.restart_timer.isActive():
            self.restart_timer.stop()
            self.countdown_label.setText("")
            self.log(self.format_log("⏸️ تم إيقاف العد التنازلي لإعادة التشغيل السابقة.", "grey"))

        if self.script_thread and self.script_thread.isRunning():
            QMessageBox.warning(self, "🔔 تحذير", "🚫 يوجد تشغيل جارٍ بالفعل.")
            return

        try:
            start_index = int(self.start_script_selector.currentText())
        except ValueError:
            start_index = 1

        scripts_to_run = []
        for row in range(self.script_table.rowCount()):
            checkbox = self.script_table.cellWidget(row, 0)
            name_item = self.script_table.item(row, 1)
            path_item = self.script_table.item(row, 2)
            if checkbox and checkbox.isChecked() and name_item and path_item:
                sn = row + 1
                script_name = name_item.text().strip()
                script_path = path_item.text().strip()
                scripts_to_run.append((sn, script_name, script_path))

        scripts_filtered = [(sn, n, p) for (sn, n, p) in scripts_to_run if sn >= start_index]
        scripts_filtered.sort(key=lambda x: x[0])
        final_scripts = [(n, p) for (_, n, p) in scripts_filtered]

        if not final_scripts:
            self.log(self.format_log("❗️ لم يتم اختيار أي سكربت للتشغيل.", "red"))
            return

        delay_str = os.getenv("DELAY_BETWEEN_SCRIPTS", "5").strip()
        try:
            delay_value = float(delay_str)
        except ValueError:
            delay_value = 0

        python_path = os.getenv("PYTHON_ENV_PATH", "python").strip()

        self.script_thread = ScriptRunner(
            scripts=final_scripts,
            python_path=python_path,
            delay_between_scripts=delay_value,
            start_index=start_index
        )
        self.script_thread.log_signal.connect(self.log)
        self.script_thread.finished_signal.connect(self.on_finished)
        self.script_thread.progress_signal.connect(self.on_progress)
        self.script_thread.start()
        self.log(self.format_log("🚀 تم بدء تشغيل السكربتات المحددة...", "green"))

        self.operation_time = 0
        self.operation_time_label.setText("⏰ وقت العملية المستغرق: 00:00:00")
        self.operation_timer.start()

    def stop_execution(self):
        if self.script_thread and self.script_thread.isRunning():
            self.log(self.format_log("⏹️ جاري إيقاف التشغيل...", "orange"))
            self.script_thread.stop()

        for row_index, thread in list(self.single_script_threads.items()):
            if thread.isRunning():
                thread.stop()
            del self.single_script_threads[row_index]

        if self.restart_timer.isActive():
            self.restart_timer.stop()
            self.countdown_label.setText("")
            self.log(self.format_log("⏸️ تم إيقاف العد التنازلي لإعادة التشغيل.", "grey"))

        self.progress_bar.setValue(0)
        self.log(self.format_log("🔄 تم إعادة شريط التقدم إلى الصفر.", "grey"))

        self.operation_timer.stop()
        self.operation_time = 0
        self.operation_time_label.setText("⏰ وقت العملية المستغرق: 00:00:00")

    def on_finished(self, last_script_name):
        self.log(self.format_log(f"✅ انتهى الخيط الرئيس لتشغيل السكربتات. السكربت الأخير: {last_script_name}", "green"))
        self.progress_bar.setValue(100)

        self.operation_timer.stop()
        self.log(self.format_log(f"⏰ وقت العملية المستغرق: {self.format_time(self.operation_time)}", "blue"))

        if last_script_name == "Script9":
            self.log(
                self.format_log("🔄 السكربت الأخير هو Script9. سيتم إغلاق العمليات وبدء العد التنازلي لإعادة التشغيل.", "purple")
            )

            self.close_specified_processes()

            try:
                restart_delay_str = os.getenv("RESTART_DELAY_AFTER_COMPLETE", "30").strip()
                restart_delay = int(restart_delay_str)
                if restart_delay > 0 and not self.script_thread.stop_flag:
                    self.restart_remaining = restart_delay
                    self.update_countdown_label()
                    self.restart_timer.start()
                    self.log(self.format_log(
                        f"🔄 سيتم إعادة تشغيل السكربتات تلقائيًا بعد {self.format_time(self.restart_remaining)}.",
                        "purple")
                    )

                    self.operation_time = 0
                    self.operation_time_label.setText("⏰ وقت العملية المستغرق: 00:00:00")
            except ValueError:
                self.log(self.format_log("⚠️ قيمة إعادة التشغيل غير صحيحة.", "red"))
        else:
            self.log(self.format_log("✅ انتهت دورة تشغيل السكربتات دون الحاجة لإعادة التشغيل التلقائي.", "green"))

    def on_progress(self, value):
        self.progress_bar.setValue(value)

    def update_countdown_label(self):
        self.countdown_label.setText(f"⏳ إعادة التشغيل بعد: {self.format_time(self.restart_remaining)}")

    def update_countdown(self):
        if self.restart_remaining > 0:
            self.restart_remaining -= 1
            self.update_countdown_label()
        if self.restart_remaining <= 0:
            self.restart_timer.stop()
            self.countdown_label.setText("")
            self.log(self.format_log("🔄 بدء إعادة تشغيل السكربتات تلقائيًا.", "purple"))
            self.start_main_script()

    def update_operation_time(self):
        self.operation_time += 1
        self.operation_time_label.setText(f"⏰ وقت العملية المستغرق: {self.format_time(self.operation_time)}")

    def format_time(self, seconds):
        hrs = seconds // 3600
        mins = (seconds % 3600) // 60
        secs = seconds % 60
        return f"{int(hrs):02d}:{int(mins):02d}:{int(secs):02d}"

    def close_application(self):
        reply = QMessageBox.question(
            self, "🔒 تأكيد الإغلاق",
            "هل تريد إغلاق البرنامج؟",
            QMessageBox.Yes | QMessageBox.No,
            QMessageBox.No
        )
        if reply == QMessageBox.Yes:
            self.stop_execution()
            QApplication.instance().quit()

    def log(self, message):
        self.log_area.append(message)
        self.log_area.moveCursor(QTextCursor.End)

    def format_log(self, message, color="black"):
        return f'<span style="color:{color};">{message}</span>'

    def clear_log_area(self):
        self.log_area.clear()
        self.log(self.format_log("🧹 تم مسح شاشة الترمينال.", "grey"))

    def eventFilter(self, source, event):
        if source == self.log_area and event.type() == event.Wheel and event.modifiers() == Qt.ControlModifier:
            angle = event.angleDelta().y()
            if angle > 0:
                self.log_area.zoomIn()
            else:
                self.log_area.zoomOut()
            return True
        return super().eventFilter(source, event)

    def update_log_area_height(self, value):
        self.log_area.setFixedHeight(value)
        self.log(self.format_log(f"📏 تم تحديث ارتفاع شاشة الترمينال إلى {value}px.", "blue"))

    def close_specified_processes(self):
        close_processes_str = os.getenv("CLOSE_PROCESSES", "").strip()
        if not close_processes_str:
            self.log(self.format_log("ℹ️ لم يتم تحديد أي عمليات لإغلاقها في ملف البيئة (CLOSE_PROCESSES).", "grey"))
            return

        process_names = [proc.strip().lower() for proc in close_processes_str.split(",") if proc.strip()]
        if not process_names:
            self.log(self.format_log("ℹ️ لم يتم تحديد أي عمليات لإغلاقها في ملف البيئة (CLOSE_PROCESSES).", "grey"))
            return

        self.log(self.format_log(f"🔒 محاولة إغلاق العمليات المحددة: {', '.join(process_names)}", "blue"))
        closed_any = False

        for proc in psutil.process_iter(['pid', 'name']):
            try:
                proc_name = proc.info['name'].lower()
                if proc_name in process_names:
                    proc.kill()
                    closed_any = True
                    self.log(self.format_log(f"✅ تم إغلاق العملية: {proc_name} (PID={proc.pid}).", "green"))
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                pass

        if not closed_any:
            self.log(self.format_log("ℹ️ لم يتم العثور على أي من العمليات المحددة قيد التشغيل.", "grey"))
        else:
            self.log(self.format_log("🔒 انتهت محاولة إغلاق العمليات المحددة.", "blue"))

    def modify_env_file(self, key, value, backup=True):
        try:
            print(f"محاولة تعديل المفتاح: {key} بالقيمة: {value}")
            if backup:
                backup_dir = os.path.join(os.path.dirname(self.env_path), "backups")
                print(f"إنشاء مجلد النسخ الاحتياطية في: {backup_dir}")
                os.makedirs(backup_dir, exist_ok=True)
                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                backup_path = os.path.join(backup_dir, f".env_backup_{timestamp}")
                print(f"إنشاء نسخة احتياطية في: {backup_path}")
                shutil.copy2(self.env_path, backup_path)
                print(f"تم إنشاء نسخة احتياطية من الملف في: {backup_path}")

            set_key(self.env_path, key, value)
            print(f"تم تحديث المفتاح '{key}' بالقيمة '{value}' في ملف .env")

            changes_log_path = os.path.join(os.path.dirname(self.env_path), "env_changes.log")
            with open(changes_log_path, "a", encoding="utf-8") as log_file:
                log_file.write(f"{datetime.now()}: تم تعديل المفتاح '{key}' إلى '{value}'\n")
            print(f"تم تسجيل التغيير في ملف: {changes_log_path}")
        except Exception as e:
            print(f"❗️ حدث خطأ أثناء تعديل ملف البيئة: {e}")

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainApp()
    window.show()
    sys.exit(app.exec_()) حول هذا الكود الى ملف اتش تى ام ال  بنفس طريقة هذا الكود <!DOCTYPE html>
<html lang="ar" dir="rtl">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>YouTubeGen Pro - لوحة التحكم</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Tajawal:wght@400;500;700&display=swap" rel="stylesheet">
    <style>
        body {
            background-color: #f8f9fa;
            font-family: 'Tajawal', sans-serif;
        }
        h1, h2 {
            color: #0d6efd;
        }
        .form-container {
            background-color: #ffffff;
            padding: 20px;
            border-radius: 10px;
            box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
            margin-bottom: 20px;
        }
        .btn-primary {
            background-color: #0d6efd;
            border-color: #0d6efd;
        }
        .btn-primary:hover {
            background-color: #0b5ed7;
            border-color: #0b5ed7;
        }
        .log-area {
            background-color: #f4f4f4;
            font-family: monospace;
            font-size: 14px;
            padding: 10px;
            border-radius: 5px;
            border: 1px solid #ddd;
            height: 300px;
            overflow-y: auto;
        }
    </style>
</head>
<body>
    <div class="container mt-5">
        {% with messages = get_flashed_messages(with_categories=true) %}
            {% if messages %}
                {% for category, message in messages %}
                    <div class="alert alert-{{ category }}">
                        {{ message }}
                    </div>
                {% endfor %}
            {% endif %}
        {% endwith %}

        <h1 class="text-center mb-4">YouTubeGen Pro - لوحة التحكم</h1>

        <div class="form-container">
            <h2 class="mb-3">الإعدادات النصية والمرئية</h2>
            <form id="combinedSettingsForm" action="/update_settings" method="POST">
                <div class="mb-3">
                    <label for="topic" class="form-label">📝 موضوع الفيديو:</label>
                    <textarea class="form-control" id="topic" name="topic" rows="3" required>{{ env_data.get('TOPIC', '') }}</textarea>
                </div>
                <div class="mb-3">
                    <label for="word_count" class="form-label">🔢 عدد الكلمات:</label>
                    <input type="number" class="form-control" id="word_count" name="word_count" value="{{ env_data.get('WORD_COUNT', '6000') }}" required>
                </div>
                <div class="mb-3">
                    <label for="text_type" class="form-label">🖋️ نوع النص:</label>
                    <select class="form-select" id="text_type" name="text_type" required>
                        <option value="حكاية" {% if env_data.get('TEXT_TYPE') == 'حكاية' %}selected{% endif %}>حكاية</option>
                        <option value="مقال" {% if env_data.get('TEXT_TYPE') == 'مقال' %}selected{% endif %}>مقال</option>
                        <option value="وصف" {% if env_data.get('TEXT_TYPE') == 'وصف' %}selected{% endif %}>وصف</option>
                        <option value="قصة" {% if env_data.get('TEXT_TYPE') == 'قصة' %}selected{% endif %}>قصة</option>
                        <option value="أفكار" {% if env_data.get('TEXT_TYPE') == 'أفكار' %}selected{% endif %}>أفكار</option>
                        <option value="تحليل" {% if env_data.get('TEXT_TYPE') == 'تحليل' %}selected{% endif %}>تحليل</option>
                    </select>
                </div>
                <div class="mb-3">
                    <label for="language_type" class="form-label">🌐 لغة النص:</label>
                    <select class="form-select" id="language_type" name="language_type" required>
                        <option value="ar" {% if env_data.get('LANGUAGE_TYPE') == 'ar' %}selected{% endif %}>العربية</option>
                        <option value="en" {% if env_data.get('LANGUAGE_TYPE') == 'en' %}selected{% endif %}>الإنجليزية</option>
                        <option value="fr" {% if env_data.get('LANGUAGE_TYPE') == 'fr' %}selected{% endif %}>الفرنسية</option>
                    </select>
                </div>
                <div class="mb-3">
                    <label for="style_number" class="form-label">🎨 اختر الاستايل:</label>
                    <select class="form-select" id="style_number" name="style_number" required>
                        <!-- ... خيارات الاستايل -->
                    </select>
                </div>
                <div class="mb-3">
                    <label for="size_number" class="form-label">📏 اختر حجم الفيديو:</label>
                    <select class="form-select" id="size_number" name="size_number" required>
                        <!-- ... خيارات الحجم -->
                    </select>
                </div>
                <div class="mb-3">
                    <label for="voice_number" class="form-label">🔊 رقم الصوت:</label>
                    <input type="number" class="form-control" id="voice_number" name="voice_number" value="{{ env_data.get('VOICE_NUMBER', '1') }}" required>
                </div>
                <div class="mb-3">
                    <label for="speed" class="form-label">⚡️ سرعة الصوت:</label>
                    <input type="range" class="form-range" id="speed" name="speed" min="50" max="200" value="{{ env_data.get('SPEED', '90') }}">
                    <span id="speedValue">{{ (env_data.get('SPEED', '90') | float) }}</span>
                </div>
                <button type="submit" class="btn btn-primary w-100">💾 حفظ الإعدادات النصية والمرئية</button>
                <button type="button" class="btn btn-secondary w-100 mt-2" onclick="clearLog()">🧹 مسح سجل العمليات</button>
                <button type="button" class="btn btn-success w-100 mt-2" onclick="runAllScripts()">🚀 تشغيل جميع السكربتات</button>
            </form>
        </div>

        <div class="form-container">
            <h2 class="mb-3">التحكم بالسكربتات</h2>
            <table class="table table-bordered">
                <thead>
                    <tr>
                        <th>✅ تشغيل</th>
                        <th>📝 اسم السكربت</th>
                        <th>📁 مسار السكربت</th>
                    </tr>
                </thead>
                <tbody id="scriptTableBody">
                    {% set scripts = [
                        {"name": "1 TOPICE GENERATE TEXT.py"},
                        {"name": "2 Prompts.py"},
                        {"name": "3 Generate Images.py"},
                        {"name": "4 Generate Tashkeel.py"},
                        {"name": "5 Generate Audio.py"},
                        {"name": "6 Generate Video 1.py"},
                        {"name": "7 Generate Video Translate 2.py"},
                        {"name": "8 Generate Video Final 3.py"},
                        {"name": "9 UPLOAD VIDEO YOUTUBE.py"}
                    ] %}
                    {% for script in scripts %}
                    <tr>
                        <td>
                            <form action="{{ url_for('run_script', script_name=script.name) }}" method="POST">
                                <button type="submit" class="btn btn-primary">تشغيل</button>
                            </form>
                        </td>
                        <td>{{ script.name }}</td>
                        <td>D:/YoutubeGen Pro Online/Models/{{ script.name }}</td>
                    </tr>
                    {% endfor %}
                </tbody>
            </table>
        </div>

        <div class="form-container">
            <h2 class="mb-3">سجل العمليات</h2>
            <div class="log-area" id="logArea"></div>
        </div>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
    <script>
        document.getElementById('speed').addEventListener('input', function () {
            const speedValue = (this.value / 100).toFixed(2);
            document.getElementById('speedValue').textContent = speedValue;
        });

        function log(message, color = 'black') {
            const logArea = document.getElementById('logArea');
            const logEntry = document.createElement('div');
            logEntry.innerHTML = `<span style="color:${color};">${message}</span>`;
            logArea.appendChild(logEntry);
            logArea.scrollTop = logArea.scrollHeight;
        }

        function clearLog() {
            document.getElementById('logArea').innerHTML = '';
        }

        function runAllScripts() {
            // إجراء لبدء جميع السكربتات، قد تحتاج إلى إجراء POST إلى خادمك لتشغيلها
            log("تشغيل جميع السكربتات...", "green");
            // توجيه POST إلى endpoint المناسب لتشغيل جميع السكربتات
            fetch('/run_all_scripts', { method: 'POST' })
                .then(response => {
                    if (response.ok) {
                        log('تم تشغيل جميع السكربتات بنجاح!', "green");
                    } else {
                        log('فشل في تشغيل السكربتات.', "red");
                    }
                })
                .catch(err => log('حدث خطأ: ' + err, "red"));
        }
    </script>
</body>
</html> معا الحفاظ على التصميم الموجود فى كود اتش تى ام ال