from parse import parse

from generate.sort import default_sort
from generate.generate import renderer
from generate.binary import start_size_value

def sorted_tilesets_constants_list():
    return sorted(parse.tileset_constants_list.items(), key=default_sort)

def includes_header():
    yield "#pragma once"
    yield ""
    yield '#include "../start_size.hpp"'
    yield ""
    for tileset_name, _ in sorted_tilesets_constants_list():
        tileset_index  = parse.tileset_constants_list[tileset_name]
        tileset_header = parse.tileset_headers_list[tileset_index]

        blockset_path = parse.gfx_tilesets_list[tileset_header.blockset()]
        gfx_path      = parse.gfx_tilesets_list[tileset_header.gfx()]

        yield f'#include "../res/{blockset_path}.h"'
        yield f'#include "../res/{gfx_path}.h"'

def struct_tileset_t():
    _sorted_tilesets_constants_list = list(sorted_tilesets_constants_list())
    tileset_names = (
        f"{name.lower()},"
        for name, _ in _sorted_tilesets_constants_list
    )
    return [
        "struct tileset_t {",
            "start_size_t blockset;",
            "start_size_t tileset;",
            "start_size_t collision;",
            "",
            "enum tileset {",
                *tileset_names,
            "};",
            "",
            f"static constexpr int32_t count = {len(_sorted_tilesets_constants_list)};",
        "};",
    ]

def extern_tilesets():
    yield "extern const tileset_t tilesets[];"

def generate_header():
    render, out = renderer()
    render(includes_header())
    render(struct_tileset_t())
    render(extern_tilesets())
    return out

def blockset_tileset(name, index):
    tileset_header = parse.tileset_headers_list[index]

    blockset_path = parse.gfx_tilesets_list[tileset_header.blockset()]
    gfx_path      = parse.gfx_tilesets_list[tileset_header.gfx()]
    coll_path     = tileset_header.coll()

    return [
        f"[tileset_t::{name.lower()}] = {{",
            ".blockset = {",
                *start_size_value(blockset_path),
            "},",
            ".tileset = {",
                *start_size_value(gfx_path),
            "},",
            ".collision = {",
                f".start = &{coll_path}[0],",
                f".size = (sizeof ({coll_path})),",
            "}",
        "},"
    ]

def tilesets():
    yield "const tileset_t tilesets[] = {"
    for name, index in sorted_tilesets_constants_list():
        yield from blockset_tileset(name, index)
    yield "};"

def includes_source():
    yield '#include <cstdint>'
    yield ''
    yield '#include "tilesets.hpp"'
    yield '#include "collision_tile_ids.hpp"'
    yield ''

def generate_source():
    render, out = renderer()
    render(includes_source())
    render(tilesets())
    return out