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

use crate::component::{
    Component,
    Handle as ComponentHandle,
    HandleMut as ComponentHandleMut,
};
use crate::query::{
    SearchResult,
    Term,
    TermMetadata,
    TermTuple,
    TermsBuilder,
    TermsBuilderInterface,
    Traversal,
    TraversalKind,
};
use crate::uid::With as WithUid;
use crate::World;

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

impl<'query, WithUidT> Term<'query> for With<WithUidT>
where
    WithUidT: WithUid,
{
    type Fields = ();

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

    fn fields(
        _world: &'query World,
        _search_result: &SearchResult<'query, '_>,
        _term_metadata: TermMetadata,
    ) -> Self::Fields
    {
        ()
    }
}

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

impl<'query, WithUidT> Term<'query> for Without<WithUidT>
where
    WithUidT: WithUid,
{
    type Fields = ();

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

    fn fields(
        _world: &'query World,
        _search_result: &SearchResult<'query, '_>,
        _term_metadata: TermMetadata,
    ) -> Self::Fields
    {
        ()
    }
}

impl<'query, ComponentT: Component> Term<'query> for Option<&ComponentT>
{
    type Fields = (Option<ComponentHandle<'query, ComponentT>>,);

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

    fn fields(
        _world: &'query World,
        search_result: &SearchResult<'query, '_>,
        _term_metadata: TermMetadata,
    ) -> Self::Fields
    {
        let component = (|| {
            let comp_ref = &search_result
                .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>()
                    );
                }
            }
        })();

        (component,)
    }
}

impl<'query, ComponentT: Component> Term<'query> for Option<&mut ComponentT>
{
    type Fields = (Option<ComponentHandleMut<'query, ComponentT>>,);

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

    fn fields(
        world: &'query World,
        search_result: &SearchResult<'query, '_>,
        _term_metadata: TermMetadata,
    ) -> Self::Fields
    {
        let component = (|| {
            let comp_ref = &search_result
                .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>()
                    );
                }
            }
        })();

        (component,)
    }
}

pub struct Traverse<TermsT, Kind, Relation>
{
    _pd: PhantomData<(TermsT, Kind, Relation)>,
}

impl<'query, TermsT, Kind, Relation> Term<'query> for Traverse<TermsT, Kind, Relation>
where
    TermsT: TermTuple<'query>,
    Kind: TraversalKindType,
    Relation: Component,
{
    type Fields = TermsT::Fields;

    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
        term_metadata: TermMetadata,
    )
    {
        terms_builder.traverse([Traversal {
            kind: Kind::traversal_kind(),
            relation: Relation::id(),
            terms: |traversal| {
                let mut terms_builder = TermsBuilder::default();

                TermsT::apply_terms_to_builder(
                    &mut terms_builder,
                    traversal
                        .term_metadata
                        .level
                        .checked_add(1)
                        .expect("Too large term level. Would overflow"),
                );

                terms_builder.build()
            },
            term_metadata,
        }]);
    }

    fn fields(
        world: &'query World,
        search_result: &SearchResult<'query, '_>,
        term_metadata: TermMetadata,
    ) -> Self::Fields
    {
        let Some(traversal_result) = search_result
            .traversal_results
            .iter()
            .find(|traversal_result| traversal_result.term_metadata == term_metadata)
        else {
            unreachable!();
        };

        let Some(found_ent) = world.get_entity(traversal_result.found_ent) else {
            unreachable!();
        };

        TermsT::get_fields(
            world,
            &SearchResult {
                entity_handle: found_ent,
                traversal_results: search_result.traversal_results,
            },
            term_metadata
                .level
                .checked_add(1)
                .expect("Too large term level. Would overflow"),
        )
    }
}

pub trait TraversalKindType: sealed::Sealed
{
    fn traversal_kind() -> TraversalKind;
}

pub struct TraverseUp;

impl TraversalKindType for TraverseUp
{
    fn traversal_kind() -> TraversalKind
    {
        TraversalKind::Up
    }
}

impl sealed::Sealed for TraverseUp {}

mod sealed
{
    pub trait Sealed {}
}