import json

from stackbuild import (
    BuildConfig,
    Repo,
    RepoFile,
    SPECIAL_TOKENS,
    build_samples,
    dependency_components,
    scan,
    write_jsonl,
)
from stackbuild.builder import _Counter, _chunks, _file_block, _repository_header


class CharacterTokenizer:
    def encode(self, text, add_special_tokens=False):
        return list(text)


class TiktokenLikeTokenizer:
    def encode(self, text, *, disallowed_special):
        assert disallowed_special == ()
        return list(text.encode())


class BoundedCharacterTokenizer:
    def __init__(self, maximum_input):
        self.maximum_input = maximum_input
        self.largest_input = 0

    def encode(self, text, add_special_tokens=False):
        self.largest_input = max(self.largest_input, len(text))
        if len(text) > self.maximum_input:
            raise AssertionError(f"unbounded tokenizer input: {len(text)}")
        return range(len(text))


def demo_repo():
    return Repo("owner/demo", "rev1", (
        RepoFile("README.md", "# Demo\n", "Markdown"),
        RepoFile("model.py", "VALUE = 1\n", "Python"),
        RepoFile("service.py", "import model\ndef get():\n    return model.VALUE\n", "Python"),
        RepoFile("main.py", "import service\nprint(service.get())\n", "Python"),
    ))


def test_dependency_components_are_complete_and_dependency_ordered():
    info = scan(demo_repo(), use_treesitter=False)
    components = dependency_components(info)
    assert {frozenset(component) for component in components} == {
        frozenset({"model.py", "service.py", "main.py"}),
        frozenset({"README.md"}),
    }
    code = next(component for component in components if "main.py" in component)
    assert code.index("model.py") < code.index("service.py") < code.index("main.py")


def test_build_emits_only_dependency_samples_in_dependency_order():
    samples = build_samples(
        demo_repo(), config=BuildConfig(max_tokens=1000), tokenizer=CharacterTokenizer(),
    )
    assert samples
    assert {sample.kind for sample in samples} == {"dependency"}
    assert all(sample.token_count == len(sample.text) <= 1000 for sample in samples)
    assert {file.path for sample in samples for file in sample.files} == {
        "README.md", "model.py", "service.py", "main.py",
    }
    code = next(sample for sample in samples if any(file.path == "main.py" for file in sample.files))
    paths = [file.path for file in code.files]
    assert paths.index("model.py") < paths.index("service.py") < paths.index("main.py")
    assert code.text.index("model.py") < code.text.index("service.py") < code.text.index("main.py")


def test_large_file_is_split_at_budget():
    content = "".join(f"line_{index:03d} = {index}\n" for index in range(100))
    repo = Repo("large", "r1", (RepoFile("large.py", content, "Python"),))
    samples = build_samples(
        repo, config=BuildConfig(max_tokens=180), tokenizer=CharacterTokenizer(),
    )
    assert len(samples) > 1
    assert all(sample.token_count <= 180 for sample in samples)
    files = [file for sample in samples for file in sample.files]
    assert [file.part for file in files] == list(range(1, files[0].parts + 1))


def test_huge_file_never_sends_the_whole_file_to_tokenizer():
    tokenizer = BoundedCharacterTokenizer(280_000)
    content = ("x" * 1_000_000) + "\n"
    samples = build_samples(
        Repo("huge", "r1", (RepoFile("huge.txt", content, None),)),
        config=BuildConfig(max_tokens=8192), tokenizer=tokenizer,
    )
    assert len(samples) > 100
    assert tokenizer.largest_input <= 280_000
    assert all(sample.token_count <= 8192 for sample in samples)
    assert sum(file.bytes for sample in samples for file in sample.files) == len(content)


def _reference_chunks(path, content, policy, role, budget, counter):
    max_candidate_chars = 262_144
    if len(content) <= max_candidate_chars and counter(
        _file_block(path, content, policy, role)
    ) <= budget:
        return (content,)

    def split_block(value):
        return _file_block(path, value, policy, role, part=999_999, parts=999_999)

    units = []
    for line in content.splitlines(keepends=True):
        units.extend(line[index:index + 16_384] for index in range(0, len(line), 16_384))
    chunks, current = [], ""
    for unit in units:
        candidate = current + unit
        if len(candidate) <= max_candidate_chars and counter(split_block(candidate)) <= budget:
            current = candidate
            continue
        if current:
            chunks.append(current)
            current = ""
        while unit:
            if counter(split_block(unit)) <= budget:
                current = unit
                break
            low, high, chars = 1, len(unit), 0
            while low <= high:
                middle = (low + high) // 2
                if counter(split_block(unit[:middle])) <= budget:
                    chars, low = middle, middle + 1
                else:
                    high = middle - 1
            assert chars
            chunks.append(unit[:chars])
            unit = unit[chars:]
    if current:
        chunks.append(current)
    return tuple(chunks)


def test_chunk_binary_search_preserves_exact_greedy_boundaries():
    content = "".join(f"row_{index:04d} = {index}\n" for index in range(2_000))
    counter = _Counter(CharacterTokenizer())
    budget = 900 - counter(_repository_header(Repo("repo", "rev", ())))
    expected = _reference_chunks("large.py", content, "full", "source", budget, counter)
    actual = _chunks("large.py", content, "full", "source", "Python", budget, counter)
    assert actual == expected


def test_notebook_is_structured_and_binary_is_metadata_only():
    notebook = json.dumps({
        "metadata": {"kernelspec": {"language": "python"}},
        "cells": [
            {"cell_type": "markdown", "source": ["Explain x"]},
            {"cell_type": "code", "source": ["x = 1\n"],
             "outputs": [{"output_type": "stream", "text": ["1\n"]}]},
        ],
    })
    repo = Repo("mixed", "r1", (
        RepoFile("analysis.ipynb", notebook, "Jupyter Notebook"),
        RepoFile("image.png", b"\x89PNG\x00payload", None),
    ))
    samples = build_samples(repo, config=BuildConfig(max_tokens=1_000))
    text = "".join(sample.text for sample in samples)
    assert "# Cell: Markdown\nExplain x" in text
    assert "# Cell: Code\nx = 1" in text
    assert "# Cell: Output\n1" in text
    assert "<｜begin▁of▁file▁name｜>image.png<｜end▁of▁file▁name｜>" in text
    binary = next(file for sample in samples for file in sample.files if file.path == "image.png")
    assert binary.content_policy == "metadata_only"


def test_isolated_files_are_packed_instead_of_one_sample_each():
    repo = Repo("isolated", "r1", tuple(
        RepoFile(f"docs/{index}.md", f"document {index}\n", "Markdown")
        for index in range(20)
    ))
    samples = build_samples(
        repo, config=BuildConfig(max_tokens=400), tokenizer=CharacterTokenizer(),
    )
    assert len(samples) < 20
    assert {file.path for sample in samples for file in sample.files} == {
        f"docs/{index}.md" for index in range(20)
    }


def test_tiktoken_style_encoder_is_supported():
    samples = build_samples(
        demo_repo(), config=BuildConfig(max_tokens=400), tokenizer=TiktokenLikeTokenizer(),
    )
    assert samples
    assert all(sample.token_count <= 400 for sample in samples)


def test_one_shot_repo_file_iterable_is_supported():
    files = (file for file in (
        RepoFile("base.py", "VALUE = 1\n", "Python"),
        RepoFile("main.py", "import base\nprint(base.VALUE)\n", "Python"),
    ))
    samples = build_samples(
        Repo("generator", "r1", files), config=BuildConfig(max_tokens=400),
        tokenizer=CharacterTokenizer(),
    )
    assert {file.path for sample in samples for file in sample.files} == {"base.py", "main.py"}


def test_samples_round_trip_as_jsonl(tmp_path):
    samples = build_samples(
        demo_repo(), config=BuildConfig(max_tokens=400), tokenizer=CharacterTokenizer(),
    )
    target = tmp_path / "samples.jsonl"
    write_jsonl(samples, target)
    rows = [json.loads(line) for line in target.read_text().splitlines()]
    assert [row["sample_id"] for row in rows] == [sample.sample_id for sample in samples]
    assert rows[0]["files"][0]["role"]


def test_samples_use_only_repository_and_file_special_tokens():
    repo = Repo("comments", "rev", (
        RepoFile("a.py", "VALUE = 1\n", "Python"),
        RepoFile("b.ts", "export const value = 1;\n", "TypeScript"),
        RepoFile("README.md", "Documentation\n", "Markdown"),
    ))
    text = "".join(sample.text for sample in build_samples(
        repo, config=BuildConfig(max_tokens=1_000), tokenizer=CharacterTokenizer(),
    ))
    assert len(SPECIAL_TOKENS) == 6
    assert "<｜begin▁of▁repo▁name｜>comments<｜end▁of▁repo▁name｜>\n" in text
    assert "<｜begin▁of▁file▁name｜>a.py<｜end▁of▁file▁name｜>" in text
    assert "<｜begin▁of▁file▁name｜>b.ts<｜end▁of▁file▁name｜>" in text
    assert "<｜begin▁of▁file▁name｜>README.md<｜end▁of▁file▁name｜>" in text
    assert "rev" not in text
    assert "<|endoftext|>" not in text
    assert "<|fim_" not in text
    custom_tokens = {
        "<｜" + part.split("｜>", 1)[0] + "｜>"
        for part in text.split("<｜")[1:]
    }
    assert custom_tokens == set(SPECIAL_TOKENS)
    samples = build_samples(
        repo, config=BuildConfig(max_tokens=1_000), tokenizer=CharacterTokenizer(),
    )
    assert all(sample.text.startswith("<｜begin▁of▁repo▁name｜>comments<｜end▁of▁repo▁name｜>\n") for sample in samples)
    assert all(
        sample.text.count("<｜begin▁of▁file▁name｜>") == len(sample.files)
        for sample in samples
    )


def test_target_context_samples_select_targets_and_put_dependencies_first():
    samples = build_samples(
        demo_repo(),
        config=BuildConfig(
            max_tokens=1_000, target_context=True, max_targets_per_repo=8,
            max_dependency_depth=3,
        ),
        tokenizer=CharacterTokenizer(),
    )
    contexts = [sample for sample in samples if sample.kind == "target_context"]
    assert contexts
    main = next(sample for sample in contexts if sample.metadata["target_path"] == "main.py")
    paths = [file.path for file in main.files]
    assert paths[-1] == "main.py"
    assert paths.index("model.py") < paths.index("service.py") < paths.index("main.py")
    assert main.files[-1].relation == "target"
    assert all(sample.token_count <= 1_000 for sample in contexts)


def test_target_context_skips_target_only_duplicates():
    repo = Repo("single", "r1", (
        RepoFile("src/only.py", "VALUE = 1\n", "Python"),
    ))
    samples = build_samples(
        repo,
        config=BuildConfig(target_context=True, max_targets_per_repo=8),
        tokenizer=CharacterTokenizer(),
    )
    assert len(samples) == 1
    assert samples[0].kind == "dependency"