import argparse
import hashlib
import json
import os
import re
import subprocess
import sys
from concurrent.futures import ThreadPoolExecutor
from itertools import combinations
from pathlib import Path
from urllib.parse import quote, urlencode

import nid_names

PARENT = 'if .parent then "\\(.parent.owner.login)/\\(.parent.name)" else .nameWithOwner end'
EXPORT = re.compile(r"^\+.*\bAPS5_VABI\s+(\w+)\s*\(")
NID_DISAMBIG = re.compile(r"_nid_disambig[0-9]+$")
DEPENDS = re.compile(r'Depends on:[ \t]*((?:#\d+\b(?:(?:[ \t]*,[ \t]*(?:and[ \t]+)?|[ \t]+and[ \t]+)#\d+\b)*|none\b)?(?:\r?\n[ \t]*[-*][ \t]*#\d+\b[^\r\n]*)*)')
PLAIN_DEPENDS = re.compile(r'Depends on[ \t]+(#\d+\b(?:(?:[ \t]*,[ \t]*(?:and[ \t]+)?|[ \t]+and[ \t]+)#\d+\b)*)')
HUNK = re.compile(r"^@@ -(\d+)(?:,(\d+))?", re.M)
MARKER = "<!-- pr-overlap -->"
FETCH_REFS = 100
PROGRESS_EVERY = 100
_REPO_ROOTS = {}


def git(*args):
    cwd = Path.cwd()
    root = _REPO_ROOTS.get(cwd)
    if root is None:
        root = subprocess.run(
            ["git", "rev-parse", "--show-toplevel"], cwd=cwd, capture_output=True, check=True
        ).stdout.decode("utf-8", errors="replace").strip()
        _REPO_ROOTS[cwd] = root
    args = list(args)
    if "--" in args:
        separator = args.index("--")
        for index in range(separator + 1, len(args)):
            pathspec = args[index]
            if pathspec.startswith(("../", "..\\")):
                absolute = (cwd / pathspec).resolve()
                try:
                    args[index] = absolute.relative_to(Path(root)).as_posix()
                except ValueError:
                    pass
    result = subprocess.run(
        ["git", "-c", "core.quotePath=false", *args],
        cwd=root,
        capture_output=True,
    )
    result.stdout = result.stdout.decode("utf-8", errors="replace")
    result.stderr = result.stderr.decode("utf-8", errors="replace")
    result.check_returncode()
    return result.stdout


def own(prs, sha):
    ancestors = set(git("rev-list", sha).splitlines())
    return {n: pr for n, pr in prs.items() if pr["sha"] not in ancestors}


def gh(*args):
    return subprocess.run(["gh", *args], capture_output=True, text=True, encoding="utf-8", check=True).stdout


def upstream():
    return os.environ.get("GITHUB_REPOSITORY") or gh("repo", "view", "--json", "nameWithOwner,parent", "--jq", PARENT).strip()


def depends_on(body):
    body = re.sub(r"<!--.*?-->", "", body or "", flags=re.S)
    repo = re.escape(globals().get("REPO", "boykopovar/AnyPS5"))
    repo_pattern = rf"(?:{repo}|boykopovar/AnyPS5)"
    body = re.sub(rf"\[([^\]]*)\]\(https?://(?:www\.)?github\.com/{repo_pattern}/pull/(\d+)(?:[#/?][^)\s]*)?\)", r"#\2", body, flags=re.IGNORECASE)
    body = re.sub(rf"\[([^\]]*)\]\(https?://(?:www\.)?github\.com/(?!{repo_pattern}/)[^/\s]+/[^/\s]+/pull/\d+[^)\s]*\)", "", body, flags=re.IGNORECASE)
    body = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", body)
    body = re.sub(rf"https?://(?:www\.)?github\.com/{repo_pattern}/pull/(\d+)\b(?:/[^\s]*)?", r"#\1", body, flags=re.IGNORECASE)
    match = next((match for match in DEPENDS.finditer(body) if match.group(1).strip()), None) or PLAIN_DEPENDS.search(body)
    return {int(n) for n in re.findall(r"#(\d+)", match.group(1))} if match else set()

def progress(message):
    print(f"pr_overlap: {message}", file=sys.stderr, flush=True)


LAST_PAGE = re.compile(r'[?&]page=(\d+)>; rel="last"')


def page(url):
    out = gh("api", "--include", url)
    if not out.startswith("HTTP/"):
        return "", out
    blank = re.search(r"\r?\n\r?\n", out)
    return (out, "") if blank is None else (out[:blank.start()], out[blank.end():])


def json_pages(out):
    decoder = json.JSONDecoder()
    offset = 0
    pages = []
    while offset < len(out):
        while offset < len(out) and out[offset].isspace():
            offset += 1
        if offset == len(out):
            break
        found, offset = decoder.raw_decode(out, offset)
        if not isinstance(found, list):
            raise ValueError("gh api returned a non-array page")
        pages.append(found)
    return pages


def open_prs(base):
    query = urlencode({"state": "open", "base": base, "per_page": 100})
    url = f"repos/{REPO}/pulls?{query}"
    head, out = page(f"{url}&page=1")
    pages = json_pages(out)
    if not pages:
        raise ValueError("gh api returned no JSON pages")
    last = LAST_PAGE.search(head)
    if last:
        numbers = range(2, int(last.group(1)) + 1)
        with ThreadPoolExecutor(max_workers=8) as executor:
            for out in executor.map(lambda number: page(f"{url}&page={number}")[1], numbers):
                pages.extend(json_pages(out))
        pushed_past_last = numbers.stop
        while len(pages[-1]) == 100:
            pages.extend(json_pages(page(f"{url}&page={pushed_past_last}")[1]) or [[]])
            pushed_past_last += 1
    pull_requests = [pr for found in pages for pr in found]
    prs = {}
    for pr in pull_requests:
        prs[pr["number"]] = {
            "ref": f"refs/pr/{pr['number']}",
            "sha": pr["head"]["sha"],
            "author": pr["user"]["login"],
            "depends": depends_on(pr["body"]),
        }
    progress(f"{len(prs)} open pull requests against {base}")
    return prs


def fetch(base, prs):
    refspecs = [f"+refs/heads/{base}:refs/pr/base"] + [f"+{pr['sha']}:{pr['ref']}" for pr in prs.values()]
    for start in range(0, len(refspecs), FETCH_REFS):
        git("fetch", "--no-tags", "-q", f"https://github.com/{REPO}.git", *refspecs[start:start + FETCH_REFS])
        progress(f"fetched {min(start + FETCH_REFS, len(refspecs)) - 1}/{len(prs)} pull request heads")


def merge(*args):
    cwd = Path.cwd()
    root = _REPO_ROOTS.get(cwd)
    if root is None:
        root = subprocess.run(
            ["git", "rev-parse", "--show-toplevel"], cwd=cwd, capture_output=True, check=True
        ).stdout.decode("utf-8", errors="replace").strip()
        _REPO_ROOTS[cwd] = root
    result = subprocess.run(["git", "-c", "core.quotePath=false", "merge-tree", "--write-tree", "--name-only", "--no-messages", "-z", *args],
                            cwd=root, capture_output=True)
    lines = result.stdout.decode("utf-8", errors="replace").rstrip("\0").split("\0")
    if result.returncode not in (0, 1) or not lines[0]:
        required = (2, 40) if any(arg.startswith("--merge-base") for arg in args) else (2, 38)
        found = re.match(rb"git version (\d+)\.(\d+)", subprocess.run(["git", "version"], capture_output=True).stdout)
        version = (int(found.group(1)), int(found.group(2))) if found else None
        if version and version < required:
            raise RuntimeError(f"git merge-tree {' '.join(args)} needs git {required[0]}.{required[1]} or newer; "
                               f"this git is {version[0]}.{version[1]}")
        error = result.stderr.decode("utf-8", errors="replace").strip()
        raise RuntimeError(f"git merge-tree {' '.join(args)} failed: {error}")
    return lines[0], set(lines[1:]) if result.returncode else set()


def commit(tree):
    return git("-c", "user.name=pr_overlap", "-c", "user.email=pr_overlap", "commit-tree", tree,
               "-p", "refs/pr/base", "-m", "pr_overlap").strip()


def exports(diff, prefix="+"):
    found = set()
    lines = diff.splitlines()
    for i, line in enumerate(lines):
        if not line.startswith(prefix) or line.startswith(prefix * 3):
            continue
        m = EXPORT.match(prefix + line[1:])
        if not m or m.group(1).endswith(("_nid_no_patch", "_nid_no_patch_cut")):
            continue
        text = line[1:]
        for nxt in lines[i + 1:]:
            if ";" in text or "{" in text or not nxt.startswith(prefix) or nxt.startswith(prefix * 3):
                break
            text += nxt[1:]
        semi, brace = text.find(";"), text.find("{")
        if semi < 0 or 0 <= brace < semi:
            name = m.group(1).removesuffix("_nid_postfix")
            found.add(NID_DISAMBIG.sub("", name))
    return found


def changed_source(diff, prefix):
    files, current, path = [], [], None
    for line in diff.splitlines():
        if line.startswith("diff --git "):
            if current and path:
                files.append((path, "\n".join(current)))
            path = line.split(" b/", 1)[1] if " b/" in line else None
            current = []
        elif line.startswith(prefix) and not line.startswith(prefix * 3):
            current.append(line[1:])
    if current and path:
        files.append((path, "\n".join(current)))
    return files


def library_for_path(path):
    parts = Path(path).parts
    return "/".join(parts[:4]) if len(parts) > 3 and parts[:3] == ("core", "libs", "prx") else ""


def source_exports(text, library=""):
    found = {}
    for match in nid_names.source_definitions(text):
        name = nid_names.strip_nid_postfix(match.group(1))
        if not name.endswith(("_nid_no_patch", "_nid_no_patch_cut")):
            found.setdefault((library, nid_names.compute_nid(name)), set()).add(name)
    for name in nid_names.source_assembly_definitions(text):
        name = nid_names.strip_nid_postfix(name)
        if not name.endswith(("_nid_no_patch", "_nid_no_patch_cut")):
            found.setdefault((library, nid_names.compute_nid(name)), set()).add(name)
    for nid, name in nid_names.source_aliases(text):
        found.setdefault((library, nid), set()).add(name)
    return found


def source_changed_exports(diff, prefix):
    found = {}
    for path, text in changed_source(diff, prefix):
        library = library_for_path(path)
        for key, names in source_exports(text, library).items():
            found.setdefault(key, set()).update(names)
        file_diff = "\n".join(prefix + line for line in text.splitlines())
        for name in exports(file_diff, prefix):
            canonical = nid_names.strip_nid_postfix(name)
            found.setdefault((library, nid_names.compute_nid(canonical)), set()).add(canonical)
    return found


def export_cache_version():
    parsers = (Path(__file__), Path(nid_names.__file__))
    return hashlib.sha256(b"".join(path.read_bytes() for path in parsers)).hexdigest()


def load_export_cache(path, version):
    try:
        cache = json.loads(path.read_text(encoding="utf-8"))
    except (OSError, ValueError):
        return {}
    if not isinstance(cache, dict) or cache.get("version") != version or not isinstance(cache.get("files"), dict):
        return {}
    return cache["files"]


def save_export_cache(path, version, files):
    temporary = path.with_name(f"{path.name}.{os.getpid()}.tmp")
    try:
        temporary.write_text(json.dumps({"version": version, "files": files}), encoding="utf-8")
        os.replace(temporary, path)
    except OSError:
        temporary.unlink(missing_ok=True)


def base_sources(root, ref):
    listing = subprocess.run(["git", "-C", root, "ls-tree", "-r", "-z", ref, "--", "core/libs"],
                             capture_output=True, check=True).stdout.decode("utf-8", errors="replace")
    sources = []
    for entry in filter(None, listing.split("\0")):
        info, name = entry.split("\t", 1)
        mode, kind, blob = info.split()
        path = Path(name)
        if kind != "blob" or mode == "120000" or path.suffix != ".cpp" or any(
                part.lower() in {"test", "tests"} for part in path.parts[2:-1]):
            continue
        sources.append((blob, name))
    return sources


def blob_texts(root, blobs):
    if not blobs:
        return {}
    out = subprocess.run(["git", "-C", root, "cat-file", "--batch"], input="".join(f"{blob}\n" for blob in blobs).encode(),
                         capture_output=True, check=True).stdout
    texts, offset = {}, 0
    for blob in blobs:
        header_end = out.index(b"\n", offset)
        size = int(out[offset:header_end].split()[2])
        texts[blob] = out[header_end + 1:header_end + 1 + size].decode("utf-8", errors="replace")
        offset = header_end + 2 + size
    return texts


def base_exports(ref):
    root = git("rev-parse", "--show-toplevel").strip()
    cache_path = Path(root, git("rev-parse", "--git-common-dir").strip()) / "pr_overlap-exports.json"
    version = export_cache_version()
    cached = load_export_cache(cache_path, version)
    sources = base_sources(root, ref)
    keys = {(blob, name): f"{blob} {library_for_path(name)}" for blob, name in sources}
    texts = blob_texts(root, sorted({blob for (blob, name), key in keys.items() if key not in cached}))
    files = {}
    found = {}
    for (blob, name), key in keys.items():
        if key not in files:
            files[key] = cached[key] if key in cached else [
                [library, nid, sorted(names)] for (library, nid), names in source_exports(texts[blob], library_for_path(name)).items()]
        for library, nid, names in files[key]:
            found.setdefault((library, nid), set()).update(names)
    older_bases_fit = len(cached) + len(files) <= 4 * len(files)
    kept = {**cached, **files} if older_bases_fit else files
    if kept != cached:
        save_export_cache(cache_path, version, kept)
    return found


def scan(pr):
    tree, conflicted = merge("refs/pr/base", pr["ref"])
    pr["tree"] = None if conflicted else commit(tree)
    old, new = (git("merge-base", "refs/pr/base", pr["ref"]).strip(), pr["ref"]) if conflicted else ("refs/pr/base", pr["tree"])
    pr["files"], pr["added"] = set(), set()
    changes = git("diff", "--name-status", "--no-renames", "-z", old, new).split("\0")
    for status, path in zip(changes[::2], changes[1::2]):
        pr["files"].add(path)
        if status == "A":
            pr["added"].add(path)
    diff = git("diff", "-U0", "--no-color", old, new, "--", "core/libs/prx/*.cpp")
    pr["exports"] = exports(diff)
    pr["added_exports"] = source_changed_exports(diff, "+")
    pr["removed_exports"] = source_changed_exports(diff, "-")


def probe(pr):
    changes = git("diff", "--name-status", "--no-renames", "-z", f"refs/pr/base...{pr['ref']}").split("\0")
    files, existing = set(), set()
    for status, path in zip(changes[::2], changes[1::2]):
        files.add(path)
        if status != "A":
            existing.add(path)
    if not any(path.startswith("core/libs/prx/") and path.endswith(".cpp") for path in files):
        return files, set(), existing
    return files, exports(git("diff", "-U0", "--no-color", f"refs/pr/base...{pr['ref']}", "--", "core/libs/prx/*.cpp")), existing


def related(prs, executor):
    mine = prs[0]
    scan(mine)
    others = {n: pr for n, pr in prs.items() if n}
    base_paths = set(git("ls-tree", "-r", "--name-only", "-z", "refs/pr/base").split("\0"))
    chosen = {}
    for index, ((n, pr), (files, found, existing)) in enumerate(zip(others.items(), executor.map(probe, others.values())), 1):
        if files & mine["files"] or found & mine["exports"] or existing - base_paths:
            chosen[n] = pr
        else:
            pr.update(tree=None, files=set(), added=set(), exports=set())
        if index % PROGRESS_EVERY == 0 or index == len(others):
            progress(f"probed {index}/{len(others)} pull requests, {len(chosen)} share files or exports with the branch")
    return chosen


def scan_all(prs, jobs):
    with ThreadPoolExecutor(max_workers=jobs) as executor:
        pending = related(prs, executor) if 0 in prs else prs
        for index, _ in enumerate(executor.map(scan, pending.values()), 1):
            if index % PROGRESS_EVERY == 0 or index == len(pending):
                progress(f"merged {index}/{len(pending)} pull requests into the base")


def hunks(pr, path):
    diff = git("diff", "-U0", "--no-color", "refs/pr/base", pr["tree"], "--", path)
    found = []
    for start, count in HUNK.findall(diff):
        start = max(int(start), 1)
        found.append((start, start + max(int(count or 1), 1) - 1))
    return found


def clashes(a, b, path):
    ranges = sorted((min(s1, s2), max(e1, e2)) for s1, e1 in hunks(a, path) for s2, e2 in hunks(b, path)
                    if s1 <= e2 + 1 and s2 <= e1 + 1)
    merged = []
    for start, end in ranges:
        if merged and start <= merged[-1][1] + 1:
            merged[-1] = (merged[-1][0], max(merged[-1][1], end))
        else:
            merged.append((start, end))
    return merged


def conflicts(a, b):
    if not (a["tree"] and b["tree"] and a["files"] & b["files"]):
        return {}
    files = merge(a["tree"], b["tree"])[1]
    return {path: [] if path in a["added"] else clashes(a, b, path) for path in files}


def dependencies(prs, number):
    found, pending = set(), [number]
    while pending:
        for n in prs[pending.pop()]["depends"]:
            if n in prs and n not in found:
                found.add(n)
                pending.append(n)
    return found


def overlaps(prs, a, b):
    pa, pb = prs[a], prs[b]
    da, db = dependencies(prs, a), dependencies(prs, b)
    if b in da or a in db:
        return None
    shared = [prs[n] for n in da & db]
    found = {"added": (pa["added"] & pb["added"]).difference(*(pr["added"] for pr in shared))}
    if pa["author"] != pb["author"]:
        found["conflicts"] = conflicts(pa, pb)
        found["exports"] = (pa["exports"] & pb["exports"]).difference(*(pr["exports"] for pr in shared))
        if not (pa["tree"] and pb["tree"]):
            uncompared = pa.get("files", set()) & pb.get("files", set())
            if uncompared:
                found["uncompared"] = uncompared
    return found if any(found.values()) else None



def code_span(item):
    item = str(item)
    runs = re.findall(r"`+", item)
    delimiter = "`" * (max((len(run) for run in runs), default=0) + 1)
    if "`" in item:
        return f"{delimiter} {item} {delimiter}"
    return f"{delimiter}{item}{delimiter}"


def cell(items):
    return "<br>".join(code_span(item) for item in sorted(items or ()))




def spans(conflicts, blob):
    return "<br>".join(
        f"{code_span(path)} " + ", ".join(
            f"[L{s}-{e}]({blob}/{quote(path)}#L{s}-L{e})"
            if s != e else f"[L{s}]({blob}/{quote(path)}#L{s})"
            for s, e in ranges
        )
        for path, ranges in sorted((conflicts or {}).items())
    )


def pull(blob, number):
    return f'[PR {number}]({blob.split("/blob/", 1)[0].replace("https://github.com/", "https://www.github.com/", 1)}/pull/{number})'


def report(rows, blob, main_exports=None):
    if not rows:
        if not main_exports:
            return ""
    confirmed = {number: found for number, found in rows.items()
                 if found.get("conflicts") or found.get("exports") or found["added"]}
    uncompared = {number: found["uncompared"] for number, found in rows.items() if found.get("uncompared")}
    lines = [MARKER]
    if confirmed:
        lines.extend([
            "Other open pull requests touch the same code. Merging one will break the other, "
            "or both implement the same thing. If this one builds on them, list them in **Depends on**.",
            "",
            "| Pull request | Conflicting files (lines on `main`) | Same exports | Same new files |",
            "|---|---|---|---|",
        ])
        for number, found in sorted(confirmed.items()):
            lines.append(f'| {pull(blob, number)} | {spans(found.get("conflicts"), blob)} | {cell(found.get("exports"))} | {cell(found["added"])} |')
    if main_exports:
        if confirmed:
            lines.append("")
        lines.append("Exports introduced here that are already present in `main`:")
        lines.append("")
        lines.append(f"- {cell(main_exports)}")
    if uncompared:
        if confirmed:
            lines.append("")
        lines.extend([
            "Some comparisons could not be completed because a pull request conflicts with the base branch. "
            "Review these shared files manually before concluding that there is no overlap.",
            "",
            "| Pull request | Shared files not compared |",
            "|---|---|",
        ])
        for number, files in sorted(uncompared.items()):
            lines.append(f"| {pull(blob, number)} | {cell(files)} |")
    return "\n".join(lines) + "\n"


def write_reports(out, rows, blob, main_exports=None):
    main_exports = main_exports or {}
    out.mkdir(parents=True, exist_ok=True)
    for number, found in rows.items():
        (out / f"{number}.md").write_text(report(found, blob, main_exports.get(number)), encoding="utf-8")


def main_export_findings(prs, current_exports):
    findings = {}
    for number, pr in prs.items():
        candidates = set(pr.get("added_exports", {})) - set(pr.get("removed_exports", {}))
        names = set()
        for key in candidates & set(current_exports):
            names.update(pr["added_exports"][key])
            names.update(current_exports[key])
        if names:
            findings[number] = names
    return findings


def describe_failure(error):
    command = " ".join(str(part) for part in error.cmd)
    message = (error.stderr or "").strip() or "no error output"
    return f"pr_overlap: {command} failed with exit code {error.returncode}: {message}"


def main(argv=None):
    if hasattr(sys.stdout, "reconfigure"):
        sys.stdout.reconfigure(encoding="utf-8", errors="backslashreplace")
    if hasattr(sys.stderr, "reconfigure"):
        sys.stderr.reconfigure(encoding="utf-8", errors="backslashreplace")
    parser = argparse.ArgumentParser(
        description="report open pull requests that overlap each other",
        epilog="The exports found in the base are cached by source blob in pr_overlap-exports.json inside the git "
               "directory; deleting that file only makes the next run slower.")
    parser.add_argument("--base", default="main")
    parser.add_argument("--out", type=Path, help="write <number>.md for every open pull request (empty when clean)")
    parser.add_argument("--branch", help="check a local branch against the open pull requests instead")
    parser.add_argument("--repo", help="owner/name; defaults to the upstream of the current checkout")
    parser.add_argument("--jobs", type=int, default=4, help="number of pull request comparisons to run at once")
    args = parser.parse_args(argv)
    if bool(args.out) == bool(args.branch):
        parser.error("pass exactly one of --out or --branch")
    if args.jobs < 1:
        parser.error("--jobs must be at least 1")
    global REPO
    try:
        REPO = args.repo or upstream()
        prs = open_prs(args.base)
        fetch(args.base, prs)
        if args.branch:
            sha = git("rev-parse", args.branch).strip()
            prs = own(prs, sha)
            prs[0] = {"ref": sha, "author": None, "depends": set()}
        scan_all(prs, args.jobs)
        current_exports = base_exports("refs/pr/base")
        rows = {n: {} for n in prs}
        main_exports = main_export_findings(prs, current_exports)
        pairs = [(0, n) for n in prs if n] if args.branch else combinations(prs, 2)
        for a, b in pairs:
            if found := overlaps(prs, a, b):
                rows[a][b] = rows[b][a] = found
        blob = f'https://github.com/{REPO}/blob/{git("rev-parse", "refs/pr/base").strip()}'
    except subprocess.CalledProcessError as error:
        raise SystemExit(describe_failure(error))
    if args.branch:
        print(report(rows[0], blob, main_exports.get(0)) or "No overlap with open pull requests.", end="")
        return 0
    write_reports(args.out, rows, blob, main_exports)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())