use glam::IVec2;

use crate::{
    content::materials::MaterialId,
    sim::{cell::Cell, entity::EntityId, sim_manager::SimManager},
};

fn write_entity_to_world(sim: &mut SimManager, entity_id: EntityId) -> Vec<(u8, u8, i32, i32)> {
    let mut cells_written: Vec<(u8, u8, i32, i32)> = Vec::new();
    if let Some(entity) = sim.entities.get(&entity_id)
        && let Some(cells) = &entity.data.cells
        && let Some((pos, (cos, sin))) = entity.data.transform(&super::SimCtx {
            cell_manager: &mut sim.cell_manager,
            rb_manager: &mut sim.rb_manager,
            particle_manager: &mut sim.particle_manager,
        })
    {
        let (half_size_x, half_size_y) = (cells.size.x as f32 / 2.0, cells.size.y as f32 / 2.0);
        // half-extent of the rotated grid's axis-aligned bounding box, plus a cell of margin
        let (radius_x, radius_y) = (
            half_size_x * (cos.abs() + sin.abs()) + 1.0,
            half_size_y * (cos.abs() + sin.abs()) + 1.0,
        );

        let world_xl = (pos.x - radius_x).floor() as i32;
        let world_xu = (pos.x + radius_x).ceil() as i32;
        let world_yl = (pos.y - radius_y).floor() as i32;
        let world_yu = (pos.y + radius_y).ceil() as i32;

        for world_x in world_xl..=world_xu {
            for world_y in world_yl..=world_yu {
                if let Some(cur_world_cell) = sim
                    .cell_manager
                    .get_cell_from_game_position(world_x, world_y)
                    && cur_world_cell.material == MaterialId::Void
                {
                    // same as shader
                    let d = (world_x as f32 + 0.5 - pos.x, world_y as f32 + 0.5 - pos.y);
                    let q = (d.0.floor() + 0.5, d.1.floor() + 0.5);
                    let (lx, ly) = (
                        (q.0 * cos + q.1 * sin + half_size_x).floor() as i32,
                        (-q.0 * sin + q.1 * cos + half_size_y).floor() as i32,
                    );

                    if lx < 0 || ly < 0 || lx >= cells.size.x || ly >= cells.size.y {
                        continue;
                    }

                    let mut cell = cells.get_cell_at_local_position(IVec2::new(lx, ly));
                    if cell.material == MaterialId::Void {
                        continue;
                    }

                    cell.match_parity(sim.cell_manager.seqno);

                    // TODO: OPTIMIZE!!
                    sim.cell_manager
                        .set_cell_from_game_position(world_x, world_y, cell, false);
                    cells_written.push((lx as u8, ly as u8, world_x, world_y));
                }
            }
        }
    }
    cells_written
}

pub fn write_entities_to_world(
    sim: &mut SimManager,
    // (entity_x, entity_y, cell_x, cell_y)
) -> Vec<(EntityId, Vec<(u8, u8, i32, i32)>)> {
    // TODO optimize
    let entity_ids: Vec<EntityId> = sim.entities.keys().copied().collect();
    let mut cells_written_by_entity: Vec<(EntityId, Vec<(u8, u8, i32, i32)>)> = Vec::new();

    for entity_id in entity_ids {
        let cells_written = write_entity_to_world(sim, entity_id);
        cells_written_by_entity.push((entity_id, cells_written));
    }

    cells_written_by_entity
}

// TODO optimize
pub fn read_back_entities_from_world(
    sim: &mut SimManager,
    cells_written_by_entity: Vec<(EntityId, Vec<(u8, u8, i32, i32)>)>,
) {
    for (entity_id, cells_written) in cells_written_by_entity {
        if let Some(entity) = sim.entities.get_mut(&entity_id) {
            let entity_cells = entity.data.cells.as_mut().unwrap();
            let mut should_update_entity = false;

            for (lx, ly, x, y) in cells_written {
                // update the entity
                // TODO optimize
                let new_local_cell = sim.cell_manager.get_cell_from_game_position(x, y).unwrap();
                if !new_local_cell.entity_integrated() {
                    // this means that the entity changed in some way, so we should recompute its shape
                    // TODO wait N frames to debounce this
                    should_update_entity = true;
                }
                // we do this unconditionally because it's cheaper than checking if it actually needs to be updated
                // and because we don't have a good way to track changes to cell state
                entity_cells
                    .set_cell_at_local_position(IVec2::new(lx as i32, ly as i32), new_local_cell);

                // update the world
                // TODO optimize
                sim.cell_manager
                    .set_cell_from_game_position(x, y, Cell::void(), false);
            }

            if should_update_entity {
                if let Some(new_collider) = entity.compute_collider() {
                    sim.rb_manager
                        .physics_manager
                        .world
                        .remove_collider(entity.data.collider_h.unwrap());

                    let new_handle = sim
                        .rb_manager
                        .physics_manager
                        .world
                        .insert_collider(new_collider, Some(entity.data.rb_h.unwrap()));

                    entity.data.collider_h = Some(new_handle);
                }
            }
        }
    }
}