pub mod rb_entity;

use fxhash::FxHashMap;
use rapier2d::{
    dynamics::{self},
    geometry,
    glamx::vec2,
    math, prelude,
};

use crate::{
    config::{CELLS_IN_CHUNK, CHUNK_SIZE, PHYSICS_DELTA_TIME, PIXELS_TO_METRES},
    sim::{
        cell::{cell::Cell, materials::MaterialId},
        rb_sim::rb_entity::RbEntity,
    },
};

pub struct PhysicsManager {
    rigid_body_set: prelude::RigidBodySet,
    collider_set: prelude::ColliderSet,
    physics_pipeline: prelude::PhysicsPipeline,
    integration_parameters: prelude::IntegrationParameters,
    island_manager: prelude::IslandManager,
    broad_phase: prelude::DefaultBroadPhase,
    narrow_phase: prelude::NarrowPhase,
    impulse_joint_set: prelude::ImpulseJointSet,
    multibody_joint_set: prelude::MultibodyJointSet,
    ccd_solver: prelude::CCDSolver,
}

impl PhysicsManager {
    pub fn new() -> Self {
        PhysicsManager {
            rigid_body_set: prelude::RigidBodySet::new(),
            collider_set: prelude::ColliderSet::new(),
            physics_pipeline: prelude::PhysicsPipeline::new(),
            integration_parameters: prelude::IntegrationParameters {
                // 20 pixels <-> 1 meter
                length_unit: PIXELS_TO_METRES,
                dt: PHYSICS_DELTA_TIME,
                ..prelude::IntegrationParameters::default()
            },
            island_manager: prelude::IslandManager::new(),
            broad_phase: prelude::DefaultBroadPhase::new(),
            narrow_phase: prelude::NarrowPhase::new(),
            impulse_joint_set: prelude::ImpulseJointSet::new(),
            multibody_joint_set: prelude::MultibodyJointSet::new(),
            ccd_solver: prelude::CCDSolver::new(),
        }
    }
}

pub struct RbSimManager {
    physics_manager: PhysicsManager,
    pub rb_entities: FxHashMap<u32, RbEntity>,
    next_id: u32,
}

impl RbSimManager {
    pub fn rb_tick(&mut self, delta_time: f32) {
        let gravity = vec2(0.0, 9.81);

        self.physics_manager.physics_pipeline.step(
            gravity,
            &self.physics_manager.integration_parameters,
            &mut self.physics_manager.island_manager,
            &mut self.physics_manager.broad_phase,
            &mut self.physics_manager.narrow_phase,
            &mut self.physics_manager.rigid_body_set,
            &mut self.physics_manager.collider_set,
            &mut self.physics_manager.impulse_joint_set,
            &mut self.physics_manager.multibody_joint_set,
            &mut self.physics_manager.ccd_solver,
            &(),
            &(),
        );
    }

    pub fn create_rb_entity(
        &mut self,
        cells: Box<[Cell; CELLS_IN_CHUNK]>,
        rb_parent: prelude::RigidBodyHandle,
    ) {
        let id = self.next_id;
        self.next_id += 1;
        let entity: RbEntity = RbEntity {
            id,
            cells,
            rb_parent,
        };

        self.rb_entities.insert(id, entity);
    }

    pub fn destroy_rb_entity(&mut self, entity_id: u32) {
        if let Some(entity) = self.rb_entities.get(&entity_id) {
            self.physics_manager.rigid_body_set.remove(
                entity.rb_parent,
                &mut self.physics_manager.island_manager,
                &mut self.physics_manager.collider_set,
                &mut self.physics_manager.impulse_joint_set,
                &mut self.physics_manager.multibody_joint_set,
                true,
            );
            self.rb_entities.remove(&entity_id);
        }
    }

    pub fn get_rb_entity_transform(&self, entity_id: u32) -> Option<(f32, f32, f32, f32)> {
        let entity = self.rb_entities.get(&entity_id);
        match entity {
            Some(entity) => {
                let rb = self.physics_manager.rigid_body_set.get(entity.rb_parent);
                rb.map(|rb| {
                    let position = rb.position();
                    let angle = position.rotation.angle();
                    (
                        position.translation.x * PIXELS_TO_METRES,
                        position.translation.y * PIXELS_TO_METRES,
                        angle.cos(),
                        angle.sin(),
                    )
                })
            }
            None => return None,
        }
    }

    pub fn test(&mut self) {
        /* Create the ground. */
        let collider =
            geometry::ColliderBuilder::cuboid(100.0 / PIXELS_TO_METRES, 8.0 / PIXELS_TO_METRES)
                .position(math::Pose2::from_translation(vec2(
                    0 as f32,
                    CHUNK_SIZE as f32 / PIXELS_TO_METRES,
                )))
                .build();
        self.physics_manager.collider_set.insert(collider);
    }

    pub fn test_spawn_box(&mut self, x: f32, y: f32, material: MaterialId) {
        /* Create the bouncing ball. */
        let rigid_body = dynamics::RigidBodyBuilder::dynamic()
            .translation(math::Vector::new(
                x / PIXELS_TO_METRES,
                y / PIXELS_TO_METRES,
            ))
            .build();
        let collider =
            geometry::ColliderBuilder::cuboid(5.0 / PIXELS_TO_METRES, 5.0 / PIXELS_TO_METRES)
                .build();
        let ball_body_handle = self.physics_manager.rigid_body_set.insert(rigid_body);
        self.physics_manager.collider_set.insert_with_parent(
            collider,
            ball_body_handle,
            &mut self.physics_manager.rigid_body_set,
        );

        let mut test_cells = Box::new([Cell::void(); CELLS_IN_CHUNK]);

        for x in CHUNK_SIZE / 2 - 5..CHUNK_SIZE / 2 + 5 {
            for y in CHUNK_SIZE / 2 - 5..CHUNK_SIZE / 2 + 5 {
                let cell_idx = x + y * CHUNK_SIZE;
                test_cells[cell_idx as usize] = Cell::from_material(material);
                test_cells[cell_idx as usize].set_rb(true);
            }
        }

        self.create_rb_entity(test_cells, ball_body_handle);
    }

    pub fn new() -> Self {
        RbSimManager {
            physics_manager: PhysicsManager::new(),
            rb_entities: FxHashMap::default(),
            next_id: 0,
        }
    }
}