"""Class for dealing with the player"""

import pygame.transform
import os

from skaapsteker.sprites.base import TILE_SIZE, PC_LAYER, MONSTER_LAYER
from skaapsteker.physics import Sprite
from skaapsteker.constants import Layers
from skaapsteker.data import get_files, load_image


class Player(Sprite):

    collision_layer = PC_LAYER
    collides_with = set([MONSTER_LAYER])
    wants_updates = True

    def __init__(self):
        Sprite.__init__(self)
        self.image = None
        self.rect = None
        self._image_dict = {}
        self._animation_frame = 0.0
        # State flags and such
        self.running = False
        self.jumping = False
        self.flying = False
        self._load_images()
        # We muck with these in load for convience, so ensure they're right
        self.tails = 0
        self.set_facing('left')
        self.set_image()
        self.set_pos((0, 0))
        self._layer = Layers.PLAYER

    def set_image(self):
        key = self._make_key()
        images = self._image_dict[key]
        if self._animation_frame >= len(images):
            self._animation_frame = 0.0
        if self.rect:
            cur_pos = self.rect.topleft
        else:
            cur_pos = (0, 0)
        self.image = images[int(self._animation_frame)]
        self.rect = self.image.get_rect()
        self.collide_rect = self.image.get_bounding_rect(1)
        self.rect_offset = self.collide_rect.left - self.rect.left, self.collide_rect.top - self.rect.top
        self.rect.topleft = cur_pos
        self.collide_rect.topleft = cur_pos[0] + self.rect_offset[0], cur_pos[1] + self.rect_offset[1]


    def update(self):
        v_x, v_y = self.velocity
        self._animation_frame += abs(v_x) / 3000.0
        if v_x == 0:
            self.running = False
        else:
            self.running = True
        self.set_image()

    def set_facing(self, new_facing):
        self.facing = new_facing


    def set_pos(self, pos):
        self.starting_tile_pos = pos
        self.collide_rect.topleft = pos[0] * TILE_SIZE[0] + self.rect_offset[0], pos[1] * TILE_SIZE[1] + self.rect_offset[1]
        self.rect.topleft = pos[0] * TILE_SIZE[0], pos[1] * TILE_SIZE[1]

    def action_left(self):
        if self.facing != 'left':
            self.facing = 'left'
            self.set_image()
        self.deltav((-100.0, 0.0))

    def action_right(self):
        if self.facing != 'right':
            self.facing = 'right'
            self.set_image()
        self.deltav((100.0, 0.0))

    def action_up(self):
        self.deltav((0.0, -100.0))

    def action_down(self):
        self.deltav((0.0, 100.0))

    def action_fire1(self):
        print "F1"

    def action_fire2(self):
        print "F2"

    def _get_action(self):
        if self.running:
            return 'running'
        if self.jumping:
            return 'jumpin'
        return 'standing'

    def _make_key(self, action=None):
        if action is None:
            action = self._get_action()
        tails = self.tails
        if self.tails >= 4:
            tails = 4
        elif self.tails >= 2:
            tails = 2
        return '%s %s %d' % (action, self.facing, tails)

    def _load_images(self):
        for action in ['standing', 'running', 'jumping']:
            for tails in [0, 1, 2, 4]:
                self.tails = tails
                directory = os.path.join('sprites',
                        'kitsune_%s' % action,
                        'kitsune_%s_%dtail' % (action, tails))
                for facing in ['left', 'right']:
                    self.facing = facing
                    key = self._make_key(action)
                    self._image_dict[key] = []
                    for image_file in get_files(directory):
                        if image_file.startswith('.'):
                            # Skip extra junk for now
                            continue
                        image = load_image(os.path.join(directory, image_file))
                        if facing == 'right':
                            image = pygame.transform.flip(image, True, False)
                        self._image_dict[key].append(image)