#!/usr/bin/env python3
"""Read-only check of the GitHub "already implemented" search (no DB, no Jira writes).

Usage (from the project root, venv active):
  python3 scripts/check_github.py                       # token, rate limit, repo access only
  python3 scripts/check_github.py AN-12 --jira          # fetch AN-12 from Jira and run the search
  python3 scripts/check_github.py AN-12 --summary "Add Customer Tier picklist on Account" \
      --description "Customer_Tier__c with Bronze, Silver, Gold"
  python3 scripts/check_github.py AN-12 --jira --llm    # also ask the LLM for the verdict
"""

from __future__ import annotations

import argparse
import asyncio
import sys
from pathlib import Path

import httpx

sys.path.insert(0, str(Path(__file__).resolve().parents[1]))

from packages.config import get_settings  # noqa: E402
from packages.integrations.code_validation import (  # noqa: E402
    build_git_check_prompt,
    file_hits,
    git_search_query,
)
from packages.integrations.github_search import HttpGitHubSearch, github_search_available  # noqa: E402
from packages.integrations.jira import JiraIssue, get_jira_client  # noqa: E402
from packages.knowledge.retrievers import get_repo_retriever  # noqa: E402


def ok(msg: str) -> None:
    print(f"  [OK]   {msg}")


def fail(msg: str) -> None:
    print(f"  [FAIL] {msg}")


async def check_access(settings) -> bool:
    print("\n1. GitHub token and access")
    headers = {"Accept": "application/vnd.github+json", "Authorization": f"Bearer {settings.github_token}"}
    api = settings.github_api_base_url.rstrip("/")
    good = True
    async with httpx.AsyncClient(timeout=20.0, headers=headers) as client:
        r = await client.get(f"{api}/user")
        if r.status_code == 200:
            ok(f"token valid, authenticated as {r.json().get('login')}")
        else:
            fail(f"/user returned {r.status_code}: {r.text[:200]}")
            good = False

        r = await client.get(f"{api}/rate_limit")
        if r.status_code == 200:
            res = r.json().get("resources", {})
            for name in ("core", "search", "code_search"):
                if name in res:
                    ok(f"rate limit {name}: {res[name].get('remaining')}/{res[name].get('limit')} left")

        parsed = settings.github_owner_repo
        if parsed:
            r = await client.get(f"{api}/repos/{parsed[0]}/{parsed[1]}")
            if r.status_code == 200:
                ok(f"repo {parsed[0]}/{parsed[1]} readable (default branch {r.json().get('default_branch')})")
            else:
                fail(f"repo {parsed[0]}/{parsed[1]} returned {r.status_code} — check GIT_REPO_URL / token scope")
                good = False
    return good


async def load_issue(args) -> JiraIssue:
    if args.jira:
        issue = await get_jira_client().get_issue(args.key)
        print(f"\nLoaded {issue.key} from Jira: {issue.summary}")
        return issue
    return JiraIssue(
        key=args.key,
        summary=args.summary or "",
        description=args.description or "",
        status="",
        issue_type="Story",
        project_key=args.key.split("-")[0],
    )


async def run_search(settings, issue: JiraIssue, use_llm: bool) -> None:
    print("\n2. Repository file paths (GIT_REPO_URL, default branch)")
    hits = await get_repo_retriever(settings).search(git_search_query(issue), limit=8)
    inventory = next((h.snippet for h in hits if h.title.startswith("Repository inventory")), "")
    files = file_hits(hits)
    print(f"  inventory: {inventory or '(none)'}")
    for h in files:
        print(f"  - {h.title}  {h.url or ''}")
    if not files:
        print("  (no matching file paths)")

    search = HttpGitHubSearch(settings)
    print(f"\n3. GitHub search (scope {search.qualifier}, max {search.max_queries} code queries)")
    print(f"  code queries: {search.code_queries(*_terms(issue))}")
    evidence = await search.gather(issue.key, issue.summary, issue.description or "")
    for label, items in (
        ("Code matches", evidence.code),
        ("Ticket key references (commits / PRs / branches)", evidence.ticket_refs),
        ("Open PR files", evidence.pr_files),
    ):
        print(f"\n  {label}: {len(items)}")
        for ev in items:
            print(f"    - {ev.label()}")
            if ev.url:
                print(f"      {ev.url}")
    if evidence.errors:
        print("\n  Errors (search continued with partial results):")
        for e in evidence.errors:
            fail(e)
    else:
        ok("all GitHub search calls succeeded")

    if not use_llm:
        return
    print(f"\n4. LLM verdict (LLM_PROVIDER={settings.llm_provider})")
    from packages.integrations.llm import get_llm_client

    if not files and evidence.is_empty():
        print("  No evidence found — the pipeline would skip the LLM and continue to design.")
        return
    prompt = build_git_check_prompt(issue, files, inventory, evidence)
    try:
        result = await get_llm_client().check_already_implemented(prompt)
    except Exception as exc:  # noqa: BLE001
        fail(f"LLM call failed: {str(exc)[:300]}")
        print("  In the pipeline this makes the Git check log 'git.check_failed' and continue without it.")
        return
    verdict = (
        "ALREADY IMPLEMENTED -> run pauses in GIT_REVIEW"
        if result.already_implemented
        else "PARTIALLY IMPLEMENTED -> Jira note + existing code passed to design"
        if result.partially_implemented
        else "NOT IMPLEMENTED -> continue as normal"
    )
    print(f"  verdict: {verdict}")
    print(f"  confidence: {result.confidence}")
    print(f"  rationale: {result.rationale}")
    for r in result.references:
        print(f"    - {r.title}  {r.url}")


def _terms(issue: JiraIssue):
    from packages.integrations.github_search import search_terms

    return search_terms(issue.summary, issue.description or "")


async def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("key", nargs="?", help="Jira key, e.g. AN-12")
    parser.add_argument("--jira", action="store_true", help="load summary/description from Jira")
    parser.add_argument("--summary", default="")
    parser.add_argument("--description", default="")
    parser.add_argument("--llm", action="store_true", help="also run the LLM verdict")
    args = parser.parse_args()

    settings = get_settings()
    print("Settings")
    print(f"  GIT_PROVIDER={settings.git_provider}  GIT_REPO_URL={settings.git_repo_url or '(empty)'}")
    print(f"  GITHUB_SEARCH_SCOPE={settings.github_search_scope}  GITHUB_ORG={settings.github_org or '(owner of GIT_REPO_URL)'}")
    print(f"  GITHUB_TOKEN={'set' if settings.github_token else 'MISSING'}")
    if not github_search_available(settings):
        fail("GitHub search is disabled: needs GIT_PROVIDER=github, GITHUB_TOKEN, and GIT_REPO_URL or GITHUB_ORG")
        return 1

    try:
        if not await check_access(settings):
            return 1
    except httpx.HTTPError as exc:
        fail(f"cannot reach {settings.github_api_base_url}: {exc} — check DNS / outbound HTTPS from this server")
        return 1
    if not args.key:
        print("\nAccess OK. Pass a Jira key (with --jira or --summary) to run the search.")
        return 0
    if not args.jira and not args.summary:
        parser.error("give --jira or --summary")

    issue = await load_issue(args)
    await run_search(settings, issue, args.llm)
    return 0


if __name__ == "__main__":
    sys.exit(asyncio.run(main()))
