use std::{error::Error, fmt};

use serde::{Deserialize, Serialize};
use shared_kernel::normalize_required_string;
#[cfg(feature = "spacetime-types")]
use spacetimedb::SpacetimeType;

pub const BIG_FISH_SESSION_ID_PREFIX: &str = "big-fish-session-";
pub const BIG_FISH_MESSAGE_ID_PREFIX: &str = "big-fish-message-";
pub const BIG_FISH_OPERATION_ID_PREFIX: &str = "big-fish-operation-";
pub const BIG_FISH_ASSET_SLOT_ID_PREFIX: &str = "big-fish-asset-";
pub const BIG_FISH_RUN_ID_PREFIX: &str = "big-fish-run-";
pub const BIG_FISH_DEFAULT_LEVEL_COUNT: u32 = 8;
pub const BIG_FISH_MIN_LEVEL_COUNT: u32 = 6;
pub const BIG_FISH_MAX_LEVEL_COUNT: u32 = 12;
pub const BIG_FISH_MERGE_COUNT_PER_UPGRADE: u32 = 3;
pub const BIG_FISH_OFFSCREEN_CULL_SECONDS: f32 = 3.0;
pub const BIG_FISH_TARGET_WILD_COUNT: usize = 12;
pub const BIG_FISH_VIEW_WIDTH: f32 = 720.0;
pub const BIG_FISH_VIEW_HEIGHT: f32 = 1280.0;
pub const BIG_FISH_WORLD_HALF_WIDTH: f32 = 900.0;
pub const BIG_FISH_WORLD_HALF_HEIGHT: f32 = 1600.0;

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum BigFishCreationStage {
    CollectingAnchors,
    DraftReady,
    AssetRefining,
    ReadyToPublish,
    Published,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum BigFishAnchorStatus {
    Confirmed,
    Inferred,
    Missing,
    Locked,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum BigFishAgentMessageRole {
    User,
    Assistant,
    System,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum BigFishAgentMessageKind {
    Chat,
    Summary,
    ActionResult,
    Warning,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum BigFishAssetKind {
    LevelMainImage,
    LevelMotion,
    StageBackground,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum BigFishAssetStatus {
    Missing,
    Ready,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum BigFishRunStatus {
    Running,
    Won,
    Failed,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishAnchorItem {
    pub key: String,
    pub label: String,
    pub value: String,
    pub status: BigFishAnchorStatus,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishAnchorPack {
    pub gameplay_promise: BigFishAnchorItem,
    pub ecology_visual_theme: BigFishAnchorItem,
    pub growth_ladder: BigFishAnchorItem,
    pub risk_tempo: BigFishAnchorItem,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct BigFishLevelBlueprint {
    pub level: u32,
    pub name: String,
    pub one_line_fantasy: String,
    pub silhouette_direction: String,
    pub size_ratio: f32,
    pub visual_prompt_seed: String,
    pub motion_prompt_seed: String,
    pub merge_source_level: Option<u32>,
    pub prey_window: Vec<u32>,
    pub threat_window: Vec<u32>,
    pub is_final_level: bool,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishBackgroundBlueprint {
    pub theme: String,
    pub color_mood: String,
    pub foreground_hints: String,
    pub midground_composition: String,
    pub background_depth: String,
    pub safe_play_area_hint: String,
    pub spawn_edge_hint: String,
    pub background_prompt_seed: String,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct BigFishRuntimeParams {
    pub level_count: u32,
    pub merge_count_per_upgrade: u32,
    pub spawn_target_count: u32,
    pub leader_move_speed: f32,
    pub follower_catch_up_speed: f32,
    pub offscreen_cull_seconds: f32,
    pub prey_spawn_delta_levels: Vec<u32>,
    pub threat_spawn_delta_levels: Vec<u32>,
    pub win_level: u32,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct BigFishGameDraft {
    pub title: String,
    pub subtitle: String,
    pub core_fun: String,
    pub ecology_theme: String,
    pub levels: Vec<BigFishLevelBlueprint>,
    pub background: BigFishBackgroundBlueprint,
    pub runtime_params: BigFishRuntimeParams,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishAgentMessageSnapshot {
    pub message_id: String,
    pub session_id: String,
    pub role: BigFishAgentMessageRole,
    pub kind: BigFishAgentMessageKind,
    pub text: String,
    pub created_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishAssetSlotSnapshot {
    pub slot_id: String,
    pub session_id: String,
    pub asset_kind: BigFishAssetKind,
    pub level: Option<u32>,
    pub motion_key: Option<String>,
    pub status: BigFishAssetStatus,
    pub asset_url: Option<String>,
    pub prompt_snapshot: String,
    pub updated_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishAssetCoverage {
    pub level_main_image_ready_count: u32,
    pub level_motion_ready_count: u32,
    pub background_ready: bool,
    pub required_level_count: u32,
    pub publish_ready: bool,
    pub blockers: Vec<String>,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct BigFishSessionSnapshot {
    pub session_id: String,
    pub owner_user_id: String,
    pub seed_text: String,
    pub current_turn: u32,
    pub progress_percent: u32,
    pub stage: BigFishCreationStage,
    pub anchor_pack: BigFishAnchorPack,
    pub draft: Option<BigFishGameDraft>,
    pub asset_slots: Vec<BigFishAssetSlotSnapshot>,
    pub asset_coverage: BigFishAssetCoverage,
    pub messages: Vec<BigFishAgentMessageSnapshot>,
    pub last_assistant_reply: Option<String>,
    pub publish_ready: bool,
    pub created_at_micros: i64,
    pub updated_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct BigFishVector2 {
    pub x: f32,
    pub y: f32,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct BigFishRuntimeEntity {
    pub entity_id: String,
    pub level: u32,
    pub position: BigFishVector2,
    pub radius: f32,
    pub offscreen_seconds: f32,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct BigFishRuntimeSnapshot {
    pub run_id: String,
    pub session_id: String,
    pub status: BigFishRunStatus,
    pub tick: u64,
    pub player_level: u32,
    pub win_level: u32,
    pub leader_entity_id: Option<String>,
    pub owned_entities: Vec<BigFishRuntimeEntity>,
    pub wild_entities: Vec<BigFishRuntimeEntity>,
    pub camera_center: BigFishVector2,
    pub last_input: BigFishVector2,
    pub event_log: Vec<String>,
    pub updated_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct BigFishSessionProcedureResult {
    pub ok: bool,
    pub session: Option<BigFishSessionSnapshot>,
    pub error_message: Option<String>,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishWorkSummarySnapshot {
    pub work_id: String,
    pub source_session_id: String,
    pub owner_user_id: String,
    pub title: String,
    pub subtitle: String,
    pub summary: String,
    pub cover_image_src: Option<String>,
    pub status: String,
    pub updated_at_micros: i64,
    pub publish_ready: bool,
    pub level_count: u32,
    pub level_main_image_ready_count: u32,
    pub level_motion_ready_count: u32,
    pub background_ready: bool,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishWorksListInput {
    pub owner_user_id: String,
    pub published_only: bool,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishWorkDeleteInput {
    pub session_id: String,
    pub owner_user_id: String,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishWorksProcedureResult {
    pub ok: bool,
    pub items_json: Option<String>,
    pub error_message: Option<String>,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct BigFishRunProcedureResult {
    pub ok: bool,
    pub run: Option<BigFishRuntimeSnapshot>,
    pub error_message: Option<String>,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishSessionCreateInput {
    pub session_id: String,
    pub owner_user_id: String,
    pub seed_text: String,
    pub welcome_message_id: String,
    pub welcome_message_text: String,
    pub created_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishSessionGetInput {
    pub session_id: String,
    pub owner_user_id: String,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishMessageSubmitInput {
    pub session_id: String,
    pub owner_user_id: String,
    pub user_message_id: String,
    pub user_message_text: String,
    pub assistant_message_id: String,
    pub submitted_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishMessageFinalizeInput {
    pub session_id: String,
    pub owner_user_id: String,
    pub assistant_message_id: Option<String>,
    pub assistant_reply_text: Option<String>,
    pub stage: BigFishCreationStage,
    pub progress_percent: u32,
    pub anchor_pack_json: String,
    pub error_message: Option<String>,
    pub updated_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishDraftCompileInput {
    pub session_id: String,
    pub owner_user_id: String,
    pub compiled_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishAssetGenerateInput {
    pub session_id: String,
    pub owner_user_id: String,
    pub asset_kind: BigFishAssetKind,
    pub level: Option<u32>,
    pub motion_key: Option<String>,
    pub asset_url: Option<String>,
    pub generated_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishPublishInput {
    pub session_id: String,
    pub owner_user_id: String,
    pub published_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishRunStartInput {
    pub run_id: String,
    pub session_id: String,
    pub owner_user_id: String,
    pub started_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct BigFishRunInputSubmitInput {
    pub run_id: String,
    pub owner_user_id: String,
    pub input_x: f32,
    pub input_y: f32,
    pub submitted_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BigFishRunGetInput {
    pub run_id: String,
    pub owner_user_id: String,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum BigFishFieldError {
    MissingSessionId,
    MissingOwnerUserId,
    MissingMessageId,
    MissingMessageText,
    MissingRunId,
    MissingDraft,
    InvalidLevel,
    InvalidAssetKind,
    InvalidRunState,
}

impl BigFishCreationStage {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::CollectingAnchors => "collecting_anchors",
            Self::DraftReady => "draft_ready",
            Self::AssetRefining => "asset_refining",
            Self::ReadyToPublish => "ready_to_publish",
            Self::Published => "published",
        }
    }
}

impl BigFishAnchorStatus {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Confirmed => "confirmed",
            Self::Inferred => "inferred",
            Self::Missing => "missing",
            Self::Locked => "locked",
        }
    }
}

impl BigFishAgentMessageRole {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::User => "user",
            Self::Assistant => "assistant",
            Self::System => "system",
        }
    }
}

impl BigFishAgentMessageKind {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Chat => "chat",
            Self::Summary => "summary",
            Self::ActionResult => "action_result",
            Self::Warning => "warning",
        }
    }
}

impl BigFishAssetKind {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::LevelMainImage => "level_main_image",
            Self::LevelMotion => "level_motion",
            Self::StageBackground => "stage_background",
        }
    }
}

impl BigFishAssetStatus {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Missing => "missing",
            Self::Ready => "ready",
        }
    }
}

impl BigFishRunStatus {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Running => "running",
            Self::Won => "won",
            Self::Failed => "failed",
        }
    }
}

pub fn empty_anchor_pack() -> BigFishAnchorPack {
    BigFishAnchorPack {
        gameplay_promise: BigFishAnchorItem {
            key: "gameplayPromise".to_string(),
            label: "玩法承诺".to_string(),
            value: String::new(),
            status: BigFishAnchorStatus::Missing,
        },
        ecology_visual_theme: BigFishAnchorItem {
            key: "ecologyVisualTheme".to_string(),
            label: "生态与视觉母题".to_string(),
            value: String::new(),
            status: BigFishAnchorStatus::Missing,
        },
        growth_ladder: BigFishAnchorItem {
            key: "growthLadder".to_string(),
            label: "成长阶梯".to_string(),
            value: String::new(),
            status: BigFishAnchorStatus::Missing,
        },
        risk_tempo: BigFishAnchorItem {
            key: "riskTempo".to_string(),
            label: "风险节奏".to_string(),
            value: "平衡".to_string(),
            status: BigFishAnchorStatus::Inferred,
        },
    }
}

pub fn infer_anchor_pack(seed_text: &str, latest_message: Option<&str>) -> BigFishAnchorPack {
    let source = normalize_required_string(latest_message.unwrap_or(seed_text))
        .or_else(|| normalize_required_string(seed_text))
        .unwrap_or_else(|| "深海弱小逆袭，逐级吞噬成长".to_string());
    let mut pack = empty_anchor_pack();
    pack.gameplay_promise.value = if source.contains("可爱") {
        "可爱生态成长".to_string()
    } else if source.contains("机械") {
        "机械微生物吞并进化".to_string()
    } else {
        "弱小逆袭和群体吞并".to_string()
    };
    pack.gameplay_promise.status = BigFishAnchorStatus::Inferred;
    pack.ecology_visual_theme.value = if source.contains("机械") {
        "机械微生物水域".to_string()
    } else if source.contains("梦") {
        "梦境纸鱼生态".to_string()
    } else {
        "深海生物生态".to_string()
    };
    pack.ecology_visual_theme.status = BigFishAnchorStatus::Inferred;
    pack.growth_ladder.value = "8 级连续进化，从幼小个体成长为终局巨兽".to_string();
    pack.growth_ladder.status = BigFishAnchorStatus::Inferred;
    pack.risk_tempo.value = if source.contains("爽") {
        "偏爽快".to_string()
    } else if source.contains("压迫") {
        "偏压迫".to_string()
    } else {
        "平衡".to_string()
    };
    pack
}

pub fn compile_default_draft(anchor_pack: &BigFishAnchorPack) -> BigFishGameDraft {
    let level_count = BIG_FISH_DEFAULT_LEVEL_COUNT;
    let theme = fallback_anchor_value(&anchor_pack.ecology_visual_theme, "深海生物生态");
    let core_fun = fallback_anchor_value(&anchor_pack.gameplay_promise, "弱小逆袭和群体吞并");
    let risk_tempo = fallback_anchor_value(&anchor_pack.risk_tempo, "平衡");

    let levels = (1..=level_count)
        .map(|level| build_level_blueprint(level, level_count, &theme))
        .collect();

    BigFishGameDraft {
        title: format!("{theme} 大鱼吃小鱼"),
        subtitle: format!("{core_fun} · {risk_tempo}节奏"),
        core_fun,
        ecology_theme: theme.clone(),
        levels,
        background: BigFishBackgroundBlueprint {
            theme: theme.clone(),
            color_mood: "深蓝、青绿、带少量暖色生物光".to_string(),
            foreground_hints: "轻微漂浮颗粒和边缘水草，不遮挡中央操作区".to_string(),
            midground_composition: "中央留出清晰活动区域，边缘有出生缓冲层".to_string(),
            background_depth: "纵深水域与远处体型剪影".to_string(),
            safe_play_area_hint: "9:16 竖屏中央 70% 为主要活动区".to_string(),
            spawn_edge_hint: "四周边缘作为野生实体出生区".to_string(),
            background_prompt_seed: format!("{theme}，竖屏 9:16，全屏游戏背景，无文字，无 UI 框"),
        },
        runtime_params: BigFishRuntimeParams {
            level_count,
            merge_count_per_upgrade: BIG_FISH_MERGE_COUNT_PER_UPGRADE,
            spawn_target_count: BIG_FISH_TARGET_WILD_COUNT as u32,
            leader_move_speed: 160.0,
            follower_catch_up_speed: 120.0,
            offscreen_cull_seconds: BIG_FISH_OFFSCREEN_CULL_SECONDS,
            prey_spawn_delta_levels: vec![1, 2],
            threat_spawn_delta_levels: vec![1, 2],
            win_level: level_count,
        },
    }
}

pub fn build_asset_coverage(
    draft: Option<&BigFishGameDraft>,
    asset_slots: &[BigFishAssetSlotSnapshot],
) -> BigFishAssetCoverage {
    let required_level_count = draft
        .map(|value| value.runtime_params.level_count)
        .unwrap_or(BIG_FISH_DEFAULT_LEVEL_COUNT);
    let main_ready = asset_slots
        .iter()
        .filter(|slot| {
            slot.asset_kind == BigFishAssetKind::LevelMainImage
                && slot.status == BigFishAssetStatus::Ready
        })
        .count() as u32;
    let motion_ready = asset_slots
        .iter()
        .filter(|slot| {
            slot.asset_kind == BigFishAssetKind::LevelMotion
                && slot.status == BigFishAssetStatus::Ready
        })
        .count() as u32;
    let background_ready = asset_slots.iter().any(|slot| {
        slot.asset_kind == BigFishAssetKind::StageBackground
            && slot.status == BigFishAssetStatus::Ready
    });

    let required_motion_count = required_level_count * 2;
    let mut blockers = Vec::new();
    if draft.is_none() {
        blockers.push("玩法草稿尚未编译".to_string());
    }
    if main_ready < required_level_count {
        blockers.push(format!(
            "还缺少 {} 个等级主图",
            required_level_count.saturating_sub(main_ready)
        ));
    }
    if motion_ready < required_motion_count {
        blockers.push(format!(
            "还缺少 {} 个基础动作",
            required_motion_count.saturating_sub(motion_ready)
        ));
    }
    if !background_ready {
        blockers.push("还缺少活动区域背景图".to_string());
    }

    BigFishAssetCoverage {
        level_main_image_ready_count: main_ready,
        level_motion_ready_count: motion_ready,
        background_ready,
        required_level_count,
        publish_ready: blockers.is_empty(),
        blockers,
    }
}

pub fn build_generated_asset_slot(
    session_id: &str,
    draft: &BigFishGameDraft,
    asset_kind: BigFishAssetKind,
    level: Option<u32>,
    motion_key: Option<String>,
    asset_url: Option<String>,
    updated_at_micros: i64,
) -> Result<BigFishAssetSlotSnapshot, BigFishFieldError> {
    let session_id =
        normalize_required_string(session_id).ok_or(BigFishFieldError::MissingSessionId)?;
    let prompt_snapshot =
        build_asset_prompt_snapshot(draft, asset_kind, level, motion_key.as_deref())?;
    let slot_id = build_asset_slot_id(&session_id, asset_kind, level, motion_key.as_deref());
    let resolved_asset_url = normalize_required_string(asset_url.as_deref().unwrap_or_default())
        .unwrap_or_else(|| build_placeholder_asset_url(asset_kind, level, updated_at_micros));

    Ok(BigFishAssetSlotSnapshot {
        slot_id,
        session_id,
        asset_kind,
        level,
        motion_key,
        status: BigFishAssetStatus::Ready,
        asset_url: Some(resolved_asset_url),
        prompt_snapshot,
        updated_at_micros,
    })
}

pub fn build_initial_runtime_snapshot(
    run_id: String,
    session_id: String,
    draft: &BigFishGameDraft,
    now_micros: i64,
) -> BigFishRuntimeSnapshot {
    let mut snapshot = BigFishRuntimeSnapshot {
        run_id,
        session_id,
        status: BigFishRunStatus::Running,
        tick: 0,
        player_level: 1,
        win_level: draft.runtime_params.win_level,
        leader_entity_id: Some("owned-1".to_string()),
        owned_entities: vec![BigFishRuntimeEntity {
            entity_id: "owned-1".to_string(),
            level: 1,
            position: BigFishVector2 { x: 0.0, y: 0.0 },
            radius: entity_radius(1),
            offscreen_seconds: 0.0,
        }],
        wild_entities: vec![
            BigFishRuntimeEntity {
                entity_id: "wild-open-1".to_string(),
                level: 1,
                position: BigFishVector2 { x: 72.0, y: 0.0 },
                radius: entity_radius(1),
                offscreen_seconds: 0.0,
            },
            BigFishRuntimeEntity {
                entity_id: "wild-open-2".to_string(),
                level: 1,
                position: BigFishVector2 { x: -88.0, y: 30.0 },
                radius: entity_radius(1),
                offscreen_seconds: 0.0,
            },
        ],
        camera_center: BigFishVector2 { x: 0.0, y: 0.0 },
        last_input: BigFishVector2 { x: 0.0, y: 0.0 },
        event_log: vec!["开局生成 2 个同级可收编目标".to_string()],
        updated_at_micros: now_micros,
    };
    maintain_wild_pool(&mut snapshot, &draft.runtime_params);
    snapshot
}

pub fn advance_runtime_snapshot(
    mut snapshot: BigFishRuntimeSnapshot,
    params: &BigFishRuntimeParams,
    input_x: f32,
    input_y: f32,
    now_micros: i64,
) -> BigFishRuntimeSnapshot {
    if snapshot.status != BigFishRunStatus::Running {
        return snapshot;
    }

    let step_seconds = resolve_step_seconds(&snapshot, now_micros);
    snapshot.tick = snapshot.tick.saturating_add(1);
    snapshot.last_input = normalize_input(input_x, input_y);
    move_owned_entities(&mut snapshot, params, step_seconds);
    resolve_collisions(&mut snapshot, params);
    apply_chain_merges(&mut snapshot, params);
    refresh_player_leader(&mut snapshot);
    apply_win_or_fail(&mut snapshot, params);
    update_wild_culling(&mut snapshot, params, step_seconds);
    maintain_wild_pool(&mut snapshot, params);
    snapshot.updated_at_micros = now_micros;
    snapshot
}

pub fn validate_session_get_input(input: &BigFishSessionGetInput) -> Result<(), BigFishFieldError> {
    validate_session_owner(&input.session_id, &input.owner_user_id)
}

pub fn validate_works_list_input(input: &BigFishWorksListInput) -> Result<(), BigFishFieldError> {
    if input.published_only {
        return Ok(());
    }
    if normalize_required_string(&input.owner_user_id).is_none() {
        return Err(BigFishFieldError::MissingOwnerUserId);
    }
    Ok(())
}

pub fn validate_session_create_input(
    input: &BigFishSessionCreateInput,
) -> Result<(), BigFishFieldError> {
    validate_session_owner(&input.session_id, &input.owner_user_id)?;
    if normalize_required_string(&input.welcome_message_id).is_none() {
        return Err(BigFishFieldError::MissingMessageId);
    }
    Ok(())
}

pub fn validate_message_submit_input(
    input: &BigFishMessageSubmitInput,
) -> Result<(), BigFishFieldError> {
    validate_session_owner(&input.session_id, &input.owner_user_id)?;
    if normalize_required_string(&input.user_message_id).is_none()
        || normalize_required_string(&input.assistant_message_id).is_none()
    {
        return Err(BigFishFieldError::MissingMessageId);
    }
    if normalize_required_string(&input.user_message_text).is_none() {
        return Err(BigFishFieldError::MissingMessageText);
    }
    Ok(())
}

pub fn validate_message_finalize_input(
    input: &BigFishMessageFinalizeInput,
) -> Result<(), BigFishFieldError> {
    validate_session_owner(&input.session_id, &input.owner_user_id)
}

pub fn validate_draft_compile_input(
    input: &BigFishDraftCompileInput,
) -> Result<(), BigFishFieldError> {
    validate_session_owner(&input.session_id, &input.owner_user_id)
}

pub fn validate_asset_generate_input(
    input: &BigFishAssetGenerateInput,
    draft: &BigFishGameDraft,
) -> Result<(), BigFishFieldError> {
    validate_session_owner(&input.session_id, &input.owner_user_id)?;
    match input.asset_kind {
        BigFishAssetKind::LevelMainImage => validate_level(input.level, draft),
        BigFishAssetKind::LevelMotion => {
            validate_level(input.level, draft)?;
            match input.motion_key.as_deref() {
                Some("idle_float" | "move_swim") => Ok(()),
                _ => Err(BigFishFieldError::InvalidAssetKind),
            }
        }
        BigFishAssetKind::StageBackground => Ok(()),
    }
}

pub fn validate_publish_input(input: &BigFishPublishInput) -> Result<(), BigFishFieldError> {
    validate_session_owner(&input.session_id, &input.owner_user_id)
}

pub fn validate_run_start_input(input: &BigFishRunStartInput) -> Result<(), BigFishFieldError> {
    validate_session_owner(&input.session_id, &input.owner_user_id)?;
    if normalize_required_string(&input.run_id).is_none() {
        return Err(BigFishFieldError::MissingRunId);
    }
    Ok(())
}

pub fn validate_run_get_input(input: &BigFishRunGetInput) -> Result<(), BigFishFieldError> {
    if normalize_required_string(&input.run_id).is_none() {
        return Err(BigFishFieldError::MissingRunId);
    }
    if normalize_required_string(&input.owner_user_id).is_none() {
        return Err(BigFishFieldError::MissingOwnerUserId);
    }
    Ok(())
}

pub fn validate_run_input_submit_input(
    input: &BigFishRunInputSubmitInput,
) -> Result<(), BigFishFieldError> {
    if normalize_required_string(&input.run_id).is_none() {
        return Err(BigFishFieldError::MissingRunId);
    }
    if normalize_required_string(&input.owner_user_id).is_none() {
        return Err(BigFishFieldError::MissingOwnerUserId);
    }
    Ok(())
}

pub fn serialize_anchor_pack(anchor_pack: &BigFishAnchorPack) -> Result<String, serde_json::Error> {
    serde_json::to_string(anchor_pack)
}

pub fn deserialize_anchor_pack(value: &str) -> Result<BigFishAnchorPack, serde_json::Error> {
    serde_json::from_str(value)
}

pub fn serialize_draft(draft: &BigFishGameDraft) -> Result<String, serde_json::Error> {
    serde_json::to_string(draft)
}

pub fn deserialize_draft(value: &str) -> Result<BigFishGameDraft, serde_json::Error> {
    serde_json::from_str(value)
}

pub fn serialize_asset_coverage(
    coverage: &BigFishAssetCoverage,
) -> Result<String, serde_json::Error> {
    serde_json::to_string(coverage)
}

pub fn deserialize_asset_coverage(value: &str) -> Result<BigFishAssetCoverage, serde_json::Error> {
    serde_json::from_str(value)
}

pub fn serialize_runtime_snapshot(
    snapshot: &BigFishRuntimeSnapshot,
) -> Result<String, serde_json::Error> {
    serde_json::to_string(snapshot)
}

pub fn deserialize_runtime_snapshot(
    value: &str,
) -> Result<BigFishRuntimeSnapshot, serde_json::Error> {
    serde_json::from_str(value)
}

fn fallback_anchor_value(anchor: &BigFishAnchorItem, fallback: &str) -> String {
    normalize_required_string(&anchor.value).unwrap_or_else(|| fallback.to_string())
}

fn build_level_blueprint(level: u32, level_count: u32, theme: &str) -> BigFishLevelBlueprint {
    let prey_window = (1..level)
        .rev()
        .take(2)
        .collect::<Vec<_>>()
        .into_iter()
        .rev()
        .collect();
    let threat_window = ((level + 1)..=(level + 2).min(level_count)).collect::<Vec<_>>();
    BigFishLevelBlueprint {
        level,
        name: format!("{theme} L{level}"),
        one_line_fantasy: if level == level_count {
            "终局巨兽形态，获得即可通关".to_string()
        } else {
            format!("第 {level} 阶实体，继续吞噬同级和低级个体成长")
        },
        silhouette_direction: format!(
            "体型约为初始的 {:.1} 倍，轮廓更清晰",
            1.0 + level as f32 * 0.22
        ),
        size_ratio: 1.0 + (level.saturating_sub(1) as f32 * 0.22),
        visual_prompt_seed: format!("{theme} 第 {level} 级实体主图，透明背景，清晰轮廓"),
        motion_prompt_seed: format!("{theme} 第 {level} 级实体 idle_float 与 move_swim 动作"),
        merge_source_level: if level == 1 { None } else { Some(level - 1) },
        prey_window,
        threat_window,
        is_final_level: level == level_count,
    }
}

fn build_asset_prompt_snapshot(
    draft: &BigFishGameDraft,
    asset_kind: BigFishAssetKind,
    level: Option<u32>,
    motion_key: Option<&str>,
) -> Result<String, BigFishFieldError> {
    match asset_kind {
        BigFishAssetKind::LevelMainImage => {
            let level = level.ok_or(BigFishFieldError::InvalidLevel)?;
            let blueprint = draft
                .levels
                .iter()
                .find(|item| item.level == level)
                .ok_or(BigFishFieldError::InvalidLevel)?;
            Ok(blueprint.visual_prompt_seed.clone())
        }
        BigFishAssetKind::LevelMotion => {
            let level = level.ok_or(BigFishFieldError::InvalidLevel)?;
            let blueprint = draft
                .levels
                .iter()
                .find(|item| item.level == level)
                .ok_or(BigFishFieldError::InvalidLevel)?;
            let motion_key = motion_key.ok_or(BigFishFieldError::InvalidAssetKind)?;
            Ok(format!(
                "{}，动作位：{}",
                blueprint.motion_prompt_seed, motion_key
            ))
        }
        BigFishAssetKind::StageBackground => Ok(draft.background.background_prompt_seed.clone()),
    }
}

fn build_asset_slot_id(
    session_id: &str,
    asset_kind: BigFishAssetKind,
    level: Option<u32>,
    motion_key: Option<&str>,
) -> String {
    let level_part = level
        .map(|value| value.to_string())
        .unwrap_or_else(|| "stage".to_string());
    let motion_part = motion_key.unwrap_or("main");
    format!(
        "{BIG_FISH_ASSET_SLOT_ID_PREFIX}{session_id}_{}_{}_{}",
        asset_kind.as_str(),
        level_part,
        motion_part
    )
}

fn build_placeholder_asset_url(
    asset_kind: BigFishAssetKind,
    level: Option<u32>,
    seed_micros: i64,
) -> String {
    let level_part = level
        .map(|value| format!("level-{value}"))
        .unwrap_or_else(|| "stage".to_string());
    format!(
        "/generated-big-fish/{}/{}/{}.png",
        asset_kind.as_str(),
        level_part,
        seed_micros
    )
}

fn validate_session_owner(session_id: &str, owner_user_id: &str) -> Result<(), BigFishFieldError> {
    if normalize_required_string(session_id).is_none() {
        return Err(BigFishFieldError::MissingSessionId);
    }
    if normalize_required_string(owner_user_id).is_none() {
        return Err(BigFishFieldError::MissingOwnerUserId);
    }
    Ok(())
}

fn validate_level(level: Option<u32>, draft: &BigFishGameDraft) -> Result<(), BigFishFieldError> {
    match level {
        Some(value) if (1..=draft.runtime_params.level_count).contains(&value) => Ok(()),
        _ => Err(BigFishFieldError::InvalidLevel),
    }
}

fn normalize_input(x: f32, y: f32) -> BigFishVector2 {
    let length = (x * x + y * y).sqrt();
    if length <= 1.0 {
        return BigFishVector2 { x, y };
    }
    BigFishVector2 {
        x: x / length,
        y: y / length,
    }
}

/// 运行态仍由 `POST input` 触发推进，因此“屏外 3 秒”这类规则必须按真实秒数累计，
/// 否则会随着输入频率变化而漂移。
fn resolve_step_seconds(snapshot: &BigFishRuntimeSnapshot, now_micros: i64) -> f32 {
    ((now_micros - snapshot.updated_at_micros).max(0) as f32) / 1_000_000.0
}

fn move_owned_entities(
    snapshot: &mut BigFishRuntimeSnapshot,
    params: &BigFishRuntimeParams,
    step_seconds: f32,
) {
    let input = snapshot.last_input.clone();
    if let Some(leader) = snapshot.owned_entities.first_mut() {
        leader.position.x = clamp_world(
            leader.position.x + input.x * params.leader_move_speed * step_seconds,
            true,
        );
        leader.position.y = clamp_world(
            leader.position.y + input.y * params.leader_move_speed * step_seconds,
            false,
        );
        snapshot.camera_center = leader.position.clone();
    }

    let leader_position = snapshot.camera_center.clone();
    for (index, follower) in snapshot.owned_entities.iter_mut().enumerate().skip(1) {
        let slot_offset = ((index as f32) * 0.7).sin() * 36.0;
        let target = BigFishVector2 {
            x: leader_position.x - 42.0 - index as f32 * 8.0,
            y: leader_position.y + slot_offset,
        };
        let delta_x = target.x - follower.position.x;
        let delta_y = target.y - follower.position.y;
        let distance = (delta_x * delta_x + delta_y * delta_y).sqrt();
        if distance <= f32::EPSILON {
            continue;
        }
        let catch_up_ratio =
            (params.follower_catch_up_speed * step_seconds / distance).clamp(0.0, 1.0);
        follower.position.x += delta_x * catch_up_ratio;
        follower.position.y += delta_y * catch_up_ratio;
    }
}

fn resolve_collisions(snapshot: &mut BigFishRuntimeSnapshot, _params: &BigFishRuntimeParams) {
    let mut owned_to_remove = Vec::new();
    let mut wild_to_remove = Vec::new();
    let mut newly_owned = Vec::new();

    for (owned_index, owned) in snapshot.owned_entities.iter().enumerate() {
        for (wild_index, wild) in snapshot.wild_entities.iter().enumerate() {
            if wild_to_remove.contains(&wild_index) || owned_to_remove.contains(&owned_index) {
                continue;
            }
            if distance(&owned.position, &wild.position) > owned.radius + wild.radius {
                continue;
            }

            if owned.level >= wild.level {
                wild_to_remove.push(wild_index);
                newly_owned.push(BigFishRuntimeEntity {
                    entity_id: format!("owned-from-{}-{}", wild.entity_id, snapshot.tick),
                    level: wild.level,
                    position: wild.position.clone(),
                    radius: entity_radius(wild.level),
                    offscreen_seconds: 0.0,
                });
                snapshot
                    .event_log
                    .push(format!("收编 {} 级实体", wild.level));
            } else {
                owned_to_remove.push(owned_index);
                snapshot.event_log.push(format!(
                    "{} 级己方实体被 {} 级野生实体吃掉",
                    owned.level, wild.level
                ));
            }
        }
    }

    remove_indices(&mut snapshot.wild_entities, &wild_to_remove);
    remove_indices(&mut snapshot.owned_entities, &owned_to_remove);
    snapshot.owned_entities.extend(newly_owned);
}

fn apply_chain_merges(snapshot: &mut BigFishRuntimeSnapshot, params: &BigFishRuntimeParams) {
    loop {
        let mut merged = false;
        for level in 1..params.win_level {
            let indices = snapshot
                .owned_entities
                .iter()
                .enumerate()
                .filter_map(|(index, entity)| (entity.level == level).then_some(index))
                .take(params.merge_count_per_upgrade as usize)
                .collect::<Vec<_>>();
            if indices.len() < params.merge_count_per_upgrade as usize {
                continue;
            }

            let center = average_position(&indices, &snapshot.owned_entities);
            remove_indices(&mut snapshot.owned_entities, &indices);
            snapshot.owned_entities.push(BigFishRuntimeEntity {
                entity_id: format!("owned-merge-{}-{}", level + 1, snapshot.tick),
                level: level + 1,
                position: center,
                radius: entity_radius(level + 1),
                offscreen_seconds: 0.0,
            });
            snapshot
                .event_log
                .push(format!("3 个 {} 级实体合成 {} 级", level, level + 1));
            merged = true;
            break;
        }

        if !merged {
            break;
        }
    }
}

fn refresh_player_leader(snapshot: &mut BigFishRuntimeSnapshot) {
    snapshot.owned_entities.sort_by(|left, right| {
        right
            .level
            .cmp(&left.level)
            .then_with(|| {
                distance(&left.position, &snapshot.camera_center)
                    .partial_cmp(&distance(&right.position, &snapshot.camera_center))
                    .unwrap_or(std::cmp::Ordering::Equal)
            })
            .then_with(|| left.entity_id.cmp(&right.entity_id))
    });
    snapshot.leader_entity_id = snapshot
        .owned_entities
        .first()
        .map(|entity| entity.entity_id.clone());
    snapshot.player_level = snapshot
        .owned_entities
        .iter()
        .map(|entity| entity.level)
        .max()
        .unwrap_or(0);
    if let Some(leader) = snapshot.owned_entities.first() {
        snapshot.camera_center = leader.position.clone();
    }
}

fn apply_win_or_fail(snapshot: &mut BigFishRuntimeSnapshot, params: &BigFishRuntimeParams) {
    if snapshot.owned_entities.is_empty() {
        snapshot.status = BigFishRunStatus::Failed;
        snapshot
            .event_log
            .push("己方实体归零，本局失败".to_string());
        return;
    }
    if snapshot.player_level >= params.win_level {
        snapshot.status = BigFishRunStatus::Won;
        snapshot
            .event_log
            .push("获得最高等级实体，通关".to_string());
    }
}

fn update_wild_culling(
    snapshot: &mut BigFishRuntimeSnapshot,
    params: &BigFishRuntimeParams,
    step_seconds: f32,
) {
    let player_level = snapshot.player_level;
    for wild in &mut snapshot.wild_entities {
        let should_cull_level = wild.level == player_level
            || wild.level >= player_level.saturating_add(3)
            || wild.level.saturating_add(3) <= player_level;
        if !should_cull_level {
            wild.offscreen_seconds = 0.0;
            continue;
        }

        if is_offscreen(&wild.position, &snapshot.camera_center, wild.radius) {
            wild.offscreen_seconds += step_seconds;
        } else {
            wild.offscreen_seconds = 0.0;
        }
    }
    snapshot
        .wild_entities
        .retain(|wild| wild.offscreen_seconds < params.offscreen_cull_seconds);
}

fn maintain_wild_pool(snapshot: &mut BigFishRuntimeSnapshot, params: &BigFishRuntimeParams) {
    if snapshot.status != BigFishRunStatus::Running {
        return;
    }
    let mut next_index = snapshot.wild_entities.len() + snapshot.tick as usize;
    while snapshot.wild_entities.len() < params.spawn_target_count as usize {
        let level = next_spawn_level(snapshot.player_level.max(1), params.win_level, next_index);
        snapshot.wild_entities.push(BigFishRuntimeEntity {
            entity_id: format!("wild-{}-{}", snapshot.tick, next_index),
            level,
            position: spawn_position(&snapshot.camera_center, next_index),
            radius: entity_radius(level),
            offscreen_seconds: 0.0,
        });
        next_index += 1;
    }
}

fn next_spawn_level(player_level: u32, win_level: u32, index: usize) -> u32 {
    if player_level == 1 && index % 4 < 2 {
        return 1;
    }
    let deltas = [-2_i32, -1, 1, 2];
    let delta = deltas[index % deltas.len()];
    (player_level as i32 + delta).clamp(1, win_level as i32) as u32
}

fn spawn_position(center: &BigFishVector2, index: usize) -> BigFishVector2 {
    let side = index % 4;
    let offset = ((index as f32 * 37.0) % 420.0) - 210.0;
    match side {
        0 => BigFishVector2 {
            x: center.x - BIG_FISH_VIEW_WIDTH * 0.62,
            y: center.y + offset,
        },
        1 => BigFishVector2 {
            x: center.x + BIG_FISH_VIEW_WIDTH * 0.62,
            y: center.y + offset,
        },
        2 => BigFishVector2 {
            x: center.x + offset,
            y: center.y - BIG_FISH_VIEW_HEIGHT * 0.58,
        },
        _ => BigFishVector2 {
            x: center.x + offset,
            y: center.y + BIG_FISH_VIEW_HEIGHT * 0.58,
        },
    }
}

fn remove_indices<T>(items: &mut Vec<T>, indices: &[usize]) {
    let mut sorted = indices.to_vec();
    sorted.sort_unstable();
    sorted.dedup();
    for index in sorted.into_iter().rev() {
        if index < items.len() {
            items.remove(index);
        }
    }
}

fn average_position(indices: &[usize], entities: &[BigFishRuntimeEntity]) -> BigFishVector2 {
    let mut x = 0.0;
    let mut y = 0.0;
    for index in indices {
        x += entities[*index].position.x;
        y += entities[*index].position.y;
    }
    let count = indices.len().max(1) as f32;
    BigFishVector2 {
        x: x / count,
        y: y / count,
    }
}

fn distance(left: &BigFishVector2, right: &BigFishVector2) -> f32 {
    let dx = left.x - right.x;
    let dy = left.y - right.y;
    (dx * dx + dy * dy).sqrt()
}

fn is_offscreen(position: &BigFishVector2, camera: &BigFishVector2, radius: f32) -> bool {
    let half_w = BIG_FISH_VIEW_WIDTH / 2.0;
    let half_h = BIG_FISH_VIEW_HEIGHT / 2.0;
    position.x + radius < camera.x - half_w
        || position.x - radius > camera.x + half_w
        || position.y + radius < camera.y - half_h
        || position.y - radius > camera.y + half_h
}

fn clamp_world(value: f32, horizontal: bool) -> f32 {
    let limit = if horizontal {
        BIG_FISH_WORLD_HALF_WIDTH
    } else {
        BIG_FISH_WORLD_HALF_HEIGHT
    };
    value.clamp(-limit, limit)
}

fn entity_radius(level: u32) -> f32 {
    18.0 + level as f32 * 4.0
}

impl fmt::Display for BigFishFieldError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::MissingSessionId => f.write_str("big_fish.session_id 不能为空"),
            Self::MissingOwnerUserId => f.write_str("big_fish.owner_user_id 不能为空"),
            Self::MissingMessageId => f.write_str("big_fish.message_id 不能为空"),
            Self::MissingMessageText => f.write_str("big_fish.message_text 不能为空"),
            Self::MissingRunId => f.write_str("big_fish.run_id 不能为空"),
            Self::MissingDraft => f.write_str("big_fish.draft 尚未编译"),
            Self::InvalidLevel => f.write_str("big_fish.level 不在合法等级范围内"),
            Self::InvalidAssetKind => f.write_str("big_fish.asset_kind 或动作位非法"),
            Self::InvalidRunState => f.write_str("big_fish.run 当前状态不允许推进"),
        }
    }
}

impl Error for BigFishFieldError {}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn default_draft_compiles_eight_levels_with_fixed_runtime_params() {
        let draft = compile_default_draft(&infer_anchor_pack("机械深海，节奏偏爽", None));

        assert_eq!(draft.levels.len(), BIG_FISH_DEFAULT_LEVEL_COUNT as usize);
        assert_eq!(draft.runtime_params.merge_count_per_upgrade, 3);
        assert_eq!(draft.runtime_params.offscreen_cull_seconds, 3.0);
        assert_eq!(draft.runtime_params.prey_spawn_delta_levels, vec![1, 2]);
        assert_eq!(draft.runtime_params.threat_spawn_delta_levels, vec![1, 2]);
        assert!(
            draft
                .levels
                .last()
                .is_some_and(|level| level.is_final_level)
        );
    }

    #[test]
    fn asset_coverage_requires_main_images_two_motions_and_background() {
        let draft = compile_default_draft(&infer_anchor_pack("深海", None));
        let coverage = build_asset_coverage(Some(&draft), &[]);

        assert!(!coverage.publish_ready);
        assert_eq!(coverage.required_level_count, 8);
        assert!(
            coverage
                .blockers
                .iter()
                .any(|item| item.contains("等级主图"))
        );
        assert!(
            coverage
                .blockers
                .iter()
                .any(|item| item.contains("基础动作"))
        );
        assert!(coverage.blockers.iter().any(|item| item.contains("背景图")));
    }

    #[test]
    fn same_level_wild_entity_can_be_collected_at_start() {
        let draft = compile_default_draft(&infer_anchor_pack("深海", None));
        let mut snapshot =
            build_initial_runtime_snapshot("run-1".to_string(), "session-1".to_string(), &draft, 1);
        snapshot.wild_entities[0].position = BigFishVector2 { x: 1.0, y: 0.0 };

        let next = advance_runtime_snapshot(snapshot, &draft.runtime_params, 0.0, 0.0, 2);

        assert!(next.owned_entities.len() >= 2);
        assert!(
            next.event_log
                .iter()
                .any(|event| event.contains("收编 1 级实体"))
        );
    }

    #[test]
    fn three_owned_entities_merge_into_next_level() {
        let draft = compile_default_draft(&infer_anchor_pack("深海", None));
        let mut snapshot = build_initial_runtime_snapshot(
            "run-merge".to_string(),
            "session-merge".to_string(),
            &draft,
            1,
        );
        snapshot.wild_entities.clear();
        snapshot.owned_entities.push(BigFishRuntimeEntity {
            entity_id: "owned-2".to_string(),
            level: 1,
            position: BigFishVector2 { x: 4.0, y: 0.0 },
            radius: entity_radius(1),
            offscreen_seconds: 0.0,
        });
        snapshot.owned_entities.push(BigFishRuntimeEntity {
            entity_id: "owned-3".to_string(),
            level: 1,
            position: BigFishVector2 { x: 8.0, y: 0.0 },
            radius: entity_radius(1),
            offscreen_seconds: 0.0,
        });

        let next = advance_runtime_snapshot(snapshot, &draft.runtime_params, 0.0, 0.0, 2);

        assert!(next.owned_entities.iter().any(|entity| entity.level == 2));
    }

    #[test]
    fn final_level_immediately_wins() {
        let draft = compile_default_draft(&infer_anchor_pack("深海", None));
        let mut snapshot = build_initial_runtime_snapshot(
            "run-win".to_string(),
            "session-win".to_string(),
            &draft,
            1,
        );
        snapshot.owned_entities[0].level = draft.runtime_params.win_level;

        let next = advance_runtime_snapshot(snapshot, &draft.runtime_params, 0.0, 0.0, 2);

        assert_eq!(next.status, BigFishRunStatus::Won);
    }

    #[test]
    fn offscreen_same_level_wild_entity_is_removed_after_three_seconds() {
        let draft = compile_default_draft(&infer_anchor_pack("深海", None));
        let mut snapshot = build_initial_runtime_snapshot(
            "run-cull".to_string(),
            "session-cull".to_string(),
            &draft,
            1,
        );
        snapshot.wild_entities.clear();
        snapshot.wild_entities.push(BigFishRuntimeEntity {
            entity_id: "wild-cull".to_string(),
            level: 1,
            position: BigFishVector2 { x: 1000.0, y: 0.0 },
            radius: entity_radius(1),
            offscreen_seconds: 2.8,
        });
        snapshot.updated_at_micros = 1_000_000;

        let next = advance_runtime_snapshot(snapshot, &draft.runtime_params, 0.0, 0.0, 1_250_000);

        assert!(
            !next
                .wild_entities
                .iter()
                .any(|entity| entity.entity_id == "wild-cull")
        );
    }

    #[test]
    fn offscreen_same_level_wild_entity_is_kept_before_three_seconds_elapsed() {
        let draft = compile_default_draft(&infer_anchor_pack("深海", None));
        let mut snapshot = build_initial_runtime_snapshot(
            "run-cull-safe".to_string(),
            "session-cull-safe".to_string(),
            &draft,
            1,
        );
        snapshot.wild_entities.clear();
        snapshot.wild_entities.push(BigFishRuntimeEntity {
            entity_id: "wild-cull-safe".to_string(),
            level: 1,
            position: BigFishVector2 { x: 1000.0, y: 0.0 },
            radius: entity_radius(1),
            offscreen_seconds: 2.7,
        });
        snapshot.updated_at_micros = 1_000_000;

        let next = advance_runtime_snapshot(snapshot, &draft.runtime_params, 0.0, 0.0, 1_200_000);

        assert!(
            next.wild_entities
                .iter()
                .any(|entity| entity.entity_id == "wild-cull-safe")
        );
    }
}