# -*- coding: utf-8 -*-
"""GitHub içerik alımı: kullanıcı adı / link -> repo listesi + README'ler.

GitHub REST API'si kullanılır (web scraping yok). Opsiyonel GITHUB_TOKEN ile
saatlik istek limiti 60'tan 5000'e çıkar; token yoksa da temel kullanım çalışır.
"""

import json
import re
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

import requests

GITHUB_API = "https://api.github.com"


def resolve_target(target: str) -> dict:
    """Kullanıcı girdisini normalleştirir; {"kind", "owner", "repo"} döndürür.

    Kabul edilen biçimler:
      - "kadiirgok"                     -> kullanıcı
      - "https://github.com/kadiirgok"  -> kullanıcı
      - "github.com/kadiirgok/bilgi-tr" -> tek repo
      - "kadiirgok/bilgi-tr"            -> tek repo
    """
    t = (target or "").strip().strip("/")
    t = t.replace("https://", "").replace("http://", "")
    t = t.removeprefix("www.")
    t = t.removeprefix("github.com/").strip("/")

    parts = [p for p in t.split("/") if p]
    if not parts or not all(_GECERLI_AD.match(p) for p in parts[:2]):
        raise ValueError(
            "Geçerli bir GitHub kullanıcı adı veya link girin (örn. kadiirgok). "
            "Soru sormak için alttaki sohbet kutusunu kullanın.")
    if len(parts) == 1:
        return {"kind": "user", "owner": parts[0], "repo": None}
    if len(parts) >= 2:
        return {"kind": "repo", "owner": parts[0], "repo": parts[1]}
    raise ValueError(f"Geçersiz GitHub hedefi: {target!r}")


_GECERLI_AD = re.compile(r"^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,99})$")


def _headers(token: str) -> dict:
    h = {"Accept": "application/vnd.github+json"}
    if token:
        h["Authorization"] = f"Bearer {token}"
    return h


_token_uyarildi = False


def _get(url: str, token: str = "", headers: dict | None = None, **kw) -> requests.Response:
    """GET isteği; token süresi dolmuş/geçersizse (401) tokensiz yeniden dener.

    Herkese açık veriler token'sız da okunur (60 istek/saat); böylece süresi biten
    bir token tüm sistemi çökertmez, yalnızca limiti düşürür.
    """
    global _token_uyarildi
    h = {**_headers(token), **(headers or {})}
    resp = requests.get(url, headers=h, **kw)
    if resp.status_code == 401 and token:
        if not _token_uyarildi:
            print("UYARI: GITHUB_TOKEN geçersiz veya süresi dolmuş (401); "
                  "tokensiz devam ediliyor. Yeni token oluşturup güncelleyin.")
            _token_uyarildi = True
        h = {**_headers(""), **(headers or {})}
        resp = requests.get(url, headers=h, **kw)
    return resp


def list_repos(user: str, token: str = "") -> list[dict]:
    """Kullanıcının (fork hariç) repolarını döndürür: [{name, full_name, html_url}]."""
    repos = []
    page = 1
    while True:
        resp = _get(
            f"{GITHUB_API}/users/{user}/repos", token,
            params={"per_page": 100, "page": page, "type": "owner", "sort": "updated"},
            timeout=30,
        )
        if resp.status_code == 404:
            raise ValueError(f"GitHub kullanıcısı bulunamadı: {user}")
        if resp.status_code == 403:
            raise RuntimeError(
                "GitHub API limiti aşıldı (403). Geçerli bir GITHUB_TOKEN ekleyerek "
                "limiti 60/saat yerine 5000/saat'e çıkarın."
            )
        resp.raise_for_status()
        batch = resp.json()
        if not batch:
            break
        repos.extend(batch)
        if len(batch) < 100:
            break
        page += 1
    return repos


def fetch_readme(owner: str, repo: str, token: str = "") -> str | None:
    """Repo'nun README metnini döndürür; yoksa None."""
    resp = _get(f"{GITHUB_API}/repos/{owner}/{repo}/readme", token,
                headers={"Accept": "application/vnd.github.raw"}, timeout=30)
    if resp.status_code in (404, 204):
        return None
    resp.raise_for_status()
    text = (resp.text or "").strip()
    return text or None


# Gerçek bilgi içermeyen, araçların otomatik ürettiği README'lerin belirteçleri.
_BOILERPLATE_ISARETLERI = (
    "a new flutter project",
    "lab: write your first flutter app",
    "getting started with create react app",
    "this project was bootstrapped with",
    "bootstrapped with create-react-app",
)


def _readme_bos_metin(text: str) -> bool:
    """README'nin şablon (boilerplate) olup olmadığını döndürür.

    Flutter/CRA gibi araçların ürettiği hazır README'ler proje hakkında hiçbir
    şey söylemez; bunlar indekse alınmazsa soru koda düşer ve asıl yapı okunur.
    """
    t = (text or "").lower()
    return any(i in t for i in _BOILERPLATE_ISARETLERI)


def _repo_metadata(r: dict) -> dict:
    """GitHub repo nesnesinden yalnızca sunum/özet için gereken alanları alır."""
    lic = r.get("license") or {}
    return {
        "name": r.get("name", ""),
        "full_name": r.get("full_name", ""),
        "description": (r.get("description") or "").strip(),
        "language": r.get("language") or "",
        "stars": r.get("stargazers_count", 0),
        "forks": r.get("forks_count", 0),
        "updated_at": r.get("updated_at", ""),
        "created_at": r.get("created_at", ""),
        "html_url": r.get("html_url", ""),
        "homepage": r.get("homepage") or "",
        "license": lic.get("spdx_id") or "",
    }


def fetch_repo_metadata(owner: str, repo: str, token: str = "") -> dict | None:
    """Tek reponun metadata'sını döndürür; bulunamazsa None."""
    resp = _get(f"{GITHUB_API}/repos/{owner}/{repo}", token, timeout=30)
    if resp.status_code != 200:
        return None
    return _repo_metadata(resp.json())


def fetch_metadata(target: str, token: str = "") -> list[dict]:
    """Yalnızca repo metadata'sını döndürür (README/embedding yok; hafif).

    Cache'li koleksiyonda metadata yan dosyası eksikse, index() bunu tek istekle
    yeniden doldurmak için kullanır.
    """
    parsed = resolve_target(target)
    if parsed["kind"] == "repo":
        meta = fetch_repo_metadata(parsed["owner"], parsed["repo"], token)
        return [meta] if meta else []
    return [_repo_metadata(r) for r in list_repos(parsed["owner"], token)]


def ingest_github(target: str, token: str = "") -> tuple[list[dict], list[dict]]:
    """Hedefi çözümleyip (docs, metadata) döndürür.

    docs:     [{"text","source","url"}]                    -> embedding için
    metadata: [{name, description, language, stars, ...}]  -> sunum/özet için
    """
    parsed = resolve_target(target)
    docs = []
    metadata = []

    if parsed["kind"] == "repo":
        owner, repo = parsed["owner"], parsed["repo"]
        meta = fetch_repo_metadata(owner, repo, token)
        if meta:
            metadata.append(meta)
        text = fetch_readme(owner, repo, token)
        if text and not _readme_bos_metin(text):
            docs.append({"text": text, "source": repo,
                         "url": f"https://github.com/{owner}/{repo}"})
        return docs, metadata

    for r in list_repos(parsed["owner"], token):
        name = r.get("name", "")
        full = r.get("full_name", "")
        if not name:
            continue
        metadata.append(_repo_metadata(r))
        text = fetch_readme(parsed["owner"], name, token)
        if text and not _readme_bos_metin(text):
            docs.append({"text": text, "source": name,
                         "url": r.get("html_url", f"https://github.com/{full}")})
    return docs, metadata


# --- Kod dosyası çekme (Katman 2) ---

CODE_EXTENSIONS = {
    ".py", ".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs",
    ".dart", ".java", ".kt", ".kts", ".go", ".rs", ".cs", ".cpp", ".c", ".h", ".hpp",
    ".rb", ".php", ".swift", ".sh", ".vue", ".sql", ".html", ".css", ".scss",
    ".yaml", ".yml", ".toml", ".md", ".ipynb",
}

# Devasa repolarda gereksiz dizinleri dışarıda bırak (build ürünleri, bağımlılıklar).
EXCLUDED_DIRS = {
    "node_modules", "dist", "build", ".git", "__pycache__", ".venv", "venv",
    "vendor", "target", ".idea", ".vscode", ".dart_tool", ".next", "coverage",
}

EXCLUDED_FILENAMES = {"package-lock.json", "yarn.lock", "pnpm-lock.yaml",
                      "poetry.lock", "Cargo.lock", "go.sum"}


def _default_branch(owner: str, repo: str, token: str = "") -> str:
    resp = _get(f"{GITHUB_API}/repos/{owner}/{repo}", token, timeout=30)
    resp.raise_for_status()
    return resp.json().get("default_branch", "main")


def fetch_code_file(owner: str, repo: str, branch: str, path: str) -> str | None:
    """raw.githubusercontent.com üzerinden tek dosyayı çeker (API limitine takılmaz)."""
    url = f"https://raw.githubusercontent.com/{owner}/{repo}/{branch}/{path}"
    resp = requests.get(url, timeout=30)
    if resp.status_code != 200:
        return None
    return resp.text


def _ipynb_to_text(text: str) -> str:
    """.ipynb (JSON) dosyasını okunabilir metne çevirir: markdown + kod hücreleri.

    Ham JSON hem token açısından verimsizdir hem de LLM için gürültülüdür; bu yüzden
    yalnızca hücrelerin kaynak metinleri (markdown açıklama + kod) birleştirilir.
    Çıktılar (outputs) ve metadata atılır.
    """
    try:
        nb = json.loads(text)
    except (ValueError, TypeError):
        return text
    parcalar = []
    for cell in nb.get("cells", []):
        kaynak = cell.get("source", [])
        if isinstance(kaynak, str):
            kaynak = [kaynak]
        icerik = "".join(kaynak).strip()
        if not icerik:
            continue
        tip = cell.get("cell_type", "")
        etiket = "## (markdown)" if tip == "markdown" else "# (kod)" if tip == "code" else ""
        parcalar.append(f"{etiket}\n{icerik}".strip())
    return "\n\n".join(parcalar)


def ingest_code(owner: str, repo: str, token: str = "",
                max_files: int = 200, max_size: int = 1_500_000) -> list[dict]:
    """Repo'nun kaynak dosyalarını filtreleyip doküman listesi olarak döndürür.

    Dosyalar git tree ile listelenir, raw CDN üzerinden paralel çekilir.
    `source` alanı dosya yoludur (örn. "github_rag/retrieval.py").
    """
    branch = _default_branch(owner, repo, token)

    tree_resp = _get(
        f"{GITHUB_API}/repos/{owner}/{repo}/git/trees/{branch}?recursive=1",
        token, timeout=60)
    tree_resp.raise_for_status()
    tree = tree_resp.json().get("tree", [])

    secilenler = []  # (path, size)
    total = 0
    for item in tree:
        if item.get("type") != "blob":
            continue
        path = item.get("path", "")
        size = item.get("size", 0)
        if Path(path).suffix.lower() not in CODE_EXTENSIONS:
            continue
        parcalar = path.split("/")
        if any(p in EXCLUDED_DIRS for p in parcalar):
            continue
        if Path(path).name in EXCLUDED_FILENAMES:
            continue
        if size > 50_000:  # tek dosya üst sınırı
            continue
        if len(secilenler) >= max_files or total + size > max_size:
            break
        secilenler.append((path, size))
        total += size

    docs = []

    def _fetchet(p):
        path, _size = p
        text = fetch_code_file(owner, repo, branch, path)
        if text and Path(path).suffix.lower() == ".ipynb":
            text = _ipynb_to_text(text)
        return path, text

    with ThreadPoolExecutor(max_workers=8) as ex:
        for path, text in ex.map(_fetchet, secilenler):
            if text and text.strip():
                # Şablon README'yi kod indeksine de alma (gerçek bilgi içermez).
                if Path(path).suffix.lower() == ".md" and _readme_bos_metin(text):
                    continue
                docs.append({"text": text, "source": path,
                             "url": f"https://github.com/{owner}/{repo}/blob/{branch}/{path}"})
    return docs