#!/usr/bin/env python3

import sys, os, subprocess, hashlib

print("TAP version 14")

args = sys.argv[1:]

verbose = False
if args and args[0] == "-v":
    verbose = True
    args = args[1:]

if not args or args[0].find("hb-shape") == -1 or not os.path.exists(args[0]):
    sys.exit("""First argument does not seem to point to usable hb-shape.""")
hb_shape, args = args[0], args[1:]

env = os.environ.copy()
env["LC_ALL"] = "C"

EXE_WRAPPER = os.environ.get("MESON_EXE_WRAPPER")


def open_shape_batch_process():
    cmd = [hb_shape, "--batch"]
    if EXE_WRAPPER:
        cmd = [EXE_WRAPPER] + cmd

    process = subprocess.Popen(
        cmd,
        stdin=subprocess.PIPE,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        env=env,
    )
    return [process]


shape_process = open_shape_batch_process()
no_glyph_names_process = None


def shape_cmd(command, shape_process, verbose=False):
    global hb_shape

    # (Re)start shaper if it is dead
    if shape_process[0].poll() is not None:
        shape_process[0].stdin.close()
        shape_process[0].stdout.close()
        shape_process[0].stderr.close()
        shape_process[0] = open_shape_batch_process()[0]

    if verbose:
        print("# " + hb_shape + " " + " ".join(command))
    shape_process[0].stdin.write((";".join(command) + "\n").encode("utf-8"))
    shape_process[0].stdin.flush()
    return shape_process[0].stdout.readline().decode("utf-8").strip()


def plural(what):
    if not what.endswith("s"):
        what += "s"
    return what


def whats_var_name(what):
    return plural(what).replace("-", "_")


def supported_whats_var_name(what):
    whats = whats_var_name(what)
    return "supported_" + whats


def supported_whats(what):
    return globals()[supported_whats_var_name(what)]


def all_whats_var_name(what):
    whats = whats_var_name(what)
    return "all_" + whats


def all_whats(what):
    return globals()[all_whats_var_name(what)]


# Collect supported backends
for what in ["shaper", "face-loader", "font-funcs"]:
    subcommand = "--list-" + plural(what)

    cmd = [hb_shape, subcommand]
    if EXE_WRAPPER:
        cmd = [EXE_WRAPPER] + cmd

    what_process = subprocess.Popen(
        cmd,
        stdin=subprocess.PIPE,
        stdout=subprocess.PIPE,
        stderr=sys.stdout,
        env=env,
    )
    # Capture the output
    what_list = what_process.communicate()[0].decode("utf-8").strip().split()
    if what_process.returncode:
        sys.exit(f"Failed to run: {hb_shape} {subcommand}")
    whats = plural(what)
    var_name = supported_whats_var_name(what)
    globals()[var_name] = what_list
    print(f"# Supported {whats}: {what_list}")

# If running under Wine and not native dlls, make the respective shapers unavailable.
if os.environ.get("WINEPATH"):
    overrides = os.environ.get("WINEDLLOVERRIDES", "").lower()
    if "directwrite" in supported_shapers and overrides.find("dwrite") == -1:
        supported_shapers.remove("directwrite")
        print("# Skipping DirectWrite shaper under Wine.")
    if "uniscribe" in supported_shapers and overrides.find("usp10") == -1:
        supported_shapers.remove("uniscribe")
        print("# Skipping Uniscribe shaper under Wine.")


number = 0
passes = 0
fails = 0
skips = 0

if not len(args):
    args = ["-"]

for filename in args:
    if filename == "-":
        print("# Running tests from standard input")
    else:
        print("# Running tests in " + filename)

    if filename == "-":
        f = sys.stdin
    else:
        f = open(filename, encoding="utf8")

    # By default test all backends
    for what in ["shaper", "face-loader", "font-funcs"]:
        all_var_name = all_whats_var_name(what)
        globals()[all_var_name] = supported_whats(what)
    all_face_loaders = os.environ.get("HB_FACE_LOADER", "ot").split(",")
    all_shapers = os.environ.get("HB_SHAPER_LIST", "ot").split(",")

    # Right now we only test the 'ot' shaper if nothing specified,
    # but try all font-funcs unless overriden.
    # Only 'ot' face-loader is tested.

    for line in f:
        comment = False
        if line.startswith("#"):
            comment = True
            line = line[1:]

            if line.startswith(" "):
                if verbose:
                    print("#%s" % line)
                continue

        line = line.strip()
        if not line:
            continue

        if line.startswith("@"):
            # Directive
            line = line.strip()
            line = line.split("#")[0].strip()[1:]
            consumed = False
            for what in ["shaper", "face-loader", "font-funcs"]:
                whats = plural(what)
                if line.startswith(what) or line.startswith(whats):
                    command, values = line.split("=")
                    values = values.strip().split(",")

                    supported = supported_whats(what)
                    if command[-1] == "-":
                        # Exclude
                        values = [v for v in supported if v not in values]
                    else:
                        # Specify
                        values = [v for v in values if v in supported]

                    var_name = all_whats_var_name(what)
                    print(f"# Setting {whats} to test to {values}")
                    globals()[var_name] = values
                    consumed = True
            if consumed:
                print("#", line)
                continue
            else:
                print("Unrecognized directive: %s" % line, file=sys.stderr)
                sys.exit(1)

        fontfile, options, unicodes, glyphs_expected = line.split(";")
        options = options.split()
        if fontfile.startswith("/") or fontfile.startswith('"/'):
            if os.name == "nt":  # Skip on Windows
                continue

            fontfile, expected_hash = (fontfile.split("@") + [""])[:2]

            try:
                with open(fontfile, "rb") as ff:
                    if expected_hash:
                        actual_hash = hashlib.sha1(ff.read()).hexdigest().strip()
                        if actual_hash != expected_hash:
                            skips += 1
                            print(
                                "# Different version of %s found; Expected hash %s, got %s; skipping."
                                % (fontfile, expected_hash, actual_hash)
                            )
                            continue
            except IOError:
                skips += 1
                print("# %s not found, skip." % fontfile)
                continue
        else:
            cwd = os.path.dirname(filename)
            fontfile = os.path.normpath(os.path.join(cwd, fontfile))

        if comment:
            if verbose:
                print('# # %s "%s" --unicodes %s' % (hb_shape, fontfile, unicodes))
            continue

        skip_test = False
        shaper = None
        face_loader = None
        font_funcs = None
        new_options = []
        it = iter(options)
        for option in it:
            consumed = False
            for what in ["shaper", "face-loader", "font-funcs"]:
                if option.startswith("--" + what):
                    try:
                        backend = option.split("=")[1]
                    except IndexError:
                        backend = next(it)
                    if backend not in supported_whats(what):
                        skips += 1
                        number += 1
                        print(
                            f"ok {number} - {fontfile} # skip {what}={backend} not supported"
                        )
                        print(f"# Skipping test with {what}={backend}.")
                        skip_test = True
                        break
                    what = what.replace("-", "_")
                    globals()[what] = backend
                    consumed = True
            if not consumed:
                new_options.append(option)

            if skip_test:
                break
        if skip_test:
            continue
        options = new_options

        for face_loader in [face_loader] if face_loader else all_whats("face-loader"):
            for shaper in [shaper] if shaper else all_whats("shaper"):
                all_font_funcs_for_shaper = (
                    all_whats("font-funcs") if shaper == "ot" else [None]
                )
                for font_funcs in (
                    [font_funcs] if font_funcs else all_font_funcs_for_shaper
                ):
                    number += 1
                    extra_options = []

                    if shaper:
                        extra_options.append("--shaper=" + shaper)
                    if face_loader:
                        extra_options.append("--face-loader=" + face_loader)
                    if font_funcs:
                        extra_options.append("--font-funcs=" + font_funcs)

                    if glyphs_expected != "*":
                        extra_options.append("--verify")
                        extra_options.append("--unsafe-to-concat")
                        extra_options.append("--safe-to-insert-tatweel")

                    if verbose:
                        print(
                            "# shaper=%s face-loader=%s font-funcs=%s"
                            % (shaper, face_loader, font_funcs)
                        )
                    cmd = (
                        [fontfile] + ["--unicodes", unicodes] + options + extra_options
                    )
                    glyphs = shape_cmd(cmd, shape_process, verbose).strip()

                    if glyphs_expected == "*":
                        passes += 1
                        print(f"ok {number} - {fontfile}")
                        continue

                    final_glyphs = glyphs
                    final_glyphs_expected = glyphs_expected

                    if glyphs != glyphs_expected and glyphs.find("gid") != -1:
                        if not no_glyph_names_process:
                            no_glyph_names_process = open_shape_batch_process()

                        cmd2 = [fontfile] + ["--glyphs", "--no-glyph-names", glyphs]
                        final_glyphs = shape_cmd(cmd2, no_glyph_names_process).strip()

                        cmd2 = [fontfile] + [
                            "--glyphs",
                            "--no-glyph-names",
                            glyphs_expected,
                        ]
                        final_glyphs_expected = shape_cmd(
                            cmd2, no_glyph_names_process
                        ).strip()

                    # If the removal of glyph_ids failed, fail the test.
                    # https://github.com/harfbuzz/harfbuzz/issues/5169
                    if (
                        not final_glyphs_expected
                        or final_glyphs != final_glyphs_expected
                    ):
                        fails += 1
                        cmd = hb_shape + " " + " ".join(cmd)
                        print(f"not ok {number} - {cmd}")
                        print("   ---", file=sys.stderr)
                        print('   test_file: "' + filename + '"', file=sys.stderr)
                        print('   cmd: "' + cmd + '"', file=sys.stderr)
                        print('   actual:   "' + glyphs + '"', file=sys.stderr)
                        print('   expected: "' + glyphs_expected + '"', file=sys.stderr)
                        if final_glyphs != glyphs:
                            print(
                                '   actual_gids:   "' + final_glyphs + '"',
                                file=sys.stderr,
                            )
                            print(
                                '   expected_gids: "' + final_glyphs_expected + '"',
                                file=sys.stderr,
                            )
                        print("   ...", file=sys.stderr)
                    else:
                        cmd = hb_shape + " " + " ".join(cmd)
                        passes += 1
                        print(f"ok {number} - {cmd}")

print("# %d tests passed; %d failed; %d skipped." % (passes, fails, skips))
if not (fails + passes):
    print("# No tests ran.")
elif not (fails + skips):
    print("# All tests passed.")

print("1..%d" % number)