import pygame
from pygame.locals import *
import os
import re

from util import *

class Level:
    def __init__(self, filename):
        self.map = Map(filename)
        self.place_monsters(self.map)
    
    def place_monsters(self, m):
        self.monsters = {}
        x, y = 0, 0
        for line in m:
            for tile in line:
                urls = m.map_key[tile]
                if urls:
                    for url in urls[1:]:
                        monster = self.create_monster(x,y, url)
                x += 1
            x = 0
            y += 1
    
    def create_monster(self, x, y, kind):
        module = __import__("monster.%s" % kind, globals(), {}, ["Mob"])
        monster = module.Mob((x, y), self)
        self.monsters[(x,y)] = monster
        return monster

class Map:
    def __init__(self, filename):
        '''Read the map from a file.'''

        self.map = []
        self.blocking = []
        self.map_key = {}
        self.w = 0
        for line in file(filename).readlines():
            m = re.match('^(?P<key>.)\s+<(?P<urls>.*)>\s*$', line)
            if m:
                urls = re.split('>\s*<', m.group('urls'))
                self.map_key[m.group('key')] = urls
            elif re.match('^\s*$', line):
                pass # Ignore empty lines
            else:
                map_line = []
                block_line = []
                for char in line:
                    if char in self.map_key:
                        map_line.append(char)
                        if char=='X':
                            block_line.append(True)
                        else:
                            block_line.append(False)
                if self.w<len(map_line):
                    self.w = len(map_line)
                self.map.append(map_line)
                self.blocking.append(block_line)
        self.h = len(self.map)
        
    def __getitem__(self, key):
        return self.map[key]
    
    def is_blocked(self, x, y):
        if x<0 or y<0:
            return True
        try:
            return self.blocking[y][x]
        except IndexError:
            return True