lib.rs

//! WebGPU client for Pong game

// FSM module - platform agnostic, can be tested natively
mod fsm;

// Re-export FSM types (always available)
pub use fsm::{FsmState, GameAction, GameFsm};

// Everything below requires wasm32
#[cfg(target_arch = "wasm32")]
mod camera;
#[cfg(target_arch = "wasm32")]
mod input;
#[cfg(target_arch = "wasm32")]
mod mesh;
#[cfg(target_arch = "wasm32")]
mod network;
#[cfg(target_arch = "wasm32")]
mod prediction;
#[cfg(target_arch = "wasm32")]
mod renderer;
#[cfg(target_arch = "wasm32")]
mod simulation;
#[cfg(target_arch = "wasm32")]
mod state;

#[cfg(target_arch = "wasm32")]
use prediction::ClientPredictor;
#[cfg(target_arch = "wasm32")]
use renderer::Renderer;
#[cfg(target_arch = "wasm32")]
use simulation::LocalGame;
#[cfg(target_arch = "wasm32")]
use state::GameState;
#[cfg(target_arch = "wasm32")]
use wasm_bindgen::prelude::*;
#[cfg(target_arch = "wasm32")]
use web_sys::{window, HtmlCanvasElement, KeyboardEvent};

/// Main client state
#[cfg(target_arch = "wasm32")]
pub struct Client {
    renderer: Renderer,
    // Game state
    game_state: GameState,
    // Input state
    paddle_dir: i8, // -1 = up, 0 = stop, 1 = down
    // Frame timing
    last_frame_time: f64,
    last_sim_time: f64,
    sim_accumulator: f32,
    // Metrics
    fps: f32,
    fps_frame_count: u32,
    fps_last_update: f64,
    ping_ms: f32,
    ping_pending: Option<f64>,
    update_display_ms: f32,
    update_last_display: f64,
    // Local game
    local_game: Option<LocalGame>,
    // Prediction
    predictor: ClientPredictor,
    local_paddle_y: f32,
    local_paddle_initialized: bool,
}

#[cfg(target_arch = "wasm32")]
#[wasm_bindgen]
pub struct WasmClient(Client);

#[cfg(target_arch = "wasm32")]
#[wasm_bindgen]
impl WasmClient {
    #[allow(deprecated)]
    #[wasm_bindgen(constructor)]
    pub async fn new(canvas: HtmlCanvasElement) -> Result<WasmClient, JsValue> {
        console_error_panic_hook::set_once();

        let renderer = Renderer::new(canvas)
            .await
            .map_err(|e| JsValue::from_str(&e))?;

        Ok(WasmClient(Client {
            renderer,
            game_state: GameState::new(),
            paddle_dir: 0,
            last_frame_time: 0.0,
            last_sim_time: 0.0,
            sim_accumulator: 0.0,
            fps: 0.0,
            fps_frame_count: 0,
            fps_last_update: 0.0,
            ping_ms: 0.0,
            ping_pending: None,
            update_display_ms: 0.0,
            update_last_display: 0.0,
            local_game: None,
            predictor: ClientPredictor::new(),
            local_paddle_y: 12.0,
            local_paddle_initialized: false,
        }))
    }

    fn performance_now() -> f64 {
        window()
            .and_then(|w| {
                js_sys::Reflect::get(&w, &JsValue::from_str("performance"))
                    .ok()
                    .and_then(|perf| {
                        js_sys::Reflect::get(&perf, &JsValue::from_str("now"))
                            .ok()
                            .and_then(|now_fn| {
                                let now_func: js_sys::Function = now_fn.dyn_into().ok()?;
                                now_func.call0(&perf).ok()?.as_f64()
                            })
                    })
            })
            .unwrap_or_else(|| js_sys::Date::now())
    }

    fn step_simulation(client: &mut Client) {
        if let Some(local_game) = &mut client.local_game {
            const SIM_FIXED_DT: f32 = 1.0 / 60.0;
            let now_ms = Self::performance_now();

            if client.last_sim_time == 0.0 {
                client.last_sim_time = now_ms;
                return;
            }

            let frame_time_ms = (now_ms - client.last_sim_time) / 1000.0;
            client.sim_accumulator += frame_time_ms as f32;
            client.last_sim_time = now_ms;

            while client.sim_accumulator >= SIM_FIXED_DT {
                client.sim_accumulator -= SIM_FIXED_DT;

                let (winner, ball_data, left_y, right_y, score_left, score_right) =
                    local_game.step(client.local_paddle_y);

                if let Some(w) = winner {
                    client.game_state.set_winner(w);
                }

                if let Some((ball_pos, ball_vel)) = ball_data {
                    client.game_state.set_current(proto::GameStateSnapshot {
                        ball_x: ball_pos.x,
                        ball_y: ball_pos.y,
                        paddle_left_y: left_y,
                        paddle_right_y: right_y,
                        ball_vx: ball_vel.x,
                        ball_vy: ball_vel.y,
                        tick: 0,
                        score_left,
                        score_right,
                    });
                }
                client.game_state.set_scores(score_left, score_right);

                // Check for win condition reset
            }
        }
    }

    #[wasm_bindgen]
    pub fn render(&mut self) -> Result<(), JsValue> {
        let client = &mut self.0;

        Self::step_simulation(client);

        if client.local_game.is_none() && client.predictor.is_active() {
            let now_ms = Self::performance_now();
            let player_id = client.game_state.get_player_id().unwrap_or(0);
            client
                .predictor
                .update(now_ms, player_id, client.paddle_dir);
        }

        let now_ms = Self::performance_now();
        let render_dt = if client.last_frame_time > 0.0 {
            ((now_ms - client.last_frame_time) / 1000.0) as f32
        } else {
            0.008
        };
        client.last_frame_time = now_ms;

        // Update local paddle for immediate response (works for both local and multiplayer)
        const PADDLE_SPEED: f32 = 18.0;
        const ARENA_HEIGHT: f32 = 24.0;
        const PADDLE_HEIGHT: f32 = 4.0;
        let half_height = PADDLE_HEIGHT / 2.0;

        // Simple local integration (client authority)
        client.local_paddle_y += client.paddle_dir as f32 * PADDLE_SPEED * render_dt;
        client.local_paddle_y = client
            .local_paddle_y
            .clamp(half_height, ARENA_HEIGHT - half_height);

        // FPS calculation
        client.fps_frame_count += 1;
        let now_sec = now_ms / 1000.0;
        if now_sec - (client.fps_last_update / 1000.0) >= 1.0 {
            let time_diff_sec = (now_ms - client.fps_last_update) / 1000.0;
            client.fps = client.fps_frame_count as f32 / time_diff_sec as f32;
            client.fps_frame_count = 0;
            client.fps_last_update = now_ms;
        }

        if now_ms - client.update_last_display >= 200.0 {
            client.update_display_ms = client.game_state.time_since_update() * 1000.0;
            client.update_last_display = now_ms;
        }

        client.game_state.update_interpolation(render_dt);

        client
            .renderer
            .draw(
                &client.game_state,
                client.local_paddle_y,
                client.local_game.is_some(),
            )
            .map_err(|e| JsValue::from_str(&e))?;

        Ok(())
    }

    #[wasm_bindgen]
    pub fn on_message(&mut self, bytes: Vec<u8>) -> Result<(), JsValue> {
        let client = &mut self.0;
        let msg = proto::S2C::from_bytes(&bytes)
            .map_err(|e| format!("Failed to deserialize: {:?}", e))?;

        if let proto::S2C::Pong { .. } = msg {
            if let Some(sent_time) = client.ping_pending {
                let rtt = Self::performance_now() - sent_time;
                client.ping_ms = rtt as f32;
                client.ping_pending = None;
            }
            return Ok(());
        }

        // Check for state changes that require local reset
        match msg {
            proto::S2C::MatchFound | proto::S2C::Countdown { .. } => {
                client.local_paddle_y = 12.0;
                client.local_paddle_initialized = false;
                client.predictor = ClientPredictor::new();
                // Reset timing to prevent massive dt on first frame
                client.last_frame_time = 0.0;
                client.last_sim_time = 0.0;
                client.sim_accumulator = 0.0;
            }
            _ => {}
        }

        let is_game_state = matches!(msg, proto::S2C::GameState(_));
        let server_tick = if let proto::S2C::GameState(snapshot) = &msg {
            Some(snapshot.tick)
        } else {
            None
        };

        if let Some(tick) = server_tick {
            client.predictor.reconcile(tick);
        }

        network::handle_message(msg, &mut client.game_state)
            .map_err(|e| JsValue::from_str(&format!("Msg error: {}", e)))?;

        if is_game_state && !client.predictor.is_active() && client.local_game.is_none() {
            if let Some(snapshot) = client.game_state.get_current_snapshot() {
                client
                    .predictor
                    .initialize(&snapshot, Self::performance_now());
                if !client.local_paddle_initialized {
                    let pid = client.game_state.get_player_id().unwrap_or(0);
                    client.local_paddle_y = if pid == 0 {
                        snapshot.paddle_left_y
                    } else {
                        snapshot.paddle_right_y
                    };
                    client.local_paddle_initialized = true;
                }
            }
        }

        Ok(())
    }

    #[wasm_bindgen]
    pub fn get_join_bytes(&self, code: String) -> Vec<u8> {
        network::create_join_message(&code).unwrap_or_default()
    }

    #[wasm_bindgen]
    pub fn get_restart_bytes(&self) -> Vec<u8> {
        network::create_restart_message().unwrap_or_default()
    }

    #[wasm_bindgen]
    pub fn reset_local_state(&mut self) {
        let client = &mut self.0;
        client.game_state.reset();
    }

    #[wasm_bindgen]
    pub fn get_input_bytes(&mut self) -> Vec<u8> {
        let client = &mut self.0;
        if client.local_game.is_some() {
            let pid = client.game_state.get_player_id().unwrap_or(0);
            return network::create_input_message(pid, client.local_paddle_y, 0)
                .unwrap_or_default();
        }

        // For client authority, we just send our current Y position
        // We can still increment seq for ordering if needed
        let pid = client.game_state.get_player_id().unwrap_or(0);
        let seq = client.predictor.input_seq;
        client.predictor.input_seq = seq.wrapping_add(1);

        // We don't need to feed predictor with our input for self-prediction
        // because we are authoritative.
        // But if predictor is used for opponent, we might leave it be.

        network::create_input_message(pid, client.local_paddle_y, seq).unwrap_or_default()
    }

    #[wasm_bindgen]
    pub fn get_score(&self) -> Vec<u8> {
        if let Some(local) = &self.0.local_game {
            vec![local.score.left, local.score.right]
        } else {
            let (l, r) = self.0.game_state.get_scores();
            vec![l, r]
        }
    }

    #[wasm_bindgen]
    pub fn get_winner(&self) -> Option<String> {
        if let Some(w) = self.0.game_state.winner {
            if Some(w) == self.0.game_state.my_player_id {
                Some("you".to_string())
            } else {
                Some("opponent".to_string())
            }
        } else {
            None
        }
    }

    /// Get and clear the latest match event from server
    /// Returns: "match_found", "countdown:3", "countdown:2", "countdown:1", "game_start", "opponent_disconnected", or empty string
    #[wasm_bindgen]
    pub fn get_match_event(&mut self) -> String {
        use state::MatchEvent;
        let event = std::mem::replace(&mut self.0.game_state.match_event, MatchEvent::None);
        match event {
            MatchEvent::None => String::new(),
            MatchEvent::MatchFound => "match_found".to_string(),
            MatchEvent::Countdown(n) => format!("countdown:{}", n),
            MatchEvent::GameStart => "game_start".to_string(),
            MatchEvent::OpponentDisconnected => "opponent_disconnected".to_string(),
        }
    }

    #[wasm_bindgen]
    pub fn start_local_game(&mut self) {
        let seed = Self::performance_now() as u64;
        self.0.local_game = Some(LocalGame::new(seed));
        self.0.game_state.reset();
        self.0.game_state.set_player_id(0);
        // Reset simulation timing
        self.0.last_sim_time = 0.0;
        self.0.sim_accumulator = 0.0;
    }

    #[wasm_bindgen]
    pub fn stop_local_game(&mut self) {
        self.0.local_game = None;
        self.0.game_state.reset();
        self.0.paddle_dir = 0;
        self.0.local_paddle_y = 12.0;
    }

    /// Reset client state for a new multiplayer session
    #[wasm_bindgen]
    pub fn reset_for_multiplayer(&mut self) {
        // Clear any local game
        self.0.local_game = None;
        // Reset game state
        self.0.game_state.reset();
        // Reset predictor
        self.0.predictor = ClientPredictor::new();
        // Reset paddle state
        self.0.local_paddle_y = 12.0;
        self.0.local_paddle_initialized = false;
        // Reset timing
        self.0.last_frame_time = 0.0;
        self.0.last_sim_time = 0.0;
        self.0.sim_accumulator = 0.0;
    }

    #[wasm_bindgen]
    pub fn get_metrics(&self) -> Vec<f32> {
        if self.0.local_game.is_some() {
            vec![self.0.fps, 0.0, 0.0]
        } else {
            vec![self.0.fps, self.0.ping_ms, self.0.update_display_ms]
        }
    }

    #[wasm_bindgen]
    pub fn send_ping(&mut self) -> Vec<u8> {
        let now = Self::performance_now();
        self.0.ping_pending = Some(now);
        network::create_ping_message(now as u32).unwrap_or_default()
    }

    #[wasm_bindgen]
    pub fn on_key_down(&mut self, event: KeyboardEvent) {
        let key = input::get_key_from_event(&event);
        self.0.paddle_dir = input::handle_key_down(&key, self.0.paddle_dir);
    }

    #[wasm_bindgen]
    pub fn on_key_up(&mut self, event: KeyboardEvent) {
        let key = input::get_key_from_event(&event);
        self.0.paddle_dir = input::handle_key_up(&key, self.0.paddle_dir);
    }

    #[wasm_bindgen]
    pub fn handle_key_string(&mut self, key: String, is_down: bool) {
        if is_down {
            self.0.paddle_dir = input::handle_key_down(&key, self.0.paddle_dir);
        } else {
            self.0.paddle_dir = input::handle_key_up(&key, self.0.paddle_dir);
        }
    }
}