// //! Ghost entity implementation.
// //!
// //! This module contains the ghost character logic, including movement,
// //! animation, and rendering. Ghosts move through the game graph using
// //! a traverser and display directional animated textures.

// use pathfinding::prelude::dijkstra;
// use rand::prelude::*;
// use smallvec::SmallVec;
// use tracing::error;

// use crate::entity::{
//     collision::Collidable,
//     direction::Direction,
//     graph::{Edge, EdgePermissions, Graph, NodeId},
//     r#trait::Entity,
//     traversal::Traverser,
// };
// use crate::texture::animated::AnimatedTexture;
// use crate::texture::directional::DirectionalAnimatedTexture;
// use crate::texture::sprite::SpriteAtlas;

// use crate::error::{EntityError, GameError, GameResult, TextureError};

// /// Determines if a ghost can traverse a given edge.
// ///
// /// Ghosts can move through edges that allow all entities or ghost-only edges.
// fn can_ghost_traverse(edge: Edge) -> bool {
//     matches!(edge.permissions, EdgePermissions::All | EdgePermissions::GhostsOnly)
// }

// /// The four classic ghost types.
// #[derive(Debug, Clone, Copy, PartialEq, Eq)]
// pub enum GhostType {
//     Blinky,
//     Pinky,
//     Inky,
//     Clyde,
// }

// impl GhostType {
//     /// Returns the ghost type name for atlas lookups.
//     pub fn as_str(self) -> &'static str {
//         match self {
//             GhostType::Blinky => "blinky",
//             GhostType::Pinky => "pinky",
//             GhostType::Inky => "inky",
//             GhostType::Clyde => "clyde",
//         }
//     }

//     /// Returns the base movement speed for this ghost type.
//     pub fn base_speed(self) -> f32 {
//         match self {
//             GhostType::Blinky => 1.0,
//             GhostType::Pinky => 0.95,
//             GhostType::Inky => 0.9,
//             GhostType::Clyde => 0.85,
//         }
//     }
// }

// /// A ghost entity that roams the game world.
// ///
// /// Ghosts move through the game world using a graph-based navigation system
// /// and display directional animated sprites. They randomly choose directions
// /// at each intersection.
// pub struct Ghost {
//     /// Handles movement through the game graph
//     pub traverser: Traverser,
//     /// The type of ghost (affects appearance and speed)
//     pub ghost_type: GhostType,
//     /// Manages directional animated textures for different movement states
//     texture: DirectionalAnimatedTexture,
//     /// Current movement speed
//     speed: f32,
// }

// impl Entity for Ghost {
//     fn traverser(&self) -> &Traverser {
//         &self.traverser
//     }

//     fn traverser_mut(&mut self) -> &mut Traverser {
//         &mut self.traverser
//     }

//     fn texture(&self) -> &DirectionalAnimatedTexture {
//         &self.texture
//     }

//     fn texture_mut(&mut self) -> &mut DirectionalAnimatedTexture {
//         &mut self.texture
//     }

//     fn speed(&self) -> f32 {
//         self.speed
//     }

//     fn can_traverse(&self, edge: Edge) -> bool {
//         can_ghost_traverse(edge)
//     }

//     fn tick(&mut self, dt: f32, graph: &Graph) {
//         // Choose random direction when at a node
//         if self.traverser.position.is_at_node() {
//             self.choose_random_direction(graph);
//         }

//         if let Err(e) = self.traverser.advance(graph, dt * 60.0 * self.speed, &can_ghost_traverse) {
//             error!("Ghost movement error: {}", e);
//         }
//         self.texture.tick(dt);
//     }
// }

// impl Ghost {
//     /// Creates a new ghost instance at the specified starting node.
//     ///
//     /// Sets up animated textures for all four directions with moving and stopped states.
//     /// The moving animation cycles through two sprite variants.
//     pub fn new(graph: &Graph, start_node: NodeId, ghost_type: GhostType, atlas: &SpriteAtlas) -> GameResult<Self> {
//         let mut textures = [None, None, None, None];
//         let mut stopped_textures = [None, None, None, None];

//         for direction in Direction::DIRECTIONS {
//             let moving_prefix = match direction {
//                 Direction::Up => "up",
//                 Direction::Down => "down",
//                 Direction::Left => "left",
//                 Direction::Right => "right",
//             };
//             let moving_tiles = vec![
//                 SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a"))
//                     .ok_or_else(|| {
//                         GameError::Texture(TextureError::AtlasTileNotFound(format!(
//                             "ghost/{}/{}_{}.png",
//                             ghost_type.as_str(),
//                             moving_prefix,
//                             "a"
//                         )))
//                     })?,
//                 SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "b"))
//                     .ok_or_else(|| {
//                         GameError::Texture(TextureError::AtlasTileNotFound(format!(
//                             "ghost/{}/{}_{}.png",
//                             ghost_type.as_str(),
//                             moving_prefix,
//                             "b"
//                         )))
//                     })?,
//             ];

//             let stopped_tiles =
//                 vec![
//                     SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a"))
//                         .ok_or_else(|| {
//                             GameError::Texture(TextureError::AtlasTileNotFound(format!(
//                                 "ghost/{}/{}_{}.png",
//                                 ghost_type.as_str(),
//                                 moving_prefix,
//                                 "a"
//                             )))
//                         })?,
//                 ];

//             textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.2)?);
//             stopped_textures[direction.as_usize()] = Some(AnimatedTexture::new(stopped_tiles, 0.1)?);
//         }

//         Ok(Self {
//             traverser: Traverser::new(graph, start_node, Direction::Left, &can_ghost_traverse),
//             ghost_type,
//             texture: DirectionalAnimatedTexture::new(textures, stopped_textures),
//             speed: ghost_type.base_speed(),
//         })
//     }

//     /// Chooses a random available direction at the current intersection.
//     fn choose_random_direction(&mut self, graph: &Graph) {
//         let current_node = self.traverser.position.from_node_id();
//         let intersection = &graph.adjacency_list[current_node];

//         // Collect all available directions
//         let mut available_directions = SmallVec::<[_; 4]>::new();
//         for direction in Direction::DIRECTIONS {
//             if let Some(edge) = intersection.get(direction) {
//                 if can_ghost_traverse(edge) {
//                     available_directions.push(direction);
//                 }
//             }
//         }
//         // Choose a random direction (avoid reversing unless necessary)
//         if !available_directions.is_empty() {
//             let mut rng = SmallRng::from_os_rng();

//             // Filter out the opposite direction if possible, but allow it if we have limited options
//             let opposite = self.traverser.direction.opposite();
//             let filtered_directions: Vec<_> = available_directions
//                 .iter()
//                 .filter(|&&dir| dir != opposite || available_directions.len() <= 2)
//                 .collect();

//             if let Some(&random_direction) = filtered_directions.choose(&mut rng) {
//                 self.traverser.set_next_direction(*random_direction);
//             }
//         }
//     }

//     /// Calculates the shortest path from the ghost's current position to a target node using Dijkstra's algorithm.
//     ///
//     /// Returns a vector of NodeIds representing the path, or an error if pathfinding fails.
//     /// The path includes the current node and the target node.
//     pub fn calculate_path_to_target(&self, graph: &Graph, target: NodeId) -> GameResult<Vec<NodeId>> {
//         let start_node = self.traverser.position.from_node_id();

//         // Use Dijkstra's algorithm to find the shortest path
//         let result = dijkstra(
//             &start_node,
//             |&node_id| {
//                 // Get all edges from the current node
//                 graph.adjacency_list[node_id]
//                     .edges()
//                     .filter(|edge| can_ghost_traverse(*edge))
//                     .map(|edge| (edge.target, (edge.distance * 100.0) as u32))
//                     .collect::<Vec<_>>()
//             },
//             |&node_id| node_id == target,
//         );

//         result.map(|(path, _cost)| path).ok_or_else(|| {
//             GameError::Entity(EntityError::PathfindingFailed(format!(
//                 "No path found from node {} to target {}",
//                 start_node, target
//             )))
//         })
//     }

//     /// Returns the ghost's color for debug rendering.
//     pub fn debug_color(&self) -> sdl2::pixels::Color {
//         match self.ghost_type {
//             GhostType::Blinky => sdl2::pixels::Color::RGB(255, 0, 0),    // Red
//             GhostType::Pinky => sdl2::pixels::Color::RGB(255, 182, 255), // Pink
//             GhostType::Inky => sdl2::pixels::Color::RGB(0, 255, 255),    // Cyan
//             GhostType::Clyde => sdl2::pixels::Color::RGB(255, 182, 85),  // Orange
//         }
//     }
// }

// impl Collidable for Ghost {
//     fn position(&self) -> crate::entity::traversal::Position {
//         self.traverser.position
//     }
// }