"""Display a game area."""

import math
import pygame
import pymunk
import pymunk.pygame_util

from nagslang.screens.base import Screen
from nagslang.level import Level
from nagslang.events import ScreenChange
from nagslang.resources import resources
from nagslang.mutators import FLIP_H


class ControlKeys(object):
    def __init__(self):
        self.keys_down = set()

    def key_down(self, key):
        self.keys_down.add(key)

    def key_up(self, key):
        self.keys_down.discard(key)

    def handle_event(self, ev):
        if ev.type == pygame.locals.KEYDOWN:
            self.key_down(ev.key)
        elif ev.type == pygame.locals.KEYUP:
            self.key_up(ev.key)


class Protagonist(object):
    def __init__(self, position):
        self.body = pymunk.Body(10, 10000)
        self.body.position = position
        self.body.velocity_func = self.velocity_func

        self.shape = pymunk.Circle(self.body, 30)
        self.shape.elasticity = 1.0
        self.shape.friction = 10.0

        self.go_human()

    def add_space(self, space):
        space.add(self.body, self.shape)

    def velocity_func(self, body, gravity, damping, dt):
        return pymunk.Body.update_velocity(body, gravity, self.damping, dt)

    def render(self, surface):
        if self.werewolf:
            pos = pymunk.pygame_util.to_pygame(self.body.position, surface)
            transforms = ()
            if abs(self.body.angle) < math.pi / 2:
                transforms = (FLIP_H,)

            wolf = resources.get_image('creatures', 'werewolf_1.png',
                                       transforms=transforms)
            surface.blit(wolf, (pos[0] - wolf.get_width() / 2,
                                pos[1] - wolf.get_height() / 2))
        else:
            pymunk.pygame_util.draw(surface, self.shape)

    def go_werewolf(self):
        self.werewolf = True
        self.body.mass = 100
        self.body.moment = 10000
        self.body.velocity_limit = 1000
        self.shape.color = pygame.color.THECOLORS['red']
        self.impulse_factor = 4000
        self.damping = 0.9

    def go_human(self):
        self.werewolf = False
        self.body.mass = 10
        self.body.moment = 1000
        self.body.velocity_limit = 1000
        self.shape.color = pygame.color.THECOLORS['blue']
        self.impulse_factor = 500
        self.damping = 0.8

    def set_direction(self, dx, dy):
        if (dx, dy) == (0, 0):
            return
        vec = pymunk.Vec2d((dx, dy))
        self.body.angle = vec.angle
        self.body.apply_impulse(
            (dx * self.impulse_factor, dy * self.impulse_factor))

    def toggle_form(self):
        if self.werewolf:
            self.go_human()
        else:
            self.go_werewolf()


class AreaScreen(Screen):

    def setup(self):
        self.keys = ControlKeys()
        self._level = Level(self.name)
        self._level.load()
        self.add_walls()
        self.add_protagonist()

    def add_walls(self):
        self.walls = []
        body = pymunk.Body()
        body.position = (0, -300)
        walls = self._level.get_walls()
        for wall in walls:
            corners = wall
            corner = corners[-1]
            for next_corner in corners:
                wall = pymunk.Segment(body, corner, next_corner, 5)
                wall.elasticity = 1.0
                self.walls.append(wall)
                corner = next_corner
        self.space.add(*self.walls)

    def add_protagonist(self):
        self.protagonist = Protagonist((400, 300))
        self.protagonist.add_space(self.space)

    def handle_event(self, ev):
        if ev.type == pygame.locals.KEYDOWN:
            if ev.key == pygame.locals.K_ESCAPE:
                ScreenChange.post('menu')
            if ev.key == pygame.locals.K_w:
                self.protagonist.toggle_form()
        self.keys.handle_event(ev)

    def render(self, surface):
        #surface.fill(pygame.color.Color(0, 0, 0))
        background = self._level.get_background()
        surface.blit(background, (0, 0))
        #pymunk.pygame_util.draw(surface, *self.walls)
        self.protagonist.render(surface)

    def tick_protagonist(self):
        dx, dy = 0, 0
        for key, tx, ty in [
            (pygame.locals.K_UP, 0, 1), (pygame.locals.K_DOWN, 0, -1),
            (pygame.locals.K_LEFT, -1, 0), (pygame.locals.K_RIGHT, 1, 0)
        ]:
            if key in self.keys.keys_down:
                dx += tx
                dy += ty
        self.protagonist.set_direction(dx, dy)

    def tick(self, seconds):
        self.tick_protagonist()
        super(AreaScreen, self).tick(seconds)