use super::*;

pub(super) fn clear_asset_drag(world: &mut World) {
    if let Some(mut assets) = world.get_resource_mut::<EditorAssets>() {
        assets.clear_drag();
    }
}

pub(super) fn primitive_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
    let material_candidates = brush_face_material_ref_candidates(world);
    let material_drop_candidate = world
        .get_resource::<EditorAssets>()
        .and_then(|assets| assets.dragging_selection().cloned())
        .and_then(|selection| {
            asset_ref_candidate_from_selection(world, &selection, AssetRefCandidateKind::Material)
        });
    let invalid_material_drop =
        material_drop_invalid_reason(world, material_drop_candidate.is_some());
    let Some(mut primitive) = world.get::<Primitive>(entity).cloned() else {
        return;
    };
    let original = primitive.clone();
    let mut changed = false;
    let mut accepted_drop = false;
    let mut options =
        ComponentCardOptions::removable(COMPONENT_PRIMITIVE, "Primitive", icons::CUBE);
    options.summary = "Shape · Size · Materials";
    let card = component_card_context(world, entity, options);
    let card_response = component_card(ui, &card, |ui| {
        property_row(ui, "Shape", |ui| {
            ui.horizontal_wrapped(|ui| {
                for (label, shape) in [
                    ("Box", PrimitiveShape::Box),
                    ("Sphere", PrimitiveShape::Sphere),
                    ("Ramp", PrimitiveShape::Ramp),
                ] {
                    changed |= ui
                        .selectable_value(&mut primitive.shape, shape, label)
                        .changed();
                }
            });
        });
        property_row(ui, "Size X", |ui| {
            changed |= ui
                .add(egui::Slider::new(&mut primitive.size.x, 0.1..=1000.0))
                .changed();
        });
        property_row(ui, "Size Y", |ui| {
            changed |= ui
                .add(egui::Slider::new(&mut primitive.size.y, 0.1..=1000.0))
                .changed();
        });
        property_row(ui, "Size Z", |ui| {
            changed |= ui
                .add(egui::Slider::new(&mut primitive.size.z, 0.1..=1000.0))
                .changed();
        });
        ui.add_space(8.0);
        let materials = crate::ui::materials::MaterialsSectionViewModel {
            slot_ids: vec![primitive.surface.id.0.clone()],
        };
        let widget = crate::ui::materials::materials_section(ui, &materials, |ui| {
            material_slot_widget_ui(
                world,
                ui,
                entity,
                &mut primitive.surface,
                MaterialSlotWidgetContext {
                    candidates: &material_candidates,
                    drop_candidate: material_drop_candidate.as_ref(),
                    invalid_drop_reason: invalid_material_drop,
                    expanded_header_when_parameters_closed: false,
                },
            )
        });
        changed |= widget.changed;
        accepted_drop |= widget.accepted_drop;
    });
    apply_component_card_response(world, entity, card_response);
    if accepted_drop {
        clear_asset_drag(world);
    }
    if changed && primitive != original {
        set_primitive_with_history(world, entity, primitive);
    }
}

pub(super) fn light_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
    let Some(mut light) = world.get::<LightDesc>(entity).cloned() else {
        return;
    };
    let _original = light.clone();
    let mut changed = false;
    let card = component_card_context(
        world,
        entity,
        ComponentCardOptions::removable(COMPONENT_LIGHT_DESC, "Light", icons::LIGHTBULB),
    );
    let card_response = component_card(ui, &card, |ui| {
        property_row(ui, "Kind", |ui| {
            ui.horizontal_wrapped(|ui| {
                for (label, kind) in [
                    ("Point", AuthoringLightKind::Point),
                    ("Spot", AuthoringLightKind::Spot),
                    ("Directional", AuthoringLightKind::Directional),
                ] {
                    if ui.selectable_label(light.kind == kind, label).clicked() {
                        let color = light.color;
                        light = LightDesc {
                            color,
                            ..LightDesc::for_kind(kind)
                        };
                        changed = true;
                    }
                }
            });
        });
        let solari_disabled = solari_disables_local_light(world, &light);
        if solari_disabled {
            ui.colored_label(
                egui::Color32::from_rgb(255, 180, 100),
                "Point and spot lights are disabled while Solari is active. Use a directional light or emissive material, or switch GI to Forward.",
            );
        }
        ui.add_enabled_ui(!solari_disabled, |ui| {
            let mut color = [light.color.r, light.color.g, light.color.b, light.color.a];
            property_row(ui, "Color", |ui| {
                if ui.color_edit_button_rgba_unmultiplied(&mut color).changed() {
                    light.color = ColorDesc {
                        r: color[0],
                        g: color[1],
                        b: color[2],
                        a: color[3],
                    };
                    changed = true;
                }
            });
            let intensity_label = match light.kind {
                AuthoringLightKind::Directional => "Intensity (lux)",
                _ => "Intensity (lumens)",
            };
            let intensity_max = match light.kind {
                AuthoringLightKind::Directional => AUTHORING_DIRECTIONAL_LUX_MAX,
                _ => AUTHORING_POINT_SPOT_LUMENS_MAX,
            };
            property_row(ui, intensity_label, |ui| {
                ui.horizontal_wrapped(|ui| {
                    if ui
                        .add(
                            egui::Slider::new(&mut light.intensity, 0.0..=intensity_max)
                                .show_value(false),
                        )
                        .changed()
                    {
                        changed = true;
                    }
                    if ui
                        .add_sized(
                            [fit_width(ui, 72.0, 120.0), 20.0],
                            egui::DragValue::new(&mut light.intensity)
                                .range(0.0..=intensity_max)
                                .speed(intensity_max * 0.001),
                        )
                        .changed()
                    {
                        changed = true;
                    }
                });
            });
            if matches!(
                light.kind,
                AuthoringLightKind::Point | AuthoringLightKind::Spot
            ) {
                property_row(ui, "Range (m)", |ui| {
                    changed |= ui
                        .add(egui::Slider::new(&mut light.range, 0.0..=100.0))
                        .changed();
                });
            }
            if matches!(light.kind, AuthoringLightKind::Spot) {
                property_row(ui, "Inner angle", |ui| {
                    changed |= ui
                        .add(egui::Slider::new(&mut light.inner_angle_deg, 1.0..=80.0))
                        .changed();
                });
                property_row(ui, "Outer angle", |ui| {
                    changed |= ui
                        .add(egui::Slider::new(&mut light.outer_angle_deg, 1.0..=90.0))
                        .changed();
                });
            }
            property_row(ui, "Shadows", |ui| {
                changed |= ui.checkbox(&mut light.shadows, "Cast shadows").changed();
            });
            if matches!(light.kind, AuthoringLightKind::Directional) {
                ui.small("Controls project sun while this directional exists.");
            }
        });
    });
    apply_component_card_response(world, entity, card_response);
    if changed {
        set_light_with_history(world, entity, light);
    }
}

pub(super) fn solari_disables_local_light(world: &World, light: &LightDesc) -> bool {
    matches!(
        light.kind,
        AuthoringLightKind::Point | AuthoringLightKind::Spot
    ) && world
        .get_resource::<settings::ActiveCameraRenderProfile>()
        .is_some_and(|profile| profile.gi_path == settings::GiPath::SolariDeferred)
        && world
            .get_resource::<settings::RenderingCapabilities>()
            .is_some_and(|caps| caps.rt_supported)
}

pub(super) fn rigid_body_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
    let Some(mut body) = world.get::<RigidBodyDesc>(entity).copied() else {
        return;
    };
    let original = body;
    let mut changed = false;
    let card = component_card_context(
        world,
        entity,
        ComponentCardOptions::removable(COMPONENT_RIGID_BODY_DESC, "Rigid Body", icons::SPHERE),
    );
    let card_response = component_card(ui, &card, |ui| {
        property_row(ui, "Body", |ui| {
            ui.horizontal_wrapped(|ui| {
                for (label, kind) in [
                    ("Static", AuthoringRigidBody::Static),
                    ("Kinematic", AuthoringRigidBody::Kinematic),
                    ("Dynamic", AuthoringRigidBody::Dynamic),
                ] {
                    changed |= ui.selectable_value(&mut body.body, kind, label).changed();
                }
            });
        });
    });
    apply_component_card_response(world, entity, card_response);
    if changed && body != original {
        set_rigid_body_with_history(world, entity, body);
    }
}

pub(super) fn collider_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
    let mesh_candidates = static_mesh_asset_ref_candidates(world, AssetRefCandidateKind::Mesh);
    let diagnostic_entry = diagnose_collider(world, entity);
    let Some(mut collider) = world.get::<ColliderDesc>(entity).cloned() else {
        return;
    };
    let original = collider.clone();
    let mut changed = false;
    let renderer_meshes: Vec<EditorAssetRef> = world
        .get::<StaticMeshRenderer>(entity)
        .map(|renderer| {
            renderer
                .slots
                .iter()
                .map(|slot| slot.mesh.clone())
                .collect()
        })
        .unwrap_or_default();

    let card = component_card_context(
        world,
        entity,
        ComponentCardOptions::removable(COMPONENT_COLLIDER_DESC, "Collider", icons::SELECTION),
    );
    let card_response = component_card(ui, &card, |ui| {
        if let Some(entry) = diagnostic_entry.as_ref() {
            let (label, color) = match entry.overlay_status {
                ColliderOverlayStatus::Valid => ("Ready", egui::Color32::from_rgb(112, 210, 144)),
                ColliderOverlayStatus::Trigger => {
                    ("Trigger", egui::Color32::from_rgb(86, 195, 235))
                }
                ColliderOverlayStatus::Disabled => {
                    ("Disabled", egui::Color32::from_rgb(143, 151, 163))
                }
                ColliderOverlayStatus::Warning => {
                    ("Warning", egui::Color32::from_rgb(242, 173, 72))
                }
                ColliderOverlayStatus::Error => ("Invalid", egui::Color32::from_rgb(244, 91, 99)),
            };
            ui.horizontal_wrapped(|ui| {
                ui.colored_label(color, egui::RichText::new(label).strong());
                ui.label(egui::RichText::new(entry.shape_label).color(TEXT_DIM));
                if entry.runtime_ready {
                    ui.label(egui::RichText::new("Hydrated").color(TEXT_MUTED).small());
                }
            });
            for diagnostic in &entry.diagnostics {
                let color = match diagnostic.severity {
                    ColliderDiagnosticSeverity::Info => TEXT_MUTED,
                    ColliderDiagnosticSeverity::Warning => egui::Color32::from_rgb(242, 173, 72),
                    ColliderDiagnosticSeverity::Error => egui::Color32::from_rgb(244, 91, 99),
                };
                ui.label(
                    egui::RichText::new(&diagnostic.message)
                        .color(color)
                        .small(),
                );
                ui.label(
                    egui::RichText::new(&diagnostic.repair)
                        .color(TEXT_MUTED)
                        .small(),
                );
            }
            if entry.highest_severity() == Some(ColliderDiagnosticSeverity::Error)
                && ui.small_button("Reset shape").clicked()
            {
                collider.shape = ColliderShapeDesc::default();
                collider.enabled = true;
                changed = true;
            }
            ui.add_space(2.0);
        }
        property_row(ui, "Mode", |ui| {
            changed |= ui.checkbox(&mut collider.enabled, "Enabled").changed();
            changed |= ui.checkbox(&mut collider.is_trigger, "Trigger").changed();
        });
        property_row(ui, "Shape", |ui| {
            let mut shape_kind = collider_shape_kind(&collider.shape);
            egui::ComboBox::from_id_salt(("collider_shape_kind", entity))
                .selected_text(shape_kind)
                .show_ui(ui, |ui| {
                    for label in ["Box", "Sphere", "Capsule", "Static Mesh"] {
                        if ui.selectable_label(shape_kind == label, label).clicked() {
                            shape_kind = label;
                        }
                    }
                });
            if shape_kind != collider_shape_kind(&collider.shape) {
                collider.shape =
                    convert_collider_shape(&collider.shape, shape_kind, renderer_meshes.clone());
                changed = true;
            }
        });

        match &mut collider.shape {
            ColliderShapeDesc::Cuboid {
                x_length,
                y_length,
                z_length,
            } => {
                changed |= dimension_drag(ui, "X", x_length);
                changed |= dimension_drag(ui, "Y", y_length);
                changed |= dimension_drag(ui, "Z", z_length);
            }
            ColliderShapeDesc::Sphere { radius } => {
                changed |= dimension_drag(ui, "Radius", radius);
            }
            ColliderShapeDesc::Capsule { radius, height } => {
                changed |= dimension_drag(ui, "Radius", radius);
                changed |= dimension_drag(ui, "Height", height);
            }
            ColliderShapeDesc::StaticMesh { meshes, .. } => {
                if meshes.is_empty() {
                    ui.label(egui::RichText::new("No mesh collider sources").color(TEXT_DIM));
                }
                for mesh in meshes.iter_mut() {
                    let mesh_response = asset_selector_row(
                        ui,
                        "Mesh",
                        icons::CUBE,
                        Some(mesh),
                        None,
                        false,
                        &mesh_candidates,
                        None,
                        None,
                        AssetSelectorActions::Full,
                    );
                    if let Some(selected) = mesh_response.selected {
                        *mesh = selected;
                        changed = true;
                    }
                    if mesh_response.locate {
                        locate_asset_ref(world, Some(mesh), &mesh_candidates);
                    }
                }
                if !renderer_meshes.is_empty() && ui.button("Use renderer meshes").clicked() {
                    *meshes = renderer_meshes.clone();
                    changed = true;
                }
            }
        }
    });
    apply_component_card_response(world, entity, card_response);

    if changed && collider != original {
        set_collider_with_history(world, entity, collider);
    }
}

pub(super) fn collider_shape_kind(shape: &ColliderShapeDesc) -> &'static str {
    match shape {
        ColliderShapeDesc::Cuboid { .. } => "Box",
        ColliderShapeDesc::Sphere { .. } => "Sphere",
        ColliderShapeDesc::Capsule { .. } => "Capsule",
        ColliderShapeDesc::StaticMesh { .. } => "Static Mesh",
    }
}

pub(super) fn convert_collider_shape(
    previous: &ColliderShapeDesc,
    shape_kind: &str,
    renderer_meshes: Vec<EditorAssetRef>,
) -> ColliderShapeDesc {
    let dimensions = match previous {
        ColliderShapeDesc::Cuboid {
            x_length,
            y_length,
            z_length,
        } => Vec3::new(*x_length, *y_length, *z_length),
        ColliderShapeDesc::Sphere { radius } => Vec3::splat(*radius * 2.0),
        ColliderShapeDesc::Capsule { radius, height } => {
            Vec3::new(*radius * 2.0, *height, *radius * 2.0)
        }
        ColliderShapeDesc::StaticMesh { .. } => Vec3::ONE,
    }
    .max(Vec3::splat(0.001));

    match shape_kind {
        "Sphere" => ColliderShapeDesc::Sphere {
            radius: dimensions.max_element() * 0.5,
        },
        "Capsule" => ColliderShapeDesc::Capsule {
            radius: dimensions.x.max(dimensions.z) * 0.5,
            height: dimensions.y,
        },
        "Static Mesh" => ColliderShapeDesc::static_mesh(renderer_meshes),
        _ => ColliderShapeDesc::Cuboid {
            x_length: dimensions.x,
            y_length: dimensions.y,
            z_length: dimensions.z,
        },
    }
}

pub(super) fn dimension_drag(ui: &mut egui::Ui, label: &str, value: &mut f32) -> bool {
    property_row(ui, label, |ui| {
        ui.add_sized(
            [fit_width(ui, 72.0, 120.0), 20.0],
            egui::DragValue::new(value)
                .range(0.001..=10_000.0)
                .speed(0.05)
                .min_decimals(2)
                .max_decimals(3),
        )
        .changed()
    })
}

pub(super) fn physics_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
    let Some(mut body) = world.get::<PhysicsBody>(entity).cloned() else {
        return;
    };
    let _original = body.clone();
    let mut changed = false;
    let card = component_card_context(
        world,
        entity,
        ComponentCardOptions::removable(COMPONENT_PHYSICS_BODY, "Physics", icons::SPHERE),
    );
    let card_response = component_card(ui, &card, |ui| {
        property_row(ui, "Body", |ui| {
            ui.horizontal_wrapped(|ui| {
                for (label, kind) in [
                    ("Static", AuthoringRigidBody::Static),
                    ("Kinematic", AuthoringRigidBody::Kinematic),
                    ("Dynamic", AuthoringRigidBody::Dynamic),
                ] {
                    if ui.selectable_label(body.body == kind, label).clicked() {
                        body.body = kind;
                        changed = true;
                    }
                }
            });
        });
    });
    apply_component_card_response(world, entity, card_response);
    if changed {
        set_physics_with_history(world, entity, body);
    }
}

pub(super) fn player_spawn_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
    if world.get::<PlayerSpawn>(entity).is_none() {
        return;
    }
    let card = component_card_context(
        world,
        entity,
        ComponentCardOptions::removable(
            COMPONENT_PLAYER_SPAWN,
            "Player Spawn",
            icons::PERSON_SIMPLE_RUN,
        ),
    );
    let card_response = component_card(ui, &card, |ui| {
        ui.label(
            egui::RichText::new("Uses this actor transform as a player start.").color(TEXT_DIM),
        );
    });
    apply_component_card_response(world, entity, card_response);
}

pub(super) fn weapon_spawn_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
    let Some(mut spawn) = world.get::<WeaponSpawn>(entity).cloned() else {
        return;
    };
    let card = component_card_context(
        world,
        entity,
        ComponentCardOptions::removable(COMPONENT_WEAPON_SPAWN, "Weapon Spawn", icons::CROSSHAIR),
    );
    let card_response = component_card(ui, &card, |ui| {
        property_row(ui, "Weapon ID", |ui| {
            ui.add_sized(
                [text_field_width(ui), 20.0],
                egui::TextEdit::singleline(&mut spawn.weapon_id),
            );
        });
    });
    apply_component_card_response(world, entity, card_response);
    if let Ok(mut e) = world.get_entity_mut(entity) {
        e.insert(spawn);
    }
}

pub(super) fn trigger_volume_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
    let Some(mut trigger) = world.get::<TriggerVolume>(entity).cloned() else {
        return;
    };
    let card = component_card_context(
        world,
        entity,
        ComponentCardOptions::removable(
            COMPONENT_TRIGGER_VOLUME,
            "Trigger Volume",
            icons::SELECTION,
        ),
    );
    let card_response = component_card(ui, &card, |ui| {
        property_row(ui, "Event", |ui| {
            ui.add_sized(
                [text_field_width(ui), 20.0],
                egui::TextEdit::singleline(&mut trigger.event_name),
            );
        });
        property_row(ui, "Half X", |ui| {
            ui.add(egui::Slider::new(&mut trigger.half_extents.x, 0.1..=50.0));
        });
        property_row(ui, "Half Y", |ui| {
            ui.add(egui::Slider::new(&mut trigger.half_extents.y, 0.1..=50.0));
        });
        property_row(ui, "Half Z", |ui| {
            ui.add(egui::Slider::new(&mut trigger.half_extents.z, 0.1..=50.0));
        });
    });
    apply_component_card_response(world, entity, card_response);
    if let Ok(mut e) = world.get_entity_mut(entity) {
        e.insert(trigger);
    }
}

pub(super) fn team_spawn_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
    let Some(mut spawn) = world.get::<TeamSpawn>(entity).cloned() else {
        return;
    };
    let card = component_card_context(
        world,
        entity,
        ComponentCardOptions::removable(COMPONENT_TEAM_SPAWN, "Team Spawn", icons::FLAG),
    );
    let card_response = component_card(ui, &card, |ui| {
        property_row(ui, "Team", |ui| {
            ui.add(egui::Slider::new(&mut spawn.team_id, 0..=8));
        });
    });
    apply_component_card_response(world, entity, card_response);
    if let Ok(mut e) = world.get_entity_mut(entity) {
        e.insert(spawn);
    }
}

pub(super) fn objective_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
    let Some(mut marker) = world.get::<ObjectiveMarker>(entity).cloned() else {
        return;
    };
    let card = component_card_context(
        world,
        entity,
        ComponentCardOptions::removable(COMPONENT_OBJECTIVE_MARKER, "Objective", icons::TARGET),
    );
    let card_response = component_card(ui, &card, |ui| {
        property_row(ui, "Objective ID", |ui| {
            ui.add_sized(
                [text_field_width(ui), 20.0],
                egui::TextEdit::singleline(&mut marker.objective_id),
            );
        });
    });
    apply_component_card_response(world, entity, card_response);
    if let Ok(mut e) = world.get_entity_mut(entity) {
        e.insert(marker);
    }
}

pub(super) fn prefab_instance_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
    crate::assets::prefab_overrides::prefab_instance_inspector_ui(world, ui, entity);
}