pub mod ser {
    use std::{collections::HashMap, marker::PhantomData};

    use itertools::Itertools;
    use serde::{ser::SerializeMap, Serialize, Serializer};

    use crate::internals::{
        query::filter::LayoutFilter,
        serialize::{ser::WorldSerializer, UnknownType},
        storage::{
            archetype::{Archetype, ArchetypeIndex},
            component::ComponentTypeId,
            ComponentIndex,
        },
        world::World,
    };

    pub struct EntitiesLayoutSerializer<'a, W: WorldSerializer, F: LayoutFilter> {
        pub world_serializer: &'a W,
        pub world: &'a World,
        pub filter: &'a F,
    }

    impl<'a, W: WorldSerializer, F: LayoutFilter> Serialize for EntitiesLayoutSerializer<'a, W, F> {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            let archetypes = self
                .world
                .archetypes()
                .iter()
                .enumerate()
                .filter(|(_, arch)| {
                    self.filter
                        .matches_layout(arch.layout().component_types())
                        .is_pass()
                })
                .map(|(i, arch)| (ArchetypeIndex(i as u32), arch))
                .collect::<Vec<_>>();

            let component_types = archetypes
                .iter()
                .flat_map(|(_, arch)| arch.layout().component_types())
                .unique();
            let mut type_mappings = HashMap::new();
            for id in component_types {
                match self.world_serializer.map_id(*id) {
                    Ok(type_id) => {
                        type_mappings.insert(*id, type_id);
                    }
                    Err(error) => {
                        match error {
                            UnknownType::Ignore => {}
                            UnknownType::Error => {
                                return Err(serde::ser::Error::custom(format!(
                                    "unknown component type {:?}",
                                    *id
                                )));
                            }
                        }
                    }
                }
            }

            let mut map = serializer.serialize_map(Some(
                archetypes
                    .iter()
                    .map(|(_, arch)| arch.entities().len())
                    .sum(),
            ))?;

            for (arch_index, arch) in archetypes {
                for (i, entity) in arch.entities().iter().enumerate() {
                    map.serialize_entry(
                        entity,
                        &EntitySerializer {
                            component_index: ComponentIndex(i),
                            arch_index,
                            arch,
                            world: self.world,
                            world_serializer: self.world_serializer,
                            type_mappings: &type_mappings,
                        },
                    )?;
                }
            }

            map.end()
        }
    }

    struct EntitySerializer<'a, W: WorldSerializer> {
        component_index: ComponentIndex,
        arch_index: ArchetypeIndex,
        arch: &'a Archetype,
        world: &'a World,
        world_serializer: &'a W,
        type_mappings: &'a HashMap<ComponentTypeId, W::TypeId>,
    }

    impl<'a, W: WorldSerializer> Serialize for EntitySerializer<'a, W> {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            let layout = self.arch.layout().component_types();
            let components = self.world.components();
            let type_count = layout
                .iter()
                .filter_map(|t| self.type_mappings.get(t))
                .count();

            let mut map = serializer.serialize_map(Some(type_count))?;

            for type_id in self.arch.layout().component_types() {
                if let Some(mapped_type_id) = self.type_mappings.get(type_id) {
                    let storage = components.get(*type_id).unwrap();
                    let (ptr, len) = storage.get_raw(self.arch_index).unwrap();
                    assert!(self.component_index.0 < len);
                    map.serialize_entry(
                        mapped_type_id,
                        &ComponentSerializer {
                            type_id: *type_id,
                            world_serializer: self.world_serializer,
                            ptr: unsafe {
                                ptr.add(self.component_index.0 * storage.element_vtable().size())
                            },
                            _phantom: PhantomData,
                        },
                    )?;
                }
            }

            map.end()
        }
    }

    struct ComponentSerializer<'a, W: WorldSerializer> {
        type_id: ComponentTypeId,
        ptr: *const u8,
        world_serializer: &'a W,
        _phantom: PhantomData<&'a u8>,
    }

    impl<'a, W: WorldSerializer> Serialize for ComponentSerializer<'a, W> {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            unsafe {
                self.world_serializer
                    .serialize_component(self.type_id, self.ptr, serializer)
            }
        }
    }
}

pub mod de {
    use std::{collections::HashMap, rc::Rc};

    use serde::{
        de::{DeserializeSeed, IgnoredAny, MapAccess, Visitor},
        Deserializer,
    };

    use crate::internals::{
        entity::Entity,
        insert::{ArchetypeSource, ArchetypeWriter, ComponentSource, IntoComponentSource},
        serialize::{de::WorldDeserializer, UnknownType},
        storage::{archetype::EntityLayout, component::ComponentTypeId},
        world::World,
    };

    pub struct EntitiesLayoutDeserializer<'a, W: WorldDeserializer> {
        pub world_deserializer: &'a W,
        pub world: &'a mut World,
    }

    impl<'a, 'de, W: WorldDeserializer> DeserializeSeed<'de> for EntitiesLayoutDeserializer<'a, W> {
        type Value = ();

        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
        where
            D: Deserializer<'de>,
        {
            struct EntitySeqVisitor<'b, D: WorldDeserializer> {
                world_deserializer: &'b D,
                world: &'b mut World,
            }

            impl<'b, 'de, D: WorldDeserializer> Visitor<'de> for EntitySeqVisitor<'b, D> {
                type Value = ();

                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("entity map")
                }

                fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
                where
                    V: MapAccess<'de>,
                {
                    while let Some(entity) = map.next_key()? {
                        self.world.remove(entity);
                        map.next_value_seed(EntityDeserializer {
                            world_deserializer: self.world_deserializer,
                            world: self.world,
                            entity,
                        })?
                    }
                    Ok(())
                }
            }

            deserializer.deserialize_map(EntitySeqVisitor {
                world_deserializer: self.world_deserializer,
                world: self.world,
            })
        }
    }

    struct EntityDeserializer<'a, W: WorldDeserializer> {
        world_deserializer: &'a W,
        world: &'a mut World,
        entity: Entity,
    }

    impl<'a, 'de, W: WorldDeserializer> DeserializeSeed<'de> for EntityDeserializer<'a, W> {
        type Value = ();

        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
        where
            D: Deserializer<'de>,
        {
            struct ComponentMapVisitor<'b, D: WorldDeserializer> {
                world_deserializer: &'b D,
                world: &'b mut World,
                entity: Entity,
            }

            impl<'b, 'de, D: WorldDeserializer> Visitor<'de> for ComponentMapVisitor<'b, D> {
                type Value = ();

                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("struct Entity")
                }

                fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
                where
                    V: MapAccess<'de>,
                {
                    let mut layout = EntityLayout::new();
                    let mut components = HashMap::new();

                    while let Some(mapped_type_id) = map.next_key::<D::TypeId>()? {
                        match self.world_deserializer.unmap_id(&mapped_type_id) {
                            Ok(type_id) => {
                                self.world_deserializer
                                    .register_component(mapped_type_id, &mut layout);
                                components.insert(
                                    type_id,
                                    map.next_value_seed(ComponentDeserializer {
                                        type_id,
                                        world_deserializer: self.world_deserializer,
                                    })?,
                                );
                            }
                            Err(missing) => {
                                match missing {
                                    UnknownType::Ignore => {
                                        map.next_value::<IgnoredAny>()?;
                                    }
                                    UnknownType::Error => {
                                        return Err(serde::de::Error::custom(
                                            "unknown component type",
                                        ));
                                    }
                                }
                            }
                        }
                    }

                    struct SingleEntity {
                        entity: Entity,
                        components: HashMap<ComponentTypeId, Box<[u8]>>,
                        layout: Rc<EntityLayout>,
                    }

                    impl ArchetypeSource for SingleEntity {
                        type Filter = Rc<EntityLayout>;

                        fn filter(&self) -> Self::Filter {
                            self.layout.clone()
                        }

                        fn layout(&mut self) -> EntityLayout {
                            (*self.layout).clone()
                        }
                    }

                    impl ComponentSource for SingleEntity {
                        fn push_components<'a>(
                            &mut self,
                            writer: &mut ArchetypeWriter<'a>,
                            _: impl Iterator<Item = Entity>,
                        ) {
                            writer.push(self.entity);
                            for (type_id, component) in self.components.drain() {
                                let mut storage = writer.claim_components_unknown(type_id);
                                unsafe { storage.extend_memcopy_raw(component.as_ptr(), 1) };
                            }
                        }
                    }

                    impl IntoComponentSource for SingleEntity {
                        type Source = Self;
                        fn into(self) -> Self::Source {
                            self
                        }
                    }

                    self.world.extend(SingleEntity {
                        entity: self.entity,
                        components,
                        layout: Rc::new(layout),
                    });

                    Ok(())
                }
            }

            deserializer.deserialize_map(ComponentMapVisitor {
                world_deserializer: self.world_deserializer,
                world: self.world,
                entity: self.entity,
            })
        }
    }

    struct ComponentDeserializer<'a, W: WorldDeserializer> {
        type_id: ComponentTypeId,
        world_deserializer: &'a W,
    }

    impl<'a, 'de, W: WorldDeserializer> DeserializeSeed<'de> for ComponentDeserializer<'a, W> {
        type Value = Box<[u8]>;

        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
        where
            D: Deserializer<'de>,
        {
            self.world_deserializer
                .deserialize_component(self.type_id, deserializer)
        }
    }
}