use bevy::prelude::*;

use crate::player::Player;

#[derive(Component)]
pub struct PlayerCamera;

#[derive(Component)]
pub struct Light;


pub fn setup(mut commands: Commands) {
    let camera_transform = Transform::from_xyz(-10.0, 10.0, 20.0)
        .looking_at(Vec3::ZERO, Vec3::Y);
    commands.spawn()
        .insert_bundle(PerspectiveCameraBundle {
            transform: camera_transform,
            ..Default::default()
        })
        .insert(PlayerCamera);


    // light
    let hilight_transform = Transform::from_xyz(0.0, 200.0, 0.0);
    commands.spawn()
        .insert_bundle(PointLightBundle {
            transform: hilight_transform,
            point_light: PointLight {
                range: 2000.0,
                radius: 2000.0,
                intensity: 4000.0,
                shadows_enabled: true,
                ..Default::default()
            },
            ..Default::default()
        })
        .insert(Light);
}

pub fn track_players(
    time: Res<Time>,
    mut queries: QuerySet<(
        QueryState<&Transform, With<Player>>,
        QueryState<&mut Transform, With<PlayerCamera>>,
        QueryState<&mut Transform, With<Light>>,
    )>,
) {
    let mut min_x = None;
    let mut max_x = None;
    let mut max_y = None;
    let mut min_z = None;
    let mut max_z = None;
    for transform in queries.q0().iter() {
        let t = &transform.translation;

        if min_x.map_or(true, |min_x| t.x < min_x) {
            min_x = Some(t.x);
        }
        if max_x.map_or(true, |max_x| t.x > max_x) {
            max_x = Some(t.x);
        }
        if max_y.map_or(true, |max_y| t.y > max_y) {
            max_y = Some(t.y);
        }
        if min_z.map_or(true, |min_z| t.z < min_z) {
            min_z = Some(t.z);
        }
        if max_z.map_or(true, |max_z| t.z > max_z) {
            max_z = Some(t.z);
        }
    }
    if let Some(target) = max_y.and_then(|max_y| {
        let dist = 10.0f32.max(
            max_x? - min_x?
        ).max(
            (max_z? - min_z?) / 2.0
        );
        Some(Vec3::new(min_x? - dist, max_y + dist, max_z? + 2.0 * dist))
    }) {
        for mut camera_transform in queries.q1().iter_mut() {
            let t = &mut camera_transform.translation;
            *t = *t + time.delta_seconds() * (target - *t) / 2.0;
        }
    }

    if let Some(light_pos) = max_y.and_then(|max_y| {
        Some(Vec3::new(
            (max_x? + min_x?) / 2.0,
            max_y + 8.0,
            (max_z? + min_z?) / 2.0 + 10.0,
        ))
    }) {
        for ref mut light_transform in queries.q2().iter_mut() {
            light_transform.translation = light_pos;
        }
    } else {
        println!("No player to target!");
    }
}