use glam::Vec2;
use pacman::constants::{CELL_SIZE, RAW_BOARD};
use pacman::map::builder::Map;

#[test]
fn test_map_creation() {
    let map = Map::new(RAW_BOARD).unwrap();

    assert!(map.graph.nodes().count() > 0);
    assert!(!map.grid_to_node.is_empty());

    // Check that some connections were made
    let mut has_connections = false;
    for intersection in &map.graph.adjacency_list {
        if intersection.edges().next().is_some() {
            has_connections = true;
            break;
        }
    }
    assert!(has_connections);
}

#[test]
fn test_map_node_positions() {
    let map = Map::new(RAW_BOARD).unwrap();

    for (grid_pos, &node_id) in &map.grid_to_node {
        let node = map.graph.get_node(node_id).unwrap();
        let expected_pos = Vec2::new((grid_pos.x * CELL_SIZE as i32) as f32, (grid_pos.y * CELL_SIZE as i32) as f32)
            + Vec2::splat(CELL_SIZE as f32 / 2.0);

        assert_eq!(node.position, expected_pos);
    }
}

// #[test]
// fn test_generate_items() {
//     use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas};
//     use std::collections::HashMap;

//     let map = Map::new(RAW_BOARD).unwrap();

//     // Create a minimal atlas for testing
//     let mut frames = HashMap::new();
//     frames.insert(
//         "maze/pellet.png".to_string(),
//         MapperFrame {
//             x: 0,
//             y: 0,
//             width: 8,
//             height: 8,
//         },
//     );
//     frames.insert(
//         "maze/energizer.png".to_string(),
//         MapperFrame {
//             x: 8,
//             y: 0,
//             width: 8,
//             height: 8,
//         },
//     );

//     let mapper = AtlasMapper { frames };
//     let texture = unsafe { std::mem::transmute::<usize, Texture<'static>>(0usize) };
//     let atlas = SpriteAtlas::new(texture, mapper);

//     let items = map.generate_items(&atlas).unwrap();

//     // Verify we have items
//     assert!(!items.is_empty());

//     // Count different types
//     let pellet_count = items
//         .iter()
//         .filter(|item| matches!(item.item_type, pacman::entity::item::ItemType::Pellet))
//         .count();
//     let energizer_count = items
//         .iter()
//         .filter(|item| matches!(item.item_type, pacman::entity::item::ItemType::Energizer))
//         .count();

//     // Should have both types
//     assert_eq!(pellet_count, 240);
//     assert_eq!(energizer_count, 4);

//     // All items should be uncollected initially
//     assert!(items.iter().all(|item| !item.is_collected()));

//     // All items should have valid node indices
//     assert!(items.iter().all(|item| item.node_index < map.graph.node_count()));
// }