use crate::{

    common::{GearId, GearData, GearDataProcessor}

};

use fpnum::*;

use integral_geometry::{

    Point, Size, GridIndex

};

#[derive(PartialEq, Eq, Clone, Copy, Debug)]

pub struct PhysicsData {

    pub position: FPPoint,

    pub velocity: FPPoint,

}

impl GearData for PhysicsData {}

pub struct DynamicPhysicsCollection {

    gear_ids: Vec<GearId>,

    positions: Vec<FPPoint>,

    velocities: Vec<FPPoint>,

}

impl DynamicPhysicsCollection {

    fn new() -> Self {

        Self {

            gear_ids: Vec::new(),

            positions: Vec::new(),

            velocities: Vec::new()

        }

    }

    fn len(&self) -> usize {

        self.gear_ids.len()

    }

    fn push(&mut self, id: GearId, physics: PhysicsData) {

        self.gear_ids.push(id);

        self.positions.push(physics.position);

        self.velocities.push(physics.velocity);

    }

    fn iter_pos_update(&mut self) -> impl Iterator<Item = (GearId, (&mut FPPoint, &FPPoint))> {

        self.gear_ids.iter().cloned()

            .zip(self.positions.iter_mut()

                .zip(self.velocities.iter()))

    }

}

pub struct StaticPhysicsCollection {

    gear_ids: Vec<GearId>,

    positions: Vec<FPPoint>

}

impl StaticPhysicsCollection {

    fn new() -> Self {

        Self {

            gear_ids: Vec::new(),

            positions: Vec::new()

        }

    }

    fn push(&mut self, gear_id: GearId, physics: PhysicsData) {

        self.gear_ids.push(gear_id);

        self.positions.push(physics.position);

    }

}

pub struct PhysicsProcessor {

    dynamic_physics: DynamicPhysicsCollection,

    static_physics: StaticPhysicsCollection,

    physics_cleanup: Vec<GearId>,

    position_updates: PositionUpdates

}

pub struct PositionUpdates {

    pub gear_ids: Vec<GearId>,

    pub positions: Vec<FPPoint>

}

impl PositionUpdates {

    pub fn new(capacity: usize) -> Self {

        Self {

            gear_ids: Vec::with_capacity(capacity),

            positions: Vec::with_capacity(capacity),

        }

    }

    pub fn push(&mut self, gear_id: GearId, position: &FPPoint) {

        self.gear_ids.push(gear_id);

        self.positions.push(*position);

    }

}

impl PhysicsProcessor {

    pub fn new() -> Self {

        PhysicsProcessor {

            dynamic_physics: DynamicPhysicsCollection::new(),

            static_physics: StaticPhysicsCollection::new(),

            physics_cleanup: Vec::new(),

            position_updates: PositionUpdates::new(0)

        }

    }

    pub fn process(&mut self, time_step: FPNum) -> &PositionUpdates {

        for (gear_id, (pos, vel)) in self.dynamic_physics.iter_pos_update() {

            *pos += *vel * time_step;

            if !vel.is_zero() {

                self.position_updates.push(gear_id, pos)

            } else {

                self.physics_cleanup.push(gear_id)

            }

        }

        &self.position_updates

    }

    pub fn push(&mut self, gear_id: GearId, physics_data: PhysicsData) {

        if physics_data.velocity.is_zero() {

            self.static_physics.push(gear_id, physics_data);

        } else {

            self.dynamic_physics.push(gear_id, physics_data);

        }

    }

}

impl GearDataProcessor<PhysicsData> for PhysicsProcessor {

    fn add(&mut self, gear_id: GearId, gear_data: PhysicsData) {

        if gear_data.velocity.is_zero() {

            self.static_physics.push(gear_id, gear_data);

        } else {

            self.dynamic_physics.push(gear_id, gear_data);

        }

    }

}