#!/usr/bin/env python3
"""Runtime error tests for surface evaluation and surface coloring.

An error ends the asy process, so each case runs a snippet of Asymptote code
in a process of its own and checks stderr against a regex pattern.  The cases
run in parallel and are reported together, in order, once all have finished.
The values returned when there is no error are tested in tests/three/*.asy.

Usage:
    python3 tests/test_surface_errors.py           # run all tests
    python3 tests/test_surface_errors.py -v        # verbose
    python3 tests/test_surface_errors.py -k PAT    # filter tests by name
"""

from __future__ import annotations

import argparse
import concurrent.futures
import os
import re
import sys

import asy_test_common

# Prepended to the snippets that use the surface named in their first line.

# A surface over box((1,2),(5,8)) with 4 x 3 mesh cells, cyclic in neither
# direction.
_PLANE = """
import graph3;
triple f(pair z) {return (z.x,z.y,0);}
surface s=surface(f,(1,2),(5,8),4,3);
"""

# A cylinder: cyclic in u (the angle, in radians), with 2 mesh cells in v.
_CYLINDER = """
import graph3;
surface s=surface(O,(1,0,0)--(1,0,1)--(1,0,3),Z,4);
"""

# A 3 x 3 grid without the four cells that touch the vertex (2,2).
_HOLE = """
import graph3;
triple f(pair z) {return (z.x,z.y,0);}
bool cond(pair z) {return z != (4,4);}
surface s=surface(f,(0,0),(6,6),3,3,cond);
"""

_COLORS = """
import three;
import palette;
"""

_OUTSIDE = r"lies outside the domain \[{},{}\] of the surface"
_UNSTRUCTURED = r"surface is unstructured \(it has no parametric coordinates\)"

# (name, code, pattern that stderr must match).  Every case costs a process, so
# there is one per kind of error rather than one per direction and method.
CASES: list[tuple[str, str, str]] = [
    # --- evaluation outside the domain of a noncyclic direction ---
    (
        "point just beyond the rounding tolerance",
        _PLANE + "s.point(4+1e-6,1);",
        "u=4.000001 " + _OUTSIDE.format(0, 4),
    ),
    ("point below v", _PLANE + "s.point(1,-2);", "v=-2 " + _OUTSIDE.format(0, 3)),
    ("normal above u", _PLANE + "s.normal(5,1);", "u=5 " + _OUTSIDE.format(0, 4)),
    # paramPoint and paramNormal report parametric coordinates.
    (
        "paramPoint above u",
        _PLANE + "s.paramPoint(6,3);",
        "u=6 " + _OUTSIDE.format(1, 5),
    ),
    (
        "paramNormal below v",
        _PLANE + "s.paramNormal(2,1);",
        "v=1 " + _OUTSIDE.format(2, 8),
    ),
    (
        "noncyclic direction of a cylinder",
        _CYLINDER + "s.point(9.5,2.5);",
        "v=2.5 " + _OUTSIDE.format(0, 2),
    ),
    # --- evaluation where a cell was omitted ---
    (
        "paramPoint in a missing cell",
        _HOLE + "s.paramPoint(3,3);",
        r"no patch at parametric coordinates \(3,3\)",
    ),
    # --- surfaces without parametric coordinates ---
    (
        "paramPoint on an unstructured surface",
        "import three; unitsphere.paramPoint(0,0);",
        "paramPoint: " + _UNSTRUCTURED,
    ),
    (
        "paramNormal on an unstructured surface",
        "import three; unitsphere.paramNormal(0,0);",
        "paramNormal: " + _UNSTRUCTURED,
    ),
    (
        "paramCoords on an unstructured surface",
        "import three; unitsphere.paramCoords(0,0);",
        "paramCoords: " + _UNSTRUCTURED,
    ),
    # --- bounds of an empty surface ---
    (
        "palette of a null surface",
        _COLORS + "surface s; s.palette(zpart,Rainbow());",
        "null surface",
    ),
    # --- cornerPen ---
    (
        "cornerPen with no rows",
        _COLORS + "cornerPen(new pen[][]);",
        "cornerPen: no pens specified$",
    ),
    (
        "cornerPen with an empty row",
        _COLORS + "cornerPen(new pen[][] {{red},{}});",
        "cornerPen: no pens specified for patch 1",
    ),
    (
        "cornerPen row shorter than the patch",
        _COLORS + """
        picture pic;
        draw(pic,surface(unitsquare3),cornerPen(red,green,blue));
        pic.fit3(currentprojection);
        """,
        "reading array of length 3 with out-of-bounds index 3",
    ),
    # --- fitColors ---
    (
        "fitColors with arrays of different length",
        _COLORS + "fitColors(new triple[] {O,X},new pen[] {red});",
        "coords and colors arrays must have the same length",
    ),
    (
        "fitColors with no data",
        _COLORS + "fitColors(new triple[],new pen[]);",
        "fitColors requires at least one data point",
    ),
]


def _available_cpus() -> int:
    """The number of CPUs this process may use (not the number in the machine)."""
    if hasattr(os, "sched_getaffinity"):
        return len(os.sched_getaffinity(0))
    return os.cpu_count() or 1


def main() -> int:
    parser = argparse.ArgumentParser(
        description="Runtime error tests for Asymptote surfaces."
    )
    parser.add_argument("-v", "--verbose", action="store_true", help="verbose output")
    parser.add_argument(
        "-k",
        "--filter",
        metavar="PATTERN",
        help="only run tests whose name matches PATTERN (case-insensitive regex)",
    )
    asy_test_common.add_asy_arguments(parser)
    args = parser.parse_args()

    cases = [
        case
        for case in CASES
        if not args.filter or re.search(args.filter, case[0], re.IGNORECASE)
    ]

    # The cases are independent processes, so run one per available core.  The
    # results come back in the order of CASES whichever finishes first, and
    # nothing is printed until then, so the report reads the same as a serial
    # run.
    with concurrent.futures.ThreadPoolExecutor(max_workers=_available_cpus()) as pool:
        results = list(
            pool.map(
                lambda case: asy_test_common.run_asy(
                    args.asy, args.asy_base_dir, case[1]
                ),
                cases,
            )
        )

    print(f"Testing runtime errors (surfaces, asy = {args.asy})")
    passed = failed = 0
    for (name, _, pattern), (stderr, returncode) in zip(cases, results):
        ok = returncode != 0 and bool(re.search(pattern, stderr, re.MULTILINE))
        if ok:
            passed += 1
        else:
            failed += 1
        if args.verbose or not ok:
            print(f"  {name} ... {'PASSED' if ok else 'FAILED'}")
        if not ok:
            print(f"    Expected pattern: {pattern!r}")
            print(f"    Got:              {stderr!r}")

    print(f"{passed}/{passed + failed} passed")
    if not failed:
        print("PASSED.")
    return 1 if failed else 0


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