main.py

import json
import sqlite3
import sys
from pathlib import Path
from core.logger import setup_logging, get_logger
from PyQt6.QtWidgets import (
    QApplication,
    QMainWindow,
    QWidget,
    QVBoxLayout,
    QHBoxLayout,
    QLabel,
    QMenuBar,
    QStatusBar,
    QStackedWidget,
    QFrame,
    QMessageBox,
)
from PyQt6.QtCore import Qt, pyqtSignal
from PyQt6.QtGui import QKeySequence, QShortcut

from core.db import init_db, save_session, update_session, get_session
from core.ai_client import has_api_key
from ui.components import load_fonts
from ui.components.sidebar import SidebarNav
from ui.tab_topic import TabTopic
from ui.tab_script import TabScript
from ui.tab_video import TabVideo
from ui.tab_seo import TabSeo
from ui.tab_history import TabHistory
from ui.tab_trending import TabTrending
from ui.tab_competitor import TabCompetitor
from ui.tab_batch import TabBatch
from ui.tab_analytics import TabAnalytics

THEME_PATH = Path(__file__).parent / "style" / "theme.qss"
THEME_LIGHT_PATH = Path(__file__).parent / "style" / "theme_light.qss"


class MainWindow(QMainWindow):
    provider_changed = pyqtSignal(str)

    def __init__(self):
        super().__init__()
        self.setWindowTitle("ContentForge — Riset & Produksi Konten")
        self.setMinimumSize(960, 640)
        self._app = QApplication.instance()
        self._init_ui()
        self.raise_()
        self.activateWindow()

    def _init_ui(self):
        self._create_menu_bar()
        self._create_central()
        self._create_status_bar()
        self._connect_signals()
        self._setup_shortcuts()
        self._update_provider_status()

    def _create_menu_bar(self):
        menu_bar = self.menuBar()
        file_menu = menu_bar.addMenu("&File")
        save_action = file_menu.addAction("&Save Session")
        save_action.setShortcut("Ctrl+S")
        save_action.triggered.connect(lambda: self.save_current_session())
        settings_action = file_menu.addAction("&Settings")
        settings_action.setShortcut("Ctrl+,")
        settings_action.triggered.connect(self._open_settings)
        file_menu.addSeparator()
        quit_action = file_menu.addAction("&Quit")
        quit_action.setShortcut("Ctrl+Q")
        quit_action.triggered.connect(self.close)

        view_menu = menu_bar.addMenu("&View")
        history_action = view_menu.addAction("&History")
        history_action.setShortcut("Ctrl+H")
        history_action.triggered.connect(lambda: self._switch_tab(4))

        trending_action = view_menu.addAction("&Trending")
        trending_action.setShortcut("Ctrl+T")
        trending_action.triggered.connect(lambda: self._switch_tab(5))

        competitor_action = view_menu.addAction("&Competitor")
        competitor_action.setShortcut("Ctrl+M")
        competitor_action.triggered.connect(lambda: self._switch_tab(6))

        batch_action = view_menu.addAction("&Batch Mode")
        batch_action.setShortcut("Ctrl+B")
        batch_action.triggered.connect(lambda: self._switch_tab(7))

        analytics_action = view_menu.addAction("&Analytics")
        analytics_action.setShortcut("Ctrl+5")
        analytics_action.triggered.connect(lambda: self._switch_tab(8))

    def _create_central(self):
        central = QWidget()
        self.setCentralWidget(central)
        layout = QHBoxLayout(central)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(0)

        # ── Left: Sidebar ──
        self.sidebar = SidebarNav()
        layout.addWidget(self.sidebar)

        # ── Right: Content area ──
        content_container = QWidget()
        content_layout = QVBoxLayout(content_container)
        content_layout.setContentsMargins(16, 16, 16, 16)
        content_layout.setSpacing(12)

        # ── QStackedWidget ──
        self.stack = QStackedWidget()

        self.tab_topic = TabTopic()
        self.stack.addWidget(self.tab_topic)

        self.tab_script = TabScript()
        self.stack.addWidget(self.tab_script)

        self.tab_video = TabVideo()
        self.stack.addWidget(self.tab_video)

        self.tab_seo = TabSeo()
        self.stack.addWidget(self.tab_seo)

        self.tab_history = TabHistory()
        self.stack.addWidget(self.tab_history)

        self.tab_trending = TabTrending()
        self.stack.addWidget(self.tab_trending)

        self.tab_competitor = TabCompetitor()
        self.stack.addWidget(self.tab_competitor)

        self.tab_batch = TabBatch()
        self.stack.addWidget(self.tab_batch)

        self.tab_analytics = TabAnalytics()
        self.stack.addWidget(self.tab_analytics)

        content_layout.addWidget(self.stack, 1)
        layout.addWidget(content_container, 1)

    def _switch_tab(self, index):
        self.sidebar.set_active_step(index)
        self.stack.setCurrentIndex(index)
        self.sidebar.set_step_status(index, 'in_progress')
        self._on_tab_changed(index)

    def _create_status_bar(self):
        self._status_bar = QStatusBar()
        self.setStatusBar(self._status_bar)

        self._provider_dot = QLabel()
        self._provider_dot.setFixedSize(6, 6)
        self._provider_dot.setStyleSheet("background: #8B95A1; border-radius: 3px; margin-right: 4px;")
        self._status_bar.addPermanentWidget(self._provider_dot)

        self._provider_status = QLabel("Provider: -")
        self._provider_status.setStyleSheet("color: #C6CCD6; font-size: 11px; padding-right: 8px;")
        self._status_bar.addPermanentWidget(self._provider_status)

        self._api_status = QLabel("")
        self._api_status.setStyleSheet("font-size: 11px; padding-right: 8px;")
        self._status_bar.addPermanentWidget(self._api_status)

        self._status_bar.showMessage("Ready")

    def _update_provider_status(self):
        if has_api_key():
            self._api_status.setText("● API Key")
            self._api_status.setStyleSheet("color: #4FBF8B; font-size: 11px; padding-right: 8px;")
        else:
            self._api_status.setText("● No API Key")
            self._api_status.setStyleSheet("color: #E74C3C; font-size: 11px; padding-right: 8px;")

    def _connect_signals(self):
        self.tab_topic.topic_selected.connect(self._on_topic_selected)
        self.provider_changed.connect(self._on_provider_changed)
        self.tab_history.session_loaded.connect(self._on_session_loaded)
        self.sidebar.workflow_step_clicked.connect(self._on_step_clicked)
        self.sidebar.tool_clicked.connect(self._on_tool_clicked)
        self.sidebar.set_active_step(0)
        self.stack.setCurrentIndex(0)
        self._current_session_id = None
        self._generate_all_mode = False

    def _setup_shortcuts(self):
        """Setup keyboard shortcuts"""
        # Navigation shortcuts
        QShortcut(QKeySequence("Ctrl+1"), self, lambda: self._switch_tab(0))
        QShortcut(QKeySequence("Ctrl+2"), self, lambda: self._switch_tab(1))
        QShortcut(QKeySequence("Ctrl+3"), self, lambda: self._switch_tab(2))
        QShortcut(QKeySequence("Ctrl+4"), self, lambda: self._switch_tab(3))
        QShortcut(QKeySequence("Ctrl+5"), self, lambda: self._switch_tab(8))
        
        # Action shortcuts
        QShortcut(QKeySequence("Ctrl+Shift+C"), self, self._copy_all_for_youtube)
        QShortcut(QKeySequence("Ctrl+G"), self, self._run_pipeline)
        QShortcut(QKeySequence("Ctrl+Shift+G"), self, self._generate_all)

    def _copy_all_for_youtube(self):
        """Trigger copy all for YouTube on the SEO tab"""
        if hasattr(self, 'tab_seo') and hasattr(self.tab_seo, '_copy_all_for_youtube'):
            self.tab_seo._copy_all_for_youtube()

    def _on_topic_selected(self, topic):
        self.tab_script.set_topic(topic)
        self.sidebar.set_step_status(0, 'completed')
        self.sidebar.set_step_status(1, 'in_progress')
        self.sidebar.set_step_status(2, 'empty')
        self.sidebar.set_step_status(3, 'empty')
        self._switch_tab(1)

    def _on_step_clicked(self, step: int):
        """Handle sidebar workflow step click - switch to that tab"""
        self.stack.setCurrentIndex(step)
        self.sidebar.set_active_step(step)
        self._on_tab_changed(step)

    def _on_tool_clicked(self, tool_name: str):
        """Handle sidebar tool click"""
        if tool_name == "generate":
            self._run_pipeline()
        elif tool_name == "generate_all":
            self._generate_all()
        elif tool_name == "history":
            self._switch_tab(4)
        elif tool_name == "analytics":
            self._switch_tab(8)
        elif tool_name == "settings":
            self._open_settings()

    def _run_pipeline(self):
        """Run the content generation pipeline - user must select topic first"""
        if not self.tab_script._topic_data:
            QMessageBox.warning(self, "Peringatan", "Pilih topik terlebih dahulu di tab Topik!")
            return
        
        self._reset_pipeline_statuses()
        
        try:
            # Step 1: Topic already selected
            self.sidebar.set_step_status(0, 'completed')
            
            # Step 2: Generate Script
            self.sidebar.set_step_status(1, 'in_progress')
            self._switch_tab(1)
            self.tab_script._on_generate()
            
        except Exception as e:
            current_step = self.stack.currentIndex()
            self.sidebar.set_step_status(current_step, 'failed')
            self.statusBar().showMessage(f"Pipeline failed: {str(e)}")

    def _reset_pipeline_statuses(self):
        """Reset all pipeline step statuses to empty"""
        for i in range(4):
            self.sidebar.set_step_status(i, 'empty')

    def _generate_all(self):
        """Generate Script + SEO + Timeline in sequence"""
        if self._generate_all_mode:
            QMessageBox.warning(self, "Peringatan", "Generate All sedang berjalan!")
            return

        if not self.tab_script._topic_data:
            QMessageBox.warning(self, "Peringatan", "Pilih topik terlebih dahulu!")
            return

        self._generate_all_mode = True
        self._generate_all_step = 1
        self._reset_pipeline_statuses()

        self.sidebar.set_step_status(0, 'completed')
        self.sidebar.set_step_status(1, 'in_progress')
        self._switch_tab(1)
        self.tab_script._on_generate()

        if self.tab_script._worker:
            self.tab_script._worker.finished.connect(self._on_generate_all_script_done)
            self.tab_script._worker.error.connect(self._on_generate_all_error)
        else:
            self._generate_all_mode = False

    def _on_generate_all_script_done(self, script, provider):
        if not self._generate_all_mode:
            return

        self.sidebar.set_step_status(1, 'completed')
        self.sidebar.set_step_status(2, 'in_progress')
        self._switch_tab(2)
        self._generate_all_step = 2

        video_mode = self.tab_script._topic_data.get("video_mode", "shorts")
        self.tab_video.set_script_text(script, video_mode)

        # Try to generate TTS first
        voice_id = self.tab_script.tts_voice_combo.currentData() if hasattr(self.tab_script, 'tts_voice_combo') else None
        if voice_id and script.strip():
            self.tab_script._generate_tts()
            
            # Check if TTS worker was created
            if hasattr(self.tab_script, '_tts_worker') and self.tab_script._tts_worker:
                self.tab_script._tts_worker.finished.connect(self._on_generate_all_tts_done)
                self.tab_script._tts_worker.error.connect(self._on_generate_all_tts_error)
                return
        
        # If TTS not available, proceed with keywords and timeline
        self._proceed_with_keywords_timeline()

    def _on_generate_all_tts_error(self, msg):
        """Handle TTS error in Generate All mode - continue anyway"""
        if not self._generate_all_mode:
            return
        # Continue with keywords and timeline even if TTS fails
        self._proceed_with_keywords_timeline()

    def _proceed_with_keywords_timeline(self):
        """Proceed with keywords and timeline generation"""
        self.tab_video._auto_kw()
        self.tab_video._gen_timeline()
        
        if self.tab_video._tl_worker:
            self.tab_video._tl_worker.done.connect(self._on_generate_all_timeline_done)
            self.tab_video._tl_worker.err.connect(self._on_generate_all_error)

    def _on_generate_all_tts_done(self, path):
        """Handle TTS completion in Generate All mode"""
        if not self._generate_all_mode:
            return
        
        # Pass audio path to video tab
        if path:
            self.tab_video.set_audio_path(path)
        
        # Now generate keywords and timeline
        self.tab_video._auto_kw()
        self.tab_video._gen_timeline()
        
        if self.tab_video._tl_worker:
            self.tab_video._tl_worker.done.connect(self._on_generate_all_timeline_done)
            self.tab_video._tl_worker.err.connect(self._on_generate_all_error)

    def _on_generate_all_timeline_done(self, timeline, provider):
        if not self._generate_all_mode:
            return

        self.sidebar.set_step_status(2, 'completed')
        self.sidebar.set_step_status(3, 'in_progress')
        self._switch_tab(3)
        self._generate_all_step = 3

        topic = self.tab_script._topic_data
        script = self.tab_script.script_edit.toPlainText()
        self.tab_seo.set_data(topic, script)
        self.tab_seo.set_timeline(timeline)

        self.tab_seo._gen()

        if self.tab_seo._worker:
            self.tab_seo._worker.done.connect(self._on_generate_all_seo_done)
            self.tab_seo._worker.err.connect(self._on_generate_all_error)

    def _on_generate_all_seo_done(self, result, provider):
        if not self._generate_all_mode:
            return

        self.sidebar.set_step_status(3, 'completed')
        self._generate_all_mode = False
        self.statusBar().showMessage("Generate All selesai!")

    def _on_generate_all_error(self, msg):
        if not self._generate_all_mode:
            return

        self.sidebar.set_step_status(self._generate_all_step, 'failed')
        self._generate_all_mode = False
        self.statusBar().showMessage(f"Generate All gagal: {msg}")

    def _on_tab_changed(self, index):
        if index == 2:
            if not self.tab_script._topic_data:
                return
            script_text = self.tab_script.script_edit.toPlainText()
            video_mode = self.tab_script._topic_data.get("video_mode", "shorts")
            self.tab_video.set_script_text(script_text, video_mode)
            if script_text.strip() and not self.tab_video.keyword_input.text().strip():
                self.tab_video._auto_generate_keywords()
        elif index == 3:
            if not self.tab_script._topic_data:
                return
            script_text = self.tab_script.script_edit.toPlainText()
            topic = self.tab_script._topic_data
            self.tab_seo.set_data(topic, script_text)
            timeline = getattr(self.tab_video, "_timeline_data", [])
            self.tab_seo.set_timeline(timeline)
        elif index == 6:
            topic = self.tab_script._topic_data
            if topic and topic.get("title"):
                self.tab_competitor.set_from_topic(topic)

    def _on_session_loaded(self, session):
        topic_data = {}
        if session.get("topic_id"):
            from core.db import get_recent_topics
            topics = get_recent_topics(365)
            topic_data = next((t for t in topics if t["id"] == session["topic_id"]), {})

        if topic_data:
            self.tab_script.set_topic(topic_data)

        if session.get("script_id"):
            from core.db import get_connection
            conn = get_connection()
            try:
                conn.row_factory = sqlite3.Row
                cursor = conn.cursor()
                cursor.execute("SELECT content FROM scripts WHERE id = ?", (session["script_id"],))
                row = cursor.fetchone()
                if row:
                    self.tab_script.script_edit.setPlainText(dict(row).get("content", ""))
            finally:
                conn.close()

        self._current_session_id = session["id"]
        self._reset_pipeline_statuses()
        self._switch_tab(0)
        self.tab_history.refresh()

        if session.get("seo_json"):
            try:
                seo_data = json.loads(session["seo_json"])
                if seo_data:
                    self.tab_seo.set_seo_data(seo_data)
            except (json.JSONDecodeError, TypeError):
                pass

        if session.get("timeline_json"):
            try:
                timeline_data = json.loads(session["timeline_json"])
                if timeline_data:
                    self.tab_video.set_timeline_data(timeline_data)
            except (json.JSONDecodeError, TypeError):
                pass

        if session.get("keywords_json"):
            try:
                keywords_data = json.loads(session["keywords_json"])
                if keywords_data:
                    self.tab_video.set_keywords_data(keywords_data)
            except (json.JSONDecodeError, TypeError):
                pass

        self.statusBar().showMessage(f"Session loaded: {session.get('name', '') or '#' + str(session['id'])}")

    def save_current_session(self, name: str = ""):
        topic = self.tab_script._topic_data
        script = self.tab_script.script_edit.toPlainText()
        topic_id = topic.get("id") if topic else None

        from core.db import get_connection
        script_id = None
        if topic_id and script:
            conn = get_connection()
            try:
                cursor = conn.cursor()
                cursor.execute("SELECT id FROM scripts WHERE topic_id = ? ORDER BY id DESC LIMIT 1", (topic_id,))
                row = cursor.fetchone()
                if row:
                    script_id = row[0]
            finally:
                conn.close()

        seo_json = json.dumps(self.tab_seo.get_seo_data()) if hasattr(self.tab_seo, 'get_seo_data') else "{}"
        timeline_json = json.dumps(self.tab_video.get_timeline_data()) if hasattr(self.tab_video, 'get_timeline_data') else "[]"
        keywords_json = json.dumps(self.tab_video.get_keywords_data()) if hasattr(self.tab_video, 'get_keywords_data') else "{}"

        session_data = {
            "name": name or (topic.get("title", "")[:30] if topic else ""),
            "topic_id": topic_id,
            "script_id": script_id,
            "seo_json": seo_json,
            "timeline_json": timeline_json,
            "keywords_json": keywords_json,
        }

        if self._current_session_id:
            update_session(self._current_session_id, session_data)
        else:
            self._current_session_id = save_session(session_data)

        self.tab_history.refresh()
        self.statusBar().showMessage("Session saved!")
        return self._current_session_id

    def _on_provider_changed(self, provider):
        self._provider_status.setText(f"Provider: {provider}")
        if "OpenRouter" in provider:
            self._provider_dot.setStyleSheet("background: #4FBF8B; border-radius: 3px; margin-right: 4px;")
        elif "Groq" in provider:
            self._provider_dot.setStyleSheet("background: #F5A623; border-radius: 3px; margin-right: 4px;")
        else:
            self._provider_dot.setStyleSheet("background: #8B95A1; border-radius: 3px; margin-right: 4px;")

    def _open_settings(self):
        from ui.settings_dialog import SettingsDialog
        dialog = SettingsDialog(self)
        if dialog.exec():
            self._update_provider_status()
            self._apply_theme()

    def _apply_theme(self):
        from core.secure_store import secure_get
        theme = secure_get("theme") or "dark"
        if theme == "light" and THEME_LIGHT_PATH.exists():
            self._app.setStyleSheet(THEME_LIGHT_PATH.read_text(encoding="utf-8"))
        else:
            self._app.setStyleSheet(THEME_PATH.read_text(encoding="utf-8"))

    def notify_provider(self, provider):
        if provider and provider != "N/A":
            self.provider_changed.emit(provider)


def main():
    setup_logging()
    logger = get_logger("main")
    logger.info("ContentForge starting...")
    init_db()
    try:
        from core.secure_store import migrate_keys_to_keyring
        migrated = migrate_keys_to_keyring()
        if migrated:
            print(f"Migrated {migrated} API keys to OS credential vault.")
    except Exception as e:
        print(f"Keyring migration skipped: {e}")
    app = QApplication(sys.argv)
    app.setStyle("Fusion")
    load_fonts()
    try:
        from core.secure_store import secure_get
        theme = secure_get("theme") or "dark"
        if theme == "light" and THEME_LIGHT_PATH.exists():
            app.setStyleSheet(THEME_LIGHT_PATH.read_text(encoding="utf-8"))
        elif THEME_PATH.exists():
            app.setStyleSheet(THEME_PATH.read_text(encoding="utf-8"))
    except Exception as e:
        print(f"Theme loading skipped: {e}")
    window = MainWindow()
    screen = app.primaryScreen()
    if screen:
        geo = screen.availableGeometry()
        window.resize(min(1200, geo.width() - 100), min(800, geo.height() - 100))
        window.move(geo.center() - window.rect().center())
    window.show()
    window.raise_()
    window.activateWindow()
    sys.exit(app.exec())


if __name__ == "__main__":
    main()