use std::collections::HashMap;

use dialga::EntityFabricator;
use palkia::prelude::*;
use serde::Deserialize;

macro_rules! impl_component {
    (@ $ty:ty) => {
        impl Component for $ty {
            fn register_handlers(
                builder: HandlerBuilder<Self>,
            ) -> HandlerBuilder<Self>
            where
                Self: Sized,
            {
                builder
            }
        }
    };
    ($($ty:ty),* $(,)?) => {
        $(
            impl_component!{@ $ty}
        )*
    };
}

#[derive(Debug, PartialEq, Eq, Deserialize)]
struct TrackedPosition;

#[derive(Debug, PartialEq, Eq, Deserialize)]
struct Positioned {
    x: i32,
    y: i32,
}

#[derive(Debug, PartialEq, Eq, Deserialize)]
struct Named(String);

#[derive(Debug, PartialEq, Eq, Deserialize)]
struct PhysicBody {
    mass: u32,
}

#[derive(Debug, PartialEq, Eq, Deserialize)]
struct HasHP {
    start_hp: u32,
    #[serde(default)]
    resistances: HashMap<String, i32>,
}

#[derive(Debug, PartialEq, Eq, Deserialize)]
struct FactionAffiliations {
    member_of: String,
    liked_by: Vec<String>,
    disliked_by: Vec<String>,
}

#[derive(Debug, PartialEq, Eq, Deserialize)]
struct Legendary;

impl_component!(
    TrackedPosition,
    Positioned,
    Named,
    PhysicBody,
    HasHP,
    FactionAffiliations,
    Legendary
);

fn setup_world() -> World {
    let mut world = World::new();
    world.register_component::<TrackedPosition>();
    world.register_component::<Positioned>();
    world.register_component::<Named>();
    world.register_component::<PhysicBody>();
    world.register_component::<HasHP>();
    world.register_component::<FactionAffiliations>();
    world.register_component::<Legendary>();
    world
}

fn setup_fab() -> EntityFabricator<()> {
    let mut fab = EntityFabricator::new();
    fab.register_serde::<TrackedPosition>("tracked-position");
    fab.register_serde::<Named>("name");
    fab.register_serde::<PhysicBody>("physic-body");
    fab.register_serde::<HasHP>("has-hp");
    fab.register_serde::<FactionAffiliations>("factions");
    fab.register_serde::<Legendary>("legendary");
    fab
}

fn setup_both() -> (World, EntityFabricator<()>) {
    (setup_world(), setup_fab())
}

#[test]
fn test() {
    let (mut world, mut fab) = setup_both();

    let bp_src = r#"
    // Two example splicees -- in real life these will be more complicated
    mob {
        tracked-position
    }

    legend {
        legendary
    }

    grass {
        physic-body mass=10
        has-hp start-hp=10
    }

    cat {
        (splice)mob
        physic-body mass=50
        has-hp { 
            start-hp 10
            resistances falling=100 ice=-20
        }
        factions {
            member-of "cats"
            liked-by "humans" "elves"
            disliked-by "dogs" "dwarves"
        }
    }

    housecat {
        (splice)cat
        name "Macy"
    }

    puma {
        (splice)cat
        physic-body mass=150
        (splice)legend
    }
    "#;
    fab.load_str(bp_src, "example.kdl")
        .unwrap_or_else(|e| panic!("{:?}", miette::Report::new(e)));

    let grass = fab.instantiate("grass", world.spawn(), &()).unwrap();
    {
        let (pb, hp) = world.query::<(&PhysicBody, &HasHP)>(grass).unwrap();
        assert_eq!(*pb, PhysicBody { mass: 10 },);
        assert_eq!(
            *hp,
            HasHP {
                start_hp: 10,
                resistances: HashMap::new(),
            },
        );
    }

    let housecat = fab.instantiate("housecat", world.spawn(), &()).unwrap();
    {
        let (name, pb, hp, fa, _tp) = world
            .query::<(
                &Named,
                &PhysicBody,
                &HasHP,
                &FactionAffiliations,
                &TrackedPosition,
            )>(housecat)
            .unwrap();

        assert_eq!(*name, Named("Macy".to_owned()));
        assert_eq!(*pb, PhysicBody { mass: 50 });
        assert_eq!(
            *hp,
            HasHP {
                start_hp: 10,
                resistances: [
                    ("falling".to_string(), 100),
                    ("ice".to_string(), -20)
                ]
                .into_iter()
                .collect(),
            }
        );

        assert_eq!(
            *fa,
            FactionAffiliations {
                member_of: "cats".to_string(),
                liked_by: vec!["humans".to_owned(), "elves".to_owned()],
                disliked_by: vec!["dogs".to_owned(), "dwarves".to_owned()],
            }
        );
    }

    let puma = fab.instantiate("puma", world.spawn(), &()).unwrap();
    {
        let (pb, hp, fa, _tp, _leg) = world
            .query::<(
                &PhysicBody,
                &HasHP,
                &FactionAffiliations,
                &TrackedPosition,
                &Legendary,
            )>(puma)
            .unwrap();

        assert_eq!(*pb, PhysicBody { mass: 150 });
        assert_eq!(
            *hp,
            HasHP {
                start_hp: 10,
                resistances: [
                    ("falling".to_string(), 100),
                    ("ice".to_string(), -20)
                ]
                .into_iter()
                .collect(),
            }
        );
        assert_eq!(
            *fa,
            FactionAffiliations {
                member_of: "cats".to_string(),
                liked_by: vec!["humans".to_owned(), "elves".to_owned()],
                disliked_by: vec!["dogs".to_owned(), "dwarves".to_owned()],
            }
        );
    }
}

#[test]
#[should_panic(
    expected = r#"BlueprintLookupError(BlueprintNotFound("unknown"))"#
)]
fn error_unknown_blueprint() {
    let (mut world, mut fab) = setup_both();

    let bp_src = r#"
    oh-no {
        tracked-position
        erroring-comp
    }
    "#;
    fab.load_str(bp_src, "example.kdl")
        .unwrap_or_else(|e| panic!("{:?}", miette::Report::new(e)));

    fab.instantiate("unknown", world.spawn(), &()).unwrap();
}

#[test]
#[should_panic(expected = r#"NoAssembler("erroring-comp")"#)]
fn error_unknown_component() {
    let (mut world, mut fab) = setup_both();

    let bp_src = r#"
    oh-no {
        tracked-position
        erroring-comp
    }
    "#;
    fab.load_str(bp_src, "example.kdl")
        .unwrap_or_else(|e| panic!("{:?}", miette::Report::new(e)));

    fab.instantiate("oh-no", world.spawn(), &()).unwrap();
}

#[test]
#[should_panic(expected = r#"BlueprintLookupError(InheritanceLoop(["#)]
fn error_loop() {
    let bp_src = r#"
    alpha {
        physic-body mass=10
        (splice)beta
    }
    beta {
        has-hp start-hp=10
        (splice)gamma
    }
    gamma {
        legendary
        (splice)delta
    }
    delta {
        tracks-position
        (splice)alpha
    }
    entrypoint {
        (splice)alpha
    }
    "#;

    let (mut world, mut fab) = setup_both();
    fab.load_str(bp_src, "example.kdl")
        .unwrap_or_else(|e| panic!("{:?}", miette::Report::new(e)));

    fab.instantiate("entrypoint", world.spawn(), &()).unwrap();
}

#[test]
#[should_panic(
    expected = r#"BlueprintLookupError(InheriteeNotFound("foobar", "oh-no"))"#
)]
fn error_splice_fail() {
    let bp_src = r#"
    foobar {
        (splice)oh-no
    }
    "#;

    let (mut world, mut fab) = setup_both();
    fab.load_str(bp_src, "example.kdl")
        .unwrap_or_else(|e| panic!("{:?}", miette::Report::new(e)));

    fab.instantiate("foobar", world.spawn(), &()).unwrap();
}