import json
import os
import re
import subprocess
import time


def try_docgen(ctx, md=None, output=None):
    docgen = binary("sp-docgen")
    runcmd(ctx, [docgen, md, "-o", output])


def run_docgen(ctx, md=None, output=None):
    try_docgen(ctx, md=md, output=output)
    exit_code_is(ctx, 0)


def run_docgen_with_date(ctx, md=None, output=None, date=None):
    docgen = binary("sp-docgen")
    runcmd(ctx, [docgen, md, "-o", output, "--date", date])
    exit_code_is(ctx, 0)


def try_codegen_and_program(ctx, filename=None, testprog=None):
    codegen = binary("sp-codegen")
    tmpldir = os.path.join(srcdir, "templates")
    runcmd(ctx, [codegen, filename, "-o", testprog, "--run", "--templates", tmpldir])


def run_codegen_and_program(ctx, filename=None, testprog=None):
    try_codegen_and_program(ctx, filename=filename, testprog=testprog)
    exit_code_is(ctx, 0)


def run_codegen(ctx, filename=None, testprog=None):
    codegen = binary("sp-codegen")
    tmpldir = os.path.join(srcdir, "templates")
    runcmd(ctx, [codegen, filename, "-o", testprog, "--templates", tmpldir])
    exit_code_is(ctx, 0)


def run_python_test_program(ctx, testprog=None, pattern=None):
    runcmd(ctx, ["python3", testprog, pattern])
    exit_code_is(ctx, 0)


def run_bash_test_program(ctx, testprog=None, pattern=None):
    runcmd(ctx, ["bash", testprog, pattern])
    exit_code_is(ctx, 0)


def run_meta(ctx, filename=None):
    meta = binary("sp-meta")
    runcmd(ctx, [meta, filename])
    exit_code_is(ctx, 0)


def run_meta_json(ctx, filename=None):
    meta = binary("sp-meta")
    runcmd(ctx, [meta, filename, "-o", "json"])
    exit_code_is(ctx, 0)


def run_extract(ctx, filename=None, embedded=None, dirname=None):
    extract = binary("sp-extract")
    runcmd(ctx, [extract, filename, embedded, "-o", dirname])
    exit_code_is(ctx, 0)


def run_pandoc_with_filter(ctx, filename=None, output=None):
    sp_filter = binary("sp-filter")
    runcmd(ctx, ["pandoc", "--filter", sp_filter, filename, "-o", output])
    exit_code_is(ctx, 0)


def scenario_was_run(ctx, name=None):
    stdout_contains(ctx, pattern="\nscenario: {}\n".format(name))


def scenario_was_not_run(ctx, name=None):
    stdout_does_not_contain(ctx, pattern="\nscenario: {}\n".format(name))


def step_was_run(ctx, keyword=None, name=None):
    stdout_contains(ctx, pattern="\n  step: {} {}\n".format(keyword, name))


def step_was_run_and_then(ctx, keyword1=None, name1=None, keyword2=None, name2=None):
    stdout_contains(
        ctx,
        pattern="\n  step: {} {}\n  step: {} {}".format(
            keyword1, name1, keyword2, name2
        ),
    )


def cleanup_was_run(ctx, keyword1=None, name1=None, keyword2=None, name2=None):
    stdout_contains(
        ctx,
        pattern="\n  cleanup: {} {}\n  cleanup: {} {}\n".format(
            keyword1, name1, keyword2, name2
        ),
    )


def cleanup_was_not_run(ctx, keyword=None, name=None):
    stdout_does_not_contain(ctx, pattern="\n  cleanup: {} {}\n".format(keyword, name))


def json_output_matches_file(ctx, filename=None):
    actual = json.loads(ctx["stdout"])
    expected = json.load(open(filename))
    assert_dict_eq(actual, expected)


def file_ends_in_zero_newlines(ctx, filename=None):
    content = open(filename, "r").read()
    print("content:", repr(content))
    assert_ne(content[-1], "\n")


def file_ends_in_one_newline(ctx, filename=None):
    content = open(filename, "r").read()
    print("content:", repr(content))
    assert_eq(content[-1], "\n")
    assert_ne(content[-2], "\n")


def file_ends_in_two_newlines(ctx, filename=None):
    content = open(filename, "r").read()
    print("content:", repr(content))
    assert_eq(content[-2:], "\n\n")


def binary(basename):
    return os.path.join(srcdir, "target", "debug", basename)