use bevy::{input_focus::{AutoFocus, InputFocus}, ui::RelativeCursorPosition};

use crate::{attachment::PartInShip, client::colors, ecs::{CanCraft, CraftingUi, MainCamera, Me, ToggleDrillEvent}, prelude::*};

pub fn crafting_ui_plugin(app: &mut App) {
    app.add_systems(Update, (close_button, drill_button));
}

#[derive(Component)]
struct CloseButton(Entity); // stores corresponding menu entity
#[derive(Component)]
struct PreviousInteraction(Interaction);
#[derive(Component)]
struct DrillButton(Entity); // stores corresponding part

pub fn open_crafting_ui(
    ev: On<Pointer<Press>>,
    crafting_parts: Query<(Entity, &Transform), (With<PartInShip>, With<CanCraft>)>,
    hearty: Query<(Entity, &Transform), (With<Me>, With<CanCraft>)>,
    camera: Single<(Entity, &Camera, &GlobalTransform), (With<MainCamera>, Without<PartInShip>)>,
    commands: Commands,
) {
    if matches!(ev.button, PointerButton::Secondary) {
        let (entity, transform) = if let Ok(part) = crafting_parts.get(ev.entity) {
            part
        } else if let Ok(part) = hearty.get(ev.entity) {
            part
        } else {
            return
        };
        // we have our crafting entity!
        // now make the ui
        setup_ui(entity, transform, commands, camera);
    }
}

fn setup_ui(
    parent_part: Entity,
    parent_transform: &Transform,
    mut commands: Commands,
    camera: Single<(Entity, &Camera, &GlobalTransform), (With<MainCamera>, Without<PartInShip>)>,
) {
    let parent_pos = camera.1.world_to_viewport(camera.2, parent_transform.translation).unwrap();
    let entity = commands.spawn((
        UiTargetCamera(camera.0),
        Node {
            position_type: PositionType::Absolute,
            left: Val::Px(parent_pos.x),
            top: Val::Px(parent_pos.y),
            width: Val::Px(100.0),
            height: Val::Px(100.0),
            ..default()
        },
        AutoFocus,
        CraftingUi,
        BackgroundColor(colors::MANTLE),
        RelativeCursorPosition::default(),
    ))
    .with_children(|parent| {
        parent.spawn((
            Node {
                width: Val::Px(25.0),
                height: Val::Px(25.0),
                justify_content: JustifyContent::Center,
                align_content: AlignContent::Center,
                ..Default::default()
            },
            Button,
            BackgroundColor(colors::RED),
            CloseButton(parent.target_entity()),
            PreviousInteraction(Interaction::None),
        ))
        .with_children(|parent| {
            parent.spawn((
                Node {
                    ..Default::default()
                },
                Text::new("x"),
            ));
        });
        parent.spawn((
            Node {
                ..Default::default()
            },
            Button,
            DrillButton(parent_part),
            BackgroundColor(colors::CRUST),
            PreviousInteraction(Interaction::None),
        ))
        .with_children(|parent| {
            parent.spawn((
                Node {
                    ..Default::default()
                },
                Text::new("Start Drill"),
            ));
        });
    });
}

fn drill_button(
    mut interaction_query: Query<
        (&Interaction, &mut PreviousInteraction, &mut BackgroundColor, &DrillButton, &mut Button),
        Changed<Interaction>,
    >,
    mut toggle_drill_writer: MessageWriter<ToggleDrillEvent>,
) {
    for (interaction, mut previous_interaction, mut color, drill_button, mut button) in &mut interaction_query {
        match *interaction {
            Interaction::Pressed => {
                *color = colors::SURFACE_1.into();
            }
            Interaction::Hovered => {
                *color = colors::SURFACE_0.into();
                if previous_interaction.0 == Interaction::Pressed {
                    // released
                    toggle_drill_writer.write(ToggleDrillEvent { drill_entity: drill_button.0 });
                }
            }
            Interaction::None => {
                *color = colors::CRUST.into();
            }
        }
        previous_interaction.0 = *interaction;
    }
}

fn close_button(
    mut commands: Commands,
    mut interaction_query: Query<
        (&Interaction, &mut PreviousInteraction, &mut BackgroundColor, &CloseButton, &mut Button),
        Changed<Interaction>,
    >,
    mouse: Res<ButtonInput<MouseButton>>,
) {
    for (interaction, mut previous_interaction, mut color,
        close_button, mut button) in &mut interaction_query
    {
        match *interaction {
            Interaction::Pressed => {
                *color = colors::MAROON.into();
            }
            Interaction::Hovered => {
                *color = colors::PINK.into();
                if previous_interaction.0 == Interaction::Pressed {
                    commands.entity(close_button.0).despawn();
                }
            }
            Interaction::None => {
                *color = colors::RED.into();
            }
        }
        previous_interaction.0 = *interaction;
    }
}