use std::f32::consts::PI;

use bevy::{ input::mouse::MouseMotion, prelude::* };
use bevy_mod_openxr::{helper_traits::ToQuat, resources::OxrViews};
use bevy_mod_xr::session::{XrState, XrTrackingRoot};
use felix_audio::voice::microphone::VoiceChatMicrophone;

use crate::net::connection::Connection;

#[derive(Component)]
pub struct DebugCamera{
  pitch: f32,
  yaw: f32
}

impl Default for DebugCamera{
  fn default() -> Self {
    Self {
      pitch: 0.0,
      yaw: -PI / 2.0
    }
  }
}

pub fn vr_locomotion( // TODO: Move locomotion to controllers instead of keyboard
  views: ResMut<OxrViews>,
  mut position_query: Query<&mut Transform, With<XrTrackingRoot>>,
  keys: Res<ButtonInput<KeyCode>>,
  xr_state: Res<XrState>,
  time: Res<Time>
){
  if *xr_state == XrState::Running{
    let mut delta_time = time.delta_secs();
    if keys.pressed(KeyCode::ShiftLeft){ delta_time *= 2.0; }

    let mut transform = position_query.single_mut().unwrap();
    let view = views.first().unwrap();

    let cam = view.pose.orientation.to_quat();

    if keys.pressed(KeyCode::KeyW){
      let mut dir = cam * -Vec3::Z * delta_time;
      dir.y = 0.0;

      transform.translation += dir;
    } else if keys.pressed(KeyCode::KeyS){
      let mut dir = cam * Vec3::Z * delta_time;
      dir.y = 0.0;

      transform.translation += dir;
    }

    if keys.pressed(KeyCode::KeyA){
      let mut dir = cam * -Vec3::X * delta_time;
      dir.y = 0.0;

      transform.translation += dir;
    } else if keys.pressed(KeyCode::KeyD){
      let mut dir = cam * Vec3::X * delta_time;
      dir.y = 0.0;

      transform.translation += dir;
    }
  }
}

pub fn update(
  mut query: Query<(&mut DebugCamera, &mut Transform)>,
  time: Res<Time>,

  keys: Res<ButtonInput<KeyCode>>,
  mouse_buttons: Res<ButtonInput<MouseButton>>,
  mut mouse_motion: MessageReader<MouseMotion>,

  // Debug Text
  mut debug_text: Query<(&mut Text, &DebugText)>,
  voice: Query<&VoiceChatMicrophone>,
  networking: Query<&Connection>,
  xr_state: Res<XrState>
){
  let net_manager = networking.single().unwrap();
  let xr_state = xr_state.into_inner();

  let ( mut debug, mut transform ) = query.single_mut().unwrap();

  if *xr_state != XrState::Running{
    let mut delta_time = time.delta_secs();
    if keys.pressed(KeyCode::ShiftLeft){ delta_time *= 2.0; }

    for ev in mouse_motion.read(){
      if mouse_buttons.pressed(MouseButton::Right){
        debug.pitch -= ev.delta.y * delta_time * 0.1;
        debug.yaw -= ev.delta.x * delta_time * 0.1;
      }
    }

    transform.rotation = Quat::from_euler(EulerRot::YXZ, debug.yaw, debug.pitch, 0.0);

    if keys.pressed(KeyCode::KeyW){
      let dir = transform.forward();
      transform.translation += dir * delta_time;
    } else if keys.pressed(KeyCode::KeyS){
      let dir = -transform.forward();
      transform.translation += dir * delta_time;
    }

    if keys.pressed(KeyCode::KeyA){
      let dir = transform.left();
      transform.translation += dir * delta_time;
    } else if keys.pressed(KeyCode::KeyD){
      let dir = -transform.left();
      transform.translation += dir * delta_time;
    }

    if keys.pressed(KeyCode::KeyE){
      let dir = transform.up();
      transform.translation += dir * delta_time;
    } else if keys.pressed(KeyCode::KeyQ){
      let dir = -transform.up();
      transform.translation += dir * delta_time;
    }
  }

  let mut remote_rms = "".to_owned();
  for id in net_manager.get_remote_player_voice_ids(){
    remote_rms += format!(
      "{}: {:.4}db\n",
      id,
      net_manager.get_remote_player_voice_rms(&id)
    ).as_str();
  }

  let ( rms, mic_open ) = if let Ok(mic) = voice.single(){
    mic.get_rms_of_last_packet()
  } else{
    ( -1.0, false )
  };

  let ( mut text, _ ) = debug_text.single_mut().unwrap();
  text.0 = format!(
"Microphone RMS: {:.4}db Open: {}
{}Position: X: {:.2} Y: {:.2} Z: {:.2}
Rotation: X: {:.2} Y: {:.2} Z: {:.2} W: {:.2}
XR State: {:#?}",
    rms,
    mic_open,

    remote_rms,

    transform.translation.x,
    transform.translation.y,
    transform.translation.z,

    transform.rotation.x,
    transform.rotation.y,
    transform.rotation.z,
    transform.rotation.w,

    xr_state
  );
}

#[derive(Component)]
pub struct DebugText;

pub fn setup(
  mut commands: Commands
){
  commands.spawn((
    Node {
      position_type: PositionType::Absolute,
      bottom: px(5.0),
      right: px(5.0),
      ..default()
    },
    Text::new("Here is some text"),
    TextColor(Color::WHITE),
    TextLayout::new_with_justify(Justify::Right),
    DebugText
  ));
}