use shared_kernel::normalize_required_string;

use crate::{
    JumpHopDifficulty, JumpHopError, JumpHopJumpResultKind, JumpHopLastJump, JumpHopPath,
    JumpHopPlatform, JumpHopRunSnapshot, JumpHopRunStatus, JumpHopScoring, JumpHopTileType,
};

const JUMP_HOP_PLATFORM_SIZE_MULTIPLIER: f32 = 2.0;
const JUMP_HOP_CHARGE_TO_DISTANCE_RATIO: f32 = 0.008;

pub fn generate_jump_hop_path(seed: &str, difficulty: JumpHopDifficulty) -> JumpHopPath {
    let config = difficulty_config(difficulty);
    let platform_count = 8usize;
    let platforms = build_platforms_until(seed, difficulty, platform_count);

    JumpHopPath {
        seed: seed.trim().to_string(),
        difficulty,
        finish_index: u32::MAX,
        platforms,
        camera_preset: "portrait-isometric-9x16".to_string(),
        scoring: JumpHopScoring {
            charge_to_distance_ratio: config.charge_to_distance_ratio,
            max_charge_ms: config.max_charge_ms,
            hit_bonus: 20,
            perfect_bonus: 60,
        },
    }
}

pub fn start_run(
    run_id: String,
    owner_user_id: String,
    profile_id: String,
    path: JumpHopPath,
    started_at_ms: u64,
) -> Result<JumpHopRunSnapshot, JumpHopError> {
    let run_id = normalize_required_string(run_id).ok_or(JumpHopError::MissingRunId)?;
    let owner_user_id =
        normalize_required_string(owner_user_id).ok_or(JumpHopError::MissingOwnerUserId)?;
    let profile_id = normalize_required_string(profile_id).ok_or(JumpHopError::MissingProfileId)?;
    if path.platforms.is_empty() {
        return Err(JumpHopError::EmptyPath);
    }
    let path = normalize_jump_hop_path_platform_size(path);

    Ok(JumpHopRunSnapshot {
        run_id,
        profile_id,
        owner_user_id,
        status: JumpHopRunStatus::Playing,
        current_platform_index: 0,
        score: 0,
        combo: 0,
        last_jump: None,
        started_at_ms,
        finished_at_ms: None,
        path,
    })
}

pub fn apply_jump(
    run: &JumpHopRunSnapshot,
    drag_distance: f32,
    drag_vector_x: Option<f32>,
    drag_vector_y: Option<f32>,
    jumped_at_ms: u64,
) -> Result<JumpHopRunSnapshot, JumpHopError> {
    if run.status != JumpHopRunStatus::Playing {
        return Err(JumpHopError::RunNotPlaying);
    }
    let current_index = run.current_platform_index as usize;
    let next_index = current_index + 1;
    let path = extend_jump_hop_path(run.path.clone(), next_index + 3);
    let current = run
        .path
        .platforms
        .get(current_index)
        .ok_or(JumpHopError::EmptyPath)?;
    let target = path
        .platforms
        .get(next_index)
        .ok_or(JumpHopError::NoNextPlatform)?;
    let capped_drag_distance = drag_distance.clamp(0.0, run.path.scoring.max_charge_ms as f32);
    let jump_distance = capped_drag_distance * run.path.scoring.charge_to_distance_ratio;
    let vector_x = target.x - current.x;
    let vector_y = target.y - current.y;
    let target_distance = vector_x.hypot(vector_y).max(0.0001);
    let (unit_x, unit_y) = normalize_jump_direction(
        drag_vector_x,
        drag_vector_y,
        vector_x / target_distance,
        vector_y / target_distance,
    );
    let landed_x = current.x + unit_x * jump_distance;
    let landed_y = current.y + unit_y * jump_distance;
    let landing_error = (landed_x - target.x).hypot(landed_y - target.y);
    let target_landing_radius = target.landing_radius;

    let mut next = run.clone();
    next.path = path;
    let result = if landing_error <= target_landing_radius {
        JumpHopJumpResultKind::Hit
    } else {
        JumpHopJumpResultKind::Miss
    };

    next.last_jump = Some(JumpHopLastJump {
        charge_ms: capped_drag_distance.round() as u32,
        jump_distance,
        target_platform_index: next_index as u32,
        landed_x,
        landed_y,
        result,
    });

    if result == JumpHopJumpResultKind::Miss {
        next.status = JumpHopRunStatus::Failed;
        next.combo = 0;
        next.finished_at_ms = Some(jumped_at_ms);
        return Ok(next);
    }

    next.current_platform_index = next_index as u32;
    next.combo = 0;
    next.score = next.current_platform_index;

    Ok(next)
}

pub fn restart_run(
    run: &JumpHopRunSnapshot,
    next_run_id: String,
    restarted_at_ms: u64,
) -> Result<JumpHopRunSnapshot, JumpHopError> {
    start_run(
        next_run_id,
        run.owner_user_id.clone(),
        run.profile_id.clone(),
        run.path.clone(),
        restarted_at_ms,
    )
}

fn normalize_jump_hop_path_platform_size(mut path: JumpHopPath) -> JumpHopPath {
    let should_scale_legacy_path = path
        .platforms
        .iter()
        .any(|platform| platform.width < 1.2 && platform.landing_radius < 0.75);
    if !should_scale_legacy_path {
        if (path.scoring.charge_to_distance_ratio - JUMP_HOP_CHARGE_TO_DISTANCE_RATIO).abs()
            > f32::EPSILON
        {
            path.scoring.charge_to_distance_ratio = JUMP_HOP_CHARGE_TO_DISTANCE_RATIO;
        }
        return path;
    }

    for platform in &mut path.platforms {
        platform.width *= JUMP_HOP_PLATFORM_SIZE_MULTIPLIER;
        platform.height *= JUMP_HOP_PLATFORM_SIZE_MULTIPLIER;
        platform.landing_radius *= JUMP_HOP_PLATFORM_SIZE_MULTIPLIER;
        platform.perfect_radius *= JUMP_HOP_PLATFORM_SIZE_MULTIPLIER;
    }
    path.scoring.charge_to_distance_ratio = JUMP_HOP_CHARGE_TO_DISTANCE_RATIO;
    path
}

struct DifficultyConfig {
    min_gap: f32,
    max_gap: f32,
    min_width: f32,
    max_width: f32,
    landing_radius_factor: f32,
    perfect_radius_factor: f32,
    charge_to_distance_ratio: f32,
    max_charge_ms: u32,
}

fn build_platforms_until(
    seed: &str,
    difficulty: JumpHopDifficulty,
    required_count: usize,
) -> Vec<JumpHopPlatform> {
    let config = difficulty_config(difficulty);
    let mut platforms = Vec::with_capacity(required_count);
    let mut x = 0.0f32;
    let mut y = 0.0f32;

    for index in 0..required_count {
        platforms.push(build_platform(seed, difficulty, index, x, y, &config));
        if index + 1 < required_count {
            let mut rng = DeterministicRng::new(seed, &format!("{}:{index}", difficulty.as_str()));
            let distance = rng.range_f32(config.min_gap, config.max_gap);
            let lane = rng.range_f32(0.42, 0.86);
            let direction = if rng.next_u32() % 2 == 0 { 1.0 } else { -1.0 };
            x += distance * lane * direction;
            y += distance;
        }
    }

    platforms
}

fn build_platform(
    seed: &str,
    difficulty: JumpHopDifficulty,
    index: usize,
    x: f32,
    y: f32,
    config: &DifficultyConfig,
) -> JumpHopPlatform {
    let mut rng = DeterministicRng::new(seed, &format!("platform:{}:{index}", difficulty.as_str()));
    let tile_type = if index == 0 {
        JumpHopTileType::Start
    } else if index % 11 == 0 {
        JumpHopTileType::Bonus
    } else if index % 7 == 0 {
        JumpHopTileType::Accent
    } else if index % 3 == 0 {
        JumpHopTileType::Target
    } else {
        JumpHopTileType::Normal
    };
    let width = rng.range_f32(config.min_width, config.max_width);
    let height = width * rng.range_f32(0.88, 1.06);
    let landing_radius = width * config.landing_radius_factor;

    JumpHopPlatform {
        platform_id: format!("jump-hop-platform-{index:05}"),
        tile_type,
        x,
        y,
        width: width * JUMP_HOP_PLATFORM_SIZE_MULTIPLIER,
        height: height * JUMP_HOP_PLATFORM_SIZE_MULTIPLIER,
        landing_radius: landing_radius * JUMP_HOP_PLATFORM_SIZE_MULTIPLIER,
        perfect_radius: landing_radius
            * config.perfect_radius_factor
            * JUMP_HOP_PLATFORM_SIZE_MULTIPLIER,
        score_value: 1,
    }
}

fn extend_jump_hop_path(mut path: JumpHopPath, required_count: usize) -> JumpHopPath {
    if path.platforms.len() >= required_count {
        return path;
    }
    path.platforms = build_platforms_until(&path.seed, path.difficulty, required_count);
    path.finish_index = u32::MAX;
    path
}

fn normalize_jump_direction(
    drag_vector_x: Option<f32>,
    drag_vector_y: Option<f32>,
    fallback_x: f32,
    fallback_y: f32,
) -> (f32, f32) {
    let Some(drag_x) = drag_vector_x.filter(|value| value.is_finite()) else {
        return (fallback_x, fallback_y);
    };
    let Some(drag_y) = drag_vector_y.filter(|value| value.is_finite()) else {
        return (fallback_x, fallback_y);
    };
    // 前端提交的是屏幕拖拽向量：x 轴同向，y 轴向下为正。
    // 真实起跳需要“反向弹出”，同时把屏幕 y 翻回世界坐标的向上为正。
    let jump_x = -drag_x;
    let jump_y = drag_y;
    let length = jump_x.hypot(jump_y);
    if length < 0.0001 {
        (fallback_x, fallback_y)
    } else {
        (jump_x / length, jump_y / length)
    }
}

fn difficulty_config(difficulty: JumpHopDifficulty) -> DifficultyConfig {
    match difficulty {
        JumpHopDifficulty::Easy => DifficultyConfig {
            min_gap: 1.0,
            max_gap: 1.45,
            min_width: 0.9,
            max_width: 1.08,
            landing_radius_factor: 0.62,
            perfect_radius_factor: 0.32,
            charge_to_distance_ratio: JUMP_HOP_CHARGE_TO_DISTANCE_RATIO,
            max_charge_ms: 700,
        },
        JumpHopDifficulty::Standard => DifficultyConfig {
            min_gap: 1.22,
            max_gap: 1.78,
            min_width: 0.82,
            max_width: 1.0,
            landing_radius_factor: 0.54,
            perfect_radius_factor: 0.26,
            charge_to_distance_ratio: JUMP_HOP_CHARGE_TO_DISTANCE_RATIO,
            max_charge_ms: 780,
        },
        JumpHopDifficulty::Advanced => DifficultyConfig {
            min_gap: 1.45,
            max_gap: 2.05,
            min_width: 0.72,
            max_width: 0.94,
            landing_radius_factor: 0.48,
            perfect_radius_factor: 0.22,
            charge_to_distance_ratio: JUMP_HOP_CHARGE_TO_DISTANCE_RATIO,
            max_charge_ms: 860,
        },
        JumpHopDifficulty::Challenge => DifficultyConfig {
            min_gap: 1.7,
            max_gap: 2.35,
            min_width: 0.66,
            max_width: 0.88,
            landing_radius_factor: 0.42,
            perfect_radius_factor: 0.18,
            charge_to_distance_ratio: JUMP_HOP_CHARGE_TO_DISTANCE_RATIO,
            max_charge_ms: 950,
        },
    }
}

struct DeterministicRng {
    state: u64,
}

impl DeterministicRng {
    fn new(seed: &str, salt: &str) -> Self {
        let mut state = 0xcbf2_9ce4_8422_2325u64;
        for byte in seed.bytes().chain(salt.bytes()) {
            state ^= u64::from(byte);
            state = state.wrapping_mul(0x1000_0000_01b3);
        }
        Self { state }
    }

    fn next_u32(&mut self) -> u32 {
        self.state = self
            .state
            .wrapping_mul(6_364_136_223_846_793_005)
            .wrapping_add(1);
        (self.state >> 32) as u32
    }

    fn range_f32(&mut self, min: f32, max: f32) -> f32 {
        if max <= min {
            return min;
        }
        let unit = self.next_u32() as f32 / u32::MAX as f32;
        min + (max - min) * unit
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        JumpHopDifficulty, JumpHopJumpResultKind, JumpHopRunStatus, apply_jump,
        generate_jump_hop_path, restart_run, start_run,
    };

    #[test]
    fn path_generation_is_seeded_and_uses_difficulty_ranges() {
        let first = generate_jump_hop_path("seed-a", JumpHopDifficulty::Standard);
        let second = generate_jump_hop_path("seed-a", JumpHopDifficulty::Standard);
        let challenge = generate_jump_hop_path("seed-a", JumpHopDifficulty::Challenge);

        assert_eq!(first, second);
        assert_eq!(first.platforms.len(), 8);
        assert_eq!(challenge.platforms.len(), 8);
        assert_eq!(first.platforms.first().unwrap().tile_type.as_str(), "start");
        assert_eq!(first.finish_index, u32::MAX);
    }

    #[test]
    fn difficulty_charge_to_distance_ratio_is_doubled() {
        let easy = generate_jump_hop_path("seed-ratio-easy", JumpHopDifficulty::Easy);
        let standard = generate_jump_hop_path("seed-ratio-standard", JumpHopDifficulty::Standard);
        let advanced = generate_jump_hop_path("seed-ratio-advanced", JumpHopDifficulty::Advanced);
        let challenge = generate_jump_hop_path("seed-ratio-challenge", JumpHopDifficulty::Challenge);

        assert_eq!(easy.scoring.charge_to_distance_ratio, 0.008);
        assert_eq!(standard.scoring.charge_to_distance_ratio, 0.008);
        assert_eq!(advanced.scoring.charge_to_distance_ratio, 0.008);
        assert_eq!(challenge.scoring.charge_to_distance_ratio, 0.008);
    }

    #[test]
    fn generated_platforms_use_double_size_and_landing_radius() {
        let path = generate_jump_hop_path("seed-size", JumpHopDifficulty::Standard);
        let first_platform = path.platforms.first().expect("platform should exist");

        assert!(first_platform.width >= 1.64);
        assert!(first_platform.width <= 2.0);
        assert!(first_platform.height >= 1.44);
        assert!(first_platform.height <= 2.12);
        assert!(first_platform.landing_radius >= 0.88);
        assert!(first_platform.landing_radius <= 1.08);
    }

    #[test]
    fn start_run_normalizes_legacy_single_size_platforms() {
        let mut path = generate_jump_hop_path("seed-legacy", JumpHopDifficulty::Standard);
        for platform in &mut path.platforms {
            platform.width /= 2.0;
            platform.height /= 2.0;
            platform.landing_radius /= 2.0;
            platform.perfect_radius /= 2.0;
        }
        let legacy_width = path.platforms[0].width;
        let legacy_landing_radius = path.platforms[0].landing_radius;

        let run = start_run(
            "run-legacy".to_string(),
            "user-legacy".to_string(),
            "profile-legacy".to_string(),
            path,
            100,
        )
        .expect("run should start");

        assert!((run.path.platforms[0].width - legacy_width * 2.0).abs() < 0.0001);
        assert!(
            (run.path.platforms[0].landing_radius - legacy_landing_radius * 2.0).abs() < 0.0001
        );
    }

    #[test]
    fn jump_resolution_distinguishes_hit_and_miss() {
        let path = generate_jump_hop_path("seed-b", JumpHopDifficulty::Easy);
        let run = start_run(
            "run-1".to_string(),
            "user-1".to_string(),
            "profile-1".to_string(),
            path,
            100,
        )
        .expect("run should start");
        let target = &run.path.platforms[1];
        let distance = target.x.hypot(target.y);
        let target_charge = (distance / run.path.scoring.charge_to_distance_ratio) as u32;

        let hit =
            apply_jump(&run, target_charge as f32, None, None, 200).expect("jump should resolve");
        assert_eq!(
            hit.last_jump.as_ref().unwrap().result,
            JumpHopJumpResultKind::Hit
        );
        assert_eq!(hit.status, JumpHopRunStatus::Playing);
        assert_eq!(hit.current_platform_index, 1);

        let miss = apply_jump(
            &run,
            target_charge.saturating_add(900) as f32,
            None,
            None,
            200,
        )
            .expect("jump should resolve");
        assert_eq!(miss.status, JumpHopRunStatus::Failed);
        assert_eq!(
            miss.last_jump.as_ref().unwrap().result,
            JumpHopJumpResultKind::Miss
        );
    }

    #[test]
    fn jump_resolution_uses_screen_drag_y_axis_for_forward_jump_direction() {
        let path = generate_jump_hop_path("seed-screen-axis", JumpHopDifficulty::Easy);
        let run = start_run(
            "run-screen-axis".to_string(),
            "user-screen-axis".to_string(),
            "profile-screen-axis".to_string(),
            path,
            100,
        )
        .expect("run should start");
        let current = &run.path.platforms[0];
        let target = &run.path.platforms[1];
        let target_distance = (target.x - current.x).hypot(target.y - current.y);
        let charge = (target_distance / run.path.scoring.charge_to_distance_ratio).round() as u32;

        let result = apply_jump(
            &run,
            charge as f32,
            Some(-(target.x - current.x)),
            Some(target.y - current.y),
            200,
        )
        .expect("jump should resolve");

        assert_eq!(result.status, JumpHopRunStatus::Playing);
        assert_eq!(
            result.last_jump.as_ref().unwrap().result,
            JumpHopJumpResultKind::Hit
        );
        assert_eq!(result.current_platform_index, 1);
    }

    #[test]
    fn restart_returns_to_first_platform_and_playing_state() {
        let path = generate_jump_hop_path("seed-c", JumpHopDifficulty::Easy);
        let mut run = start_run(
            "run-1".to_string(),
            "user-1".to_string(),
            "profile-1".to_string(),
            path,
            100,
        )
        .expect("run should start");
        run.status = JumpHopRunStatus::Failed;
        run.current_platform_index = 3;
        run.score = 300;
        run.combo = 2;
        run.finished_at_ms = Some(200);

        let restarted = restart_run(&run, "run-2".to_string(), 300).expect("run should restart");

        assert_eq!(restarted.run_id, "run-2");
        assert_eq!(restarted.status, JumpHopRunStatus::Playing);
        assert_eq!(restarted.current_platform_index, 0);
        assert_eq!(restarted.score, 0);
        assert_eq!(restarted.combo, 0);
        assert!(restarted.last_jump.is_none());
        assert_eq!(restarted.started_at_ms, 300);
        assert!(restarted.finished_at_ms.is_none());
    }

    #[test]
    fn successful_jump_extends_infinite_path_buffer_and_counts_jumps() {
        let path = generate_jump_hop_path("seed-d", JumpHopDifficulty::Easy);
        let mut run = start_run(
            "run-1".to_string(),
            "user-1".to_string(),
            "profile-1".to_string(),
            path,
            100,
        )
        .expect("run should start");

        for step in 0..9 {
            let current = &run.path.platforms[run.current_platform_index as usize];
            let target = &run.path.platforms[run.current_platform_index as usize + 1];
            let distance = (target.x - current.x).hypot(target.y - current.y);
            let charge = (distance / run.path.scoring.charge_to_distance_ratio).round() as u32;
            run = apply_jump(&run, charge as f32, None, None, 200 + step)
                .expect("jump should resolve");
        }

        assert_eq!(run.status, JumpHopRunStatus::Playing);
        assert_eq!(run.current_platform_index, 9);
        assert_eq!(run.score, 9);
        assert!(run.path.platforms.len() >= 12);
        assert!(run.finished_at_ms.is_none());
    }
}