from lib.pgfw.pgfw.Sprite import Sprite

class StaticEnvironment(Sprite):

    def __init__(self, parent):
        Sprite.__init__(self, parent)
        self.load_from_path(self.get_resource("home",
                                              "static-environment-path"),
                            True)

from pygame import mixer
from pygame.image import load

from lib.pgfw.pgfw.GameChild import GameChild
from food_spring.home.View import View
from food_spring.home.StaticEnvironment import StaticEnvironment
from food_spring.home.Foods import Foods
from food_spring.home.collection.Collection import Collection

class Home(GameChild):

    any_press_ignored = ["left", "right"]

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.display_surface = self.get_display_surface()
        self.input = self.get_input()
        self.compare = self.get_delegate().compare
        self.audio = self.get_audio()
        self.audio_path = self.get_resource("home", "audio")
        self.static_environment = StaticEnvironment(self)
        self.view = View(self)
        self.foods = Foods(self)
        self.collection = Collection(self)
        self.reset()
        self.deactivate()

    def deactivate(self):
        self.active = False
        self.input.unregister_any_press_ignore(*self.any_press_ignored)
        self.audio.stop_current_channel()
        mixer.quit()
        mixer.init(self.stored_frequency)

    def reset(self):
        self.foods.reset()
        self.store_frequency()

    def store_frequency(self):
        self.stored_frequency = mixer.get_init()[0]

    def activate(self):
        self.active = True
        self.input.register_any_press_ignore(*self.any_press_ignored)
        self.foods.activate()
        self.start_audio()

    def start_audio(self):
        self.store_frequency()
        mixer.quit()
        mixer.init(int(self.parent.timer.get_ratio_remaining() * \
                       self.stored_frequency))
        self.audio.play_bgm(self.audio_path)

    def update(self):
        if self.active:
            self.view.update()
            self.static_environment.update()
            self.foods.update()

from pygame import Rect

from lib.pgfw.pgfw.GameChild import GameChild

class Foods(GameChild, list):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.active_index = 0
        self.display_surface = self.get_display_surface()
        self.compare = self.get_delegate().compare
        self.bounds = self.get_display_surface().get_rect()
        self.load_configuration()
        self.set_foods()
        self.set_tv_rect()
        self.reset()
        self.subscribe(self.respond)

    def load_configuration(self):
        config = self.get_configuration("home")
        self.inactive_x = config["food-inactive-x"]
        self.inactive_y = config["food-inactive-y"]
        self.active_y = config["food-active-y"]
        self.margin = config["food-margin"]
        self.step = config["food-step"]
        self.tv_edge = config["tv-edge"]

    def set_foods(self):
        levels = self.get_game().levels
        for ii in range(len(levels)):
            self.append(levels[ii].food)

    def set_tv_rect(self):
        self.tv_rect = Rect(0, 0, self.tv_edge,
                            self.display_surface.get_height())

    def swap_in(self, index):
        self.store(self.get_active())
        self.active_index = index
        self.step_forward()

    def step_forward(self):
        self.get_active().location.bottomleft = self.get_x(self.active_index), \
                                                self.active_y

    def get_x(self, index):
        x = self.inactive_x
        for ii in range(index):
            x += self[ii].location.w + self.margin
        return x

    def respond(self, event):
        if self.parent.active:
            if self.compare(event, "left"):
                self.moving[0] = True
            elif self.compare(event, "left", True):
                self.moving[0] = False
            elif self.compare(event, "right"):
                self.moving[1] = True
            elif self.compare(event, "right", True):
                self.moving[1] = False
            elif self.compare(event, "any"):
                self.do()

    def do(self):
        rect = self.get_active().location
        if not self.collide_other():
            if rect.colliderect(self.tv_rect):
                self.stop_moving()
                self.store_location()
                self.parent.deactivate()
                self.get_game().levels.activate(self.active_index)
            elif rect.colliderect(self.parent.collection):
                pass

    def stop_moving(self):
        self.moving = [False, False]

    def collide_other(self):
        active = self.get_active()
        rect = active.location
        clip = None
        closest = None
        for food in self:
            if active != food and rect.colliderect(food):
                if not clip or rect.clip(food).w > clip.w:
                    clip = rect.clip(food)
                    closest = food
        if closest:
            self.swap_in(self.index(closest))
            return True

    def store_location(self):
        self.stored_location = self.get_active().location.topleft

    def reset(self):
        for food in self:
            self.store(food)
        self.swap_in(0)
        self.stop_moving()
        self.store_location()

    def activate(self):
        for food in self:
            if self.index(food) != self.active_index:
                self.store(food)
        self.get_active().location.topleft = self.stored_location

    def store(self, food):
        index = self.index(food)
        self[index].location.bottomleft = self.get_x(index), self.inactive_y

    def update(self):
        active = self.get_active()
        if True in self.moving:
            if self.moving[0]:
                active.move(-self.step)
            if self.moving[1]:
                active.move(self.step)
            self.wrap()
        for food in self:
            if self.index(food) != self.active_index:
                food.update()
        active.update()

    def get_active(self):
        return self[self.active_index]

    def wrap(self):
        rect = self.get_active().location
        bounds = self.bounds
        if rect.left > bounds.right:
            rect.right = bounds.left
        elif rect.right < bounds.left:
            rect.left = bounds.right