"""
Level for our shiny game.
"""

from pygame.sprite import Sprite
from pygame.surface import Surface

from mamba.data import load_file, load_image

TILE_SIZE = (20, 20)


def tile_sizify(pos):
    ts_x, ts_y = TILE_SIZE
    p_x, p_y = pos
    return (ts_x * p_x, ts_y * p_y)


class TileSprite(Sprite):
    def __init__(self, image_path, *groups):
        super(TileSprite, self).__init__(*groups)
        if image_path is None:
            self.image = Surface(TILE_SIZE)
        else:
            self.image = load_image(image_path)

    def set_tile_pos(self, tile_pos):
        self.rect = self.image.get_rect().move(tile_sizify(tile_pos))


TILE_MAP = {
    '.': None,
    'X': 'randomtile',
    }

THING_MAP = {
    'a': (TileSprite, 'tiles/dev/randomtile.png'),
    }


class Tileset(object):
    def __init__(self, tileset_name):
        self.name = tileset_name
        self.load_tiles()

    def load_tiles(self):
        self.tiles = {}
        for k, v in TILE_MAP.items():
            if v:
                v = 'tiles/%s/%s.png' % (self.name, v)
            self.tiles[k] = (TileSprite, (v,))
        for k, v in THING_MAP.items():
            self.tiles[k] = (v[0], v[1:])

    def __getitem__(self, key):
        cls, args = self.tiles[key]
        return cls(*args)

    def get_tile(self, key, tile_pos):
        tile = self[key]
        tile.set_tile_pos(tile_pos)
        return tile


class Level(object):
    def __init__(self, level_name):
        self.level_name = level_name
        self.load_level_data()

    def load_level_data(self):
        """
        This file format is potentially yucky.
        """
        level_data = load_file('levels/%s.txt' % (self.level_name,))
        tileset_name = level_data.readline().strip()
        self.tileset = Tileset(tileset_name)
        tiles_ascii = level_data.readlines()
        self.tiles = [[self.tileset.get_tile(tile, (x, y))
                       for x, tile in enumerate(row.strip())]
                      for y, row in enumerate(tiles_ascii)]

    def get_size(self):
        return tile_sizify((len(self.tiles[0]), len(self.tiles)))