use super::*;

const PLAYER_BASE_MAX_HP: i32 = 180;
const DEFAULT_PLAYER_MAX_MANA: i32 = 999;
pub(super) const RESOLVED_ENTITY_X_METERS: f64 = 12.0;

pub async fn begin_runtime_story_session(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    Json(payload): Json<RuntimeStoryBootstrapRequest>,
) -> Result<Json<Value>, Response> {
    let actor_user_id = authenticated.claims().user_id().to_string();
    let now = OffsetDateTime::now_utc();
    let now_micros = offset_datetime_to_unix_micros(now);
    let session_id = build_runtime_session_id(
        actor_user_id.as_str(),
        payload.custom_world_profile.as_ref(),
        &payload.character,
        now_micros,
    );
    let game_state =
        build_initial_runtime_game_state(&payload, session_id.as_str()).map_err(|message| {
            runtime_story_error_response(
                &request_context,
                AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                    "provider": "runtime-story",
                    "message": message,
                })),
            )
        })?;
    let snapshot = RuntimeStorySnapshotPayload {
        saved_at: Some(format_now_rfc3339()),
        bottom_tab: "adventure".to_string(),
        game_state,
        current_story: None,
    };
    let persisted =
        persist_runtime_story_snapshot(&state, &request_context, actor_user_id, snapshot).await?;
    let persisted_snapshot = runtime_snapshot_payload_from_record(&persisted);

    Ok(json_success_body(
        Some(&request_context),
        RuntimeStoryBootstrapResponse {
            session_id,
            server_version: 1,
            snapshot: persisted_snapshot,
        },
    ))
}

fn build_runtime_session_id(
    actor_user_id: &str,
    custom_world_profile: Option<&Value>,
    character: &Value,
    now_micros: i64,
) -> String {
    let profile_id = custom_world_profile
        .and_then(|profile| read_optional_string_field(profile, "id"))
        .or_else(|| {
            custom_world_profile.and_then(|profile| read_optional_string_field(profile, "name"))
        })
        .unwrap_or_else(|| "builtin".to_string());
    let character_id = read_optional_string_field(character, "id")
        .or_else(|| read_optional_string_field(character, "name"))
        .unwrap_or_else(|| "character".to_string());

    format!(
        "runtime-{}-{}-{}-{now_micros}",
        sanitize_id_segment(actor_user_id),
        sanitize_id_segment(profile_id.as_str()),
        sanitize_id_segment(character_id.as_str())
    )
}

fn sanitize_id_segment(value: &str) -> String {
    let normalized = value
        .trim()
        .chars()
        .filter(|ch| ch.is_ascii_alphanumeric() || *ch == '-' || *ch == '_')
        .take(36)
        .collect::<String>();
    if normalized.is_empty() {
        "unknown".to_string()
    } else {
        normalized
    }
}

fn build_initial_runtime_game_state(
    payload: &RuntimeStoryBootstrapRequest,
    session_id: &str,
) -> Result<Value, String> {
    let world_type = normalize_required_string(payload.world_type.as_str())
        .ok_or_else(|| "worldType 不能为空".to_string())?;
    if world_type == "CUSTOM" && payload.custom_world_profile.is_none() {
        return Err("自定义世界开局必须提供 customWorldProfile".to_string());
    }
    if !payload.character.is_object() {
        return Err("character 必须是 JSON object".to_string());
    }

    let runtime_mode = normalize_runtime_mode(payload.runtime_mode.as_deref());
    let custom_world_profile = payload.custom_world_profile.clone().unwrap_or(Value::Null);
    let character = payload.character.clone();
    let initial_scene_preset =
        resolve_initial_scene_preset(world_type.as_str(), payload.custom_world_profile.as_ref());
    let initial_encounter = resolve_initial_encounter(
        world_type.as_str(),
        payload.custom_world_profile.as_ref(),
        &character,
        initial_scene_preset.as_ref(),
    );
    let initial_npc_state = initial_encounter
        .as_ref()
        .map(build_initial_npc_state_value)
        .unwrap_or(Value::Null);
    let player_max_hp = resolve_character_max_hp(&character);
    let player_max_mana = resolve_character_max_mana(&character);
    let initial_inventory = build_initial_player_inventory(
        world_type.as_str(),
        payload.custom_world_profile.as_ref(),
        &character,
    );
    let initial_equipment = build_initial_player_equipment(
        world_type.as_str(),
        payload.custom_world_profile.as_ref(),
        &character,
        &initial_inventory,
    );
    let equipment_bonuses = read_equipment_total_bonuses(&initial_equipment);
    let player_max_hp_with_equipment = player_max_hp + equipment_bonuses.max_hp_bonus;
    let story_engine_memory = build_opening_story_engine_memory(
        payload.custom_world_profile.as_ref(),
        &initial_scene_preset,
    );

    let mut npc_states = Map::new();
    if let (Some(encounter), Value::Object(npc_state)) = (&initial_encounter, initial_npc_state) {
        let npc_id = read_optional_string_field(encounter, "id")
            .unwrap_or_else(|| current_encounter_name(encounter));
        npc_states.insert(npc_id, Value::Object(npc_state));
    }

    let mut game_state = json!({
        "worldType": world_type,
        "customWorldProfile": custom_world_profile,
        "playerCharacter": character,
        "runtimeSessionId": session_id,
        "runtimeActionVersion": 1,
        "runtimeMode": runtime_mode,
        "runtimePersistenceDisabled": payload.disable_persistence.unwrap_or(false),
        "runtimeStats": {
            "playTimeMs": 0,
            "lastPlayTickAt": Value::Null,
            "hostileNpcsDefeated": 0,
            "questsAccepted": 0,
            "itemsUsed": 0,
            "scenesTraveled": 0
        },
        "playerProgression": {
            "level": 1,
            "currentLevelXp": 0,
            "totalXp": 0,
            "xpToNextLevel": 100,
            "pendingLevelUps": 0,
            "lastGrantedSource": Value::Null
        },
        "currentScene": "Story",
        "storyHistory": [],
        "storyEngineMemory": story_engine_memory,
        "chapterState": Value::Null,
        "campaignState": Value::Null,
        "activeScenarioPackId": payload.custom_world_profile.as_ref().and_then(|profile| read_optional_string_field(profile, "scenarioPackId")),
        "activeCampaignPackId": payload.custom_world_profile.as_ref().and_then(|profile| read_optional_string_field(profile, "campaignPackId")),
        "characterChats": {},
        "lastObserveSignsSceneId": Value::Null,
        "lastObserveSignsReport": Value::Null,
        "animationState": "idle",
        "currentEncounter": initial_encounter,
        "npcInteractionActive": false,
        "currentScenePreset": initial_scene_preset,
        "sceneHostileNpcs": [],
        "playerX": 0,
        "playerOffsetY": 0,
        "playerFacing": "right",
        "playerActionMode": "idle",
        "scrollWorld": false,
        "inBattle": false,
        "playerHp": player_max_hp_with_equipment,
        "playerMaxHp": player_max_hp_with_equipment,
        "playerMana": player_max_mana,
        "playerMaxMana": player_max_mana,
        "playerSkillCooldowns": {},
        "activeBuildBuffs": [],
        "activeCombatEffects": [],
        "playerCurrency": resolve_initial_player_currency(world_type.as_str(), payload.custom_world_profile.as_ref()),
        "playerInventory": initial_inventory,
        "playerEquipment": initial_equipment,
        "npcStates": npc_states,
        "quests": [],
        "roster": [],
        "companions": [],
        "currentBattleNpcId": Value::Null,
        "currentNpcBattleMode": Value::Null,
        "currentNpcBattleOutcome": Value::Null,
        "sparReturnEncounter": Value::Null,
        "sparPlayerHpBefore": Value::Null,
        "sparPlayerMaxHpBefore": Value::Null,
        "sparStoryHistoryBefore": Value::Null
    });
    ensure_json_object(&mut game_state).insert(
        "playerSkillCooldowns".to_string(),
        build_character_skill_cooldowns(&payload.character),
    );
    Ok(game_state)
}

fn normalize_runtime_mode(value: Option<&str>) -> &'static str {
    match value.map(str::trim) {
        Some("preview") => "preview",
        Some("test") => "test",
        _ => "play",
    }
}

fn resolve_initial_scene_preset(world_type: &str, profile: Option<&Value>) -> Option<Value> {
    if world_type == "CUSTOM" {
        let profile = profile?;
        let scene_id =
            resolve_opening_scene_id(profile).unwrap_or_else(|| "custom-scene-camp".to_string());
        return build_custom_scene_preset(profile, scene_id.as_str());
    }

    Some(build_builtin_camp_scene_preset(world_type))
}

fn resolve_opening_scene_id(profile: &Value) -> Option<String> {
    let opening_chapter = read_array_field(profile, "sceneChapterBlueprints")
        .into_iter()
        .next()?;
    let opening_act = read_array_field(opening_chapter, "acts").into_iter().next();
    [
        opening_act.and_then(|act| read_optional_string_field(act, "sceneId")),
        read_optional_string_field(opening_chapter, "sceneId"),
        read_array_field(opening_chapter, "linkedLandmarkIds")
            .into_iter()
            .find_map(Value::as_str)
            .map(str::to_string),
    ]
    .into_iter()
    .flatten()
    .map(|scene_id| resolve_custom_runtime_scene_id(profile, scene_id.as_str()))
    .find(|scene_id| !scene_id.trim().is_empty())
}

pub(super) fn resolve_custom_runtime_scene_id(profile: &Value, scene_id: &str) -> String {
    let normalized = scene_id.trim();
    if normalized.is_empty()
        || normalized == "custom-scene-camp"
        || read_object_field(profile, "camp")
            .and_then(|camp| read_optional_string_field(camp, "id"))
            .as_deref()
            == Some(normalized)
    {
        return "custom-scene-camp".to_string();
    }

    for (index, landmark) in read_array_field(profile, "landmarks")
        .into_iter()
        .enumerate()
    {
        if read_optional_string_field(landmark, "id").as_deref() == Some(normalized) {
            return format!("custom-scene-landmark-{}", index + 1);
        }
    }

    normalized.to_string()
}

fn build_builtin_camp_scene_preset(world_type: &str) -> Value {
    let is_xianxia = world_type == "XIANXIA";
    json!({
        "id": if is_xianxia { "xianxia-star-vessel" } else { "wuxia-border-camp" },
        "name": if is_xianxia { "星槎泊台" } else { "边城营地" },
        "description": if is_xianxia { "星槎停泊在云海边缘，远处灵潮微明。" } else { "边城营地炊烟未散，旧路与山影在前方交错。" },
        "imageSrc": "",
        "worldType": world_type,
        "forwardSceneId": Value::Null,
        "connectedSceneIds": [],
        "connections": [],
        "npcs": [],
        "treasureHints": [],
        "narrativeResidues": []
    })
}

pub(super) fn build_custom_scene_preset(profile: &Value, scene_id: &str) -> Option<Value> {
    if scene_id == "custom-scene-camp" {
        let camp = read_object_field(profile, "camp");
        let name = camp
            .and_then(|value| read_optional_string_field(value, "name"))
            .unwrap_or_else(|| "开局归处".to_string());
        let description = camp
            .and_then(|value| read_optional_string_field(value, "description"))
            .unwrap_or_else(|| read_optional_string_field(profile, "summary").unwrap_or_default());
        let connected_scene_ids = read_array_field(profile, "landmarks")
            .into_iter()
            .take(3)
            .enumerate()
            .map(|(index, _)| Value::String(format!("custom-scene-landmark-{}", index + 1)))
            .collect::<Vec<_>>();
        let npcs = build_custom_scene_npcs(profile, scene_id);
        return Some(json!({
            "id": "custom-scene-camp",
            "name": name,
            "description": description,
            "imageSrc": camp.and_then(|value| read_optional_string_field(value, "imageSrc")).unwrap_or_default(),
            "worldType": "CUSTOM",
            "forwardSceneId": connected_scene_ids.first().cloned().unwrap_or(Value::Null),
            "connectedSceneIds": connected_scene_ids,
            "connections": [],
            "npcs": npcs,
            "treasureHints": [],
            "narrativeResidues": camp.and_then(|value| read_field(value, "narrativeResidues")).cloned().unwrap_or(Value::Array(Vec::new()))
        }));
    }

    let landmark_index = scene_id
        .strip_prefix("custom-scene-landmark-")
        .and_then(|value| value.parse::<usize>().ok())
        .and_then(|value| value.checked_sub(1))
        .unwrap_or(0);
    let landmark = *read_array_field(profile, "landmarks").get(landmark_index)?;
    let npcs = build_custom_scene_npcs(profile, scene_id);
    Some(json!({
        "id": scene_id,
        "name": read_optional_string_field(landmark, "name").unwrap_or_else(|| format!("地标{}", landmark_index + 1)),
        "description": read_optional_string_field(landmark, "description").unwrap_or_default(),
        "imageSrc": read_optional_string_field(landmark, "imageSrc").unwrap_or_default(),
        "worldType": "CUSTOM",
        "forwardSceneId": Value::Null,
        "connectedSceneIds": ["custom-scene-camp"],
        "connections": [],
        "npcs": npcs,
        "treasureHints": [],
        "narrativeResidues": read_field(landmark, "narrativeResidues").cloned().unwrap_or(Value::Array(Vec::new()))
    }))
}

pub(super) fn build_custom_scene_npcs(profile: &Value, scene_id: &str) -> Vec<Value> {
    let mut npc_ids = Vec::new();
    if scene_id == "custom-scene-camp" {
        read_object_field(profile, "camp")
            .map(|camp| read_array_field(camp, "sceneNpcIds"))
            .unwrap_or_default()
            .into_iter()
            .filter_map(Value::as_str)
            .for_each(|id| push_unique_string(&mut npc_ids, id));
    } else if let Some(landmark_index) = scene_id
        .strip_prefix("custom-scene-landmark-")
        .and_then(|value| value.parse::<usize>().ok())
        .and_then(|value| value.checked_sub(1))
    {
        if let Some(landmark) = read_array_field(profile, "landmarks").get(landmark_index) {
            read_array_field(landmark, "sceneNpcIds")
                .into_iter()
                .filter_map(Value::as_str)
                .for_each(|id| push_unique_string(&mut npc_ids, id));
        }
    }

    collect_scene_act_npc_ids(profile, scene_id)
        .into_iter()
        .for_each(|id| push_unique_string(&mut npc_ids, id.as_str()));

    npc_ids
        .into_iter()
        .filter_map(|npc_id| find_custom_world_role_by_reference(profile, npc_id.as_str()))
        .map(build_custom_scene_npc)
        .collect()
}

fn collect_scene_act_npc_ids(profile: &Value, scene_id: &str) -> Vec<String> {
    let aliases = custom_scene_aliases(profile, scene_id);
    let mut npc_ids = Vec::new();
    for chapter in read_array_field(profile, "sceneChapterBlueprints") {
        let chapter_scene_ids = [
            read_optional_string_field(chapter, "sceneId"),
            Some(
                read_array_field(chapter, "linkedLandmarkIds")
                    .into_iter()
                    .filter_map(Value::as_str)
                    .map(str::to_string)
                    .collect::<Vec<_>>()
                    .join("|"),
            ),
        ];
        let mut matches_scene = chapter_scene_ids
            .into_iter()
            .flatten()
            .flat_map(|entry| entry.split('|').map(str::to_string).collect::<Vec<_>>())
            .any(|id| aliases.contains(&resolve_custom_runtime_scene_id(profile, id.as_str())));
        for act in read_array_field(chapter, "acts") {
            if aliases.contains(&resolve_custom_runtime_scene_id(
                profile,
                read_optional_string_field(act, "sceneId")
                    .unwrap_or_default()
                    .as_str(),
            )) {
                matches_scene = true;
            }
            if matches_scene {
                [
                    read_optional_string_field(act, "primaryNpcId"),
                    read_optional_string_field(act, "oppositeNpcId"),
                ]
                .into_iter()
                .flatten()
                .for_each(|id| {
                    let resolved = resolve_custom_role_id_reference(profile, id.as_str());
                    push_unique_string(&mut npc_ids, resolved.as_str());
                });
                read_array_field(act, "encounterNpcIds")
                    .into_iter()
                    .filter_map(Value::as_str)
                    .for_each(|id| {
                        let resolved = resolve_custom_role_id_reference(profile, id);
                        push_unique_string(&mut npc_ids, resolved.as_str());
                    });
            }
        }
    }
    npc_ids
}

fn custom_scene_aliases(profile: &Value, scene_id: &str) -> Vec<String> {
    let runtime_id = resolve_custom_runtime_scene_id(profile, scene_id);
    let mut aliases = vec![runtime_id.clone()];
    if runtime_id == "custom-scene-camp" {
        if let Some(camp_id) = read_object_field(profile, "camp")
            .and_then(|camp| read_optional_string_field(camp, "id"))
        {
            aliases.push(camp_id);
        }
    }
    aliases
}

fn push_unique_string(values: &mut Vec<String>, value: &str) {
    let normalized = value.trim();
    if !normalized.is_empty() && !values.iter().any(|entry| entry == normalized) {
        values.push(normalized.to_string());
    }
}

fn build_custom_scene_npc(role: Value) -> Value {
    let role_id = read_optional_string_field(&role, "id").unwrap_or_default();
    let name = read_optional_string_field(&role, "name").unwrap_or_else(|| role_id.clone());
    let initial_affinity = read_i32_field(&role, "initialAffinity").unwrap_or(18);
    let hostile = initial_affinity < 0;
    json!({
        "id": role_id,
        "characterId": read_optional_string_field(&role, "id"),
        "name": name,
        "title": read_optional_string_field(&role, "title"),
        "role": read_optional_string_field(&role, "role").unwrap_or_default(),
        "avatar": read_optional_string_field(&role, "imageSrc").unwrap_or_else(|| name.chars().next().map(|ch| ch.to_string()).unwrap_or_else(|| "?".to_string())),
        "description": read_optional_string_field(&role, "description").unwrap_or_default(),
        "gender": "unknown",
        "initialAffinity": initial_affinity,
        "hostile": hostile,
        "recruitable": !hostile,
        "functions": if hostile { json!(["fight"]) } else { json!(["trade", "fight", "spar", "help", "chat", "recruit", "gift"]) },
        "backstory": read_optional_string_field(&role, "backstory"),
        "personality": read_optional_string_field(&role, "personality"),
        "motivation": read_optional_string_field(&role, "motivation"),
        "combatStyle": read_optional_string_field(&role, "combatStyle"),
        "relationshipHooks": read_field(&role, "relationshipHooks").cloned().unwrap_or(Value::Array(Vec::new())),
        "tags": read_field(&role, "tags").cloned().unwrap_or(Value::Array(Vec::new())),
        "backstoryReveal": read_field(&role, "backstoryReveal").cloned(),
        "skills": read_field(&role, "skills").cloned().unwrap_or(Value::Array(Vec::new())),
        "initialItems": read_field(&role, "initialItems").cloned().unwrap_or(Value::Array(Vec::new())),
        "imageSrc": read_optional_string_field(&role, "imageSrc"),
        "visual": read_field(&role, "visual").cloned(),
        "narrativeProfile": read_field(&role, "narrativeProfile").cloned(),
        "attributeProfile": read_field(&role, "attributeProfile").cloned()
    })
}

fn resolve_initial_encounter(
    world_type: &str,
    profile: Option<&Value>,
    character: &Value,
    scene_preset: Option<&Value>,
) -> Option<Value> {
    if world_type == "CUSTOM" {
        let profile = profile?;
        if let Some(role_id) = resolve_opening_act_encounter_role_id(profile, character) {
            if let Some(scene_npc) = scene_preset.and_then(|scene| {
                read_array_field(scene, "npcs").into_iter().find(|npc| {
                    do_role_references_match(
                        profile,
                        read_optional_string_field(npc, "id").as_deref(),
                        Some(role_id.as_str()),
                    )
                })
            }) {
                return Some(build_encounter_from_scene_npc(scene_npc));
            }
            return find_custom_world_role_by_reference(profile, role_id.as_str())
                .map(build_opening_encounter_from_custom_role);
        }
        return None;
    }

    scene_preset.and_then(|scene| {
        read_array_field(scene, "npcs")
            .into_iter()
            .find(|npc| {
                read_optional_string_field(npc, "characterId")
                    != read_optional_string_field(character, "id")
            })
            .map(build_encounter_from_scene_npc)
    })
}

fn resolve_opening_act_encounter_role_id(profile: &Value, character: &Value) -> Option<String> {
    let opening_chapter = read_array_field(profile, "sceneChapterBlueprints")
        .into_iter()
        .next()?;
    let opening_act = read_array_field(opening_chapter, "acts")
        .into_iter()
        .next()?;
    let references = [
        read_optional_string_field(opening_act, "oppositeNpcId"),
        read_optional_string_field(opening_act, "primaryNpcId"),
    ]
    .into_iter()
    .flatten()
    .chain(
        read_array_field(opening_act, "encounterNpcIds")
            .into_iter()
            .filter_map(Value::as_str)
            .map(str::to_string),
    );
    for reference in references {
        let role_id = resolve_custom_role_id_reference(profile, reference.as_str());
        if do_role_references_match(
            profile,
            Some(role_id.as_str()),
            read_optional_string_field(character, "id").as_deref(),
        ) || do_role_references_match(
            profile,
            Some(role_id.as_str()),
            read_optional_string_field(character, "name").as_deref(),
        ) {
            continue;
        }
        if !role_id.trim().is_empty() {
            return Some(role_id);
        }
    }
    None
}

pub(super) fn build_encounter_from_scene_npc(npc: &Value) -> Value {
    let name = read_optional_string_field(npc, "name").unwrap_or_else(|| "当前遭遇".to_string());
    json!({
        "id": read_optional_string_field(npc, "id"),
        "kind": "npc",
        "characterId": read_optional_string_field(npc, "characterId"),
        "npcName": name,
        "npcDescription": read_optional_string_field(npc, "description").unwrap_or_default(),
        "npcAvatar": read_optional_string_field(npc, "avatar").unwrap_or_else(|| name.chars().next().map(|ch| ch.to_string()).unwrap_or_else(|| "?".to_string())),
        "context": read_optional_string_field(npc, "role").unwrap_or_default(),
        "gender": read_optional_string_field(npc, "gender").unwrap_or_else(|| "unknown".to_string()),
        "xMeters": RESOLVED_ENTITY_X_METERS,
        "initialAffinity": read_i32_field(npc, "initialAffinity"),
        "hostile": read_bool_field(npc, "hostile").unwrap_or(false) || read_i32_field(npc, "initialAffinity").unwrap_or(0) < 0,
        "title": read_optional_string_field(npc, "title"),
        "backstory": read_optional_string_field(npc, "backstory"),
        "personality": read_optional_string_field(npc, "personality"),
        "motivation": read_optional_string_field(npc, "motivation"),
        "combatStyle": read_optional_string_field(npc, "combatStyle"),
        "relationshipHooks": read_field(npc, "relationshipHooks").cloned().unwrap_or(Value::Array(Vec::new())),
        "tags": read_field(npc, "tags").cloned().unwrap_or(Value::Array(Vec::new())),
        "backstoryReveal": read_field(npc, "backstoryReveal").cloned(),
        "skills": read_field(npc, "skills").cloned().unwrap_or(Value::Array(Vec::new())),
        "initialItems": read_field(npc, "initialItems").cloned().unwrap_or(Value::Array(Vec::new())),
        "imageSrc": read_optional_string_field(npc, "imageSrc"),
        "visual": read_field(npc, "visual").cloned(),
        "narrativeProfile": read_field(npc, "narrativeProfile").cloned(),
        "attributeProfile": read_field(npc, "attributeProfile").cloned()
    })
}

fn build_opening_encounter_from_custom_role(role: Value) -> Value {
    let scene_npc = build_custom_scene_npc(role);
    build_encounter_from_scene_npc(&scene_npc)
}

fn build_initial_npc_state_value(encounter: &Value) -> Value {
    let affinity = read_i32_field(encounter, "initialAffinity").unwrap_or_else(|| {
        if read_bool_field(encounter, "hostile").unwrap_or(false) {
            -40
        } else {
            18
        }
    });
    json!({
        "affinity": affinity,
        "chattedCount": 0,
        "helpUsed": false,
        "giftsGiven": 0,
        "inventory": [],
        "recruited": false,
        "relationState": build_runtime_story_relation_state_value(affinity),
        "revealedFacts": [],
        "knownAttributeRumors": [],
        "firstMeaningfulContactResolved": false,
        "seenBackstoryChapterIds": [],
        "tradeStockSignature": Value::Null,
        "stanceProfile": build_runtime_story_stance_profile_value(
            affinity,
            false,
            read_bool_field(encounter, "hostile").unwrap_or(false),
            read_optional_string_field(encounter, "context").as_deref(),
            None,
        )
    })
}

fn build_opening_story_engine_memory(
    profile: Option<&Value>,
    scene_preset: &Option<Value>,
) -> Value {
    let current_scene_act_state = profile
        .and_then(|profile| {
            scene_preset.as_ref().and_then(|scene| {
                read_optional_string_field(scene, "id").map(|scene_id| (profile, scene_id))
            })
        })
        .and_then(|(profile, scene_id)| {
            build_initial_scene_act_runtime_state(profile, scene_id.as_str())
        });
    json!({
        "visibleFacts": [],
        "hiddenFacts": [],
        "threadStates": {},
        "companionMemory": {},
        "worldMutations": [],
        "currentSceneActState": current_scene_act_state
    })
}

fn build_initial_scene_act_runtime_state(profile: &Value, scene_id: &str) -> Option<Value> {
    let aliases = custom_scene_aliases(profile, scene_id);
    for chapter in read_array_field(profile, "sceneChapterBlueprints") {
        let chapter_scene_id = read_optional_string_field(chapter, "sceneId")
            .map(|id| resolve_custom_runtime_scene_id(profile, id.as_str()));
        let chapter_matches = chapter_scene_id
            .as_ref()
            .is_some_and(|id| aliases.contains(id))
            || read_array_field(chapter, "linkedLandmarkIds")
                .into_iter()
                .filter_map(Value::as_str)
                .any(|id| aliases.contains(&resolve_custom_runtime_scene_id(profile, id)));
        if !chapter_matches {
            continue;
        }
        let Some(first_act) = read_array_field(chapter, "acts").into_iter().next() else {
            continue;
        };
        return Some(json!({
            "sceneId": read_optional_string_field(chapter, "sceneId").unwrap_or_else(|| scene_id.to_string()),
            "chapterId": read_optional_string_field(chapter, "id").unwrap_or_default(),
            "currentActId": read_optional_string_field(first_act, "id").unwrap_or_default(),
            "currentActIndex": 0,
            "completedActIds": [],
            "visitedActIds": [read_optional_string_field(first_act, "id").unwrap_or_default()]
        }));
    }
    None
}

fn build_character_skill_cooldowns(character: &Value) -> Value {
    let mut cooldowns = Map::new();
    read_array_field(character, "skills")
        .into_iter()
        .filter_map(|skill| read_optional_string_field(skill, "id"))
        .for_each(|skill_id| {
            cooldowns.insert(skill_id, json!(0));
        });
    Value::Object(cooldowns)
}

fn resolve_character_max_hp(character: &Value) -> i32 {
    read_object_field(character, "resourceProfile")
        .and_then(|profile| read_i32_field(profile, "maxHp"))
        .unwrap_or_else(|| {
            let strength = read_object_field(character, "attributes")
                .and_then(|attributes| read_i32_field(attributes, "strength"))
                .unwrap_or(6);
            let spirit = read_object_field(character, "attributes")
                .and_then(|attributes| read_i32_field(attributes, "spirit"))
                .unwrap_or(4);
            PLAYER_BASE_MAX_HP.max(90 + strength * 10 + spirit * 4)
        })
}

fn resolve_character_max_mana(character: &Value) -> i32 {
    read_object_field(character, "resourceProfile")
        .and_then(|profile| read_i32_field(profile, "maxMana"))
        .unwrap_or(DEFAULT_PLAYER_MAX_MANA)
}

fn resolve_initial_player_currency(world_type: &str, profile: Option<&Value>) -> i32 {
    profile
        .and_then(|profile| read_object_field(profile, "ownedSettingLayers"))
        .and_then(|layers| read_object_field(layers, "ruleProfile"))
        .and_then(|rule| read_object_field(rule, "economyProfile"))
        .and_then(|economy| read_i32_field(economy, "initialCurrency"))
        .unwrap_or_else(|| if world_type == "XIANXIA" { 140 } else { 160 })
}

fn build_initial_player_inventory(
    world_type: &str,
    profile: Option<&Value>,
    character: &Value,
) -> Vec<Value> {
    let mut items = Vec::new();
    if world_type == "CUSTOM" {
        if let Some(profile) = profile {
            if let Some(role) = resolve_custom_character_role(profile, character) {
                read_array_field(&role, "initialItems")
                    .into_iter()
                    .enumerate()
                    .map(|(index, item)| build_explicit_role_inventory_item(&role, item, index))
                    .for_each(|item| merge_inventory_item(&mut items, item));
            }
        }
    }

    read_array_field(character, "inventory")
        .into_iter()
        .enumerate()
        .map(|(index, item)| normalize_character_inventory_item(character, item, index))
        .for_each(|item| merge_inventory_item(&mut items, item));

    if items.is_empty() {
        items.push(json!({
            "id": format!("starter:{}:supply", read_optional_string_field(character, "id").unwrap_or_else(|| "character".to_string())),
            "category": "消耗品",
            "name": if world_type == "XIANXIA" { "回灵散" } else { "行囊补给" },
            "quantity": 2,
            "rarity": "common",
            "tags": ["healing", "supply"],
            "description": "开局随身携带的基础补给。"
        }));
    }

    items
}

fn build_initial_player_equipment(
    world_type: &str,
    profile: Option<&Value>,
    character: &Value,
    inventory: &[Value],
) -> Value {
    let mut equipment = json!({
        "weapon": Value::Null,
        "armor": Value::Null,
        "relic": Value::Null
    });

    for item in inventory {
        let Some(slot) = read_optional_string_field(item, "equipmentSlotId") else {
            continue;
        };
        if ["weapon", "armor", "relic"].contains(&slot.as_str())
            && read_field(&equipment, slot.as_str()).is_some_and(Value::is_null)
        {
            write_field(&mut equipment, slot.as_str(), item.clone());
        }
    }

    for (slot, label) in [("weapon", "武器"), ("armor", "护甲"), ("relic", "饰品")] {
        if read_field(&equipment, slot).is_some_and(Value::is_null) {
            write_field(
                &mut equipment,
                slot,
                build_fallback_equipment_item(world_type, profile, character, slot, label),
            );
        }
    }

    equipment
}

fn build_fallback_equipment_item(
    world_type: &str,
    _profile: Option<&Value>,
    character: &Value,
    slot: &str,
    label: &str,
) -> Value {
    let character_id =
        read_optional_string_field(character, "id").unwrap_or_else(|| "character".to_string());
    let character_name =
        read_optional_string_field(character, "name").unwrap_or_else(|| "旅人".to_string());
    let name = match (world_type, slot) {
        ("XIANXIA", "weapon") => format!("{character_name}的灵刃"),
        ("XIANXIA", "armor") => format!("{character_name}的护行法衣"),
        ("XIANXIA", "relic") => format!("{character_name}的行旅护符"),
        (_, "weapon") => format!("{character_name}的短刃"),
        (_, "armor") => format!("{character_name}的护行短甲"),
        _ => format!("{character_name}的旧信物"),
    };
    json!({
        "id": format!("starter:{character_id}:{slot}"),
        "category": label,
        "name": name,
        "quantity": 1,
        "rarity": "common",
        "tags": [slot],
        "equipmentSlotId": slot
    })
}

fn normalize_character_inventory_item(character: &Value, item: &Value, index: usize) -> Value {
    let category =
        read_optional_string_field(item, "category").unwrap_or_else(|| "消耗品".to_string());
    json!({
        "id": read_optional_string_field(item, "id").unwrap_or_else(|| format!("starter:{}:inventory:{}", read_optional_string_field(character, "id").unwrap_or_else(|| "character".to_string()), index + 1)),
        "category": category,
        "name": read_optional_string_field(item, "name").or_else(|| read_optional_string_field(item, "item")).unwrap_or_else(|| "随身物品".to_string()),
        "quantity": read_i32_field(item, "quantity").unwrap_or(1).max(1),
        "rarity": read_optional_string_field(item, "rarity").unwrap_or_else(|| "common".to_string()),
        "tags": read_field(item, "tags").cloned().unwrap_or(Value::Array(Vec::new())),
        "description": read_optional_string_field(item, "description"),
        "equipmentSlotId": infer_explicit_starter_slot(category.as_str())
    })
}

fn build_explicit_role_inventory_item(role: &Value, item: &Value, index: usize) -> Value {
    let category = normalize_explicit_starter_category(
        read_optional_string_field(item, "category")
            .unwrap_or_else(|| "专属物品".to_string())
            .as_str(),
    );
    let role_id = read_optional_string_field(role, "id").unwrap_or_else(|| "role".to_string());
    let role_name = read_optional_string_field(role, "name").unwrap_or_else(|| "角色".to_string());
    json!({
        "id": format!("custom-role-item:{role_id}:{}", index + 1),
        "category": category,
        "name": read_optional_string_field(item, "name").unwrap_or_else(|| "初始物品".to_string()),
        "quantity": read_i32_field(item, "quantity").unwrap_or(1).max(1),
        "rarity": read_optional_string_field(item, "rarity").unwrap_or_else(|| "common".to_string()),
        "tags": read_field(item, "tags").cloned().unwrap_or(Value::Array(Vec::new())),
        "description": read_optional_string_field(item, "description"),
        "equipmentSlotId": infer_explicit_starter_slot(category.as_str()),
        "runtimeMetadata": {
            "origin": "ai_compiled",
            "generationChannel": "discovery",
            "seedKey": format!("{role_id}:{}", index + 1),
            "relationAnchor": {
                "type": "npc",
                "npcId": role_id,
                "npcName": role_name,
                "roleText": read_optional_string_field(role, "role").unwrap_or_default()
            },
            "sourceReason": format!("{role_name}在自定义世界开局时自带的初始物品。")
        }
    })
}

fn normalize_explicit_starter_category(category: &str) -> String {
    let normalized = category.trim();
    if normalized == "专属物" {
        "专属物品".to_string()
    } else {
        normalized.to_string()
    }
}

fn infer_explicit_starter_slot(category: &str) -> Value {
    match normalize_explicit_starter_category(category).as_str() {
        "武器" => json!("weapon"),
        "护甲" => json!("armor"),
        "饰品" | "稀有品" | "专属物品" => json!("relic"),
        _ => Value::Null,
    }
}

fn merge_inventory_item(items: &mut Vec<Value>, item: Value) {
    let key = format!(
        "{}:{}",
        read_optional_string_field(&item, "category").unwrap_or_default(),
        read_optional_string_field(&item, "name").unwrap_or_default()
    );
    if items.iter().any(|entry| {
        format!(
            "{}:{}",
            read_optional_string_field(entry, "category").unwrap_or_default(),
            read_optional_string_field(entry, "name").unwrap_or_default()
        ) == key
    }) {
        return;
    }
    items.push(item);
}

fn resolve_custom_character_role(profile: &Value, character: &Value) -> Option<Value> {
    read_optional_string_field(character, "id")
        .and_then(|id| find_custom_world_role_by_reference(profile, id.as_str()))
        .or_else(|| {
            read_optional_string_field(character, "name")
                .and_then(|name| find_custom_world_role_by_reference(profile, name.as_str()))
        })
}

fn find_custom_world_role_by_reference(profile: &Value, reference: &str) -> Option<Value> {
    let normalized_reference = normalize_role_reference(reference);
    if normalized_reference.is_empty() {
        return None;
    }
    read_array_field(profile, "storyNpcs")
        .into_iter()
        .chain(read_array_field(profile, "playableNpcs"))
        .find(|role| role_reference_aliases(role).contains(&normalized_reference))
        .cloned()
}

fn resolve_custom_role_id_reference(profile: &Value, reference: &str) -> String {
    find_custom_world_role_by_reference(profile, reference)
        .and_then(|role| read_optional_string_field(&role, "id"))
        .unwrap_or_else(|| reference.trim().to_string())
}

fn do_role_references_match(profile: &Value, left: Option<&str>, right: Option<&str>) -> bool {
    let left = left.map(|value| resolve_custom_role_id_reference(profile, value));
    let right = right.map(|value| resolve_custom_role_id_reference(profile, value));
    matches!((left, right), (Some(left), Some(right)) if !left.is_empty() && left == right)
}

fn role_reference_aliases(role: &Value) -> Vec<String> {
    let name = read_optional_string_field(role, "name").unwrap_or_default();
    let title = read_optional_string_field(role, "title").unwrap_or_default();
    let role_text = read_optional_string_field(role, "role").unwrap_or_default();
    [
        read_optional_string_field(role, "id").unwrap_or_default(),
        name.clone(),
        title.clone(),
        format!("{name}{title}"),
        format!("{title}{name}"),
        format!("{role_text}{name}"),
        format!("{name}{role_text}"),
    ]
    .into_iter()
    .map(|value| normalize_role_reference(value.as_str()))
    .filter(|value| !value.is_empty())
    .collect()
}

fn normalize_role_reference(value: &str) -> String {
    value
        .trim()
        .replace("character-npc-", "")
        .replace("character-npc:", "")
        .replace("playable-", "")
        .replace("story-", "")
        .replace("role-", "")
        .replace("npc-", "")
        .replace([' ', '（', '）', '(', ')'], "")
}

fn read_equipment_total_bonuses(equipment: &Value) -> EquipmentBonusSummary {
    let mut summary = EquipmentBonusSummary::default();
    for slot in ["weapon", "armor", "relic"] {
        let Some(item) = read_field(equipment, slot) else {
            continue;
        };
        let Some(item_object) = item.as_object() else {
            continue;
        };
        if let Some(stat_profile) = item_object.get("statProfile") {
            summary.max_hp_bonus += read_i32_field(stat_profile, "maxHpBonus").unwrap_or(0);
        } else if slot == "armor" {
            summary.max_hp_bonus += 14;
        }
    }
    summary
}

#[derive(Default)]
struct EquipmentBonusSummary {
    max_hp_bonus: i32,
}

fn write_field(target: &mut Value, key: &str, value: Value) {
    let object = ensure_json_object(target);
    object.insert(key.to_string(), value);
}

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

    #[test]
    fn custom_world_bootstrap_builds_opening_act_state_on_server() {
        let payload = RuntimeStoryBootstrapRequest {
            world_type: "CUSTOM".to_string(),
            runtime_mode: Some("play".to_string()),
            disable_persistence: Some(true),
            character: json!({
                "id": "player-1",
                "name": "沈砺",
                "resourceProfile": { "maxHp": 188, "maxMana": 999 },
                "skills": [{ "id": "skill-1" }]
            }),
            custom_world_profile: Some(json!({
                "id": "profile-1",
                "name": "回潮群岛",
                "summary": "潮雾里有旧账。",
                "camp": {
                    "id": "camp-1",
                    "name": "回潮暂栖所",
                    "description": "一间靠海的暂栖所。",
                    "sceneNpcIds": ["story-act-only"]
                },
                "landmarks": [],
                "playableNpcs": [{
                    "id": "player-1",
                    "name": "沈砺",
                    "role": "主角",
                    "initialItems": [{
                        "name": "旧潮短刃",
                        "category": "武器",
                        "quantity": 1,
                        "rarity": "rare",
                        "tags": ["weapon"],
                        "description": "旧账留下的短刃。"
                    }]
                }],
                "storyNpcs": [{
                    "id": "story-act-only",
                    "name": "陆衡",
                    "title": "账房",
                    "role": "守账人",
                    "description": "守着账本的人。",
                    "backstory": "",
                    "personality": "",
                    "motivation": "",
                    "combatStyle": "",
                    "initialAffinity": 12,
                    "relationshipHooks": [],
                    "tags": [],
                    "initialItems": [],
                    "skills": [],
                    "backstoryReveal": { "publicSummary": "", "chapters": [] }
                }],
                "sceneChapterBlueprints": [{
                    "id": "chapter-1",
                    "sceneId": "camp-1",
                    "title": "开局",
                    "linkedLandmarkIds": [],
                    "acts": [{
                        "id": "act-1",
                        "sceneId": "camp-1",
                        "title": "对账",
                        "primaryNpcId": "story-primary-only",
                        "oppositeNpcId": "character-npc-story-act-only",
                        "encounterNpcIds": []
                    }]
                }]
            })),
        };

        let state = build_initial_runtime_game_state(&payload, "runtime-test")
            .expect("bootstrap should build state");

        assert_eq!(state["runtimeSessionId"], json!("runtime-test"));
        assert_eq!(state["currentScene"], json!("Story"));
        assert_eq!(
            state["currentScenePreset"]["id"],
            json!("custom-scene-camp")
        );
        assert_eq!(
            state["storyEngineMemory"]["currentSceneActState"]["currentActId"],
            json!("act-1")
        );
        assert_eq!(state["currentEncounter"]["id"], json!("story-act-only"));
        assert_eq!(state["playerInventory"][0]["name"], json!("旧潮短刃"));
        assert_eq!(
            state["playerEquipment"]["weapon"]["name"],
            json!("旧潮短刃")
        );
    }
}