from libstormgames import *
from src.object import Object
import random


class Pumpkin:
    def __init__(self, x, isHigh, direction, playerMaxHealth):
        self.x = x
        self.isHigh = isHigh
        self.direction = direction  # 1 for right, -1 for left
        self.speed = 0.15
        self.isActive = True
        self.damage = playerMaxHealth // 2  # Half of player's max health
        self.soundChannel = None
        self.soundName = 'pumpkin_low' if isHigh else 'pumpkin_high'  # Inverted mapping

    def update(self, sounds, playerX):
        """Update pumpkin position and sound"""
        if not self.isActive:
            return False
        
        self.x += self.direction * self.speed
        
        # Update or start positional audio
        if self.soundChannel is None or not self.soundChannel.get_busy():
            self.soundChannel = obj_play(sounds, self.soundName, playerX, self.x)
        else:
            self.soundChannel = obj_update(self.soundChannel, playerX, self.x)
            
        return True

    def stop_sound(self, sounds, playerX):
        """Stop the pumpkin's sound and play splat if needed"""
        if self.soundChannel:
            obj_stop(self.soundChannel)
            self.soundChannel = None
            # Calculate volume and pan for splat sound based on final position
            volume, left, right = calculate_volume_and_pan(playerX, self.x)
            if volume > 0:  # Only play if within audible range
                channel = sounds["pumpkin_splat"].play()
                if channel:
                    channel.set_volume(volume * left, volume * right)

    def check_collision(self, player):
        """Check if pumpkin hits player"""
        if not self.isActive:
            return False
            
        distance = abs(player.xPos - self.x)
        if distance < 1:  # Within 1 tile
            if self.isHigh and not player.isJumping:
                return True  # Hit by high pumpkin while on ground
            elif not self.isHigh and player.isJumping:
                return True  # Hit by low pumpkin while jumping
        return False


class Catapult(Object):
    def __init__(self, x, y, sounds, direction=1, fireInterval=5000, firingRange=20):
        super().__init__(
            x, y, "catapult",
            isStatic=True,
            isCollectible=False,
        )
        self.sounds = sounds
        self.direction = direction
        self.fireInterval = fireInterval  # Time between shots in milliseconds
        self.firingRange = firingRange  # How close player needs to be to trigger firing
        self.lastFireTime = 0
        self.activePumpkins = []
        self.isFiring = False  # Track if we're currently in firing mode
        self.launchDelay = 900  # Time between launch sound and pumpkin firing
        self.pendingPumpkin = None  # Store pending pumpkin data
        self.pumpkinLaunchTime = 0  # When to launch the pending pumpkin

    def fire(self, currentTime, player):
        """Start the firing sequence"""
        self.lastFireTime = currentTime
        
        # Play launch sound
        self.sounds['catapult_launch'].play()
        
        # Set up pending pumpkin
        isHigh = random.choice([True, False])
        fireDirection = 1 if player.xPos > self.xPos else -1
        
        # Store pumpkin data for later creation
        self.pendingPumpkin = {
            'isHigh': isHigh,
            'direction': fireDirection,
            'playerMaxHealth': player.get_max_health()
        }
        
        # Set when to actually launch the pumpkin
        self.pumpkinLaunchTime = currentTime + self.launchDelay

    def update(self, currentTime, player):
        """Update catapult and its pumpkins"""
        if not self.isActive:
            return
            
        # Check if player is in range
        distance = abs(player.xPos - self.xPos)
        inRange = distance <= self.firingRange
        
        # Handle entering/leaving range
        if inRange and not self.isFiring:
            self.isFiring = True
            self.lastFireTime = currentTime  # Reset timer when entering range
            speak("Pumpkin catapult activates!")
        elif not inRange and self.isFiring:
            self.isFiring = False
            speak("Out of pumpkin catapult range.")
            
        # Check for pending pumpkin launch
        if self.pendingPumpkin and currentTime >= self.pumpkinLaunchTime:
            # Create and fire the pending pumpkin
            pumpkin = Pumpkin(
                self.xPos,
                self.pendingPumpkin['isHigh'],
                self.pendingPumpkin['direction'],
                self.pendingPumpkin['playerMaxHealth']
            )
            self.activePumpkins.append(pumpkin)
            self.pendingPumpkin = None
            
        # Only start new fire sequence if in range and enough time has passed
        if self.isFiring and currentTime - self.lastFireTime >= self.fireInterval:
            self.fire(currentTime, player)
            
        # Always update existing pumpkins
        for pumpkin in self.activePumpkins[:]:  # Copy list to allow removal
            if not pumpkin.update(self.sounds, player.xPos):
                pumpkin.stop_sound(self.sounds, player.xPos)
                self.activePumpkins.remove(pumpkin)
                continue
                
            if pumpkin.check_collision(player):
                player.set_health(player.get_health() - pumpkin.damage)
                pumpkin.stop_sound(self.sounds, player.xPos)
                pumpkin.isActive = False
                self.activePumpkins.remove(pumpkin)
                speak("Hit by a pumpkin!")