from parse import parse

from generate.generate import renderer
from generate.maps import sorted_map_headers

def warp_event(ev):
    x, y = ev.position
    return [
        "{",
            f".position = {{ {x}, {y} }},",
            ".destination = {",
                f".map = map_t::{ev.destination_map.lower()},",
                f".warp_index = {ev.destination_warp_index},",
            "}",
        "},",
    ]

def bg_event(ev):
    x, y = ev.position
    return [
	"{",
            f".position = {{ {x}, {y} }},",
            ".sign_id = 0,", # fixme
        "},",
    ]

def range_or_direction(ev):
    direction = ev.range_or_direction.lower()
    if direction == '0':
        direction = 'any_dir' # hack?
    yield f".range_or_direction = object_event_t::range_or_direction::{direction},"

def object_event(ev):
    x, y = ev.position
    return [
        "{",
            f".type = object_event_t::type::{ev.type},",
            f".position = {{ {x}, {y} }},",
            ".sprite_id = 0,", # fixme
            f".movement = object_event_t::movement::{ev.movement.lower()},",
            *(range_or_direction(ev)),
            ".text_id = 0,", # fixme
            ".trainer = { 0 },", # fixme
        "},",
    ]

def warp_events(map_name, obj):
    yield f"const warp_event_t {map_name}_warp_events[] = {{"
    for ev in obj.warp_events:
        yield from warp_event(ev)
    yield "};"

def bg_events(map_name, obj):
    yield f"const bg_event_t {map_name}_bg_events[] = {{"
    for ev in obj.bg_events:
        yield from bg_event(ev)
    yield "};"

def object_events(map_name, obj):
    yield f"const object_event_t {map_name}_object_events[] = {{"
    for ev in obj.object_events:
        yield from object_event(ev)
    yield "};"

def object(map_name, obj):
    return [
        f"[map_t::{map_name}] = {{",
            f".border_block = {obj.border_block},",
            f".warp_length = {len(obj.warp_events)},",
            f".bg_length = {len(obj.bg_events)},",
            f".object_length = {len(obj.object_events)},",
            f".warp_events = &{map_name}_warp_events[0],",
            f".bg_events = &{map_name}_bg_events[0],",
            f".object_events = &{map_name}_object_events[0],",
        "},",
    ]

def includes_source():
    yield '#include <cstdint>'
    yield ""
    yield '#include "../map_objects.hpp"'
    yield '#include "maps.hpp"'
    yield ""

def map_objects():
    map_headers = list(sorted_map_headers())
    for map_header in map_headers:
        map_name = map_header.name2.lower()
        map_objects = parse.map_objects_list[map_header.object()]
        yield from warp_events(map_name, map_objects)
        yield from bg_events(map_name, map_objects)
        yield from object_events(map_name, map_objects)

    yield "const object_t map_objects[] = {"
    for map_header in map_headers:
        map_name = map_header.name2.lower()
        map_objects = parse.map_objects_list[map_header.object()]
        yield from object(map_name, map_objects)
    yield "};"

def generate_map_objects_source():
    render, out = renderer()
    render(includes_source())
    render(map_objects())
    return out