import tkinter as tk
from tkinter import ttk, messagebox
import urllib.parse
import requests
import json
import threading


class App061:
    """GitHub APIビューア"""

    BASE = "https://api.github.com"
    PER_PAGE = 100
    MAX_PAGES = 3

    def __init__(self, root):
        self.root = root
        self.root.title("GitHub APIビューア")
        self.root.geometry("1000x660")
        self.root.minsize(1000, 660)
        self.root.configure(bg="#0d1117")
        self._token = ""
        self._build_ui()

    def _build_ui(self):
        header = tk.Frame(self.root, bg="#161b22", pady=6)
        header.pack(fill=tk.X)
        tk.Label(header, text="🐙 GitHub APIビューア",
                 font=("Noto Sans JP", 12, "bold"),
                 bg="#161b22", fg="#f0f6fc").pack(side=tk.LEFT, padx=12)

        # トークン設定
        tk.Label(header, text="Token:", bg="#161b22", fg="#8b949e",
                 font=("Arial", 9)).pack(side=tk.LEFT, padx=(12, 4))
        self.token_var = tk.StringVar()
        ttk.Entry(header, textvariable=self.token_var,
                  width=36, show="*").pack(side=tk.LEFT)
        ttk.Button(header, text="適用",
                   command=self._apply_token).pack(side=tk.LEFT, padx=4)

        # 検索バー
        search_f = tk.Frame(self.root, bg="#0d1117", pady=4)
        search_f.pack(fill=tk.X, padx=8)
        self.search_mode = tk.StringVar(value="user")
        ttk.Combobox(search_f, textvariable=self.search_mode,
                     values=["user", "repos", "search", "langs"],
                     state="readonly", width=8).pack(side=tk.LEFT, padx=2)
        self.query_var = tk.StringVar(value="torvalds")
        ttk.Entry(search_f, textvariable=self.query_var,
                  width=30).pack(side=tk.LEFT, padx=4)
        ttk.Button(search_f, text="🔍 取得",
                   command=self._fetch).pack(side=tk.LEFT)
        self.search_mode.trace_add("write", self._on_mode_change)

        # 説明ラベル
        self.hint_lbl = tk.Label(search_f, text="ユーザー名を入力",
                                  bg="#0d1117", fg="#8b949e", font=("Arial", 9))
        self.hint_lbl.pack(side=tk.LEFT, padx=8)

        # メインエリア
        paned = ttk.PanedWindow(self.root, orient=tk.HORIZONTAL)
        paned.pack(fill=tk.BOTH, expand=True, padx=4, pady=4)

        # 左: 結果リスト
        left = tk.Frame(paned, bg="#0d1117")
        paned.add(left, weight=1)
        tk.Label(left, text="結果", bg="#0d1117", fg="#8b949e",
                 font=("Arial", 9)).pack(anchor="w")
        self.result_tree = ttk.Treeview(left, columns=("name", "stars", "desc"),
                                         show="headings", selectmode="browse")
        self.result_tree.heading("name", text="名前")
        self.result_tree.heading("stars", text="スター")
        self.result_tree.heading("desc", text="説明")
        self.result_tree.column("name", width=150, anchor="w")
        self.result_tree.column("stars", width=70, anchor="e")
        self.result_tree.column("desc", width=180, anchor="w")
        rsb = ttk.Scrollbar(left, command=self.result_tree.yview)
        self.result_tree.configure(yscrollcommand=rsb.set)
        rsb.pack(side=tk.RIGHT, fill=tk.Y)
        self.result_tree.pack(fill=tk.BOTH, expand=True)
        self.result_tree.bind("<<TreeviewSelect>>", self._on_result_select)

        # 右: 詳細
        right = tk.Frame(paned, bg="#0d1117")
        paned.add(right, weight=2)
        tk.Label(right, text="詳細", bg="#0d1117", fg="#8b949e",
                 font=("Arial", 9)).pack(anchor="w")
        self.detail_text = tk.Text(right, bg="#161b22", fg="#c9d1d9",
                                    font=("Courier New", 9), relief=tk.FLAT,
                                    state=tk.DISABLED, wrap=tk.WORD)
        dsb = ttk.Scrollbar(right, command=self.detail_text.yview)
        self.detail_text.configure(yscrollcommand=dsb.set)
        dsb.pack(side=tk.RIGHT, fill=tk.Y)
        self.detail_text.pack(fill=tk.BOTH, expand=True)

        # RAWパネル
        raw_f = tk.Frame(self.root, bg="#0d1117")
        raw_f.pack(fill=tk.X, padx=4, pady=2)
        tk.Label(raw_f, text="Raw JSON:", bg="#0d1117", fg="#8b949e",
                 font=("Arial", 8)).pack(anchor="w")
        self.raw_text = tk.Text(raw_f, height=5, bg="#0d1117", fg="#6e7681",
                                 font=("Courier New", 8), relief=tk.FLAT,
                                 state=tk.DISABLED, wrap=tk.NONE)
        raw_sb = ttk.Scrollbar(raw_f, orient=tk.HORIZONTAL,
                               command=self.raw_text.xview)
        self.raw_text.configure(xscrollcommand=raw_sb.set)
        self.raw_text.pack(fill=tk.X)
        raw_sb.pack(fill=tk.X)

        self.status_var = tk.StringVar(value="ユーザー名を入力して取得してください")
        tk.Label(self.root, textvariable=self.status_var,
                 bg="#21262d", fg="#8b949e", font=("Arial", 9),
                 anchor="w", padx=8).pack(fill=tk.X, side=tk.BOTTOM)

        self._data_cache = {}

    def _apply_token(self):
        self._token = self.token_var.get().strip()
        self.status_var.set("トークンを設定しました" if self._token
                             else "トークンをクリアしました")

    def _on_mode_change(self, *args):
        hints = {"user": "ユーザー名を入力 (例: torvalds)",
                 "repos": "ユーザー名を入力 (例: torvalds)",
                 "search": "キーワードを入力 (例: python tkinter)",
                 "langs": "ユーザー名を入力 (言語統計を集計)"}
        self.hint_lbl.config(text=hints.get(self.search_mode.get(), ""))

    def _make_request(self, url, params=None):
        headers = {"Accept": "application/vnd.github.v3+json",
                   "User-Agent": "PythonLandApp"}
        if self._token:
            headers["Authorization"] = f"token {self._token}"
        resp = requests.get(url, headers=headers, params=params, timeout=10)
        resp.raise_for_status()
        return resp.json()

    def _fetch(self):
        query = self.query_var.get().strip()
        if not query:
            messagebox.showwarning("警告", "検索クエリを入力してください")
            return
        mode = self.search_mode.get()
        self.status_var.set("取得中...")
        self.result_tree.delete(*self.result_tree.get_children())
        threading.Thread(target=self._do_fetch, args=(mode, query),
                          daemon=True).start()

    def _do_fetch(self, mode, query):
        try:
            if mode == "user":
                url = f"{self.BASE}/users/{urllib.parse.quote(query)}"
                data = self._make_request(url)
                self.root.after(0, self._show_user, data)
            elif mode == "repos":
                repos = self._fetch_repos(query)
                self.root.after(0, self._show_repos, repos)
            elif mode == "search":
                url = f"{self.BASE}/search/repositories"
                data = self._make_request(url, {"q": query, "per_page": 30})
                self.root.after(0, self._show_search_results,
                                data.get("items", []))
            elif mode == "langs":
                repos = self._fetch_repos(query)
                stats = self._aggregate_languages(repos)
                self.root.after(0, self._show_lang_stats, stats, len(repos))
        except Exception as e:
            self.root.after(0, self.status_var.set, f"エラー: {e}")

    def _fetch_repos(self, user):
        """リポジトリ一覧をページングで取得する（最大 PER_PAGE×MAX_PAGES 件）"""
        url = f"{self.BASE}/users/{urllib.parse.quote(user)}/repos"
        repos = []
        for page in range(1, self.MAX_PAGES + 1):
            batch = self._make_request(url, {"per_page": self.PER_PAGE,
                                             "sort": "updated", "page": page})
            repos.extend(batch)
            if len(batch) < self.PER_PAGE:
                break
        return repos

    def _aggregate_languages(self, repos):
        """リポジトリ一覧を主要言語ごとに集計する（件数とスター合計）"""
        stats = {}
        for repo in repos:
            lang = repo.get("language") or "(未設定)"
            entry = stats.setdefault(lang, {"count": 0, "stars": 0})
            entry["count"] += 1
            entry["stars"] += repo.get("stargazers_count") or 0
        return dict(sorted(stats.items(),
                           key=lambda kv: (-kv[1]["count"], kv[0])))

    def _show_user(self, data):
        self.result_tree.delete(*self.result_tree.get_children())
        self._data_cache.clear()
        iid = self.result_tree.insert(
            "", tk.END,
            values=(data.get("login", ""), "", data.get("bio", "") or ""),
            tags=("user",))
        self._data_cache[iid] = data
        self._show_detail(data)
        self.status_var.set(f"ユーザー: {data.get('login', '')}")

    def _show_repos(self, data):
        self.result_tree.delete(*self.result_tree.get_children())
        self._data_cache.clear()
        for repo in data:
            iid = self.result_tree.insert(
                "", tk.END,
                values=(repo.get("name", ""),
                         repo.get("stargazers_count") or 0,
                         repo.get("description", "") or ""))
            self._data_cache[iid] = repo
        total = sum(r.get("stargazers_count") or 0 for r in data)
        self.status_var.set(f"{len(data)} 件のリポジトリ / スター合計 {total}")

    def _show_search_results(self, items):
        self.result_tree.delete(*self.result_tree.get_children())
        self._data_cache.clear()
        for repo in items:
            name = f"{repo.get('full_name', '')}"
            iid = self.result_tree.insert(
                "", tk.END,
                values=(name, repo.get("stargazers_count") or 0,
                         repo.get("description", "") or ""))
            self._data_cache[iid] = repo
        self.status_var.set(f"{len(items)} 件のリポジトリが見つかりました")

    def _show_lang_stats(self, stats, total_repos):
        self.result_tree.delete(*self.result_tree.get_children())
        self._data_cache.clear()
        lines = [f"言語統計 (対象リポジトリ {total_repos} 件)", ""]
        for lang, v in stats.items():
            ratio = v["count"] / total_repos * 100 if total_repos else 0
            self.result_tree.insert(
                "", tk.END,
                values=(lang, v["stars"], f"{v['count']} 件 ({ratio:.1f}%)"))
            bar = "#" * int(round(ratio / 5))
            lines.append(f"{lang:18s} {v['count']:4d} 件 {ratio:5.1f}% "
                         f"star {v['stars']:5d} {bar}")
        self._set_text(self.detail_text, "\n".join(lines))
        self._set_text(self.raw_text,
                       json.dumps(stats, ensure_ascii=False, indent=2))
        self.status_var.set(f"{len(stats)} 言語 / {total_repos} 件を集計しました")

    def _on_result_select(self, event=None):
        sel = self.result_tree.selection()
        if not sel:
            return
        data = self._data_cache.get(sel[0])
        if data is None:  # 言語統計の行には元のJSONが無いので何もしない
            return
        self._show_detail(data)

    def _set_text(self, widget, content):
        widget.configure(state=tk.NORMAL)
        widget.delete("1.0", tk.END)
        widget.insert(tk.END, content)
        widget.configure(state=tk.DISABLED)

    def _show_detail(self, data):
        lines = []
        if "login" in data:  # ユーザー
            for k in ("login", "name", "bio", "location", "email",
                       "public_repos", "followers", "following",
                       "created_at", "html_url"):
                if data.get(k) is not None:
                    lines.append(f"{k:20s}: {data[k]}")
        else:  # リポジトリ
            for k in ("full_name", "description", "language", "stargazers_count",
                       "forks_count", "open_issues_count", "license",
                       "created_at", "updated_at", "html_url", "clone_url"):
                v = data.get(k)
                if isinstance(v, dict):
                    v = v.get("name", "")
                if v is not None:
                    lines.append(f"{k:22s}: {v}")

        self._set_text(self.detail_text, "\n".join(lines))
        self._set_text(self.raw_text,
                       json.dumps(data, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    root = tk.Tk()
    app = App061(root)
    root.mainloop()