timer.py

"""Countdown timer for heist phases"""

import time
from typing import Callable, Optional
from game.core.exceptions import TimeoutException


class CountdownTimer:
    """Manages countdown timers for heist phases"""
    
    def __init__(self, duration_seconds: int, label: str = "Timer"):
        """Initialize timer"""
        self.duration = duration_seconds
        self.remaining = duration_seconds
        self.label = label
        self.start_time = None
        self.paused_at = None
        self.is_running = False
        self.is_paused = False
        self.callback: Optional[Callable] = None
    
    def start(self) -> None:
        """Start the timer"""
        self.start_time = time.time()
        self.remaining = self.duration
        self.is_running = True
        self.is_paused = False
    
    def pause(self) -> None:
        """Pause the timer"""
        if self.is_running and not self.is_paused:
            self.paused_at = time.time()
            self.is_paused = True
    
    def resume(self) -> None:
        """Resume the timer"""
        if self.is_paused:
            pause_duration = time.time() - self.paused_at
            self.start_time += pause_duration
            self.is_paused = False
    
    def stop(self) -> None:
        """Stop the timer"""
        self.is_running = False
        self.is_paused = False
    
    def get_remaining(self) -> int:
        """Get remaining time in seconds"""
        if not self.is_running:
            return self.remaining
        
        if self.is_paused:
            return self.remaining
        
        elapsed = time.time() - self.start_time
        self.remaining = max(0, int(self.duration - elapsed))
        return self.remaining
    
    def get_elapsed(self) -> int:
        """Get elapsed time in seconds"""
        return self.duration - self.get_remaining()
    
    def is_expired(self) -> bool:
        """Check if time is up"""
        return self.get_remaining() <= 0
    
    def get_progress(self) -> float:
        """Get progress as percentage (0.0 to 1.0)"""
        if self.duration == 0:
            return 1.0
        return min(1.0, self.get_elapsed() / self.duration)
    
    def set_callback(self, callback: Callable) -> None:
        """Set callback function for when timer expires"""
        self.callback = callback
    
    def update(self) -> bool:
        """Update timer and check expiration"""
        if self.is_expired():
            self.stop()
            if self.callback:
                self.callback()
            return True
        return False
    
    def get_formatted_remaining(self) -> str:
        """Get remaining time as formatted string (MM:SS)"""
        remaining = self.get_remaining()
        minutes = remaining // 60
        seconds = remaining % 60
        return f"{minutes:02d}:{seconds:02d}"
    
    def reset(self) -> None:
        """Reset timer to full duration"""
        self.remaining = self.duration
        self.start_time = None
        self.is_running = False
        self.is_paused = False


class PhaseTimer(CountdownTimer):
    """Extended timer for game phases"""
    
    def __init__(self, duration_seconds: int, phase_name: str = "Phase"):
        """Initialize phase timer"""
        super().__init__(duration_seconds, phase_name)
        self.phase_name = phase_name
        self.phase_events = []
    
    def add_event(self, time_seconds: int, event_name: str) -> None:
        """Add an event that triggers at specific time"""
        self.phase_events.append({
            "time": time_seconds,
            "name": event_name,
            "triggered": False,
        })
    
    def get_triggered_events(self) -> list:
        """Get events that have been triggered"""
        elapsed = self.get_elapsed()
        triggered = []
        
        for event in self.phase_events:
            if not event["triggered"] and elapsed >= event["time"]:
                event["triggered"] = True
                triggered.append(event["name"])
        
        return triggered
    
    def check_timeout(self) -> None:
        """Check if phase has timed out"""
        if self.is_expired():
            raise TimeoutException(self.phase_name)