# -*- coding: utf-8 -*-
from __future__ import division

import pygame
from pygame.locals import K_ESCAPE, K_q, KEYDOWN, SRCALPHA

from . import constants
from . import data
from .engine import ChangeScene, Scene
from .widgets.text import Text, ButtonSet, TextButton, unindent_text

class CutScene(Scene):
    def __init__(self, game_state, soundsystem, text, background, music=None):
        super(CutScene, self).__init__(game_state, soundsystem)
        self.background = data.load_image('backgrounds/' + background)
        fill = pygame.Surface(self.background.get_size(), flags=SRCALPHA)
        fill.fill((255, 255, 255, 128))
        self.background.convert_alpha(fill)
        self.background.blit(fill, (0, 0))
        self.background.convert_alpha()
        self.start_time = pygame.time.get_ticks()
        self.run_time = 60000 # ms

        self._background_music = None
        self._background_music = music

        text_widget = Text(text, pygame.Rect(20, 20,
                                             constants.SCREEN[0] - 40,
                                             constants.SCREEN[1] - 40),
                           size=24, shadow='gray', wrap=True)
        self.widgets.append(text_widget)

        button_set = ButtonSet()
        # TODO: Dynamic position
        button_set.append(TextButton("Continue", (20, constants.SCREEN[1] - 68),
                                     size=24, color='red'))
        button_set.callbacks.append(self.done)
        self.widgets.append(button_set)

    def done(self, selected=None, data=None):
        # Avoid circular import...
        from .menuscene import MenuScene
        ChangeScene.post((MenuScene,))

    def draw(self, surface, engine):
        viewport = surface.get_clip()

        # Scoll background back and forth:
        max_pos = self.background.get_rect().width - viewport.width
        bottom = self.background.get_rect().height - viewport.height
        pos = ((pygame.time.get_ticks() - self.start_time)
               % (self.run_time * 2)) * max_pos // (self.run_time)
        if pos > max_pos:
            pos = (2 * max_pos) - pos
        surface.blit(self.background, viewport.topleft,
                     pygame.Rect((pos, bottom), viewport.size))

        super(CutScene, self).draw(surface, engine)

    def dispatch(self, ev):
        if ev.type is KEYDOWN:
            if ev.key in(K_q, K_ESCAPE):
                self.done()
        super(CutScene, self).dispatch(ev)

    def enter(self):
        if self._background_music:
            self._soundsystem.play_background_music(self._background_music)


def opening_cutscene(game_state, soundsystem):
    text = u"""
    Many moons ago, an evil nine-tailed kitsune, a fearsome fox god, ruled the
    land.

    It had many powers — the ability to shape shift, turn invisible, control
    the elements. Its powers came from its majestic tails and the kitsune
    guarded them ferociously. If any fox attained eight tails, it would battle
    the kitsune for domination of the celestial world. To prevent this, the
    kitsune stole the tails of all the foxes it encountered.

    The evil kitsune challenged every fox to a haiku contest. But the
    competition was not fair, and the kitsune cheated every time. When it
    defeated the poor fox, it stole its tail and threw it to the four winds.

    The kitsune stole your tail. Now it’s time to get it back.
    """
    text = unindent_text(text)
    return CutScene(game_state, soundsystem, text, 'background_01_back.png')