"""Run finalized synthetic notification regressions against notification modules from EXE PYZ.

Both tested modules and their lazy reply_session_policy helper use this same EXE.

Run only after the final EXE and production test files have been synchronized:
  C:\\wechat_rpa\\.build-venv\\Scripts\\python.exe <this-script>

No packages are installed. Only pure Python pytest dependencies may fall back to
Python 3.11 site-packages. All application state stays in a temporary directory;
unmocked external actions and skipped tests make the verification fail.
"""
from __future__ import annotations

import argparse
import contextlib
import hashlib
import importlib
import importlib.abc
import importlib.machinery
import importlib.util
import io
import json
import marshal
import os
from pathlib import Path
import socket
import sqlite3
import sys
import tempfile
import time
import traceback
import types
from unittest import mock
from urllib.parse import unquote, urlsplit


PROJECT = Path(r"C:\wechat_rpa")
FALLBACK = Path(r"C:\Users\isard\AppData\Local\Programs\Python\Python311\Lib\site-packages")
EXE_RELATIVE = "dist/ZhenAI-WeCom-Assistant-v1.4.29/ZhenAI-WeCom-Assistant-v1.4.29.exe"
PURE_FALLBACK = frozenset({"pytest", "_pytest", "pluggy", "iniconfig", "packaging", "pygments", "colorama"})


def inside(path, root):
    try:
        Path(path).resolve().relative_to(root.resolve())
        return True
    except (TypeError, ValueError, OSError):
        return False


def sha256(path):
    digest = hashlib.sha256()
    with path.open("rb") as stream:
        for part in iter(lambda: stream.read(1024 * 1024), b""):
            digest.update(part)
    return digest.hexdigest()


def allowed_fallback(name, origin, root):
    if Path(origin).suffix.lower() not in (".py", ".pyc"):
        return False
    if name.split(".", 1)[0] in PURE_FALLBACK:
        return True
    # pytest 8.4 ships this shim in its own distribution RECORD. Reject the
    # unrelated pylib package (py/__init__.py) if it has higher precedence.
    return (name == "py" and Path(origin).resolve() == root / "py.py") or (
        name in {"py.error", "py.path"} and inside(origin, root / "_pytest" / "_py"))


class PureFallbackOnly(importlib.abc.MetaPathFinder):
    """Prevent other CPython 3.11 packages/extensions entering a 3.12 process."""
    def __init__(self, root):
        self.root = root

    def find_spec(self, fullname, path=None, target=None):
        spec = importlib.machinery.PathFinder.find_spec(fullname, path, target)
        if spec is None:
            return None
        locations = [spec.origin] if spec.origin not in (None, "built-in", "frozen") else []
        locations += list(spec.submodule_search_locations or ())
        if any(inside(location, self.root) for location in locations):
            if not spec.origin or not allowed_fallback(fullname, spec.origin, self.root):
                raise ImportError("Forbidden Python 3.11 fallback dependency: " + fullname)
        return None


def fallback_inventory(root):
    result = []
    for name, module in tuple(sys.modules.items()):
        origin = getattr(module, "__file__", None)
        if origin and inside(origin, root):
            if not allowed_fallback(name, origin, root):
                raise RuntimeError("Unexpected Python 3.11 module: " + name)
            result.append({"module": name, "path": str(origin)})
    return sorted(result, key=lambda row: row["module"])


class FrozenCode(importlib.abc.MetaPathFinder, importlib.abc.Loader):
    def __init__(self, code, exe, isolated_root):
        self.code, self.exe, self.isolated_root = code, exe, isolated_root

    def find_spec(self, fullname, path=None, target=None):
        if fullname in self.code:
            return importlib.util.spec_from_loader(fullname, self, origin=str(self.exe) + "!PYZ.pyz/" + fullname)
        return None

    def create_module(self, spec):
        return None

    def exec_module(self, module):
        # Contacts includes __file__.parent in cache search paths. Keep it isolated
        # while retaining the real EXE origin in __spec__ and this loader.
        module.__file__ = str(self.isolated_root / (module.__name__ + ".py"))
        exec(self.code[module.__name__], module.__dict__)


class Outcomes:
    def __init__(self):
        self.collected = []
        self.reports = []
        self.collection_errors = []

    def pytest_collection_finish(self, session):
        self.collected = [item.nodeid for item in session.items]

    def pytest_collectreport(self, report):
        if report.failed or report.skipped:
            self.collection_errors.append({"test": report.nodeid, "outcome": report.outcome,
                                           "detail": str(report.longrepr)})

    def pytest_runtest_logreport(self, report):
        self.reports.append({"test": report.nodeid, "phase": report.when, "outcome": report.outcome,
                             "xfail": str(getattr(report, "wasxfail", "")),
                             "detail": str(report.longrepr) if report.failed or report.skipped else ""})


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--project", type=Path, default=PROJECT)
    parser.add_argument("--exe", type=Path)
    parser.add_argument("--fallback", type=Path, default=FALLBACK)
    parser.add_argument("--output", type=Path, default=Path(__file__).with_name("frozen-plaintext-chat-notifications.json"))
    args = parser.parse_args()
    plan = json.loads(Path(__file__).with_name('plaintext-chat-release-plan.json').read_text(encoding='utf-8-sig'))
    if plan.get('finalized') is not True or plan.get('version') != '1.4.29':
        raise RuntimeError('Root-finalized 1.4.29 plan required')
    expected_tests = int(plan.get('notificationExpectedTests', 0))
    frozen_modules = tuple(plan.get('notificationFrozenModules', ()))
    test_names = tuple(plan.get('notificationTestFiles', ()))
    if expected_tests <= 0 or not test_names:
        raise RuntimeError('Confirm exact synthetic notification test files/count before verification')
    if not {'review_assistant_contacts','review_assistant','reply_session_policy','review_state'} <= set(frozen_modules):
        raise RuntimeError('Notification modules and review-state policy must come from EXE PYZ')
    if not set(frozen_modules) <= set(plan['frozenModules']):
        raise RuntimeError('Notification PYZ modules must also pass source fingerprint verification')
    project, fallback = args.project.resolve(), args.fallback.resolve()
    exe = (args.exe or project / EXE_RELATIVE).resolve()
    output = args.output.resolve()
    output.parent.mkdir(parents=True, exist_ok=True)
    log = io.StringIO()
    started = time.monotonic()
    attempts = []
    report = {"ok": False, "expected_tests": expected_tests, "python": sys.version,
              "executable": sys.executable, "project": str(project), "exe": str(exe),
              "blocked_external_actions": attempts, "tests_run": 0, "passed": 0,
              "failures": 0, "skipped": 0, "plugin_autoload_disabled": True}
    state = {"active": False}
    initial_cwd = Path.cwd()

    def reject(name):
        attempts.append(name)
        raise RuntimeError("Frozen notification audit blocks external action: " + name)

    def blocked(name):
        def call(*a, **kw):
            return reject(name)
        return call

    try:
        with contextlib.redirect_stdout(log), contextlib.redirect_stderr(log):
            if sys.version_info[:2] != (3, 12):
                raise RuntimeError("Use the production Python 3.12 build venv")
            if not inside(sys.executable, project / ".build-venv"):
                raise RuntimeError("Interpreter is not the production build venv")
            tests = [project / 'tests' / name for name in test_names]
            if any(not inside(path, project / 'tests') or path.suffix != '.py' for path in tests):
                raise RuntimeError('Only synthetic Python tests below project/tests may be selected')
            for path in [exe, *tests, fallback / "pytest" / "__init__.py"]:
                if not path.is_file():
                    raise FileNotFoundError("Required finalized artifact is missing: " + str(path))
            report["test_files"] = [{"path": str(path), "sha256": sha256(path)} for path in tests]
            report["exe_sha256"] = sha256(exe)
            sys.dont_write_bytecode = True
            os.environ["QT_QPA_PLATFORM"] = "offscreen"
            os.environ["PYTEST_DISABLE_PLUGIN_AUTOLOAD"] = "1"
            os.environ.pop("PYTEST_PLUGINS", None)
            os.environ.pop("PYTEST_ADDOPTS", None)
            # Load native Qt BEFORE making any 3.11 dependencies discoverable.
            from PySide6 import QtCore
            import PySide6
            import shiboken6
            qt_modules = (PySide6, QtCore, shiboken6)
            for module in qt_modules:
                if not inside(module.__file__, project / ".build-venv"):
                    raise RuntimeError("Qt must come from the Python 3.12 build venv")
            report["qt_dependencies"] = {module.__name__: module.__file__ for module in qt_modules}
            fallback_guard = PureFallbackOnly(fallback)
            sys.meta_path.insert(0, fallback_guard)
            sys.path.append(str(fallback))  # No .pth execution, no installation.
            dependencies = {name: importlib.import_module(name) for name in
                            ("pytest", "pluggy", "iniconfig", "packaging", "pygments", "colorama")}
            pytest = dependencies["pytest"]
            report["pytest_dependencies"] = {name: {"path": module.__file__,
                "version": str(getattr(module, "__version__", "")),
                "from_311_fallback": inside(module.__file__, fallback)}
                for name, module in dependencies.items()}
            report["pytest_compatibility_shim"] = {"distribution": "pytest", "path": sys.modules["py"].__file__}
            from PyInstaller.archive.readers import CArchiveReader
            pyz = CArchiveReader(str(exe)).open_embedded_archive("PYZ.pyz")
            code = {name: pyz.extract(name) for name in frozen_modules}
            if any(not isinstance(value, types.CodeType) for value in code.values()):
                raise RuntimeError("Required executable PYZ modules were not found")
            report["frozen_modules"] = {name: {"origin": str(exe) + "!PYZ.pyz/" + name,
                "code_sha256": hashlib.sha256(marshal.dumps(value)).hexdigest()} for name, value in code.items()}
            with tempfile.TemporaryDirectory(prefix="frozen-customer-notify-", ignore_cleanup_errors=True) as temp, contextlib.ExitStack() as stack:
                isolated = Path(temp).resolve()
                os.chdir(isolated)
                report["isolated_state"] = str(isolated)
                stack.enter_context(mock.patch.dict(os.environ, {"LOCALAPPDATA": str(isolated),
                    "APPDATA": str(isolated), "TMP": str(isolated), "TEMP": str(isolated)}))
                stack.enter_context(mock.patch.object(tempfile, "tempdir", str(isolated)))
                # Runtime helpers are infrastructure, not either tested module.
                sys.path.insert(0, str(project))
                try:
                    runtime = importlib.import_module("runtime_paths")
                finally:
                    sys.path.remove(str(project))
                for name in ("application_data_dir", "resource_dir"):
                    stack.enter_context(mock.patch.object(runtime, name, return_value=isolated))
                stack.enter_context(mock.patch.object(runtime, "resource_path", side_effect=lambda *parts: isolated.joinpath(*parts)))
                for name in ("connect", "connect_ex", "send", "sendall", "sendto"):
                    stack.enter_context(mock.patch.object(socket.socket, name, blocked("socket." + name)))
                stack.enter_context(mock.patch.object(socket, "getaddrinfo", blocked("socket.getaddrinfo")))
                # Native modules are blocked underneath each test's explicit fakes.
                native = types.ModuleType("wecom_native_sender")
                native.NativeSender = blocked("native.NativeSender")
                native.discover = blocked("native.discover")
                native.readonly_build_validation_scope = contextlib.nullcontext
                reply_db = types.ModuleType("reply_database")
                reply_db.LiveReplyDatabase = type("BlockedLiveReplyDatabase", (),
                    {"_open_database": staticmethod(blocked("native.LiveReplyDatabase"))})
                send_lock = types.ModuleType("send_lock")
                send_lock.try_acquire = blocked("native.send_lock.acquire")
                send_lock.release = blocked("native.send_lock.release")
                substitutes = {"wecom_native_sender": native, "reply_database": reply_db, "send_lock": send_lock}
                for module_name in ("pyautogui", "pyperclip", "win32gui", "win32api", "PIL.ImageGrab"):
                    module = types.ModuleType(module_name)
                    def get_attribute(name, prefix=module_name):
                        if name.startswith("__"):
                            raise AttributeError(name)
                        return blocked(prefix + "." + name)
                    module.__getattr__ = get_attribute
                    substitutes[module_name] = module
                stack.enter_context(mock.patch.dict(sys.modules, substitutes))

                def database_path(value):
                    text = os.fsdecode(value)
                    if text == ":memory:":
                        return isolated / "memory"
                    if text.startswith("file:"):
                        parsed = urlsplit(text)
                        if parsed.netloc:
                            return Path("//" + parsed.netloc + unquote(parsed.path))
                        text = unquote(parsed.path)
                        if len(text) > 2 and text[0] == "/" and text[2] == ":":
                            text = text[1:]
                    return Path(text)

                real_connect = sqlite3.connect
                def safe_connect(database, *a, **kw):
                    if not inside(database_path(database), isolated):
                        return reject("sqlite outside isolated state")
                    return real_connect(database, *a, **kw)
                stack.enter_context(mock.patch.object(sqlite3, "connect", safe_connect))
                private_roots = (project, Path(r"C:\kefu\wechat_rpa"),
                    Path(os.environ.get("USERPROFILE", str(isolated))) / "AppData/Local/ZhenYangTangRPA")

                def audit(event, values):
                    if not state["active"]:
                        return
                    if event in {"subprocess.Popen", "os.system", "os.startfile", "os.startfile/2",
                                 "ctypes.dlopen", "ctypes.dlsym", "socket.connect", "socket.bind", "socket.sendto"}:
                        reject(event)
                    if event == "sqlite3.connect" and not inside(database_path(values[0]), isolated):
                        reject("sqlite audit outside isolated state")
                    if event == "open" and isinstance(values[0], (str, bytes, os.PathLike)):
                        path = Path(os.fsdecode(values[0]))
                        if inside(path, isolated):
                            return
                        flags = values[2] if len(values) > 2 and isinstance(values[2], int) else 0
                        mode = values[1] if len(values) > 1 and isinstance(values[1], str) else ""
                        write = flags & (os.O_WRONLY | os.O_RDWR | os.O_CREAT | os.O_TRUNC | os.O_APPEND) or any(c in mode for c in "wax+")
                        if write:
                            reject("file write outside isolated state")
                        if (any(inside(path, root) for root in private_roots)
                                and not inside(path, project / ".build-venv")
                                and path.suffix.lower() not in {".py", ".pyc", ".pyd", ".dll"}):
                            reject("real application data read")
                    if event in {"os.remove", "os.rmdir", "os.mkdir", "os.rename"}:
                        paths = values[:2] if event == "os.rename" else values[:1]
                        if any(isinstance(path, (str, bytes, os.PathLike)) and not inside(os.fsdecode(path), isolated) for path in paths):
                            reject("filesystem mutation outside isolated state")

                sys.addaudithook(audit)
                state["active"] = True
                frozen_loader = FrozenCode(code, exe, isolated)
                if any(name in sys.modules for name in frozen_modules):
                    raise RuntimeError("Tested module was loaded before the frozen loader")
                sys.meta_path.insert(0, frozen_loader)
                frozen_loaded = {name: importlib.import_module(name) for name in frozen_modules}
                for name, module in frozen_loaded.items():
                    if module.__loader__ is not frozen_loader:
                        raise RuntimeError("Source fallback detected: " + name)
                ini = isolated / "pytest.ini"
                ini.write_text("[pytest]\n", encoding="utf-8")
                outcomes = Outcomes()
                pytest_args = ["-q", "--strict-markers", "-p", "no:cacheprovider", "--noconftest",
                    "--import-mode=importlib", "--rootdir=" + str(isolated), "-c", str(ini),
                    "--basetemp=" + str(isolated / "pytest-tmp"),
                    "--log-file=" + str(isolated / "pytest.log"), *map(str, tests)]
                report["pytest_args"] = pytest_args
                report["pytest_exit_code"] = int(pytest.main(pytest_args, plugins=[outcomes]))
                report["tests_run"] = len(outcomes.collected)
                report["passed"] = sum(row["phase"] == "call" and row["outcome"] == "passed" for row in outcomes.reports)
                report["skipped"] = sum(row["outcome"] == "skipped" or bool(row["xfail"]) for row in outcomes.reports)
                report["failures"] = sum(row["outcome"] == "failed" for row in outcomes.reports)
                report["collection_errors"] = outcomes.collection_errors
                report["test_results"] = outcomes.reports
                report["fallback_modules"] = fallback_inventory(fallback)
                for name, module in frozen_loaded.items():
                    if sys.modules.get(name) is not module or module.__loader__ is not frozen_loader:
                        raise RuntimeError("Tested frozen module was not restored after test mocks: " + name)
                report["ok"] = (report["pytest_exit_code"] == 0 and report["tests_run"] == expected_tests
                    and report["passed"] == expected_tests and report["skipped"] == 0
                    and report["failures"] == 0 and not outcomes.collection_errors and not attempts)
                state["active"] = False
                os.chdir(initial_cwd)
    except BaseException:
        state["active"] = False
        report["error"] = traceback.format_exc()
        log.write(report["error"])
        report["ok"] = False
    finally:
        state["active"] = False
        os.chdir(initial_cwd)
        report["elapsed_seconds"] = round(time.monotonic() - started, 3)
        output.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
        output.with_suffix(".log").write_text(log.getvalue(), encoding="utf-8")
    print(json.dumps({key: report[key] for key in
        ("ok", "tests_run", "passed", "failures", "skipped", "blocked_external_actions", "elapsed_seconds")}, ensure_ascii=False))
    print("Report: " + str(output))
    print("Log: " + str(output.with_suffix(".log")))
    return 0 if report["ok"] else 1


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