from engine import *
from engine.event import *
from pygame.locals import *
from breakout_highscore import *
from breakout_player import *
from breakout_graphics import *
from breakout_gameover import *
from breakout_level import *
import Queue
import pickle

## Class describing how the game should act when the game
## is running. Keeps track of current level, current score
## events passed objects and changes level when needed.
##
## Will also switch state when game is over and pass
## along the highscore list for viewing.
class breakout_ingame(model.abstract_gamestate):
    def __init__(self):
        self.current_level = None

        self.breakout_events = event_manager()
        self.breakout_events.add_listener(self)
        self.load_levels()
        self.next_level()

        self.init_player()
        self.highscore = highscore()

        ## The ball should be manually loaded since it
        ## belongs to the game state.
        self.ball = ball()
        self.reset_ball()
        self.ball.set_event_handler(self.breakout_events)
        
        self.breakout_events.add_listener(self.player)
        self.breakout_events.add_listener(self.ball)

        ## This variable takes care of pausing the game.
        self.playing = True
        self.exit = False
    def reset_ball(self):
        self.ball.set_image(misc.load_image("ball.png"))
        x,y = self.player.get_pos()
        w,h = self.player.get_size()
        self.ball.reset(((x+(w/2)-5),y-10))
    
    def notify(self, event):
        if isinstance(event, next_level_event):
            ## Count the score for later use.
            self.current_score.increase(event.score)
            self.reset_ball()
            self.player.reset_paddle()
            self.next_level()
        elif isinstance(event, game_over_event):
            ## Get the final score and die!
            ## How can we make sure this is only done once?
            if self.exit == False:
                self.exit = True
                self.current_score.increase(event.score)
                self.highscore.add(self.current_score)
                self.set_state(breakout_gameover(self.highscore))

    def init_player(self):
        self.player = player("Mr. Noname")
        self.current_score = highscore_entry(0, self.player.get_name())
        self.player.set_event_handler(self.breakout_events)
    def get_player(self, player):
        return self.player
    def set_playername(self, name):
        if len(name) > 0:
            self.player.set_name(name)
            self.current_score = highscore_entry(0, self.player.get_name())

    def load_levels(self):
        print "breakout_ingame: Loading levels..."
        ## Mmm, Mr. Pickles...
        levels = Queue.Queue()
        for filename in levellist():
##            level = misc.load("level"+str(num)+".lev")
            level = misc.load(filename)
            levels.put(level)
            print ".."+filename+" loaded."
        self.levels = levels
        
    def next_level(self):
        if self.current_level == None:
            ## This can only occurr at the initialialization of
            ## our instance. There must be atleast one level
            ## loaded.
            self.current_level = self.levels.get()
            ## Load the current level.
            self.current_level.load((640,480))
            ## Make sure that the current level receives events
            ## and knows about the event gandler.
            self.current_level.set_event_handler(self.breakout_events)
            self.breakout_events.add_listener(self.current_level)
            print "breakout_ingame: Next level activated & added "+\
                  "to the event handler"
        else:
            if not self.levels.empty():
                ## First, remove the current level from the event handler.
                ## It shouldn't get any more events.
                self.breakout_events.remove_listener(self.current_level)
                ## Switch level.
                self.current_level = self.levels.get()
                ## Load the current level.
                self.current_level.load((640,480))
                ## Then, make the new level receive events & know about the
                ## event handler.
##                self.current_level.load_sprites()
                self.current_level.set_event_handler(self.breakout_events)
                self.breakout_events.add_listener(self.current_level)
            else:
                ## Do something funny here. I have no idea what, though.
                print "breakout_ingame: Damnit! We're out of levels."+\
                      "Oh well, congrats!"
                ## End the game in some way...
                self.breakout_events.announce(game_over_event(0))

                
    ## Mainly used for transferring the highscore list to a new instance
    ## of this class in case the user wants to play the game again.
    def set_highscore(self, highscore):
        self.highscore = highscore

    ## Draws the current score to screen.
    def draw_score(self, screen):
        font = pygame.font.Font(pygame.font.get_default_font(), 15)
        score = font.render("Score: "+\
                            str(self.current_level.get_score()+\
                                self.current_score.score),\
                            True, (0,0,0))
        screen.blit(score, (10,10))
            
    def clocktick(self):
        if self.playing == True:
            self.breakout_events.announce(tick_event())
    def draw(self, screen):
        self.draw_score(screen)
        self.breakout_events.announce(draw_event(screen))
        if self.playing == False:
            misc.draw_text("paused", 40, (40,0,244), screen, (250, 220))
    def mouse_moved(self, pos):
        if self.playing == True:
            self.breakout_events.announce(mouse_moved_event(pos))
    def mouse_pressed(self, pos):
        self.breakout_events.announce(mouse_pressed_event(pos))
    def key_pressed(self, key):
        if key == pygame.locals.K_SPACE:
            self.playing = not self.playing