import math

import pygame
import pymunk

from nagslang.options import options


class Renderer(object):
    def set_game_object(self, game_object):
        self.game_object = game_object

    def _render_shape(self, surface):
        shape = self.game_object.get_shape()
        # Less general that pymunk.pygame_util.draw, but also a lot less noisy.
        color = getattr(shape, 'color', pygame.color.THECOLORS['lightblue'])
        # We only explicitly draw Circle and Poly shapes. Everything else we
        # forward to pymunk.
        if isinstance(shape, pymunk.Circle):
            centre = pymunk.pygame_util.to_pygame(shape.body.position, surface)
            radius = int(shape.radius)
            pygame.draw.circle(surface, color, centre, radius, 2)
        elif isinstance(shape, pymunk.Poly):
            # polygon bounding box
            points = [pymunk.pygame_util.to_pygame(p, surface)
                      for p in shape.get_vertices()]
            pygame.draw.lines(surface, color, True, points, 2)
        else:
            pymunk.pygame_util.draw(surface, shape)

    def render(self, surface):
        if options.debug:
            self._render_shape(surface)

    def animate(self):
        # Used by time animatations to advance the clock
        pass


def image_pos(image, pos):
    return (pos[0] - image.get_width() / 2,
            pos[1] - image.get_height() / 2)


class ImageRenderer(Renderer):
    def __init__(self, image):
        self._image = image

    def get_image(self):
        return self._image

    def rotate_image(self, image):
        angle = self.game_object.get_render_angle() * 180 / math.pi
        return pygame.transform.rotate(image, angle)

    def render_image(self, surface, image):
        image = self.rotate_image(image)
        pos = self.game_object.get_render_position(surface)
        surface.blit(image, image_pos(image, pos))

    def render(self, surface):
        self.render_image(surface, self.get_image())
        super(ImageRenderer, self).render(surface)


class ImageStateRenderer(ImageRenderer):
    def __init__(self, state_images):
        self._state_images = state_images

    def get_image(self):
        return self._state_images[self.game_object.puzzler.get_state()]


class FacingImageRenderer(ImageRenderer):
    def __init__(self, left_image, right_image):
        self._images = {
            'left': left_image,
            'right': right_image,
        }
        self._face = 'left'

    def _update_facing(self, angle):
        if abs(angle) < math.pi / 2:
            self._face = 'right'
        elif abs(angle) > math.pi / 2:
            self._face = 'left'

    def rotate_image(self, image):
        # Facing images don't get rotated.
        return image

    def get_facing_image(self):
        return self._images[self._face]

    def get_image(self):
        angle = self.game_object.get_render_angle()
        self._update_facing(angle)
        return self.get_facing_image()


class AnimatedFacingImageRenderer(FacingImageRenderer):
    def __init__(self, left_images, right_images):
        self._images = {
            'left': left_images,
            'right': right_images,
        }
        self._frame = 0
        self._moving = False
        self._face = 'left'

    def get_facing_image(self):
        if self._frame >= len(self._images[self._face]):
            self._frame = 0
        return self._images[self._face][self._frame]

    def animate(self):
        if self._moving:
            self._frame += 1
        else:
            self._frame = 0

    def start(self):
        self._moving = True

    def stop(self):
        self._moving = False


class TimedAnimatedRenderer(ImageRenderer):

    def __init__(self, images):
        self._images = images
        self._frame = 0
        self._image = None

    def get_image(self):
        if self._frame > len(self._imaages):
            self._frame = 0
        return self._images[self._frame]

    def animate(self):
        self._frame += 1


class ShapeRenderer(Renderer):
    def render(self, surface):
        self._render_shape(surface)
        super(ShapeRenderer, self).render(surface)


class ShapeStateRenderer(ShapeRenderer):
    """Renders the shape in a different colour depending on the state.

    Requires the game object it's attached to to have a puzzler.
    """
    def render(self, surface):
        if self.game_object.puzzler.get_state():
            color = pygame.color.THECOLORS['green']
        else:
            color = pygame.color.THECOLORS['red']

        self.game_object.get_shape().color = color
        super(ShapeStateRenderer, self).render(surface)