gui.py

"""GUI 界面模块 —— Tkinter (v4 三标签页: 一键下载 / 批量检索 / 手动导入)."""

from __future__ import annotations

import os
import threading
import tkinter as tk
from tkinter import messagebox
from tkinter import scrolledtext
from tkinter import ttk

from config import OUTPUT_DIR
from crawler import (
    discover_article_urls,
    fetch_account_articles,
    fetch_article_content,
    fetch_from_url_list,
    set_progress_callback,
)
from exporter import export_all
from parser import detect_split_groups


class ArticleFetcherApp:
    def __init__(self) -> None:
        self.root = tk.Tk()
        self.root.title("微信公众号文章批量抓取工具 v4")
        self.root.geometry("800x640")
        self.root.resizable(True, True)
        self.fetching = False
        self._cancelled = False
        self._discovered_urls: list[dict[str, str]] = []
        self._build_ui()

    # ─── UI 构建 ───

    def _build_ui(self) -> None:
        main = ttk.Frame(self.root, padding=10)
        main.pack(fill=tk.BOTH, expand=True)

        ttk.Label(main, text="微信公众号文章批量抓取工具",
                  font=("微软雅黑", 15, "bold")).pack(anchor=tk.W, pady=(0, 6))

        notebook = ttk.Notebook(main)
        notebook.pack(fill=tk.BOTH, expand=True, pady=(0, 6))

        self._tab_oneclick(notebook)
        self._tab_discover(notebook)
        self._tab_manual(notebook)

        self._build_bottom_bar(main)

    def _tab_oneclick(self, nb: ttk.Notebook) -> None:
        f = ttk.Frame(nb, padding=10)
        nb.add(f, text="⚡ 一键下载")

        try:
            from collector_playwright import is_playwright_available
            pw_ok = is_playwright_available()
        except Exception:
            pw_ok = False

        status_text = (
            "状态: ✅ 增强模式 (Playwright 可用，支持全量文章自动收集)"
            if pw_ok
            else "状态: ⚠ 基础模式 (仅递归发现，建议用「批量检索链接」标签页)"
        )
        ttk.Label(f, text=status_text,
                  font=("微软雅黑", 9), foreground="green" if pw_ok else "darkorange").pack(anchor=tk.W, pady=(0, 8))

        ttk.Label(f, text="粘贴任意一篇公众号文章链接，自动收集 + 下载：",
                  font=("微软雅黑", 10)).pack(anchor=tk.W, pady=(0, 5))

        uf = ttk.Frame(f)
        uf.pack(fill=tk.X)
        self.t1_url = ttk.Entry(uf, font=("微软雅黑", 10))
        self.t1_url.pack(side=tk.LEFT, fill=tk.X, expand=True)
        ttk.Button(uf, text="粘贴", command=lambda: self._paste_to(self.t1_url)).pack(side=tk.RIGHT, padx=(5, 0))

        ttk.Label(f, text="公众号名称（可选，辅助搜狗搜索）：",
                  font=("微软雅黑", 9)).pack(anchor=tk.W, pady=(8, 0))
        self.t1_name = ttk.Entry(f, font=("微软雅黑", 10))
        self.t1_name.pack(fill=tk.X, pady=(2, 0))

        if not pw_ok:
            ttk.Label(f,
                text="💡 要启用全量文章自动收集，请运行：\n"
                     "   pip install playwright\n"
                     "   python -m playwright install chromium\n"
                     "   （安装后重启本程序即可自动收集数百篇文章）",
                font=("微软雅黑", 8), foreground="gray").pack(anchor=tk.W, pady=(15, 0))

    def _tab_discover(self, nb: ttk.Notebook) -> None:
        f = ttk.Frame(nb, padding=10)
        nb.add(f, text="🔗 批量检索链接")

        ttk.Label(f, text="第1步：输入文章链接 → 检索该公众号的全部文章链接",
                  font=("微软雅黑", 10, "bold")).pack(anchor=tk.W, pady=(0, 5))

        uf = ttk.Frame(f)
        uf.pack(fill=tk.X, pady=(0, 5))
        self.t2_url = ttk.Entry(uf, font=("微软雅黑", 10))
        self.t2_url.pack(side=tk.LEFT, fill=tk.X, expand=True)
        ttk.Button(uf, text="粘贴", command=lambda: self._paste_to(self.t2_url)).pack(side=tk.RIGHT, padx=(5, 0))

        bf = ttk.Frame(f)
        bf.pack(fill=tk.X, pady=(0, 10))
        self.t2_search_btn = ttk.Button(bf, text="🔍 开始检索链接", command=self._start_discover)
        self.t2_search_btn.pack(side=tk.LEFT)
        ttk.Label(bf, text="（仅收集标题和链接，不下载正文）",
                  font=("微软雅黑", 8), foreground="gray").pack(side=tk.LEFT, padx=(10, 0))

        ttk.Label(f, text="第2步：勾选要下载的文章 → 批量下载",
                  font=("微软雅黑", 10, "bold")).pack(anchor=tk.W, pady=(10, 5))

        list_frame = ttk.Frame(f)
        list_frame.pack(fill=tk.BOTH, expand=True)

        canvas = tk.Canvas(list_frame, height=200)
        scrollbar = ttk.Scrollbar(list_frame, orient=tk.VERTICAL, command=canvas.yview)
        self.t2_inner = ttk.Frame(canvas)

        self.t2_inner.bind("<Configure>", lambda e: canvas.configure(scrollregion=canvas.bbox("all")))
        canvas.create_window((0, 0), window=self.t2_inner, anchor=tk.NW)
        canvas.configure(yscrollcommand=scrollbar.set)

        canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

        self.t2_vars: list[tk.BooleanVar] = []
        self.t2_checkbuttons: list[ttk.Checkbutton] = []
        self._render_checklist()

        df = ttk.Frame(f)
        df.pack(fill=tk.X, pady=(8, 0))
        ttk.Button(df, text="全选", command=self._check_all).pack(side=tk.LEFT)
        ttk.Button(df, text="取消全选", command=self._check_none).pack(side=tk.LEFT, padx=(5, 0))
        self.t2_dl_btn = ttk.Button(df, text="⬇ 下载选中文章", command=self._start_batch_download)
        self.t2_dl_btn.pack(side=tk.RIGHT)

    def _tab_manual(self, nb: ttk.Notebook) -> None:
        f = ttk.Frame(nb, padding=10)
        nb.add(f, text="📋 手动粘贴链接")

        ttk.Label(f, text="将文章链接粘贴到下方（每行一个），批量抓取正文：",
                  font=("微软雅黑", 10)).pack(anchor=tk.W, pady=(0, 5))

        self.t3_text = scrolledtext.ScrolledText(f, height=18, font=("Consolas", 10))
        self.t3_text.pack(fill=tk.BOTH, expand=True)

        ttk.Label(f, text="获取链接: 微信打开文章 → 右上角 ··· → 复制链接 → 粘贴到此处（可多行批量）",
                  font=("微软雅黑", 8), foreground="gray").pack(anchor=tk.W, pady=(5, 0))

    def _build_bottom_bar(self, main: ttk.Frame) -> None:
        btn = ttk.Frame(main)
        btn.pack(fill=tk.X, pady=(0, 4))

        self.start_btn = ttk.Button(btn, text="▶ 开始抓取", command=self._start_main)
        self.start_btn.pack(side=tk.LEFT)
        self.open_btn = ttk.Button(btn, text="📂 打开输出目录", command=self._open_output)
        self.open_btn.pack(side=tk.LEFT, padx=(6, 0))
        self.stop_btn = ttk.Button(btn, text="⏹ 停止", command=self._stop, state=tk.DISABLED)
        self.stop_btn.pack(side=tk.LEFT, padx=(6, 0))
        ttk.Label(btn, text=f"输出: {OUTPUT_DIR}",
                  font=("微软雅黑", 8), foreground="gray").pack(side=tk.RIGHT)

        self.progress = ttk.Progressbar(main, mode="determinate")
        self.progress.pack(fill=tk.X)
        self.progress_label = ttk.Label(main, text="就绪", font=("微软雅黑", 9))
        self.progress_label.pack(anchor=tk.W, pady=(2, 1))

        self.log_area = scrolledtext.ScrolledText(
            main, height=13, font=("Consolas", 9), wrap=tk.WORD,
            bg="#1e1e1e", fg="#d4d4d4", insertbackground="white",
        )
        self.log_area.pack(fill=tk.BOTH, expand=True)

    # ─── 辅助 ───

    def _paste_to(self, entry: ttk.Entry) -> None:
        try:
            c = self.root.clipboard_get()
            if c:
                entry.delete(0, tk.END)
                entry.insert(0, c)
        except tk.TclError:
            pass

    def _log(self, msg: str) -> None:
        self.log_area.insert(tk.END, msg + "\n")
        self.log_area.see(tk.END)
        self.root.update_idletasks()

    def _progress(self, current: int, total: int, title: str) -> None:
        if self._cancelled:
            return
        pct = int(current / total * 100) if total > 0 else 0
        st = (title[:50] + "...") if len(title) > 50 else title

        def upd() -> None:
            self.progress.configure(value=pct)
            self.progress_label.configure(text=f"进度: {current}/{total}  —  {st}")
        self.root.after(0, upd)

    def _disable_ui(self) -> None:
        self.fetching = True
        self.start_btn.config(state=tk.DISABLED)
        self.stop_btn.config(state=tk.NORMAL)
        self.progress.configure(value=0)

    def _enable_ui(self) -> None:
        self.fetching = False
        self.start_btn.config(state=tk.NORMAL)
        self.stop_btn.config(state=tk.DISABLED)

    def _stop(self) -> None:
        self._cancelled = True
        self._log("⏹ 已请求停止...")

    def _open_output(self) -> None:
        os.makedirs(OUTPUT_DIR, exist_ok=True)
        os.startfile(OUTPUT_DIR)

    # ─── 清单渲染 ───

    def _render_checklist(self) -> None:
        for w in self.t2_inner.winfo_children():
            w.destroy()
        self.t2_vars.clear()
        self.t2_checkbuttons.clear()

        if not self._discovered_urls:
            ttk.Label(self.t2_inner, text="（暂无检索结果，请先点击「开始检索链接」）",
                      font=("微软雅黑", 9), foreground="gray").pack()
            return

        for item in self._discovered_urls:
            var = tk.BooleanVar(value=True)
            cb = ttk.Checkbutton(
                self.t2_inner,
                text=f"{item['title'][:60]}",
                variable=var,
            )
            cb.pack(anchor=tk.W)
            self.t2_vars.append(var)
            self.t2_checkbuttons.append(cb)

    def _check_all(self) -> None:
        for v in self.t2_vars:
            v.set(True)

    def _check_none(self) -> None:
        for v in self.t2_vars:
            v.set(False)

    # ─── Tab 1: 一键下载 ───

    def _start_main(self) -> None:
        if self.fetching:
            messagebox.showwarning("提示", "正在运行中")
            return
        notebook = self._find_notebook()
        if notebook is None:
            return
        idx = notebook.index(notebook.select())

        if idx == 0:
            url = self.t1_url.get().strip()
            if not url or "mp.weixin.qq.com" not in url:
                messagebox.showerror("错误", "请输入有效的公众号文章链接")
                return
            name = self.t1_name.get().strip()
            self._cancelled = False
            self._disable_ui()
            self.log_area.delete(1.0, tk.END)
            set_progress_callback(self._progress)
            threading.Thread(target=self._run_oneclick, args=(url, name), daemon=True).start()
        elif idx == 2:
            raw = self.t3_text.get(1.0, tk.END).strip()
            if not raw:
                messagebox.showerror("错误", "请粘贴文章 URL（每行一个）")
                return
            urls = [l.strip() for l in raw.split("\n") if l.strip() and "mp.weixin.qq.com" in l]
            if not urls:
                messagebox.showerror("错误", "未检测到有效链接")
                return
            self._cancelled = False
            self._disable_ui()
            self.log_area.delete(1.0, tk.END)
            set_progress_callback(self._progress)
            threading.Thread(target=self._run_manual, args=(urls,), daemon=True).start()
        else:
            messagebox.showinfo("提示", "请切换到「一键下载」或「手动粘贴链接」标签页后点击此按钮")

    def _run_oneclick(self, url: str, name: str) -> None:
        try:
            self._log("=" * 50)
            self._log("  一键下载模式")
            self._log("=" * 50)
            self._log(f"  链接: {url[:70]}...")
            articles = fetch_account_articles(url, name)
            if self._cancelled:
                return
            self._export_articles(articles)
        except Exception as e:
            self._log(f"错误: {e}")
            import traceback
            self._log(traceback.format_exc())
        finally:
            self.root.after(0, self._enable_ui)

    def _run_manual(self, urls: list[str]) -> None:
        try:
            self._log("=" * 50)
            self._log("  手动批量导入模式")
            self._log("=" * 50)
            self._log(f"  共 {len(urls)} 个链接")
            articles = fetch_from_url_list(urls)
            if self._cancelled:
                return
            self._export_articles(articles)
        except Exception as e:
            self._log(f"错误: {e}")
            import traceback
            self._log(traceback.format_exc())
        finally:
            self.root.after(0, self._enable_ui)

    # ─── Tab 2: 批量检索 ───

    def _start_discover(self) -> None:
        if self.fetching:
            messagebox.showwarning("提示", "正在运行中")
            return
        url = self.t2_url.get().strip()
        if not url or "mp.weixin.qq.com" not in url:
            messagebox.showerror("错误", "请输入有效的公众号文章链接")
            return
        self._cancelled = False
        self._disable_ui()
        self.t2_search_btn.config(state=tk.DISABLED)
        self.log_area.delete(1.0, tk.END)
        set_progress_callback(self._progress)
        threading.Thread(target=self._run_discover, args=(url,), daemon=True).start()

    def _run_discover(self, url: str) -> None:
        try:
            self._log("=" * 50)
            self._log("  批量检索链接模式")
            self._log("=" * 50)
            self._log(f"  种子链接: {url[:70]}...")
            self._log("  递归深度: 3 层")
            self._log("")

            self._discovered_urls = discover_article_urls(url, max_articles=50, depth=3)
            if self._cancelled:
                return

            self._log(f"检索完成！共发现 {len(self._discovered_urls)} 篇文章链接：")
            for i, art in enumerate(self._discovered_urls):
                self._log(f"  [{i+1}] {art['title'][:60]}")
            self._log("")
            self._log("请在列表中勾选要下载的文章，然后点击「下载选中文章」")
        except Exception as e:
            self._log(f"错误: {e}")
            import traceback
            self._log(traceback.format_exc())
        finally:
            self.root.after(0, self._finish_discover)

    def _finish_discover(self) -> None:
        self._enable_ui()
        self.t2_search_btn.config(state=tk.NORMAL)
        self._render_checklist()

    def _start_batch_download(self) -> None:
        if not self._discovered_urls:
            messagebox.showwarning("提示", "请先检索链接")
            return
        selected = []
        for i, var in enumerate(self.t2_vars):
            if var.get() and i < len(self._discovered_urls):
                selected.append(self._discovered_urls[i]["url"])
        if not selected:
            messagebox.showwarning("提示", "请至少勾选一篇文章")
            return

        self._cancelled = False
        self._disable_ui()
        self.log_area.delete(1.0, tk.END)
        set_progress_callback(self._progress)
        threading.Thread(target=self._run_batch_dl, args=(selected,), daemon=True).start()

    def _run_batch_dl(self, urls: list[str]) -> None:
        try:
            self._log("=" * 50)
            self._log("  批量下载选中文章")
            self._log("=" * 50)
            self._log(f"  共 {len(urls)} 篇")
            articles = fetch_from_url_list(urls)
            if self._cancelled:
                return
            self._export_articles(articles)
        except Exception as e:
            self._log(f"错误: {e}")
            import traceback
            self._log(traceback.format_exc())
        finally:
            self.root.after(0, self._enable_ui)

    # ─── 导出 ───

    def _export_articles(self, articles: list) -> None:
        if not articles:
            self._log("未抓取到任何文章。可尝试手动粘贴链接。")
            return
        self._log(f"抓取到 {len(articles)} 篇文章")
        self._log("检测连载/分篇文章...")
        groups = detect_split_groups(articles)
        sc = sum(1 for g in groups if len(g) > 1)
        self._log(f"  单篇: {len(groups) - sc}  |  连载: {sc} 组")
        self._log("生成 Word 文档...")
        saved = export_all(groups)
        self._log(f"已保存 {len(saved)} 个文档:")
        for p in saved:
            self._log(f"   {os.path.basename(p)}")
        self._log("")
        self._log("完成！点击「打开输出目录」查看。")

    # ─── 工具 ───

    def _find_notebook(self) -> ttk.Notebook | None:
        def _recurse(w):
            if isinstance(w, ttk.Notebook):
                return w
            for child in w.winfo_children():
                result = _recurse(child)
                if result:
                    return result
            return None
        return _recurse(self.root)

    def run(self) -> None:
        self.root.mainloop()


def main() -> None:
    app = ArticleFetcherApp()
    app.run()


if __name__ == "__main__":
    main()