import os
import re
import subprocess
import time


def create_file(ctx, filename=None):
    with open(filename, "wb") as f:
        f.write(get_file(filename))


def touch_file(ctx, filename=None, y=None, mon=None, d=None, h=None, min=None, s=None):
    t = (int(y), int(mon), int(d), int(h), int(min), int(s), -1, -1, -1)
    ts = time.mktime(t)
    os.utime(filename, times=(ts, ts))


def update_mtime(ctx, filename=None):
    os.utime(filename)


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_zero(ctx)


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_zero(ctx)


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


def run_codegen_and_program(ctx, filename=None):
    try_codegen_and_program(ctx, filename=filename)
    exit_code_zero(ctx)


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_zero(ctx)


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


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


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


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_zero(ctx)


def file_exists(ctx, filename=None):
    assert_eq(os.path.exists(filename), True)


def file_does_not_exist(ctx, filename=None):
    assert_eq(os.path.exists(filename), False)


def file_matches(ctx, filename=None, regex=None):
    with open(filename) as f:
        content = f.read()
    m = re.search(regex, content)
    if m is None:
        print("content:", repr(content))
        print("regex:", repr(regex))
    assert_eq(bool(m), True)


def file_contains(ctx, filename=None, pattern=None):
    with open(filename) as f:
        content = f.read()
    assert_eq(pattern in content, True)


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


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


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


def exit_code_zero(ctx):
    if ctx.get("exit") != 0:
        print("context:", ctx.as_dict())
    assert_eq(ctx.get("exit"), 0)


def exit_code_nonzero(ctx):
    assert_ne(ctx.get("exit"), 0)


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


def stdout_matches(ctx, pattern=None):
    stdout = ctx.get("stdout", "")
    if pattern not in stdout:
        print("pattern:", repr(pattern))
        print("stdout:", repr(stdout))
        print("ctx:", ctx.as_dict())
    assert_eq(pattern in stdout, True)


def stdout_does_not_match(ctx, pattern=None):
    stdout = ctx.get("stdout", "")
    if pattern in stdout:
        print("pattern:", repr(pattern))
        print("stdout:", repr(stdout))
        print("ctx:", ctx.as_dict())
    assert_eq(pattern not in stdout, True)


def stderr_matches(ctx, pattern=None):
    stderr = ctx.get("stderr", "")
    if pattern not in stderr:
        print("pattern:", repr(pattern))
        print("stderr:", repr(stderr))
        print("ctx:", ctx.as_dict())
    assert_eq(pattern in stderr, True)


def stderr_does_not_match(ctx, pattern=None):
    stderr = ctx.get("stderr", "")
    if pattern not in stderr:
        print("pattern:", repr(pattern))
        print("stderr:", repr(stderr))
        print("ctx:", ctx.as_dict())
    assert_eq(pattern not in stderr, True)


def _get_metadata(filename):
    st = os.lstat(filename)
    keys = ["st_dev", "st_gid", "st_ino", "st_mode", "st_mtime", "st_size", "st_uid"]
    return {key: getattr(st, key) for key in keys}


def remember_metadata(ctx, filename=None):
    ctx["remembered-metadata"] = _get_metadata(filename)


def has_same_metadata_as_remembered(ctx, filename=None):
    assert_eq(ctx["remembered-metadata"], _get_metadata(filename))


def has_diff_metadata_than_remembered(ctx, filename=None):
    assert_ne(ctx["remembered-metadata"], _get_metadata(filename))


def only_these_files_exist(ctx, filenames=None):
    filenames = filenames.replace(",", "").split()
    assert_eq(set(os.listdir(".")), set(filenames))


def runcmd(ctx, argv):
    p = subprocess.Popen(argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout, stderr = p.communicate("")
    ctx["argv"] = argv
    ctx["stdout"] = stdout.decode("utf-8")
    ctx["stderr"] = stderr.decode("utf-8")
    ctx["exit"] = p.returncode