"""GitHub evidence search: code contents, Jira-key references, and open PR files."""

from __future__ import annotations

import re
from dataclasses import asdict, dataclass, field
from typing import Any, Dict, Iterable, List, Optional, Protocol, Set, Tuple

import httpx
import structlog

from packages.config import Settings, get_settings
from packages.integrations.sanitize import sanitize_text
from packages.knowledge.retrievers import _confluence_search_terms

logger = structlog.get_logger(__name__)

TEXT_MATCH_ACCEPT = "application/vnd.github.text-match+json"
MAX_PR_SCAN = 10
MAX_BRANCH_REPOS = 5
MAX_FILES_PER_KEY_PR = 10


@dataclass
class CodeEvidence:
    kind: str  # code | commit | pr | branch | pr_file
    repo: str
    title: str  # file path for code/pr_file, message/title/name otherwise
    url: str = ""
    snippet: str = ""
    ref: str = ""  # branch name, commit sha, or PR number
    state: str = ""  # default | merged | open | closed

    def label(self) -> str:
        where = f"{self.repo}@{self.ref}" if self.ref else self.repo
        state = f" {self.state}" if self.state else ""
        return f"[{self.kind}{state}] {where}: {self.title}"

    def to_dict(self) -> Dict[str, str]:
        return asdict(self)

    @classmethod
    def from_dict(cls, data: Dict[str, Any]) -> "CodeEvidence":
        return cls(**{k: str(data.get(k) or "") for k in cls.__dataclass_fields__})


@dataclass
class GitHubEvidence:
    code: List[CodeEvidence] = field(default_factory=list)
    ticket_refs: List[CodeEvidence] = field(default_factory=list)
    pr_files: List[CodeEvidence] = field(default_factory=list)
    errors: List[str] = field(default_factory=list)

    def all(self) -> List[CodeEvidence]:
        return [*self.code, *self.ticket_refs, *self.pr_files]

    def is_empty(self) -> bool:
        return not (self.code or self.ticket_refs or self.pr_files)

    def counts(self) -> Dict[str, int]:
        counts: Dict[str, int] = {}
        for ev in self.all():
            counts[ev.kind] = counts.get(ev.kind, 0) + 1
        return counts


class CodeSearch(Protocol):
    async def gather(self, jira_key: str, summary: str, description: str) -> GitHubEvidence: ...


_USER_STORY_ROLE = re.compile(r"^\s*as an?\s+[^,]+,\s*i\s+(?:want|need|would like)\s+(?:to\s+)?", re.IGNORECASE)
_USER_STORY_BENEFIT = re.compile(r"\s+so that\b.*$", re.IGNORECASE)
_CODE_STOPWORDS = frozenset(
    {"want", "user", "users", "existing", "automatically", "based", "logic", "their", "quickly",
     "identify", "able", "make", "sure", "ensure", "new", "field", "fields", "value", "values"}
)


def _feature_text(summary: str) -> str:
    """'As a Sales User, I want to X so that Y' -> 'X'."""
    return _USER_STORY_BENEFIT.sub("", _USER_STORY_ROLE.sub("", summary or "")).strip() or summary


def search_terms(summary: str, description: str = "", *, max_keywords: int = 4) -> Tuple[List[str], List[str]]:
    """(api_names, keywords) used for code search and PR file matching."""
    from packages.integrations.code_validation import api_names_in

    names = api_names_in(f"{summary}\n{description}")
    keywords = [
        t
        for t in _confluence_search_terms(_feature_text(summary), max_terms=12)
        if "__c" not in t.lower() and t.lower() not in _CODE_STOPWORDS
    ]
    return names, keywords[:max_keywords]


def key_pattern(jira_key: str) -> re.Pattern[str]:
    """Match AN-5 but not AN-58 / XAN-5."""
    return re.compile(rf"(?<![A-Za-z0-9]){re.escape(jira_key)}(?![0-9])", re.IGNORECASE)


def _repo_from_api_url(url: str) -> str:
    m = re.search(r"/repos/([^/]+/[^/]+)", url or "")
    return m.group(1) if m else ""


def _excerpt(text: str, terms: Iterable[str], width: int = 300) -> str:
    low = (text or "").lower()
    pos = -1
    for t in terms:
        pos = low.find(t.lower())
        if pos >= 0:
            break
    start = max(0, pos - width // 3) if pos >= 0 else 0
    return sanitize_text(re.sub(r"\s+", " ", text[start : start + width]), max_len=width)


class HttpGitHubSearch:
    """Live GitHub search across the org (or a single repo)."""

    def __init__(
        self,
        settings: Optional[Settings] = None,
        transport: Optional[httpx.AsyncBaseTransport] = None,
    ) -> None:
        self.settings = settings or get_settings()
        self.transport = transport
        parsed = self.settings.github_owner_repo
        self.repo_full = f"{parsed[0]}/{parsed[1]}" if parsed else ""
        self.org = (self.settings.github_org or (parsed[0] if parsed else "")).strip()
        scope = (self.settings.github_search_scope or "org").strip().lower()
        if scope == "org" and self.org:
            self.qualifier = f"org:{self.org}"
        elif self.repo_full:
            self.qualifier = f"repo:{self.repo_full}"
        else:
            raise ValueError("Set GIT_REPO_URL or GITHUB_ORG for GitHub search")
        self.max_queries = max(1, self.settings.github_search_max_queries)
        self._api = self.settings.github_api_base_url.rstrip("/")

    def _headers(self) -> Dict[str, str]:
        headers = {"Accept": "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28"}
        if self.settings.github_token:
            headers["Authorization"] = f"Bearer {self.settings.github_token}"
        return headers

    async def gather(self, jira_key: str, summary: str, description: str) -> GitHubEvidence:
        names, keywords = search_terms(summary, description)
        evidence = GitHubEvidence()
        async with httpx.AsyncClient(
            timeout=30.0, headers=self._headers(), transport=self.transport
        ) as client:
            evidence.code = await self._guard(evidence, "code search", self.search_code(client, names, keywords))
            evidence.ticket_refs = await self._guard(
                evidence, "ticket key search", self.search_ticket_key(client, jira_key)
            )
            evidence.pr_files = await self._guard(
                evidence,
                "open PR files",
                self.open_pr_files(client, names, keywords, jira_key, evidence.ticket_refs),
            )
        return evidence

    async def _guard(self, evidence: GitHubEvidence, what: str, coro) -> List[CodeEvidence]:
        try:
            return await coro
        except httpx.HTTPError as exc:
            logger.warning("github_search_failed", step=what, error=str(exc))
            evidence.errors.append(f"{what}: {exc}")
            return []

    async def _get(self, client: httpx.AsyncClient, path: str, **kwargs) -> Any:
        resp = await client.get(f"{self._api}{path}", **kwargs)
        resp.raise_for_status()
        return resp.json()

    def code_queries(self, names: List[str], keywords: List[str]) -> List[str]:
        queries = [f'"{n}" {self.qualifier}' for n in names]
        if keywords:
            queries.append(" ".join(f'"{k}"' for k in keywords[:3]) + f" {self.qualifier}")
        return queries[: self.max_queries]

    async def search_code(
        self, client: httpx.AsyncClient, names: List[str], keywords: List[str]
    ) -> List[CodeEvidence]:
        seen: Set[Tuple[str, str]] = set()
        hits: List[CodeEvidence] = []
        for q in self.code_queries(names, keywords):
            data = await self._get(
                client,
                "/search/code",
                params={"q": q, "per_page": 5},
                headers={"Accept": TEXT_MATCH_ACCEPT},
            )
            for item in data.get("items") or []:
                repo = (item.get("repository") or {}).get("full_name") or ""
                path = item.get("path") or ""
                if not path or (repo, path) in seen:
                    continue
                seen.add((repo, path))
                fragments = " … ".join(
                    m.get("fragment") or "" for m in (item.get("text_matches") or [])[:2]
                )
                hits.append(
                    CodeEvidence(
                        kind="code",
                        repo=repo,
                        title=path,
                        url=item.get("html_url") or "",
                        snippet=sanitize_text(re.sub(r"\s+", " ", fragments), max_len=400),
                        state="default",
                    )
                )
        return hits

    async def search_ticket_key(self, client: httpx.AsyncClient, jira_key: str) -> List[CodeEvidence]:
        if not jira_key:
            return []
        pat = key_pattern(jira_key)
        hits: List[CodeEvidence] = []

        commits = await self._get(
            client, "/search/commits", params={"q": f'"{jira_key}" {self.qualifier}', "per_page": 10}
        )
        for item in commits.get("items") or []:
            message = ((item.get("commit") or {}).get("message") or "").strip()
            if not pat.search(message):
                continue
            hits.append(
                CodeEvidence(
                    kind="commit",
                    repo=(item.get("repository") or {}).get("full_name") or "",
                    title=sanitize_text(message.splitlines()[0], max_len=200),
                    url=item.get("html_url") or "",
                    snippet=sanitize_text(message, max_len=400),
                    ref=(item.get("sha") or "")[:12],
                    state="default",
                )
            )

        prs = await self._get(
            client,
            "/search/issues",
            params={"q": f'"{jira_key}" type:pr {self.qualifier}', "per_page": 10},
        )
        for item in prs.get("items") or []:
            title = item.get("title") or ""
            body = item.get("body") or ""
            if not pat.search(f"{title}\n{body}"):
                continue
            merged = bool((item.get("pull_request") or {}).get("merged_at"))
            hits.append(
                CodeEvidence(
                    kind="pr",
                    repo=_repo_from_api_url(item.get("repository_url") or ""),
                    title=sanitize_text(title, max_len=200),
                    url=item.get("html_url") or "",
                    snippet=sanitize_text(re.sub(r"\s+", " ", body), max_len=300),
                    ref=str(item.get("number") or ""),
                    state="merged" if merged else (item.get("state") or ""),
                )
            )

        for pr in [h for h in hits if h.kind == "pr"][:MAX_PR_SCAN]:
            detail = await self._get(client, f"/repos/{pr.repo}/pulls/{pr.ref}")
            head = (detail.get("head") or {}).get("ref") or ""
            if head:
                pr.snippet = f"branch {head}; {pr.snippet}".strip("; ")

        repos = [r for r in dict.fromkeys([self.repo_full, *(h.repo for h in hits)]) if r]
        for repo in repos[:MAX_BRANCH_REPOS]:
            branches = await self._get(client, f"/repos/{repo}/branches", params={"per_page": 100})
            for b in branches or []:
                name = b.get("name") or ""
                if pat.search(name):
                    hits.append(
                        CodeEvidence(
                            kind="branch",
                            repo=repo,
                            title=name,
                            url=f"https://github.com/{repo}/tree/{name}",
                            ref=name,
                            state="open",
                        )
                    )
        return hits

    async def open_pr_files(
        self,
        client: httpx.AsyncClient,
        names: List[str],
        keywords: List[str],
        jira_key: str,
        ticket_refs: List[CodeEvidence],
    ) -> List[CodeEvidence]:
        """Changed files on open PR branches (code search only indexes default branches).

        A file matches when it contains one of the ticket's API names; tickets without API
        names need at least two keywords, so a generic word like "Customer" is not enough.
        """
        low_names = [n.lower() for n in names]
        low_keywords = [k.lower() for k in keywords if len(k) >= 4]
        low_terms = low_names + low_keywords
        pat = key_pattern(jira_key) if jira_key else None

        def matches(haystack: str) -> bool:
            if low_names:
                return any(n in haystack for n in low_names)
            return sum(1 for k in low_keywords if k in haystack) >= min(2, len(low_keywords) or 1)

        candidates: Dict[Tuple[str, str], Tuple[str, bool]] = {}
        for pr in ticket_refs:
            if pr.kind == "pr" and pr.state == "open":
                candidates[(pr.repo, pr.ref)] = ("", True)
        if self.repo_full:
            pulls = await self._get(
                client, f"/repos/{self.repo_full}/pulls", params={"state": "open", "per_page": 20}
            )
            for p in pulls or []:
                key = (self.repo_full, str(p.get("number") or ""))
                for_ticket = bool(pat and pat.search(f"{p.get('title') or ''}\n{p.get('body') or ''}"))
                head = (p.get("head") or {}).get("ref") or ""
                prev = candidates.get(key, ("", False))
                candidates[key] = (head, prev[1] or for_ticket)

        hits: List[CodeEvidence] = []
        for (repo, number), (head, for_ticket) in list(candidates.items())[:MAX_PR_SCAN]:
            files = await self._get(
                client, f"/repos/{repo}/pulls/{number}/files", params={"per_page": 100}
            )
            kept = 0
            for f in files or []:
                path = f.get("filename") or ""
                patch = f.get("patch") or ""
                haystack = f"{path}\n{patch}".lower()
                if not for_ticket and not matches(haystack):
                    continue
                hits.append(
                    CodeEvidence(
                        kind="pr_file",
                        repo=repo,
                        title=path,
                        url=f.get("blob_url") or "",
                        snippet=_excerpt(patch, low_terms) or "(no patch)",
                        ref=head or f"PR #{number}",
                        state="open",
                    )
                )
                kept += 1
                if for_ticket and kept >= MAX_FILES_PER_KEY_PR:
                    break
        return hits


class MockGitHubSearch:
    """Returns seeded evidence; empty by default so offline runs behave as before."""

    def __init__(self, evidence: Optional[GitHubEvidence] = None) -> None:
        self.evidence = evidence or GitHubEvidence()
        self.calls: List[Dict[str, str]] = []

    async def gather(self, jira_key: str, summary: str, description: str) -> GitHubEvidence:
        self.calls.append({"jira_key": jira_key, "summary": summary})
        return self.evidence


def github_search_available(settings: Settings) -> bool:
    return (
        settings.git_provider == "github"
        and bool(settings.github_token)
        and bool(settings.github_org or settings.github_owner_repo)
    )


def get_github_search(settings: Optional[Settings] = None) -> CodeSearch:
    settings = settings or get_settings()
    if github_search_available(settings):
        return HttpGitHubSearch(settings)
    return MockGitHubSearch()
