chahuadev_hub/main.py

import customtkinter as ctk
import threading
import urllib.parse
import requests
import os
import webbrowser

# ── CONFIG ──────────────────────────────────────────────────────────────────
HF_AUTHOR      = "chahuadev"
HF_REPO        = "chahuadev/chahuadev-framework-binaries"
HF_API_URL     = f"https://huggingface.co/api/datasets/{HF_REPO}/tree/main"
HF_COMMITS_URL = f"https://huggingface.co/api/datasets/{HF_REPO}/commits/main"
HF_CDN_BASE    = f"https://huggingface.co/datasets/{HF_REPO}/resolve/main"
DOWNLOAD_DIR   = os.path.join(os.path.expanduser("~"), "Downloads", "ChahuadevHub")

# ── HF Explorer API ──────────────────────────────────────────────────────────
HF_DATASETS_API = f"https://huggingface.co/api/datasets?author={HF_AUTHOR}&full=true"
HF_MODELS_API   = f"https://huggingface.co/api/models?author={HF_AUTHOR}&full=true"
HF_SPACES_API   = f"https://huggingface.co/api/spaces?author={HF_AUTHOR}&full=true"

REPO_TYPE_META = {
    "dataset": {"icon": "🗄️",  "color": "#8b5cf6", "label": "Dataset"},
    "model":   {"icon": "🤖",  "color": "#3b82f6", "label": "Model"},
    "space":   {"icon": "🚀",  "color": "#10b981", "label": "Space"},
}

# ── SKIP non-app files ───────────────────────────────────────────────────────
SKIP_FILES = {".gitattributes", "README.md", "chahuadev-framework-binaries.png",
              "emoji-cleaner-app.png"}

# ── APP METADATA ─────────────────────────────────────────────────────────────
APP_META = {
    "Chahuadev Framework": {
        "icon": "⚙️",
        "desc": "Full-stack development framework by Chahuadev",
    },
    "Emoji Cleaner": {
        "icon": "🌐",
        "desc": "Strip & sanitize emoji from any file type",
    },
    "Junk Sweeper": {
        "icon": "🧹",
        "desc": "Detect and remove junk/temp files automatically",
    },
}

# ── ENTERPRISE PALETTE ────────────────────────────────────────────────────────
ctk.set_appearance_mode("dark")
ctk.set_default_color_theme("blue")

BG_BASE     = "#09090f"
SIDEBAR_BG  = "#0f172a"   # slate-900
SURFACE     = "#1e293b"   # slate-800
CARD_BG     = "#1e293b"
HEADER_BG   = "#0f172a"
BORDER      = "#334155"   # slate-700
MUTED       = "#64748b"   # slate-500
TEXT        = "#f1f5f9"   # slate-100
TEXT_DIM    = "#94a3b8"   # slate-400
ACCENT      = "#3b82f6"   # blue-500
ACCENT_DARK = "#1d4ed8"   # blue-700
SUCCESS     = "#10b981"
DANGER      = "#ef4444"
WIN_COLOR   = "#3b82f6"
LINUX_COLOR = "#f59e0b"   # amber-500


def format_size(n):
    for unit in ("B", "KB", "MB", "GB"):
        if n < 1024:
            return f"{n:.1f} {unit}"
        n /= 1024
    return f"{n:.1f} TB"


def guess_app_name(path):
    name = path.replace("-win-ia32.exe", "").replace("-win-x64.exe", "")
    name = name.replace("-1.0.0.AppImage", "").replace(".AppImage", "").replace(".exe", "")
    name = name.replace("-", " ").strip()
    return name


def guess_platform(path):
    p = path.lower()
    if "ia32" in p:
        return "Windows  32-bit", WIN_COLOR
    if "x64" in p or ".exe" in p:
        return "Windows  64-bit", WIN_COLOR
    if ".appimage" in p:
        return "Linux  AppImage", LINUX_COLOR
    return "Unknown", MUTED


# ════════════════════════════════════════════════════════════════════════════
class StatCard(ctk.CTkFrame):
    """Summary stat card shown at top of dashboard."""

    def __init__(self, master, label: str, value: str, accent: str, icon: str):
        super().__init__(master, fg_color=SURFACE, corner_radius=10,
                         border_width=1, border_color=BORDER)
        self.columnconfigure(0, weight=1)
        ctk.CTkLabel(self, text=icon, font=ctk.CTkFont(size=20)).grid(
            row=0, column=0, padx=16, pady=(14, 2), sticky="w"
        )
        self._val_lbl = ctk.CTkLabel(
            self, text=value,
            font=ctk.CTkFont(size=28, weight="bold"),
            text_color=accent, anchor="w"
        )
        self._val_lbl.grid(row=1, column=0, padx=16, pady=0, sticky="w")
        ctk.CTkLabel(
            self, text=label, font=ctk.CTkFont(size=11),
            text_color=TEXT_DIM, anchor="w"
        ).grid(row=2, column=0, padx=16, pady=(0, 14), sticky="w")

    def update_value(self, value: str):
        self._val_lbl.configure(text=value)


# ════════════════════════════════════════════════════════════════════════════
class SkeletonCard(ctk.CTkFrame):
    """Animated placeholder shown while file list is loading."""

    def __init__(self, master):
        super().__init__(master, fg_color=CARD_BG, corner_radius=10,
                         border_width=1, border_color=BORDER, height=80)
        self.grid_propagate(False)
        self.columnconfigure(1, weight=1)
        self._step   = 0
        self._colors = [BORDER, SURFACE, BORDER]

        self._icon = ctk.CTkFrame(self, width=36, height=36, corner_radius=18,
                                   fg_color=BORDER)
        self._icon.grid(row=0, column=0, rowspan=2, padx=16, pady=16)
        self._icon.grid_propagate(False)

        self._title = ctk.CTkFrame(self, height=14, corner_radius=4, fg_color=BORDER)
        self._title.grid(row=0, column=1, padx=6, pady=(18, 4), sticky="ew")
        self._title.grid_propagate(False)

        self._sub = ctk.CTkFrame(self, height=10, corner_radius=4, fg_color=SURFACE)
        self._sub.grid(row=1, column=1, padx=6, pady=(0, 18), sticky="ew")
        self._sub.grid_propagate(False)

        self.columnconfigure(2, weight=0, minsize=140)
        self._btn_ph = ctk.CTkFrame(self, width=120, height=34, corner_radius=6,
                                     fg_color=BORDER)
        self._btn_ph.grid(row=0, column=3, rowspan=2, padx=16, pady=16)
        self._btn_ph.grid_propagate(False)

        self._animate()

    def _animate(self):
        if not self.winfo_exists():
            return
        self._step = (self._step + 1) % len(self._colors)
        self._title.configure(fg_color=self._colors[self._step])
        self._sub.configure(fg_color=self._colors[(self._step + 1) % len(self._colors)])
        self.after(500, self._animate)


# ════════════════════════════════════════════════════════════════════════════
class ChangelogEntry(ctk.CTkFrame):
    """One commit entry in the Changelog panel."""

    def __init__(self, master, commit: dict):
        super().__init__(master, fg_color=SURFACE, corner_radius=8,
                         border_width=1, border_color=BORDER)
        self.columnconfigure(0, weight=1)

        title  = commit.get("title") or commit.get("message", "—")
        sha    = (commit.get("id") or "")[:7]
        date   = (commit.get("date") or "")[:10]
        author = commit.get("authors") or [{}]
        author_name = author[0].get("name", "—") if author else "—"

        ctk.CTkLabel(self, text=title,
                     font=ctk.CTkFont(size=13, weight="bold"),
                     text_color=TEXT, anchor="w", wraplength=560).grid(
            row=0, column=0, padx=14, pady=(12, 2), sticky="w"
        )
        ctk.CTkLabel(self, text=f"#{sha}  ·  {author_name}  ·  {date}",
                     font=ctk.CTkFont(size=10),
                     text_color=TEXT_DIM, anchor="w").grid(
            row=1, column=0, padx=14, pady=(0, 12), sticky="w"
        )


# ════════════════════════════════════════════════════════════════════════════
class RepoCard(ctk.CTkFrame):
    """Clickable repo card in Explorer panel."""

    def __init__(self, master, repo: dict, repo_type: str, on_select):
        meta = REPO_TYPE_META.get(repo_type, {"icon": "📦", "color": ACCENT, "label": repo_type})
        self._repo      = repo
        self._repo_type = repo_type
        self._on_select = on_select
        super().__init__(master, fg_color=SURFACE, corner_radius=8,
                         border_width=1, border_color=BORDER, cursor="hand2")
        self.columnconfigure(1, weight=1)

        ctk.CTkLabel(self, text=meta["icon"], font=ctk.CTkFont(size=18)).grid(
            row=0, column=0, rowspan=2, padx=(12, 6), pady=10
        )

        repo_id  = repo.get("id") or repo.get("modelId", "")
        short_id = repo_id.split("/")[-1] if "/" in repo_id else repo_id
        last_mod = (repo.get("lastModified") or repo.get("updatedAt") or "")[:10]
        downloads = repo.get("downloads") or repo.get("downloadsAllTime") or ""
        private  = "🔒" if repo.get("private") else ""

        self._name_lbl = ctk.CTkLabel(
            self, text=short_id,
            font=ctk.CTkFont(size=12, weight="bold"),
            text_color=TEXT, anchor="w"
        )
        self._name_lbl.grid(row=0, column=1, padx=4, pady=(10, 1), sticky="w")

        info_parts = [meta["label"]]
        if downloads:
            info_parts.append(f"↓{downloads}")
        if last_mod:
            info_parts.append(last_mod)
        if private:
            info_parts.append(private)
        ctk.CTkLabel(
            self, text="  ·  ".join(info_parts),
            font=ctk.CTkFont(size=10), text_color=TEXT_DIM, anchor="w"
        ).grid(row=1, column=1, padx=4, pady=(0, 10), sticky="w")

        ctk.CTkLabel(
            self, text=meta["label"],
            fg_color=meta["color"], corner_radius=4,
            font=ctk.CTkFont(size=9, weight="bold"), padx=6, pady=1,
            text_color="white"
        ).grid(row=0, column=2, padx=8, pady=(10, 0), sticky="e")

        for w in (self, self._name_lbl):
            w.bind("<Button-1>", lambda e: self._on_select(self._repo, self._repo_type))

    def set_active(self, active: bool):
        self.configure(
            fg_color="#1e3a5f" if active else SURFACE,
            border_color=ACCENT if active else BORDER
        )


# ════════════════════════════════════════════════════════════════════════════
class AppCard(ctk.CTkFrame):
    """Single file download card."""

    def __init__(self, master, file_info: dict, download_dir: str, status_cb):
        super().__init__(master, fg_color=CARD_BG, corner_radius=10,
                         border_width=1, border_color=BORDER)

        self.file_info    = file_info
        self.download_dir = download_dir
        self.status_cb    = status_cb
        self._thread      = None

        path     = file_info["path"]
        size     = file_info.get("size", 0)
        app_name = guess_app_name(path)
        meta     = APP_META.get(app_name, {"icon": "📦", "desc": path})
        plat, plat_color = guess_platform(path)

        self.columnconfigure(1, weight=1)

        # Icon
        ctk.CTkLabel(self, text=meta["icon"], font=ctk.CTkFont(size=32)).grid(
            row=0, column=0, rowspan=2, padx=(16, 10), pady=16
        )

        # App name
        ctk.CTkLabel(self, text=app_name,
                     font=ctk.CTkFont(size=15, weight="bold"),
                     text_color=TEXT, anchor="w").grid(
            row=0, column=1, sticky="sw", padx=4, pady=(14, 0)
        )

        # Description + size
        ctk.CTkLabel(self, text=f"{meta['desc']}   •   {format_size(size)}",
                     font=ctk.CTkFont(size=11),
                     text_color=TEXT_DIM, anchor="w").grid(
            row=1, column=1, sticky="nw", padx=4, pady=(0, 14)
        )

        # Platform badge
        ctk.CTkLabel(self, text=plat, fg_color=plat_color,
                     corner_radius=6, font=ctk.CTkFont(size=10, weight="bold"),
                     padx=8, pady=2).grid(
            row=0, column=2, padx=8, pady=(14, 0), sticky="e"
        )

        # Filename label (small)
        ctk.CTkLabel(self, text=path, font=ctk.CTkFont(size=10),
                     text_color=MUTED, anchor="e").grid(
            row=1, column=2, padx=8, pady=(0, 14), sticky="e"
        )

        # Download button
        self.btn = ctk.CTkButton(self, text="⬇  Download", width=130,
                                  fg_color=ACCENT, hover_color=ACCENT_DARK,
                                  command=self._start_download)
        self.btn.grid(row=0, column=3, rowspan=2, padx=16, pady=16)

        # Progress bar (hidden initially)
        self.pbar = ctk.CTkProgressBar(self, width=130,
                                        progress_color=ACCENT, fg_color=BORDER)
        self.pbar.set(0)

        # Percent label
        self.pct_lbl = ctk.CTkLabel(self, text="", font=ctk.CTkFont(size=10),
                                     text_color=TEXT_DIM)

    # ── download logic ────────────────────────────────────────────────────────
    def _start_download(self):
        if self._thread and self._thread.is_alive():
            return
        os.makedirs(self.download_dir, exist_ok=True)
        self.btn.configure(state="disabled", text="Connecting…")
        self.pbar.grid(row=2, column=0, columnspan=4, padx=16, pady=(0, 4), sticky="ew")
        self.pct_lbl.grid(row=3, column=0, columnspan=4, padx=16, pady=(0, 10), sticky="e")
        self._thread = threading.Thread(target=self._download_task, daemon=True)
        self._thread.start()

    def _download_task(self):
        path       = self.file_info["path"]
        total      = self.file_info.get("size", 0)
        url        = f"{HF_CDN_BASE}/{urllib.parse.quote(path)}"
        dest       = os.path.join(self.download_dir, path)
        chunk_size = 65536

        try:
            self.btn.configure(text="Connecting…")
            with requests.get(url, stream=True, timeout=30) as resp:
                resp.raise_for_status()
                downloaded = 0
                self.btn.configure(text="Downloading…")
                with open(dest, "wb") as fh:
                    for chunk in resp.iter_content(chunk_size=chunk_size):
                        if chunk:
                            fh.write(chunk)
                            downloaded += len(chunk)
                            if total > 0:
                                pct = downloaded / total
                                self.pbar.set(pct)
                                self.pct_lbl.configure(
                                    text=f"{format_size(downloaded)} / {format_size(total)}  ({pct*100:.0f}%)"
                                )

            if total > 0 and downloaded != total:
                raise IOError(
                    f"Incomplete download: got {format_size(downloaded)}, expected {format_size(total)}"
                )

            self.btn.configure(text="✓  Done", fg_color=SUCCESS, state="normal")
            self.pbar.set(1)
            self.pct_lbl.configure(text=f"Saved → {dest}")
            self.status_cb(f"✓ Downloaded: {path}")

        except Exception as exc:
            self.btn.configure(text="⚠  Retry", state="normal", fg_color=DANGER)
            self.pct_lbl.configure(text=f"Error: {exc}")
            self.status_cb(f"✗ Failed: {path} — {exc}")
            if os.path.exists(dest):
                try:
                    os.remove(dest)
                except OSError:
                    pass


# ════════════════════════════════════════════════════════════════════════════
class ChahuadevHub(ctk.CTk):

    def __init__(self):
        super().__init__()
        self.title("Chahuadev Hub")
        self.geometry("1080x720")
        self.minsize(900, 580)
        self.configure(fg_color=BG_BASE)
        self._filter    = "All"
        self._cards     = []
        self._all_files = []
        self._skeletons = []
        self._nav       = "downloads"

        self._build_layout()
        threading.Thread(target=self._fetch_files, daemon=True).start()

    # ── Layout ───────────────────────────────────────────────────────────────
    def _build_layout(self):
        self.grid_rowconfigure(0, weight=1)
        self.grid_rowconfigure(1, weight=0)
        self.grid_columnconfigure(1, weight=1)

        # ── Sidebar ──────────────────────────────────────────────────────────
        self.sidebar = ctk.CTkFrame(self, width=220, corner_radius=0,
                                     fg_color=SIDEBAR_BG)
        self.sidebar.grid(row=0, column=0, rowspan=2, sticky="nsew")
        self.sidebar.grid_propagate(False)
        self.sidebar.grid_rowconfigure(20, weight=1)

        ctk.CTkLabel(self.sidebar, text="CHAHUADEV\nHUB",
                     font=ctk.CTkFont(size=22, weight="bold"),
                     text_color="#7c3aed").grid(
            row=0, column=0, padx=20, pady=(28, 4)
        )
        ctk.CTkLabel(self.sidebar, text="Official App Distribution",
                     font=ctk.CTkFont(size=10), text_color=MUTED).grid(
            row=1, column=0, padx=20, pady=(0, 24)
        )

        # ─ Navigation ─
        ctk.CTkLabel(self.sidebar, text="NAVIGATE",
                     font=ctk.CTkFont(size=10, weight="bold"),
                     text_color=MUTED).grid(row=2, column=0, padx=20, sticky="w")

        self._nav_btns = {}
        for i, (label, key) in enumerate([
            ("  ⬇  Downloads", "downloads"),
            ("  �  Explorer",  "explorer"),
            ("  �📋  Changelog", "changelog"),
        ], start=3):
            btn = ctk.CTkButton(
                self.sidebar, text=label, anchor="w",
                fg_color=ACCENT if key == "downloads" else "transparent",
                hover_color=ACCENT_DARK,
                command=lambda k=key: self._switch_nav(k)
            )
            btn.grid(row=i, column=0, padx=12, pady=3, sticky="ew")
            self._nav_btns[key] = btn

        # ─ Filter ─
        ctk.CTkLabel(self.sidebar, text="FILTER BY PLATFORM",
                     font=ctk.CTkFont(size=10, weight="bold"),
                     text_color=MUTED).grid(row=6, column=0, padx=20, pady=(20, 4), sticky="w")

        self._filter_btns = {}
        for i, (label, key) in enumerate([
            ("  All Files", "All"),
            ("  🪟  Windows", "Windows"),
            ("  🐧  Linux", "Linux"),
        ], start=7):
            btn = ctk.CTkButton(
                self.sidebar, text=label, anchor="w",
                fg_color=ACCENT if key == "All" else "transparent",
                hover_color=ACCENT_DARK,
                command=lambda k=key: self._set_filter(k)
            )
            btn.grid(row=i, column=0, padx=12, pady=3, sticky="ew")
            self._filter_btns[key] = btn

        # ─ Bottom actions ─
        ctk.CTkButton(
            self.sidebar, text="📂  Open Downloads",
            fg_color="transparent", hover_color=SURFACE,
            command=self._open_download_dir,
        ).grid(row=20, column=0, padx=12, pady=(0, 6), sticky="ew")

        ctk.CTkButton(
            self.sidebar, text="🔄  Refresh",
            fg_color="transparent", hover_color=SURFACE,
            command=self._refresh,
        ).grid(row=21, column=0, padx=12, pady=(0, 6), sticky="ew")

        ctk.CTkButton(
            self.sidebar, text="🔗  Hugging Face",
            fg_color="transparent", hover_color=SURFACE,
            command=lambda: webbrowser.open(f"https://huggingface.co/{HF_REPO}")
        ).grid(row=22, column=0, padx=12, pady=(0, 20), sticky="ew")

        # ── Main area ────────────────────────────────────────────────────────
        self.main = ctk.CTkFrame(self, fg_color=HEADER_BG, corner_radius=0)
        self.main.grid(row=0, column=1, sticky="nsew")
        self.main.grid_rowconfigure(2, weight=1)
        self.main.grid_columnconfigure(0, weight=1)

        # Header bar
        hdr = ctk.CTkFrame(self.main, fg_color=BG_BASE, corner_radius=0, height=64)
        hdr.grid(row=0, column=0, sticky="ew")
        hdr.grid_columnconfigure(0, weight=1)
        hdr.grid_propagate(False)

        self.hdr_title = ctk.CTkLabel(
            hdr, text="Available Downloads",
            font=ctk.CTkFont(size=18, weight="bold"),
            text_color=TEXT, anchor="w"
        )
        self.hdr_title.grid(row=0, column=0, padx=24, pady=18, sticky="w")

        self.hdr_count = ctk.CTkLabel(
            hdr, text="Fetching…",
            font=ctk.CTkFont(size=12), text_color=MUTED, anchor="e"
        )
        self.hdr_count.grid(row=0, column=1, padx=24, pady=18, sticky="e")

        # Stats cards row
        stats_row = ctk.CTkFrame(self.main, fg_color=HEADER_BG, corner_radius=0, height=110)
        stats_row.grid(row=1, column=0, sticky="ew", padx=20, pady=(10, 0))
        stats_row.grid_columnconfigure((0, 1, 2), weight=1)
        stats_row.grid_propagate(False)

        self._stat_total = StatCard(stats_row, "Total Files",   "—", ACCENT,     "📦")
        self._stat_win   = StatCard(stats_row, "Windows Files", "—", WIN_COLOR,  "🪟")
        self._stat_linux = StatCard(stats_row, "Linux Files",   "—", LINUX_COLOR,"🐧")
        self._stat_total.grid(row=0, column=0, padx=(0, 8), pady=0, sticky="nsew")
        self._stat_win.grid  (row=0, column=1, padx=8,      pady=0, sticky="nsew")
        self._stat_linux.grid(row=0, column=2, padx=(8, 0), pady=0, sticky="nsew")

        # Content frame (holds downloads & changelog panels)
        self.content_frame = ctk.CTkFrame(self.main, fg_color=HEADER_BG, corner_radius=0)
        self.content_frame.grid(row=2, column=0, sticky="nsew", padx=0, pady=(12, 0))
        self.content_frame.grid_rowconfigure(0, weight=1)
        self.content_frame.grid_columnconfigure(0, weight=1)

        # Downloads panel
        self.downloads_panel = ctk.CTkScrollableFrame(
            self.content_frame, fg_color=HEADER_BG, corner_radius=0
        )
        self.downloads_panel.grid(row=0, column=0, sticky="nsew")
        self.downloads_panel.grid_columnconfigure(0, weight=1)

        for i in range(4):
            sk = SkeletonCard(self.downloads_panel)
            sk.grid(row=i, column=0, padx=20, pady=8, sticky="ew")
            self._skeletons.append(sk)

        # ── Explorer panel (hidden initially) ────────────────────────────────
        self.explorer_panel = ctk.CTkFrame(
            self.content_frame, fg_color=HEADER_BG, corner_radius=0
        )
        self.explorer_panel.grid(row=0, column=0, sticky="nsew")
        self.explorer_panel.grid_rowconfigure(0, weight=1)
        self.explorer_panel.grid_columnconfigure(0, weight=0, minsize=280)
        self.explorer_panel.grid_columnconfigure(1, weight=1)
        self.explorer_panel.grid_remove()

        # Left: repo list
        self._repo_list_frame = ctk.CTkScrollableFrame(
            self.explorer_panel, fg_color=SURFACE, corner_radius=0, width=260
        )
        self._repo_list_frame.grid(row=0, column=0, sticky="nsew", padx=(0, 1))
        self._repo_list_frame.grid_columnconfigure(0, weight=1)

        self._repo_loading_lbl = ctk.CTkLabel(
            self._repo_list_frame, text="⏳  Fetching repos…",
            font=ctk.CTkFont(size=13), text_color=MUTED
        )
        self._repo_loading_lbl.grid(row=0, column=0, pady=40)

        # Right: commit detail
        self._commit_frame = ctk.CTkFrame(
            self.explorer_panel, fg_color=HEADER_BG, corner_radius=0
        )
        self._commit_frame.grid(row=0, column=1, sticky="nsew")
        self._commit_frame.grid_rowconfigure(1, weight=1)
        self._commit_frame.grid_columnconfigure(0, weight=1)

        self._commit_hdr = ctk.CTkLabel(
            self._commit_frame,
            text="← Select a repo to view commits",
            font=ctk.CTkFont(size=13), text_color=MUTED, anchor="w"
        )
        self._commit_hdr.grid(row=0, column=0, padx=20, pady=14, sticky="w")

        self._commit_scroll = ctk.CTkScrollableFrame(
            self._commit_frame, fg_color=HEADER_BG, corner_radius=0
        )
        self._commit_scroll.grid(row=1, column=0, sticky="nsew")
        self._commit_scroll.grid_columnconfigure(0, weight=1)

        self._repo_cards: list = []
        self._active_repo_card = None

        # Changelog panel (hidden initially)
        self.changelog_panel = ctk.CTkScrollableFrame(
            self.content_frame, fg_color=HEADER_BG, corner_radius=0
        )
        self.changelog_panel.grid(row=0, column=0, sticky="nsew")
        self.changelog_panel.grid_columnconfigure(0, weight=1)
        self.changelog_panel.grid_remove()

        self._changelog_lbl = ctk.CTkLabel(
            self.changelog_panel, text="⏳  Loading commit history…",
            font=ctk.CTkFont(size=14), text_color=MUTED
        )
        self._changelog_lbl.grid(row=0, column=0, pady=60)

        # Status bar
        self.statusbar = ctk.CTkLabel(
            self, text=f"  Download folder: {DOWNLOAD_DIR}",
            font=ctk.CTkFont(size=10), text_color=MUTED,
            fg_color=BG_BASE, anchor="w", corner_radius=0
        )
        self.statusbar.grid(row=1, column=1, sticky="ew", padx=0, pady=0)

    # ── Navigation ───────────────────────────────────────────────────────────
    def _switch_nav(self, key: str):
        self._nav = key
        for k, btn in self._nav_btns.items():
            btn.configure(fg_color=ACCENT if k == key else "transparent")

        self.downloads_panel.grid_remove()
        self.explorer_panel.grid_remove()
        self.changelog_panel.grid_remove()

        if key == "downloads":
            self.hdr_title.configure(text="Available Downloads")
            self.downloads_panel.grid()
        elif key == "explorer":
            self.hdr_title.configure(text="🔍  Repo Explorer — huggingface.co/chahuadev")
            self.hdr_count.configure(text="")
            self.explorer_panel.grid()
            if not hasattr(self, "_explorer_loaded"):
                threading.Thread(target=self._fetch_all_repos, daemon=True).start()
        else:
            self.hdr_title.configure(text="Changelog — Commit History")
            self.changelog_panel.grid()
            if not hasattr(self, "_changelog_loaded"):
                threading.Thread(target=self._fetch_changelog, daemon=True).start()

    # ── API fetch — files ─────────────────────────────────────────────────────
    def _fetch_files(self):
        try:
            resp  = requests.get(HF_API_URL, timeout=15)
            resp.raise_for_status()
            files = resp.json()
            blobs = [f for f in files
                     if f.get("type") == "file" and f["path"] not in SKIP_FILES]
            self.after(0, self._populate_cards, blobs)
        except Exception as exc:
            self.after(0, self._show_error, str(exc))

    def _populate_cards(self, files: list):
        for sk in self._skeletons:
            sk.destroy()
        self._skeletons.clear()
        self._all_files = files
        self._update_stats(files)
        self._render_cards(files)

    def _render_cards(self, files: list):
        for card in self._cards:
            card.destroy()
        self._cards.clear()

        for i, f in enumerate(files):
            card = AppCard(self.downloads_panel, f, DOWNLOAD_DIR, self._set_status)
            card.grid(row=i, column=0, padx=20, pady=8, sticky="ew")
            self._cards.append(card)

        count = len(files)
        self.hdr_count.configure(text=f"{count} file{'s' if count != 1 else ''} available")
        self._set_status(f"Loaded {count} files from huggingface.co/{HF_REPO}")

    def _show_error(self, msg: str):
        for sk in self._skeletons:
            sk.destroy()
        self._skeletons.clear()
        ctk.CTkLabel(
            self.downloads_panel,
            text=f"⚠  Failed to connect to Hugging Face\n{msg}",
            font=ctk.CTkFont(size=14), text_color=DANGER
        ).grid(row=0, column=0, pady=60)
        self._set_status(f"✗ Error: {msg}")

    def _update_stats(self, files: list):
        total = len(files)
        wins  = sum(1 for f in files if ".exe" in f["path"].lower())
        lins  = sum(1 for f in files if ".appimage" in f["path"].lower())
        self._stat_total.update_value(str(total))
        self._stat_win.update_value(str(wins))
        self._stat_linux.update_value(str(lins))

    # ── API fetch — ALL repos (Explorer) ─────────────────────────────────────
    def _fetch_all_repos(self):
        results = []
        for url, rtype in [
            (HF_DATASETS_API, "dataset"),
            (HF_MODELS_API,   "model"),
            (HF_SPACES_API,   "space"),
        ]:
            try:
                resp = requests.get(url, timeout=15)
                resp.raise_for_status()
                for r in resp.json():
                    results.append((r, rtype))
            except Exception:
                pass
        results.sort(
            key=lambda x: x[0].get("lastModified") or x[0].get("updatedAt") or "",
            reverse=True
        )
        self.after(0, self._populate_repos, results)

    def _populate_repos(self, results: list):
        self._explorer_loaded = True
        if hasattr(self, "_repo_loading_lbl") and self._repo_loading_lbl.winfo_exists():
            self._repo_loading_lbl.destroy()

        total = len(results)
        types: dict = {}
        for _, t in results:
            types[t] = types.get(t, 0) + 1
        parts = [f"{total} repos"]
        for t in ("dataset", "model", "space"):
            if types.get(t):
                m = REPO_TYPE_META[t]
                parts.append(f"{m['icon']} {types[t]} {m['label']}s")
        self.hdr_count.configure(text="  ·  ".join(parts))
        self._set_status(f"Loaded {total} repos from huggingface.co/{HF_AUTHOR}")

        for i, (repo, rtype) in enumerate(results):
            card = RepoCard(self._repo_list_frame, repo, rtype, self._on_repo_select)
            card.grid(row=i, column=0, padx=8, pady=4, sticky="ew")
            self._repo_cards.append(card)

    def _on_repo_select(self, repo: dict, repo_type: str):
        repo_id = repo.get("id") or repo.get("modelId", "")
        for card in self._repo_cards:
            cid = card._repo.get("id") or card._repo.get("modelId", "")
            card.set_active(cid == repo_id)

        for w in self._commit_scroll.winfo_children():
            w.destroy()
        self._commit_hdr.configure(text=f"📋  Commits — {repo_id}", text_color=TEXT)

        lbl = ctk.CTkLabel(
            self._commit_scroll, text="⏳  Loading commits…",
            font=ctk.CTkFont(size=13), text_color=MUTED
        )
        lbl.grid(row=0, column=0, pady=40)
        threading.Thread(
            target=self._fetch_repo_commits,
            args=(repo_id, repo_type),
            daemon=True
        ).start()

    def _fetch_repo_commits(self, repo_id: str, repo_type: str):
        url = f"https://huggingface.co/api/{repo_type}s/{repo_id}/commits/main"
        try:
            resp = requests.get(url, timeout=15)
            resp.raise_for_status()
            commits = resp.json()
            self.after(0, self._show_repo_commits, commits, repo_id)
        except Exception as exc:
            self.after(0, self._show_repo_commits_error, str(exc))

    def _show_repo_commits(self, commits: list, repo_id: str):
        for w in self._commit_scroll.winfo_children():
            w.destroy()
        if not commits:
            ctk.CTkLabel(
                self._commit_scroll, text="No commits found",
                font=ctk.CTkFont(size=13), text_color=MUTED
            ).grid(row=0, column=0, pady=40)
            return
        for i, commit in enumerate(commits):
            entry = ChangelogEntry(self._commit_scroll, commit)
            entry.grid(row=i, column=0, padx=12, pady=5, sticky="ew")
        self._commit_scroll.grid_columnconfigure(0, weight=1)
        self._set_status(f"{len(commits)} commits — {repo_id}")

    def _show_repo_commits_error(self, msg: str):
        for w in self._commit_scroll.winfo_children():
            w.destroy()
        ctk.CTkLabel(
            self._commit_scroll, text=f"⚠  {msg}",
            font=ctk.CTkFont(size=13), text_color=DANGER
        ).grid(row=0, column=0, pady=40)

    # ── API fetch — changelog ─────────────────────────────────────────────────
    def _fetch_changelog(self):
        try:
            resp = requests.get(HF_COMMITS_URL, timeout=15)
            resp.raise_for_status()
            commits = resp.json()
            self.after(0, self._populate_changelog, commits)
        except Exception as exc:
            self.after(0, self._changelog_error, str(exc))

    def _populate_changelog(self, commits: list):
        self._changelog_loaded = True
        self._changelog_lbl.destroy()
        for i, commit in enumerate(commits):
            entry = ChangelogEntry(self.changelog_panel, commit)
            entry.grid(row=i, column=0, padx=20, pady=6, sticky="ew")
        self._set_status(f"Loaded {len(commits)} commits from Hugging Face")

    def _changelog_error(self, msg: str):
        self._changelog_lbl.configure(
            text=f"⚠  Failed to load changelog\n{msg}", text_color=DANGER
        )

    # ── Filter ────────────────────────────────────────────────────────────────
    def _set_filter(self, key: str):
        self._filter = key
        for k, btn in self._filter_btns.items():
            btn.configure(fg_color=ACCENT if k == key else "transparent")
        if not self._all_files:
            return
        if key == "All":
            filtered = self._all_files
        elif key == "Windows":
            filtered = [f for f in self._all_files if ".exe" in f["path"].lower()]
        else:
            filtered = [f for f in self._all_files if ".appimage" in f["path"].lower()]
        self._render_cards(filtered)

    # ── Helpers ───────────────────────────────────────────────────────────────
    def _set_status(self, msg: str):
        self.statusbar.configure(text=f"  {msg}")

    def _open_download_dir(self):
        os.makedirs(DOWNLOAD_DIR, exist_ok=True)
        if os.name == "nt":
            os.startfile(DOWNLOAD_DIR)
        else:
            import subprocess
            subprocess.Popen(["xdg-open", DOWNLOAD_DIR])

    def _refresh(self):
        for card in self._cards:
            card.destroy()
        self._cards.clear()
        self._all_files = []
        self._stat_total.update_value("—")
        self._stat_win.update_value("—")
        self._stat_linux.update_value("—")
        self.hdr_count.configure(text="Fetching…")

        for i in range(4):
            sk = SkeletonCard(self.downloads_panel)
            sk.grid(row=i, column=0, padx=20, pady=8, sticky="ew")
            self._skeletons.append(sk)

        if hasattr(self, "_changelog_loaded"):
            del self._changelog_loaded
        for w in self.changelog_panel.winfo_children():
            w.destroy()
        self._changelog_lbl = ctk.CTkLabel(
            self.changelog_panel, text="⏳  Loading commit history…",
            font=ctk.CTkFont(size=14), text_color=MUTED
        )
        self._changelog_lbl.grid(row=0, column=0, pady=60)

        # Reset explorer
        if hasattr(self, "_explorer_loaded"):
            del self._explorer_loaded
        for card in self._repo_cards:
            card.destroy()
        self._repo_cards.clear()
        self._active_repo_card = None
        for w in self._commit_scroll.winfo_children():
            w.destroy()
        self._commit_hdr.configure(
            text="← Select a repo to view commits", text_color=MUTED
        )
        self._repo_loading_lbl = ctk.CTkLabel(
            self._repo_list_frame, text="⏳  Fetching repos…",
            font=ctk.CTkFont(size=13), text_color=MUTED
        )
        self._repo_loading_lbl.grid(row=0, column=0, pady=40)

        threading.Thread(target=self._fetch_files, daemon=True).start()


# ════════════════════════════════════════════════════════════════════════════
def run_hub():
    os.makedirs(DOWNLOAD_DIR, exist_ok=True)
    app = ChahuadevHub()
    app.mainloop()

if __name__ == "__main__":
    run_hub()