use std::any::type_name;
use std::marker::PhantomData;

use crate::World;
use crate::component::{
    Component,
    Handle as ComponentHandle,
    HandleMut as ComponentHandleMut,
};
use crate::entity::Handle as EntityHandle;
use crate::query::{
    Term,
    TermsBuilder,
    TermsBuilderInterface,
};
use crate::tuple::Tuple;
use crate::uid::With as WithUid;

pub struct With<WithUidT>
where
    WithUidT: WithUid,
{
    _pd: PhantomData<WithUidT>,
}

impl<'world, WithUidT> Term<'world> for With<WithUidT>
where
    WithUidT: WithUid,
{
    type AddField<Fields: Tuple> = Fields;

    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
    )
    {
        terms_builder.present([WithUidT::uid()]);
    }

    fn add_field<Fields: Tuple>(
        _entity_handle: &EntityHandle<'world>,
        _world: &'world World,
        fields: Fields,
    ) -> Self::AddField<Fields>
    {
        fields
    }
}

pub struct Without<WithUidT>
where
    WithUidT: WithUid,
{
    _pd: PhantomData<WithUidT>,
}

impl<'world, WithUidT> Term<'world> for Without<WithUidT>
where
    WithUidT: WithUid,
{
    type AddField<Fields: Tuple> = Fields;

    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
    )
    {
        terms_builder.absent([WithUidT::uid()]);
    }

    fn add_field<Fields: Tuple>(
        _entity_handle: &EntityHandle<'world>,
        _world: &'world World,
        fields: Fields,
    ) -> Self::AddField<Fields>
    {
        fields
    }
}

impl<'world, ComponentT: Component> Term<'world> for Option<&ComponentT>
{
    type AddField<Fields: Tuple> =
        Fields::WithElementAtEnd<Option<ComponentHandle<'world, ComponentT>>>;

    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
        _terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
    )
    {
    }

    fn add_field<Fields: Tuple>(
        entity_handle: &EntityHandle<'world>,
        _world: &'world World,
        fields: Fields,
    ) -> Self::AddField<Fields>
    {
        let component = (|| {
            let comp_ref = &entity_handle
                .get_matching_components(ComponentT::id())
                .next()?;

            match ComponentHandle::<ComponentT>::from_entity_component_ref(comp_ref) {
                Ok(component) => Some(component),
                Err(err) => {
                    panic!(
                        "Creating handle to component {} failed: {err}",
                        type_name::<ComponentT>()
                    );
                }
            }
        })();

        fields.with_elem(component)
    }
}

impl<'world, ComponentT: Component> Term<'world> for Option<&mut ComponentT>
{
    type AddField<Fields: Tuple> =
        Fields::WithElementAtEnd<Option<ComponentHandleMut<'world, ComponentT>>>;

    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
        _terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
    )
    {
    }

    fn add_field<Fields: Tuple>(
        entity_handle: &EntityHandle<'world>,
        world: &'world World,
        fields: Fields,
    ) -> Self::AddField<Fields>
    {
        let component = (|| {
            let comp_ref = &entity_handle
                .get_matching_components(ComponentT::id())
                .next()?;

            match ComponentHandleMut::<ComponentT>::from_entity_component_ref(comp_ref, world) {
                Ok(component) => Some(component),
                Err(err) => {
                    panic!(
                        "Creating mut handle to component {} failed: {err}",
                        type_name::<ComponentT>()
                    );
                }
            }
        })();

        fields.with_elem(component)
    }
}