use bevy::{color::palettes::css::RED, prelude::*};

use crate::{
    game_settings::GameSettings, match_loading::MatchConfig, math::{int::FGi32, vec3::FGVec3}, stage::{
        line::{StageCollision, StageLedgeSide, StagePolyLineSegmentType}, manifest::{StageManifest, StageManifestRegistry},
    },
};

pub fn debug_draw_scene(mut gizmos: Gizmos, stage_collision: Res<StageCollision>, game_settings: Res<GameSettings>) {
    for poly in stage_collision.stage_polys.iter() {
        for (segment, next_segment) in poly.segments.iter().zip(poly.segments.iter().cycle().skip(1)) {
            let wavedash_normal = ((next_segment.normal.to_vec2() + segment.normal.to_vec2()) * 0.5).normalize();
            let from = segment.segment.point1().to_vec2();
            let to = segment.segment.point2().to_vec2();
            let from_3d = Vec3::new(from.x, from.y, 0.0);
            let end_3d = Vec3::new(to.x, to.y, 0.0);
            let normal_3d = Vec3::new(segment.normal.x.to_num(), segment.normal.y.to_num(), 0.0);
            gizmos.line(from_3d, end_3d, RED);
            let midpoint = (from_3d + end_3d) * 0.5;
            gizmos.arrow(midpoint, midpoint + normal_3d, RED);
            if matches!(segment.segment_type, StagePolyLineSegmentType::Floor) {
                let radius = game_settings.fighter_common.waveland_snap_distance.to_num::<f32>();
                let a = segment.segment.point1().to_vec2();
                let a = Vec3::new(a.x, a.y, 0.0);
                let b = segment.segment.point2().to_vec2();
                let b = Vec3::new(b.x, b.y, 0.0);
                let offset = Vec3::new(wavedash_normal.x, wavedash_normal.y, 0.0) * radius;
                gizmos.line(a + offset, b + offset, bevy::color::palettes::css::HOT_PINK);
                gizmos.line(a - offset, b - offset, bevy::color::palettes::css::HOT_PINK);
            }
        }
    }

    for ledge in &stage_collision.ledges {
        let position = ledge.position.to_vec2().extend(0.0);
        let direction = match ledge.hang_side {
            StageLedgeSide::Left => Vec3::NEG_X,
            StageLedgeSide::Right => Vec3::X,
        };
        gizmos.circle(position, 1.5, bevy::color::palettes::css::LIME);
        gizmos.arrow(
            position,
            position + direction * 4.0,
            bevy::color::palettes::css::LIME,
        );
    }
}

pub fn debug_draw_blast_zones(
    mut gizmos: Gizmos,
    stage_registry: Res<StageManifestRegistry>,
    stage_manifests: Res<Assets<StageManifest>>,
    match_config: Res<MatchConfig>,
) {
    let Some(stage_manifest_handle) = stage_registry.get(match_config.stage) else {
        return;
    };

    let Some(stage_manifest) = stage_manifests.get(&stage_manifest_handle) else {
        return;
    };

    let top_left = stage_manifest.blast_zone_top_left.to_vec2();
    let bottom_right = stage_manifest.blast_zone_bottom_right.to_vec2();
    let center = (top_left + bottom_right) / 2.0;
    let size = (bottom_right - top_left).abs();

    gizmos.rect(
        Vec3::new(center.x, center.y, 0.0),
        size,
        bevy::color::palettes::css::BLUE,
    );
}

pub fn debug_draw_spawn_positions(
    mut gizmos: Gizmos,
    stage_registry: Res<StageManifestRegistry>,
    stage_manifests: Res<Assets<StageManifest>>,
    match_config: Res<MatchConfig>,
) {
    let Some(stage_manifest_handle) = stage_registry.get(match_config.stage) else {
        return;
    };

    let Some(stage_manifest) = stage_manifests.get(&stage_manifest_handle) else {
        return;
    };

    for spawn_point in stage_manifest.spawn_points.iter() {
        gizmos.cross(FGVec3::new(spawn_point.x, spawn_point.y, FGi32::ZERO).to_vec3(), 2.0, bevy::color::palettes::css::BLUE);
    }

    for respawn_point in stage_manifest.respawn_points.iter() {
        gizmos.cross(FGVec3::new(respawn_point.x, respawn_point.y, FGi32::ZERO).to_vec3(), 2.0, bevy::color::palettes::css::HOT_PINK);
    }
}