use bevy::prelude::*;
use bevy_rapier2d::prelude::{
    ExternalForce, ExternalImpulse, ReadMassProperties, RigidBody, Velocity,
};
use serde::{Deserialize, Serialize};
use starkingdoms_common::PartType as c_PartType;

#[derive(Component, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Debug, Default)]
pub struct PartType(pub c_PartType);

impl From<PartType> for c_PartType {
    fn from(value: PartType) -> Self {
        value.0
    }
}
impl From<c_PartType> for PartType {
    fn from(value: c_PartType) -> Self {
        PartType(value)
    }
}

#[derive(Component, Clone, Debug)]
pub struct Attach {
    pub associated_player: Option<Entity>,
    pub parent: Option<Entity>,
    pub children: [Option<Entity>; 4],
}

#[derive(Component, Clone, Debug)]
pub struct LooseAttach {
    pub children: [Option<Entity>; 4],
}

#[derive(Component, Clone, Copy, PartialEq, Debug)]
pub struct CanAttach(pub u8); // each bit means a slot able to attach to

#[derive(Component, Copy, Clone, Default)]
pub struct PartFlags {
    pub attached: bool,
}

#[derive(Bundle)]
pub struct PartBundle {
    pub transform: TransformBundle,
    pub part_type: PartType,
    pub flags: PartFlags,
    pub velocity: Velocity,
    pub force: ExternalForce,
    pub impulse: ExternalImpulse,
    pub rigidbody: RigidBody,
    pub read_mass_properties: ReadMassProperties,
}

impl Default for PartBundle {
    fn default() -> Self {
        Self {
            transform: TransformBundle::default(),
            part_type: PartType::default(),
            flags: PartFlags::default(),
            velocity: Velocity::default(),
            force: ExternalForce::default(),
            impulse: ExternalImpulse::default(),
            rigidbody: RigidBody::Dynamic,
            read_mass_properties: ReadMassProperties::default(),
        }
    }
}

#[derive(Resource)]
pub struct ModuleTimer(pub Timer);
impl ModuleTimer {
    pub fn new() -> Self {
        Self(Timer::from_seconds(0.3, TimerMode::Repeating))
    }
}
impl Default for ModuleTimer {
    fn default() -> Self {
        Self::new()
    }
}