pub mod collision;

pub mod common;

mod data;

mod grid;

pub mod physics;

use integral_geometry::PotSize;

use land2d::Land2D;

use std::any::{Any, TypeId};

use crate::collision::CollisionData;

use crate::physics::VelocityData;

use crate::{

    collision::CollisionProcessor,

    common::{GearAllocator, GearId, Millis},

    data::{DataIterator, GearDataManager, TypeIter},

    physics::PhysicsProcessor,

};

pub struct World {

    allocator: GearAllocator,

    data: GearDataManager,

    physics: PhysicsProcessor,

    collision: CollisionProcessor,

}

impl World {

    pub fn new(world_size: PotSize) -> Self {

        let mut data = GearDataManager::new();

        PhysicsProcessor::register_components(&mut data);

        CollisionProcessor::register_components(&mut data);

        Self {

            data,

            allocator: GearAllocator::new(),

            physics: PhysicsProcessor::new(),

            collision: CollisionProcessor::new(world_size),

        }

    }

    #[inline]

    pub fn new_gear(&mut self) -> Option<GearId> {

        self.allocator.alloc()

    }

    #[inline]

    pub fn delete_gear(&mut self, gear_id: GearId) {

        self.data.remove_all(gear_id);

        self.collision.remove(gear_id);

        self.allocator.free(gear_id)

    }

    pub fn step(&mut self, time_step: Millis, land: &Land2D<u32>) {

        let updates = self.physics.process(&mut self.data, time_step);

        let collisions = self.collision.process(land, &updates);

    }

    pub fn add_gear_data<T: Clone + 'static>(&mut self, gear_id: GearId, data: &T) {

        self.data.add(gear_id, data);

        if TypeId::of::<T>() == TypeId::of::<VelocityData>() {

            self.collision.remove(gear_id);

        }

    }

    pub fn remove_gear_data<T: Clone + 'static>(&mut self, gear_id: GearId) {

        self.data.remove::<T>(gear_id);

        if TypeId::of::<T>() == TypeId::of::<VelocityData>() {

            if let Some(collision_data) = self.data.get::<CollisionData>(gear_id) {

                self.collision.add(gear_id, *collision_data);

            }

        }

    }

    #[inline]

    pub fn iter_data<T: TypeIter + 'static>(&mut self) -> DataIterator<T> {

        self.data.iter()

    }

}

#[cfg(test)]

mod tests {

    use crate::{

        collision::{CircleBounds, CollisionData},

        common::Millis,

        physics::{PositionData, VelocityData},

        World,

    };

    use fpnum::{fp, FPNum, FPPoint};

    use integral_geometry::{PotSize, Size};

    use land2d::Land2D;

    #[test]

    fn data_flow() {

        let world_size = PotSize::new(2048, 2048).unwrap();

        let mut world = World::new(world_size);

        let gear_id = world.new_gear().unwrap();

        world.add_gear_data(gear_id, &PositionData(FPPoint::zero()));

        world.add_gear_data(gear_id, &VelocityData(FPPoint::unit_y()));

        world.add_gear_data(

            gear_id,

            &CollisionData {

                bounds: CircleBounds {

                    center: FPPoint::zero(),

                    radius: fp!(10),

                },

            },

        );

        let land = Land2D::new(

            Size::new(world_size.width() - 2, world_size.height() - 2),

            0,

        );

        world.step(Millis::new(1), &land);

    }

}