import os
import re
from engine.event import *
from breakout_event import *
from breakout_graphics import *

## Class which contains everything to be drawn onto a
## specific level.
class level(listener):
    def __init__(self):
        self.level_sprites = breakout_sprites()
        self.walls = []
        self.score = 0
        
    def notify(self, event):
        if isinstance(event, ball_moved_event):
            ## The ball has moved, detect collisions.

            self.detect_collisions(event.ball, self.level_sprites)
            self.detect_wall_collisions(event.ball)
            
        elif isinstance(event, draw_event):
            self.level_sprites.draw(event.get_screen())
            for wall in self.walls:
                wall.draw(event.get_screen())
        elif isinstance(event, tick_event):
            if len(self.level_sprites.sprites()) == 0:
                self.event_handler.announce(next_level_event(self.score))
        elif isinstance(event, increase_score_event):
            self.score += event.score
        elif isinstance(event, remove_brick_event):
            self.level_sprites.remove(event.brick)
    
    ## Detects collision between the ball and a given group
    ## of sprites.
    def detect_collisions(self, ball, level_sprites):
##        print "breakout_level: Detecting collisions between ball & objects"
        ## Eventually send some ball_bounce_down_event() or similar here.

        sprites = pygame.sprite.spritecollide(ball, level_sprites, False)
        for sprite in sprites:
            ball_collide(ball, sprite, self.event_handler.announce)
            sprite.update(self.event_handler.announce)

        ## Call each action() with a reference to the announce method of our
        ## event handler, so that sprites can send events on collisions.
        ## for sprite in level_sprites:
        ## sprite.action(self.event_handler.announce)

    def detect_wall_collisions(self, ball):
        for wall in self.walls:
            if ball_collide(ball, wall, self.event_handler.announce) == True:
                wall.update()
        
    def add_sprite(self, sprite):
        self.level_sprites.add(sprite)

    def load(self, res):
        for sprite in self.level_sprites:
            sprite.load()
        self.create_walls(res)
    def clear(self):
        for sprite in self.level_sprites:
            sprite.clear()
        del self.walls[:]

    def empty_level(self):
        self.level_sprites = breakout_sprites()

    ## This method creates "walls", given a resolution. The walls
    ## are of thickness 4 pixels and gets placed around the given
    ## resolution.
    def create_walls(self, res):
        walls = []
        width, height = res

        left_wall = wall()
        left_wall.set_size((4,height))
        left_wall.set_pos((0,0))
        walls.append(left_wall)
        
        right_wall = wall()
        right_wall.set_size((4,height))
        right_wall.set_pos((width-4,0))
        walls.append(right_wall)

        top_wall=wall()
        top_wall.set_size((width-8, 4))
        top_wall.set_pos((4, 0))
        walls.append(top_wall)

        bottom_wall=wall()
        bottom_wall.set_size((width-8, 4))
        bottom_wall.set_pos((4, height-4))
        bottom_wall.set_update(self.game_over)
        walls.append(bottom_wall)
        self.walls = walls

    def get_score(self):
        return self.score

    def get_levelsprites(self):
        return self.level_sprites

    def game_over(self):
        print "GAaAaAAmE OVER!!!"
        self.event_handler.announce(game_over_event(self.score))


## Messy way of getting a list of the levelfiles in the current
## working directory.
def levellist():
    levels = []
    files = os.listdir(".")
    p = re.compile("^level\d*\.lev")
    for file in files:
        m = p.match(file)
        if m:
            levels.append(file)
    levels.sort(key = lambda x: int(x.split(".")[0][5:]))
    return levels