import sys

import pytest

from misc.codegen.test.utils import *

import hashlib

generator = "foo"


@pytest.fixture
def pystache_renderer_cls():
    with mock.patch("pystache.Renderer") as ret:
        yield ret


@pytest.fixture
def pystache_renderer(pystache_renderer_cls):
    ret = mock.Mock()
    pystache_renderer_cls.return_value = ret
    return ret


@pytest.fixture
def sut(pystache_renderer):
    return render.Renderer(generator)


def assert_file(file, text):
    assert file.is_file()
    with open(file) as inp:
        assert inp.read() == text


def create_registry(files_and_hashes):
    if not files_and_hashes:
        return ""
    return "\n".join(" ".join(data) for data in files_and_hashes) + "\n"


def write_registry(file, *files_and_hashes):
    write(file, create_registry(files_and_hashes))


def assert_registry(file, *files_and_hashes):
    assert_file(file, create_registry(files_and_hashes))
    files = [file.name, ".gitattributes"] + [f for f, _, _ in files_and_hashes]
    assert_file(
        file.parent / ".gitattributes",
        "\n".join(f"/{f} linguist-generated" for f in files) + "\n",
    )


def hash(text):
    h = hashlib.sha256()
    h.update(text.encode())
    return h.hexdigest()


def test_constructor(pystache_renderer_cls, sut):
    (pystache_init,) = pystache_renderer_cls.mock_calls
    assert set(pystache_init.kwargs) == {"search_dirs", "escape"}
    assert pystache_init.kwargs["search_dirs"] == str(paths.templates_dir)
    an_object = object()
    assert pystache_init.kwargs["escape"](an_object) is an_object


def test_render(pystache_renderer, sut):
    data = mock.Mock(spec=("template",))
    text = "some text"
    pystache_renderer.render_name.side_effect = (text,)
    output = paths.root_dir / "a/some/output.txt"
    sut.render(data, output)

    assert_file(output, text)
    assert pystache_renderer.mock_calls == [
        mock.call.render_name(data.template, data, generator=generator),
    ]


def test_render_provided_template(pystache_renderer, sut):
    data = mock.Mock(spec=())
    custom_template = object()
    text = "some text"
    pystache_renderer.render_name.side_effect = (text,)
    output = paths.root_dir / "a/some/output.txt"
    sut.render(data, output, template=custom_template)

    assert_file(output, text)
    assert pystache_renderer.mock_calls == [
        mock.call.render_name(custom_template, data, generator=generator),
    ]


def test_render_to_string(pystache_renderer, sut):
    data = mock.Mock(spec=("template",))
    text = "some text"
    pystache_renderer.render_name.side_effect = (text,)
    result = sut.render_str(data)

    assert result == text
    assert pystache_renderer.mock_calls == [
        mock.call.render_name(data.template, data, generator=generator),
    ]


def test_render_to_string_with_provided_template(pystache_renderer, sut):
    data = mock.Mock(spec=())
    custom_template = object()
    text = "some text"
    pystache_renderer.render_name.side_effect = (text,)
    result = sut.render_str(data, custom_template)

    assert result == text
    assert pystache_renderer.mock_calls == [
        mock.call.render_name(custom_template, data, generator=generator),
    ]


def test_managed_render(pystache_renderer, sut):
    data = mock.Mock(spec=("template",))
    text = "some text"
    pystache_renderer.render_name.side_effect = (text,)
    output = paths.root_dir / "a/some/output.txt"
    registry = paths.root_dir / "a/registry.list"
    write_registry(registry)

    with sut.manage(generated=(), stubs=(), registry=registry) as renderer:
        renderer.render(data, output)
        assert renderer.written == {output}
        assert_file(output, text)

    assert_registry(registry, ("some/output.txt", hash(text), hash(text)))
    assert pystache_renderer.mock_calls == [
        mock.call.render_name(data.template, data, generator=generator),
    ]


def test_managed_render_with_no_registry(pystache_renderer, sut):
    data = mock.Mock(spec=("template",))
    text = "some text"
    pystache_renderer.render_name.side_effect = (text,)
    output = paths.root_dir / "a/some/output.txt"
    registry = paths.root_dir / "a/registry.list"

    with sut.manage(generated=(), stubs=(), registry=registry) as renderer:
        renderer.render(data, output)
        assert renderer.written == {output}
        assert_file(output, text)

    assert_registry(registry, ("some/output.txt", hash(text), hash(text)))
    assert pystache_renderer.mock_calls == [
        mock.call.render_name(data.template, data, generator=generator),
    ]


def test_managed_render_with_post_processing(pystache_renderer, sut):
    data = mock.Mock(spec=("template",))
    text = "some text"
    postprocessed_text = "some other text"
    pystache_renderer.render_name.side_effect = (text,)
    output = paths.root_dir / "a/some/output.txt"
    registry = paths.root_dir / "a/registry.list"
    write_registry(registry)

    with sut.manage(generated=(), stubs=(), registry=registry) as renderer:
        renderer.render(data, output)
        assert renderer.written == {output}
        assert_file(output, text)
        write(output, postprocessed_text)

    assert_registry(registry, ("some/output.txt", hash(text), hash(postprocessed_text)))
    assert pystache_renderer.mock_calls == [
        mock.call.render_name(data.template, data, generator=generator),
    ]


def test_managed_render_with_erasing(pystache_renderer, sut):
    output = paths.root_dir / "a/some/output.txt"
    stub = paths.root_dir / "a/some/stub.txt"
    registry = paths.root_dir / "a/registry.list"
    write(output)
    write(stub, "// generated bla bla")
    write_registry(registry)

    with sut.manage(generated=(output,), stubs=(stub,), registry=registry) as renderer:
        pass

    assert not output.is_file()
    assert not stub.is_file()
    assert_registry(registry)
    assert pystache_renderer.mock_calls == []


def test_managed_render_with_skipping_of_generated_file(pystache_renderer, sut):
    data = mock.Mock(spec=("template",))
    output = paths.root_dir / "a/some/output.txt"
    some_output = "some output"
    registry = paths.root_dir / "a/registry.list"
    write(output, some_output)
    write_registry(registry, ("some/output.txt", hash(some_output), hash(some_output)))

    pystache_renderer.render_name.side_effect = (some_output,)

    with sut.manage(generated=(output,), stubs=(), registry=registry) as renderer:
        renderer.render(data, output)
        assert renderer.written == set()
        assert_file(output, some_output)

    assert_registry(registry, ("some/output.txt", hash(some_output), hash(some_output)))
    assert pystache_renderer.mock_calls == [
        mock.call.render_name(data.template, data, generator=generator),
    ]


def test_managed_render_with_skipping_of_stub_file(pystache_renderer, sut):
    data = mock.Mock(spec=("template",))
    stub = paths.root_dir / "a/some/stub.txt"
    some_output = "// generated some output"
    some_processed_output = "// generated some processed output"
    registry = paths.root_dir / "a/registry.list"
    write(stub, some_processed_output)
    write_registry(
        registry, ("some/stub.txt", hash(some_output), hash(some_processed_output))
    )

    pystache_renderer.render_name.side_effect = (some_output,)

    with sut.manage(generated=(), stubs=(stub,), registry=registry) as renderer:
        renderer.render(data, stub)
        assert renderer.written == set()
        assert_file(stub, some_processed_output)

    assert_registry(
        registry, ("some/stub.txt", hash(some_output), hash(some_processed_output))
    )
    assert pystache_renderer.mock_calls == [
        mock.call.render_name(data.template, data, generator=generator),
    ]


def test_managed_render_with_modified_generated_file(pystache_renderer, sut):
    output = paths.root_dir / "a/some/output.txt"
    some_processed_output = "// some processed output"
    registry = paths.root_dir / "a/registry.list"
    write(output, "// something else")
    write_registry(
        registry, ("some/output.txt", "whatever", hash(some_processed_output))
    )

    with pytest.raises(render.Error):
        sut.manage(generated=(output,), stubs=(), registry=registry)


def test_managed_render_with_modified_stub_file_still_marked_as_generated(
    pystache_renderer, sut
):
    stub = paths.root_dir / "a/some/stub.txt"
    some_processed_output = "// generated some processed output"
    registry = paths.root_dir / "a/registry.list"
    write(stub, "// generated something else")
    write_registry(registry, ("some/stub.txt", "whatever", hash(some_processed_output)))

    with pytest.raises(render.Error):
        sut.manage(generated=(), stubs=(stub,), registry=registry)


def test_managed_render_with_modified_stub_file_not_marked_as_generated(
    pystache_renderer, sut
):
    stub = paths.root_dir / "a/some/stub.txt"
    some_processed_output = "// generated some processed output"
    registry = paths.root_dir / "a/registry.list"
    write(stub, "// no more generated")
    write_registry(registry, ("some/stub.txt", "whatever", hash(some_processed_output)))

    with sut.manage(generated=(), stubs=(stub,), registry=registry) as renderer:
        pass

    assert_registry(registry)


class MyError(Exception):
    pass


def test_managed_render_exception_drops_written_and_inexsistent_from_registry(
    pystache_renderer, sut
):
    data = mock.Mock(spec=("template",))
    text = "some text"
    pystache_renderer.render_name.side_effect = (text,)
    output = paths.root_dir / "a/some/output.txt"
    registry = paths.root_dir / "a/registry.list"
    write(output, text)
    write(paths.root_dir / "a/a")
    write(paths.root_dir / "a/c")
    write_registry(
        registry, "aaa", ("some/output.txt", "whatever", hash(text)), "bbb", "ccc"
    )

    with pytest.raises(MyError):
        with sut.manage(generated=(), stubs=(), registry=registry) as renderer:
            renderer.render(data, output)
            raise MyError

    assert_registry(registry, "aaa", "ccc")


def test_managed_render_drops_inexsistent_from_registry(pystache_renderer, sut):
    registry = paths.root_dir / "a/registry.list"
    write(paths.root_dir / "a/a")
    write(paths.root_dir / "a/c")
    write_registry(
        registry, ("a", hash(""), hash("")), "bbb", ("c", hash(""), hash(""))
    )

    with sut.manage(generated=(), stubs=(), registry=registry):
        pass

    assert_registry(registry, ("a", hash(""), hash("")), ("c", hash(""), hash("")))


def test_managed_render_exception_does_not_erase(pystache_renderer, sut):
    output = paths.root_dir / "a/some/output.txt"
    stub = paths.root_dir / "a/some/stub.txt"
    registry = paths.root_dir / "a/registry.list"
    write(output)
    write(stub, "// generated bla bla")
    write_registry(registry)

    with pytest.raises(MyError):
        with sut.manage(
            generated=(output,), stubs=(stub,), registry=registry
        ) as renderer:
            raise MyError

    assert output.is_file()
    assert stub.is_file()


def test_render_with_extensions(pystache_renderer, sut):
    data = mock.Mock(spec=("template", "extensions"))
    data.template = "test_template"
    data.extensions = ["foo", "bar", "baz"]
    output = pathlib.Path("my", "test", "file")
    expected_outputs = [
        pathlib.Path("my", "test", p) for p in ("file.foo", "file.bar", "file.baz")
    ]
    rendered = [f"text{i}" for i in range(len(expected_outputs))]
    pystache_renderer.render_name.side_effect = rendered
    sut.render(data, output)
    expected_templates = ["test_template_foo", "test_template_bar", "test_template_baz"]
    assert pystache_renderer.mock_calls == [
        mock.call.render_name(t, data, generator=generator) for t in expected_templates
    ]
    for expected_output, expected_contents in zip(expected_outputs, rendered):
        assert_file(expected_output, expected_contents)


def test_managed_render_with_force_not_skipping_generated_file(pystache_renderer, sut):
    data = mock.Mock(spec=("template",))
    output = paths.root_dir / "a/some/output.txt"
    some_output = "some output"
    registry = paths.root_dir / "a/registry.list"
    write(output, some_output)
    write_registry(registry, ("some/output.txt", hash(some_output), hash(some_output)))

    pystache_renderer.render_name.side_effect = (some_output,)

    with sut.manage(
        generated=(output,), stubs=(), registry=registry, force=True
    ) as renderer:
        renderer.render(data, output)
        assert renderer.written == {output}
        assert_file(output, some_output)

    assert_registry(registry, ("some/output.txt", hash(some_output), hash(some_output)))
    assert pystache_renderer.mock_calls == [
        mock.call.render_name(data.template, data, generator=generator),
    ]


def test_managed_render_with_force_not_skipping_stub_file(pystache_renderer, sut):
    data = mock.Mock(spec=("template",))
    stub = paths.root_dir / "a/some/stub.txt"
    some_output = "// generated some output"
    some_processed_output = "// generated some processed output"
    registry = paths.root_dir / "a/registry.list"
    write(stub, some_processed_output)
    write_registry(
        registry, ("some/stub.txt", hash(some_output), hash(some_processed_output))
    )

    pystache_renderer.render_name.side_effect = (some_output,)

    with sut.manage(
        generated=(), stubs=(stub,), registry=registry, force=True
    ) as renderer:
        renderer.render(data, stub)
        assert renderer.written == {stub}
        assert_file(stub, some_output)

    assert_registry(registry, ("some/stub.txt", hash(some_output), hash(some_output)))
    assert pystache_renderer.mock_calls == [
        mock.call.render_name(data.template, data, generator=generator),
    ]


def test_managed_render_with_force_ignores_modified_generated_file(sut):
    output = paths.root_dir / "a/some/output.txt"
    some_processed_output = "// some processed output"
    registry = paths.root_dir / "a/registry.list"
    write(output, "// something else")
    write_registry(
        registry, ("some/output.txt", "whatever", hash(some_processed_output))
    )

    with sut.manage(generated=(output,), stubs=(), registry=registry, force=True):
        pass


def test_managed_render_with_force_ignores_modified_stub_file_still_marked_as_generated(
    sut,
):
    stub = paths.root_dir / "a/some/stub.txt"
    some_processed_output = "// generated some processed output"
    registry = paths.root_dir / "a/registry.list"
    write(stub, "// generated something else")
    write_registry(registry, ("some/stub.txt", "whatever", hash(some_processed_output)))

    with sut.manage(generated=(), stubs=(stub,), registry=registry, force=True):
        pass


if __name__ == "__main__":
    sys.exit(pytest.main([__file__] + sys.argv[1:]))