mod common;

mod physics;

mod grid;

mod collision;

use fpnum::FPNum;

use integral_geometry::Size;

use land2d::Land2D;

use crate::{

    common::{

        GearId,

        GearData,

        GearDataAggregator,

        GearDataProcessor

    },

    physics::{

        PhysicsProcessor,

        PhysicsData

    },

    collision::{

        CollisionProcessor,

        CollisionData,

        ContactData

    }

};

pub struct JoinedData {

    gear_id: GearId,

    physics: PhysicsData,

    collision: CollisionData,

    contact: ContactData

}

pub struct World {

    physics: PhysicsProcessor,

    collision: CollisionProcessor,

}

macro_rules! processor_map {

    ( $data_type: ident => $field: ident ) => {

        impl GearDataAggregator<$data_type> for World {

            fn find_processor(&mut self) -> &mut GearDataProcessor<$data_type> {

                &mut self.$field

            }

        }

    }

}

processor_map!(PhysicsData => physics);

processor_map!(CollisionData => collision);

impl World {

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

        Self {

            physics: PhysicsProcessor::new(),

            collision: CollisionProcessor::new(world_size)

        }

    }

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

        let updates = self.physics.process(time_step);

        self.collision.process(land, &updates);

    }

    pub fn add_gear_data<T>(&mut self, gear_id: GearId, data: T)

        where T: GearData,

              Self: GearDataAggregator<T>

    {

        self.find_processor().add(gear_id, data);

    }

}

#[cfg(test)]

mod tests {

    use crate::{

        World,

        physics::PhysicsData,

        collision::{CollisionData, CircleBounds}

    };

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

    use integral_geometry::Size;

    use land2d::Land2D;

    #[test]

    fn data_flow() {

        let world_size = Size::new(2048, 2048);

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

        let gear_id = 46631;

        world.add_gear_data(gear_id, PhysicsData {

            position: FPPoint::zero(),

            velocity: 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(fp!(1), &land);

    }

}