from .unit import Unit
from .points import Point
from engine.collision_system import CollisionLayer

import random
import uuid

# Costanti
AGE_THRESHOLD = 200
SPEED_REDUCTION = 0.5
PREGNANCY_DURATION = 500
BABY_INTERVAL = 50


class Rat(Unit):
    def __init__(self, game, position=(0,0), id=None):
        super().__init__(game, position, id, collision_layer=CollisionLayer.RAT)
        # Specific attributes for rats
        self.speed = 0.10  # Rats are slower
        self.fight = False
        self.gassed = 0
        self.direction = "DOWN"  # Default direction
        # Initialize position using pathfinding
        self.position = self.find_next_position()

    def calculate_rat_direction(self):
        x, y = self.position
        x_before, y_before = self.position_before
        if x > x_before:
            return "RIGHT"
        elif x < x_before:
            return "LEFT"
        elif y > y_before:
            return "DOWN"
        elif y < y_before:
            return "UP"
        else:
            return "DOWN"
        
    def find_next_position(self):
        neighbors = []
        x, y = self.position
        while not neighbors:
            for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
                nx, ny = x + dx, y + dy
                if not self.game.map.matrix[ny][nx] and not (nx, ny) == self.position_before:
                    neighbors.append((nx, ny))
            if not neighbors:
                self.position_before = self.position
            self.position_before = self.position
        return neighbors[random.randint(0, len(neighbors) - 1)]

    def choked(self):
        self.game.render_engine.play_sound("CHOKE.WAV")
        self.die(score=10)

    def move(self):
        if self.gassed > 35:
            self.choked()
            return
        self.age += 1
        if self.age == AGE_THRESHOLD:
            self.speed *= SPEED_REDUCTION
        if getattr(self, "pregnant", False):
            self.procreate()
        if self.stop:
            self.stop -= 1
            return
        if self.partial_move < 1:
            self.partial_move = round(self.partial_move + self.speed, 2)
        if self.partial_move >= 1:
            self.partial_move = 0
            self.position = self.find_next_position()
        self.direction = self.calculate_rat_direction()
        
        # Pre-calculate render position for draw() - optimization
        self._update_render_position()
    
    def _update_render_position(self):
        """Pre-calculate rendering position and bbox during move() to optimize draw()"""
        sex = self.sex if self.age > AGE_THRESHOLD else "BABY"
        
        # Get cached image size instead of calling get_image_size()
        image_size = self.game.rat_image_sizes[sex][self.direction]
        
        # Calculate partial movement offset
        if self.direction in ["UP", "DOWN"]:
            partial_x = 0
            partial_y = self.partial_move * self.game.cell_size * (1 if self.direction == "DOWN" else -1)
        else:
            partial_x = self.partial_move * self.game.cell_size * (1 if self.direction == "RIGHT" else -1)
            partial_y = 0
        
        # Calculate final render position
        self.render_x = self.position_before[0] * self.game.cell_size + (self.game.cell_size - image_size[0]) // 2 + partial_x
        self.render_y = self.position_before[1] * self.game.cell_size + (self.game.cell_size - image_size[1]) // 2 + partial_y
        
        # Update bbox for collision system
        self.bbox = (self.render_x, self.render_y, self.render_x + image_size[0], self.render_y + image_size[1])
        
    def collisions(self):
        """
        Optimized collision detection using the vectorized collision system.
        Uses spatial hashing and numpy for efficient checks with 200+ units.
        """
        OVERLAP_TOLERANCE = self.game.cell_size // 4
        
        # Only adult rats can collide for reproduction/fighting
        if self.age < AGE_THRESHOLD:
            return
        
        # Get collisions from the optimized collision system
        collisions = self.game.collision_system.get_collisions_for_unit(
            self.id, 
            CollisionLayer.RAT,
            tolerance=OVERLAP_TOLERANCE
        )
        
        # Process each collision
        for _, other_id in collisions:
            other_unit = self.game.get_unit_by_id(other_id)
            
            # Skip if not another Rat
            if not isinstance(other_unit, Rat):
                continue
            
            if not other_unit or other_unit.age < AGE_THRESHOLD:
                continue
            
            # Check if units are actually moving towards each other
            if self.position != other_unit.position_before:
                continue
            
            # Both units still exist in game
            if self.id in self.game.units and other_id in self.game.units:
                if self.sex == other_unit.sex and self.fight:
                    # Same sex + fight mode = combat
                    self.die(other_unit)
                elif self.sex != other_unit.sex:
                    # Different sex = reproduction
                    if "fuck" in dir(self):
                        self.fuck(other_unit)
                    
    def die(self, unit=None, score=10):
        """Handle rat death and spawn points."""
        target_unit = unit if unit else self
        death_position = target_unit.position_before
        
        # Use base class cleanup
        if target_unit.id in self.game.units:
            self.game.units.pop(target_unit.id)
        
        # Rat-specific behavior: spawn points
        if score not in [None, 0]:
            self.game.spawn_unit(Point, death_position, value=score)

        # Add blood stain directly to background
        self.game.add_blood_stain(death_position)

    def draw(self):
        """Optimized draw using pre-calculated positions from move()"""
        sex = self.sex if self.age > AGE_THRESHOLD else "BABY"
        image = self.game.rat_assets_textures[sex][self.direction]
        
        # Calculate render position if not yet set (first frame)
        if not hasattr(self, 'render_x'):
            self._calculate_render_position()
        
        # Use pre-calculated positions
        self.game.render_engine.draw_image(self.render_x, self.render_y, image, anchor="nw", tag="unit")
        # bbox already updated in _update_render_position()
        #self.game.render_engine.draw_rectangle(self.bbox[0], self.bbox[1], self.bbox[2] - self.bbox[0], self.bbox[3] - self.bbox[1], "unit")
    
    def _calculate_render_position(self):
        """Calculate render position and bbox (used when render_x not yet set)"""
        sex = self.sex if self.age > AGE_THRESHOLD else "BABY"
        image_size = self.game.render_engine.get_image_size(
            self.game.rat_assets_textures[sex][self.direction]
        )
        
        partial_x, partial_y = 0, 0
        if self.direction in ["UP", "DOWN"]:
            partial_y = self.partial_move * self.game.cell_size * (1 if self.direction == "DOWN" else -1)
        else:
            partial_x = self.partial_move * self.game.cell_size * (1 if self.direction == "RIGHT" else -1)
        
        self.render_x = self.position_before[0] * self.game.cell_size + (self.game.cell_size - image_size[0]) // 2 + partial_x
        self.render_y = self.position_before[1] * self.game.cell_size + (self.game.cell_size - image_size[1]) // 2 + partial_y
        self.bbox = (self.render_x, self.render_y, self.render_x + image_size[0], self.render_y + image_size[1])
        
class Male(Rat):
    def __init__(self, game, position=(0,0), id=None):
        super().__init__(game, position, id)
        self.sex = "MALE"
        
    def fuck(self, unit):
        if not unit.pregnant:
            self.game.render_engine.play_sound("SEX.WAV")
            self.stop = 100
            unit.stop = 200
            unit.pregnant = PREGNANCY_DURATION
            unit.babies = random.randint(1, 3)
    
class Female(Rat):
    def __init__(self, game, position=(0,0), id=None):
        super().__init__(game, position, id)
        self.sex = "FEMALE"
        self.pregnant = False
        self.babies = 0
        
    def procreate(self):
        self.pregnant -= 1
        if self.pregnant == self.babies * BABY_INTERVAL:
            self.babies -= 1
            self.stop = 20
            if self.partial_move > 0.2:
                self.game.spawn_rat(self.position)
            else:
                self.game.spawn_rat(self.position_before)
            self.game.render_engine.play_sound("BIRTH.WAV")