"""ActorInterval module: contains the ActorInterval class"""

from PandaModules import *
from Interval import *
import math

import DirectNotifyGlobal

class ActorInterval(Interval):

    # create ActorInterval DirectNotify category
    notify = directNotify.newCategory('ActorInterval')

    # Name counter
    animNum = 1
    # Class methods
    # Interval used to play an animation.  If loop = 0, animation is
    # played only once and the pose of the anim depends on t passed
    # into the setT method every frame.  If loop = 1, the animation is
    # started and plays on its own and stopped when t >= duration or
    # playback stop event occurs.  If no duration is specified, interval
    # duration defaults to be equal to the length of the animation.
    # Note: if loop == 0 and duration > anim duration then the animation
    # will play once and then nothing will happen for the remainder of the
    # interval
    def __init__(self, actor, animName, loop=0, duration=0.0,
                 startTime=0.0, endTime=None, name=None):
        """__init__(name)
        """
        # Generate unique id
        id = 'Actor-%d' % ActorInterval.animNum
        ActorInterval.animNum += 1
        # Record class specific variables
        self.actor = actor
        self.animName = animName
        self.loop = loop
        self.frameRate = self.actor.getFrameRate(self.animName)
        self.numFrames = self.actor.getNumFrames(self.animName)
        # Compute start time
        self.startTime = startTime
        # If no name specified, use id as name
        if (name == None):
            name = id
        # Compute duration if no duration specified
        reverse = 0
        if duration == 0.0:
            if (endTime == None):
                duration = max(self.actor.getDuration(self.animName) - \
                                startTime, 0.0)
            else:
                duration = endTime - startTime
                if (duration < 0.0):
                    duration = -duration
        if (endTime == None):
            self.finishTime = self.startTime + duration
        else:
            self.finishTime = endTime
        if (self.startTime > self.finishTime):
            reverse = 1

        # Initialize superclass
        Interval.__init__(self, name, duration, reverse=reverse)
        # Update stopEvent
        self.stopEvent = id + '_stopEvent'
        if self.loop:
            self.stopEventList = [self.stopEvent]

    def calcFrame(self, t):
        segmentLength = abs(self.finishTime - self.startTime)
        offset = t % segmentLength
        # Handle boundary case where we want to set the final frame
        if (t == self.getDuration() and offset < 0.0001):
            offset = segmentLength
        # Compute current frame based upon current time
        if (self.reverse == 0):
            floatFrame = self.frameRate * (self.startTime + offset)
        else:
            negOffset = (self.startTime - self.finishTime) - offset
            floatFrame = self.frameRate * (self.finishTime + negOffset)
        # Need max to avoid frame = -1 when t = 0
        frame = max(0, int(math.ceil(floatFrame)) - 1)
        # Modulo in case of looping anim
        return frame % self.numFrames

    def goToT(self, t):
        # Calc integer frame number
        frame = self.calcFrame(t)
        # Pose anim
        self.actor.pose(self.animName, frame)
        # Print debug information
        self.notify.debug('goToT() - %s pose to frame: %d' %
                          (self.name,frame))
        return frame

    def updateFunc(self, t, event=IVAL_NONE):
        """ updateFunc(t, event)
            Go to time t
        """
        if (self.actor.isEmpty()):
            self.notify.warning('updateFunc() - %s empty actor!' % self.name)
            return
        # Update animation based upon current time
        # Pose or stop anim
        if (t >= self.getDuration()):
            self.actor.stop()
            frame = self.goToT(self.getDuration())
            if self.loop:
                self.ignore(self.stopEvent)
            # Print debug information
            self.notify.debug(
                'updateFunc() - %s stoping at frame: ' % self.name +
                '%d Num frames: %d' % (frame, self.numFrames))
        elif self.loop == 1:
            if event == IVAL_INIT:
                # Pose anim
                self.goToT(t)
                # And start loop, restart flag says continue from current frame
                self.actor.loop(self.animName, restart=0)
                self.acceptOnce(self.stopEvent, self.actor.stop)
                # Print debug information
                self.notify.debug(
                    'updateFunc() - IVAL_INIT %s looping anim' %
                    self.name)
        else:
            # Pose anim
            self.goToT(t)

