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

const BLOCK_SIZE: usize = 8192;

pub trait TypeTuple {
    type Storage: Default;

    fn len() -> usize;
    fn get_types(dest: &mut Vec<TypeId>);
}

//TODO macroise this template for tuples up to sufficient size
impl<T: 'static> TypeTuple for (T,) {
    type Storage = (Vec<T>,);

    #[inline]
    fn len() -> usize {
        1
    }

    #[inline]
    fn get_types(dest: &mut Vec<TypeId>) {
        dest.push(TypeId::of::<T>());
    }
}

pub struct GearDataCollection<T: TypeTuple> {
    len: usize,
    blocks: T::Storage,
}

impl<T: TypeTuple> GearDataCollection<T> {
    fn new() -> Self {
        Self {
            len: 0,
            blocks: T::Storage::default(),
        }
    }

    fn iter<F: Fn(T)>(&self, f: F) {}
}

pub struct GearDataGroup {
    group_selector: u64,
    data: Box<dyn Any + 'static>,
}

impl GearDataGroup {
    fn iter() {}
}

pub struct GearDataManager {
    types: Vec<TypeId>,
    groups: Vec<GearDataGroup>,
}

impl GearDataManager {
    pub fn new() -> Self {
        Self {
            types: vec![],
            groups: vec![],
        }
    }

    pub fn register<T: 'static>(&mut self) {
        assert!(self.types.len() <= 64);
        let id = TypeId::of::<T>();
        if !self.types.contains(&id) {
            self.types.push(id);
        }
    }

    fn create_selector(&self, types: &[TypeId]) -> u64 {
        let mut selector = 0u64;
        for (i, typ) in self.types.iter().enumerate() {
            if types.contains(&typ) {
                selector |= 1 << (i as u64)
            }
        }
        selector
    }

    pub fn iter<T: TypeTuple + 'static, F: Fn(T) + Copy>(&self, f: F) {
        let mut types = vec![];
        T::get_types(&mut types);
        let selector = self.create_selector(&types);
        for group in &self.groups {
            if group.group_selector & selector == selector {
                group
                    .data
                    .downcast_ref::<GearDataCollection<T>>()
                    .unwrap()
                    .iter(f);
            }
        }
    }
}