"""
Provider-agnostic input validation shared by every front end onto the
grounding pipeline (the local FastAPI app in server.py, and the
Hugging Face Spaces/ZeroGPU app in scripts/spaces_app/). None of this
depends on which model actually does the grounding -- it's the (1) is
this a real paper / (2) does it link a real GitHub repo gate that runs
before any model call, so it belongs to neither backend specifically.
"""
from __future__ import annotations

import re
import subprocess
from pathlib import Path
from typing import Optional

GITHUB_URL_RE = re.compile(r"https?://github\.com/([\w.-]+)/([\w.-]+?)(?=[)\]\s,.;\"'<>]|$)")
ARXIV_ABS_RE = re.compile(r"^https?://arxiv\.org/abs/(\d{4}\.\d{4,5}(v\d+)?)/?$")


def normalize_paper_url(url: str) -> str:
    m = ARXIV_ABS_RE.match(url.strip())
    if m:
        return f"https://arxiv.org/pdf/{m.group(1)}"
    return url.strip()


def looks_like_a_paper(pdf_path: Path) -> tuple[bool, str]:
    """Heuristic, not a classifier: a real academic paper has an Abstract
    near the start and a References/Bibliography section later, and is a
    plausible page count. Good enough to reject "someone uploaded a random
    PDF" without needing an ML model for it."""
    proc = subprocess.run(["pdfinfo", str(pdf_path)], capture_output=True, text=True)
    if proc.returncode != 0:
        return False, "not a readable PDF"
    pages = 0
    for line in proc.stdout.splitlines():
        if line.startswith("Pages:"):
            pages = int(line.split(":", 1)[1].strip())
    if pages < 4 or pages > 80:
        return False, f"page count ({pages}) doesn't look like a paper"

    text_proc = subprocess.run(["pdftotext", str(pdf_path), "-"], capture_output=True, text=True)
    text = text_proc.stdout.lower()
    first_page = "\n".join(text.splitlines()[:80])
    if "abstract" not in first_page:
        return False, "no 'Abstract' found near the start of the document"
    if "references" not in text and "bibliography" not in text:
        return False, "no 'References'/'Bibliography' section found"
    return True, "looks like a paper"


def _degap(text: str) -> str:
    """pdftotext preserves the PDF's visual line wrapping, which routinely
    splits a URL across a line break (e.g. 'https:' / '//github.com/...'
    have shown up on two separate lines in real papers). A real URL never
    contains whitespace, so it's always safe to strip it out before
    searching for one -- this can't create a false match, only recover a
    real one that line-wrapping broke."""
    return re.sub(r"\s+", "", text)


def _candidate_repo_urls(text: str) -> list[str]:
    """All github.com/owner/repo matches in `text`, each followed by a
    variant with one trailing digit stripped. A citation superscript or
    footnote marker (e.g. 'UniComp¹') routinely gets flattened by
    pdftotext into a bare digit glued directly onto the repo name with no
    separating whitespace or punctuation for the regex to stop at -- so
    'UniComp1' as extracted may really be 'UniComp' + a footnote number.
    Only offering the stripped variant as a fallback (checked in
    extract_github_repo, not preferred blindly) avoids ever preferring a
    guess over what was actually printed."""
    out = []
    for m in GITHUB_URL_RE.finditer(_degap(text)):
        owner, repo = m.group(1), m.group(2)
        out.append(f"https://github.com/{owner}/{repo}")
        if repo[-1:].isdigit() and len(repo) > 1:
            out.append(f"https://github.com/{owner}/{repo[:-1]}")
    return out


def repo_exists(repo_url: str) -> bool:
    proc = subprocess.run(["git", "ls-remote", repo_url], capture_output=True, text=True, timeout=20)
    return proc.returncode == 0


def extract_github_repo(pdf_path: Path) -> Optional[str]:
    """Prefer a repo link on page 1 (where authors usually put their own
    code link, in the abstract or a footnote) over one found anywhere else
    in the document (which might just be a cited related-work repo).
    Within each page, prefer a candidate that's actually a real, reachable
    repo over one that merely matches the URL shape -- catches the
    trailing-footnote-digit case above without ever silently proceeding
    with a repo nobody actually linked."""
    page1 = subprocess.run(
        ["pdftotext", "-f", "1", "-l", "1", str(pdf_path), "-"],
        capture_output=True, text=True,
    ).stdout
    for url in _candidate_repo_urls(page1):
        if repo_exists(url):
            return url

    full = subprocess.run(["pdftotext", str(pdf_path), "-"], capture_output=True, text=True).stdout
    for url in _candidate_repo_urls(full):
        if repo_exists(url):
            return url
    return None