#!/usr/bin/env python
# -*- coding: utf-8 -*-

import pygame
import math
import Image
from api.Vector import CVector

from Mouse import CMouse

class CSprite(pygame.sprite.Sprite):
    """ An enhanced Sprite class
        expects a gameEngine.Scene class as its one parameter
        Use methods to change image, direction, speed
        Will automatically travel in direction and speed indicated
    """

    def __init__(self):
        pygame.sprite.Sprite.__init__(self)

        self.mPos = CVector(0, 0)
        self.mVel = CVector(0, 0)

        # Registration point offset.
        self.mOffsetX = 0
        self.mOffsetY = 0
    
        # Speed of the sprite.
        self.mSpeed = 0

        self.maxSpeed = 50
        self.minSpeed = -3

        self.mactive = False
        self.mclicked = False
        
        self.image = pygame.surface.Surface((0, 0), 0)
        self.rect = self.image.get_rect()
 
    def setRegistrationPointOffset(self, aOffsetX, aOffsetY):
        self.mOffsetX = aOffsetX
        self.mOffsetY = aOffsetY

    def setXY(self, aX, aY):
        self.mPos.setXY(aX, aY)
        self.calculatePositionWithOffset()

    def setVelXY(self, aVelX, aVelY):
        self.mVel.setXY(aVelX, aVelY)
        self.mVel.truncate(self.maxSpeed)
        
    def setVelVec(self, aVec):
        self.mVel.setXY(aVec.getX(), aVec.getY())
        self.mVel.truncate(self.maxSpeed)

    def setMaxSpeed(self, aMaxSpeed):
        self.maxSpeed = aMaxSpeed

    def update(self):

        self.mPos.add(self.mVel)
        
        self.calculatePositionWithOffset()
        
        self.mclicked = False
        
        if CMouse().firstPress():
            if self.rect.collidepoint(CMouse().getPos()):
                self.mactive = True

        if self.mactive == True:
            if CMouse().release():
                self.mactive = False
                if self.rect.collidepoint(CMouse().getPos()):
                    self.mclicked = True

    def setSpeed(self, speed):
        """ immediately sets the objects speed to the 
            given value.
        """
        self.mSpeed = speed

    def speedUp(self, amount):
        """ changes speed by the given amount
            Use a negative value to slow down
        """
        self.mSpeed += amount
        if self.mSpeed < self.minSpeed:
            self.mSpeed = self.minSpeed
        if self.mSpeed > self.maxSpeed:
            self.mSpeed = self.maxSpeed
    
    def loadImage(self, aImageFilename, aIsTransparent=True):
        self.setImage(Image.loadImage(aImageFilename, aIsTransparent))
    
    def setImage(self, aImage):
        self.image = aImage
        self.rect = self.image.get_rect()
        self.calculatePositionWithOffset()

    def setPosition(self, position):
        """ place the sprite directly at the given position
            expects an vector
        """
        self.mPos.setX(position.getX())
        self.mPos.setY(position.getY())

    def setPosTuple(self, position):
        """ place the sprite directly at the given position

            expects an (x, y) tuple
        """
        self.mPos.setXY(position[0], position[1])

    def setSpeedLimits(self, amax, amin):
        """ determines maximum and minimum
            speeds you will allow through
            speedUp() method.  You can still
            directly set any speed you want
            with setSpeed() Default values:
                max: 10
                min: -3
        """
        self.maxSpeed = amax
        self.minSpeed = amin

    def dataTrace(self):
        """ utility method for debugging
            print major properties
            extend to add your own properties
        """
        print "x: %d, y: %d, speed: %.2f, dx: %.2f, dy: %.2f" % \
              (self.mPos.x, self.mPos.y, self.mSpeed, self.mAngle, self.dx, self.dy)
            
    def mouseDown(self):
        """ boolean function. Returns True if the mouse is 
            clicked over the sprite, False otherwise
        """
        self.pressed = False
        if CMouse().pressed():
            if self.rect.collidepoint(CMouse().getPos()):
                self.pressed = True
        return self.pressed

    def mouseOver(self):
        if not CMouse().pressed():
            if self.rect.collidepoint(CMouse().getPos()):
                return True
            else:
                return False
        else:
            return False
            
    def clicked(self):
        """ Boolean function. Returns True only if mouse
            is pressed and released over sprite           
        """
        return self.mclicked
        
    def distanceTo(self, point):
        """ returns distance to any point in pixels
            can be used in circular collision detection
        """
        dx = self.mPos.x - point[0]
        dy = self.mPos.y - point[1]
        
        return math.sqrt((dx * dx) + (dy * dy))

    def destroy(self):
        self.image = None
    
    def calculatePositionWithOffset(self):
        self.rect.x = self.mPos.getX() - self.mOffsetX
        self.rect.y = self.mPos.getY() - self.mOffsetY
        
    def getX(self):
        return self.mPos.getX()
    
    def getY(self):
        return self.mPos.getY()
   
    def getSize(self):
        if self.image:
            return (self.rect[2], self.rect[3])
        else:
            return (0,0)