/*
 * This file is part of laurelin_client
 * Copyright (C) 2023 Jonni Liljamo <jonni@liljamo.com>
 *
 * Licensed under GPL-3.0-only.
 * See LICENSE for licensing information.
 */

use bevy::prelude::*;
use bevy_rapier3d::prelude::*;

use crate::game_status::Card;

pub struct CardPlugin;

impl Plugin for CardPlugin {
    fn build(&self, app: &mut App) {
        app.init_resource::<VisualCardData>()
            .add_system(on_spawn_card);
    }
}

// NOTE: kind of like using enum variants
pub mod visual_card_kind {
    use bevy::prelude::*;

    #[derive(Component)]
    pub struct Normal;
    #[derive(Component)]
    pub struct Supply(pub usize);
}

#[derive(Component)]
pub struct VisualCard {
    pub card: Card,
}

impl VisualCard {
    pub const ASPECT_RATIO: f32 = 5. / 8.;
}

impl Default for VisualCard {
    fn default() -> Self {
        Self {
            card: Card {
                name: "".to_string(),
                short_details: vec![],
                long_details: vec![],
                cost: 0,
                actions: vec![],
            },
        }
    }
}

#[derive(Bundle)]
pub struct VisualCardBundle {
    pub visual_card: VisualCard,
    pub transform: Transform,
    pub global_transform: GlobalTransform,
    pub visibility: Visibility,
    pub computed_visibility: ComputedVisibility,
    pub collider: Collider,
    pub rigid_body: RigidBody,
}

impl Default for VisualCardBundle {
    fn default() -> Self {
        Self {
            visual_card: VisualCard::default(),
            transform: Transform {
                translation: Vec3 {
                    x: 0.,
                    y: 0.,
                    z: 0.,
                },
                /// defaults to being rotated 90 degress on X, so flat on the
                /// table.
                rotation: Quat::from_euler(EulerRot::XYZ, -1.571, 0., 0.),
                ..Default::default()
            },
            global_transform: GlobalTransform::default(),
            visibility: Visibility::default(),
            computed_visibility: ComputedVisibility::default(),
            collider: Collider::cuboid(VisualCard::ASPECT_RATIO / 2., VisualCard::ASPECT_RATIO, 0.01),
            rigid_body: RigidBody::Dynamic,
        }
    }
}

#[derive(Resource)]
pub struct VisualCardData {
    mesh: Handle<Mesh>,
    card_background: Handle<StandardMaterial>,
}

impl FromWorld for VisualCardData {
    fn from_world(world: &mut World) -> Self {
        let world = world.cell();
        let mut meshes = world.resource_mut::<Assets<Mesh>>();
        let mut materials = world.resource_mut::<Assets<StandardMaterial>>();
        let asset_server = world.resource::<AssetServer>();

        let card_background_material = StandardMaterial {
            unlit: true,
            alpha_mode: AlphaMode::Blend,
            base_color_texture: Some(asset_server.load("card_background.png")),
            ..Default::default()
        };

        Self {
            mesh: meshes.add(
                      shape::Quad {
                          size: Vec2::new(VisualCard::ASPECT_RATIO / 2., VisualCard::ASPECT_RATIO),
                          ..Default::default()
                      }
                      .into(),
                      ),
            card_background: materials.add(card_background_material),
        }
    }
}

fn on_spawn_card(
    mut commands: Commands,
    card_data: Res<VisualCardData>,
    new_cards: Query<(Entity, &VisualCard), Added<VisualCard>>,
) {
    for (entity, card) in &new_cards {
        commands.entity(entity).with_children(|parent| {
            parent.spawn(PbrBundle {
                material: card_data.card_background.clone(),
                mesh: card_data.mesh.clone(),
                transform: Transform {
                    scale: Vec3::new(2., 2., 1.),
                    ..Default::default()
                },
                ..Default::default()
            });
        });
    }
}