"""
McRogueFace Tutorial - Part 3: Procedural Dungeon Generation

This tutorial builds on Part 2 by adding:
- Binary Space Partition (BSP) dungeon generation
- Rooms connected by hallways using libtcod.line()
- Walkable/non-walkable terrain
- Player spawning in a valid location
- Wall tiles that block movement

Key code references:
- src/scripts/cos_level.py (lines 7-15, 184-217, 218-224) - BSP algorithm
- mcrfpy.libtcod.line() for smooth hallway generation
"""
import mcrfpy
import random

# Create and activate a new scene
mcrfpy.createScene("tutorial")
mcrfpy.setScene("tutorial")

# Load the texture (4x3 tiles, 64x48 pixels total, 16x16 per tile)
texture = mcrfpy.Texture("assets/tutorial2.png", 16, 16)

# Load the hero sprite texture
hero_texture = mcrfpy.Texture("assets/custom_player.png", 16, 16)

# Create a grid of tiles
grid_width, grid_height = 40, 30  # Larger grid for dungeon

# Calculate the size in pixels to fit the entire grid on-screen
zoom = 2.0
grid_size = grid_width * zoom * 16, grid_height * zoom * 16

# Calculate the position to center the grid on the screen
grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2

# Create the grid with a TCODMap for pathfinding/FOV
grid = mcrfpy.Grid(
    pos=grid_position,
    grid_size=(grid_width, grid_height),
    texture=texture,
    size=grid_size,
)

grid.zoom = zoom

# Define tile types
FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
WALL_TILES = [3, 7, 11]

# Room class for BSP
class Room:
    def __init__(self, x, y, w, h):
        self.x1 = x
        self.y1 = y
        self.x2 = x + w
        self.y2 = y + h
        self.w = w
        self.h = h
    
    def center(self):
        """Return the center coordinates of the room"""
        center_x = (self.x1 + self.x2) // 2
        center_y = (self.y1 + self.y2) // 2
        return (center_x, center_y)
    
    def intersects(self, other):
        """Return True if this room overlaps with another"""
        return (self.x1 <= other.x2 and self.x2 >= other.x1 and
                self.y1 <= other.y2 and self.y2 >= other.y1)

# Dungeon generation functions
def carve_room(room):
    """Carve out a room in the grid - referenced from cos_level.py lines 117-120"""
    # Using individual updates for now (batch updates would be more efficient)
    for x in range(room.x1, room.x2):
        for y in range(room.y1, room.y2):
            if 0 <= x < grid_width and 0 <= y < grid_height:
                point = grid.at(x, y)
                if point:
                    point.tilesprite = random.choice(FLOOR_TILES)
                    point.walkable = True
                    point.transparent = True

def carve_hallway(x1, y1, x2, y2):
    """Carve a hallway between two points using libtcod.line()
    Referenced from cos_level.py lines 184-217, improved with libtcod.line()
    """
    # Get all points along the line
    points = mcrfpy.libtcod.line(x1, y1, x2, y2)
    
    # Carve out each point
    for x, y in points:
        if 0 <= x < grid_width and 0 <= y < grid_height:
            point = grid.at(x, y)
            if point:
                point.tilesprite = random.choice(FLOOR_TILES)
                point.walkable = True
                point.transparent = True

def generate_dungeon(max_rooms=10, room_min_size=4, room_max_size=10):
    """Generate a dungeon using simplified BSP approach
    Referenced from cos_level.py lines 218-224
    """
    rooms = []
    
    # First, fill everything with walls
    for y in range(grid_height):
        for x in range(grid_width):
            point = grid.at(x, y)
            if point:
                point.tilesprite = random.choice(WALL_TILES)
                point.walkable = False
                point.transparent = False
    
    # Generate rooms
    for _ in range(max_rooms):
        # Random room size
        w = random.randint(room_min_size, room_max_size)
        h = random.randint(room_min_size, room_max_size)
        
        # Random position (with margin from edges)
        x = random.randint(1, grid_width - w - 1)
        y = random.randint(1, grid_height - h - 1)
        
        new_room = Room(x, y, w, h)
        
        # Check if it overlaps with existing rooms
        failed = False
        for other_room in rooms:
            if new_room.intersects(other_room):
                failed = True
                break
        
        if not failed:
            # Carve out the room
            carve_room(new_room)
            
            # If not the first room, connect to previous room
            if rooms:
                # Get centers
                prev_x, prev_y = rooms[-1].center()
                new_x, new_y = new_room.center()
                
                # Carve hallway using libtcod.line()
                carve_hallway(prev_x, prev_y, new_x, new_y)
            
            rooms.append(new_room)
    
    return rooms

# Generate the dungeon
rooms = generate_dungeon(max_rooms=8, room_min_size=4, room_max_size=8)

# Add the grid to the scene
mcrfpy.sceneUI("tutorial").append(grid)

# Spawn player in the first room
if rooms:
    spawn_x, spawn_y = rooms[0].center()
else:
    # Fallback spawn position
    spawn_x, spawn_y = 4, 4

# Create a player entity at the spawn position
player = mcrfpy.Entity(
    (spawn_x, spawn_y),
    texture=hero_texture,
    sprite_index=0
)

# Add the player entity to the grid
grid.entities.append(player)
grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16

# Movement state tracking (from Part 2)
is_moving = False
move_queue = []
current_destination = None
current_move = None

# Store animation references
player_anim_x = None
player_anim_y = None
grid_anim_x = None
grid_anim_y = None

def movement_complete(anim, target):
    """Called when movement animation completes"""
    global is_moving, move_queue, current_destination, current_move
    global player_anim_x, player_anim_y
    
    is_moving = False
    current_move = None
    current_destination = None
    player_anim_x = None
    player_anim_y = None
    
    grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16
    
    if move_queue:
        next_move = move_queue.pop(0)
        process_move(next_move)

motion_speed = 0.20  # Slightly faster for dungeon exploration

def can_move_to(x, y):
    """Check if a position is valid for movement"""
    # Boundary check
    if x < 0 or x >= grid_width or y < 0 or y >= grid_height:
        return False
    
    # Walkability check
    point = grid.at(x, y)
    if point and point.walkable:
        return True
    return False

def process_move(key):
    """Process a move based on the key"""
    global is_moving, current_move, current_destination, move_queue
    global player_anim_x, player_anim_y, grid_anim_x, grid_anim_y
    
    if is_moving:
        move_queue.clear()
        move_queue.append(key)
        return
    
    px, py = int(player.x), int(player.y)
    new_x, new_y = px, py
    
    if key == "W" or key == "Up":
        new_y -= 1
    elif key == "S" or key == "Down":
        new_y += 1
    elif key == "A" or key == "Left":
        new_x -= 1
    elif key == "D" or key == "Right":
        new_x += 1
    
    # Check if we can move to the new position
    if new_x != px or new_y != py:
        if can_move_to(new_x, new_y):
            is_moving = True
            current_move = key
            current_destination = (new_x, new_y)
            
            if new_x != px:
                player_anim_x = mcrfpy.Animation("x", float(new_x), motion_speed, "easeInOutQuad", callback=movement_complete)
                player_anim_x.start(player)
            elif new_y != py:
                player_anim_y = mcrfpy.Animation("y", float(new_y), motion_speed, "easeInOutQuad", callback=movement_complete)
                player_anim_y.start(player)
            
            grid_anim_x = mcrfpy.Animation("center_x", (new_x + 0.5) * 16, motion_speed, "linear")
            grid_anim_y = mcrfpy.Animation("center_y", (new_y + 0.5) * 16, motion_speed, "linear")
            grid_anim_x.start(grid)
            grid_anim_y.start(grid)
        else:
            # Play a "bump" sound or visual feedback here
            print(f"Can't move to ({new_x}, {new_y}) - blocked!")

def handle_keys(key, state):
    """Handle keyboard input to move the player"""
    if state == "start":
        if key in ["W", "Up", "S", "Down", "A", "Left", "D", "Right"]:
            process_move(key)

# Register the keyboard handler
mcrfpy.keypressScene(handle_keys)

# Add UI elements
title = mcrfpy.Caption((320, 10),
    text="McRogueFace Tutorial - Part 3: Dungeon Generation",
)
title.fill_color = mcrfpy.Color(255, 255, 255, 255)
mcrfpy.sceneUI("tutorial").append(title)

instructions = mcrfpy.Caption((150, 750),
    text=f"Procedural dungeon with {len(rooms)} rooms connected by hallways!",
)
instructions.font_size = 18
instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
mcrfpy.sceneUI("tutorial").append(instructions)

# Debug info
debug_caption = mcrfpy.Caption((10, 40),
    text=f"Grid: {grid_width}x{grid_height} | Player spawned at ({spawn_x}, {spawn_y})",
)
debug_caption.font_size = 16
debug_caption.fill_color = mcrfpy.Color(255, 255, 0, 255)
mcrfpy.sceneUI("tutorial").append(debug_caption)

print("Tutorial Part 3 loaded!")
print(f"Generated dungeon with {len(rooms)} rooms")
print(f"Player spawned at ({spawn_x}, {spawn_y})")
print("Walls now block movement!")
print("Use WASD or Arrow keys to explore the dungeon!")