use serde_json::{Map, Value, json};

use shared_contracts::{
    runtime_story::{
        RuntimeBattlePresentation, RuntimeStoryActionRequest, RuntimeStoryChoiceAction,
        RuntimeStoryOptionView, RuntimeStoryPatch, RuntimeStoryPresentation, RuntimeStoryViewModel,
    },
    story::{ResolveStoryRuntimeActionRequest, StoryRuntimeSnapshotPayload},
};

use crate::{
    CONTINUE_ADVENTURE_FUNCTION_ID, StoryResolution, add_inventory_items_to_list,
    append_story_history, apply_equipment_loadout_to_state, build_battle_runtime_story_options,
    build_current_build_toast, build_npc_gift_result_text,
    build_runtime_story_option_from_story_option, build_runtime_story_view_model,
    build_static_runtime_story_option, build_status_patch, build_story_option_from_runtime_option,
    clear_encounter_state, clone_inventory_item_with_quantity, current_encounter_name,
    ensure_json_object, find_player_inventory_entry, normalize_equipment_slot_id,
    normalize_required_string, npc_buyback_price, npc_purchase_price,
    project_story_engine_after_action, read_array_field, read_bool_field, read_field,
    read_i32_field, read_inventory_item_name, read_object_field, read_optional_string_field,
    read_player_equipment_item, read_player_inventory_values, read_runtime_session_id,
    read_u32_field, recruit_companion_to_party, remove_inventory_item_from_list,
    resolve_action_text, resolve_battle_action, resolve_equipment_slot_for_item,
    resolve_forge_craft_action, resolve_forge_dismantle_action, resolve_forge_reforge_action,
    resolve_npc_gift_affinity_gain, restore_player_resource, simple_story_resolution,
    write_bool_field, write_i32_field, write_null_field, write_player_equipment_item,
    write_player_inventory_values, write_runtime_npc_interaction_view, write_string_field,
    write_u32_field,
};

const NPC_RECRUIT_AFFINITY: i32 = 60;

pub struct StoryRuntimeActionResolveInput {
    pub story_session_id: String,
    pub runtime_session_id: String,
    pub snapshot: StoryRuntimeSnapshotPayload,
    pub request: ResolveStoryRuntimeActionRequest,
}

#[derive(Debug)]
pub struct StoryRuntimeActionResolveOutput {
    pub server_version: u32,
    pub narrative_text: String,
    pub choice_function_id: Option<String>,
    pub view_model: RuntimeStoryViewModel,
    pub presentation: RuntimeStoryPresentation,
    pub patches: Vec<RuntimeStoryPatch>,
    pub snapshot: StoryRuntimeSnapshotPayload,
}

/// 结算 story-session scoped runtime action。
///
/// 中文注释：该函数不访问 HTTP、AppState 或 SpacetimeDB，只消费服务端快照并输出下一版快照。
pub fn resolve_story_runtime_action(
    input: StoryRuntimeActionResolveInput,
) -> Result<StoryRuntimeActionResolveOutput, String> {
    validate_action_request(&input.request)?;
    let requested_story_session_id = normalize_required_string(input.story_session_id.as_str())
        .ok_or_else(|| "storySessionId 不能为空".to_string())?;
    let requested_runtime_session_id = normalize_required_string(input.runtime_session_id.as_str())
        .ok_or_else(|| "runtimeSessionId 不能为空".to_string())?;
    let function_id = normalize_required_string(input.request.function_id.as_str())
        .ok_or_else(|| "action.functionId 不能为空".to_string())?;
    let mut snapshot = input.snapshot;
    let current_snapshot_runtime_id =
        read_runtime_session_id(&snapshot.game_state).ok_or_else(|| {
            "runtime snapshot 缺少 runtimeSessionId，无法执行 story action".to_string()
        })?;
    if current_snapshot_runtime_id != requested_runtime_session_id {
        return Err("runtime snapshot 与 story session 不匹配".to_string());
    }

    ensure_json_object(&mut snapshot.game_state).insert(
        "storySessionId".to_string(),
        Value::String(requested_story_session_id),
    );
    let previous_game_state = snapshot.game_state.clone();
    let current_story_before = snapshot.current_story.clone();
    let mut game_state = snapshot.game_state.clone();
    let request =
        runtime_action_request_from_story_request(&requested_runtime_session_id, input.request);
    let mut resolution = resolve_runtime_story_choice_action(
        &mut game_state,
        current_story_before.as_ref(),
        &request,
        function_id.as_str(),
    )?;

    let server_version = read_u32_field(&game_state, "runtimeActionVersion")
        .unwrap_or(0)
        .saturating_add(1);
    write_u32_field(&mut game_state, "runtimeActionVersion", server_version);
    write_string_field(
        &mut game_state,
        "runtimeSessionId",
        requested_runtime_session_id.as_str(),
    );

    let mut options = resolution
        .presentation_options
        .take()
        .unwrap_or_else(|| build_fallback_runtime_story_options(&game_state));
    if options.is_empty() {
        options = build_fallback_runtime_story_options(&game_state);
    }

    let story_text = resolution
        .story_text
        .clone()
        .unwrap_or_else(|| resolution.result_text.clone());
    let history_result_text = resolution.result_text.clone();
    let saved_current_story = resolution
        .saved_current_story
        .take()
        .unwrap_or_else(|| build_current_story(story_text.as_str(), &options));

    append_story_history(
        &mut game_state,
        resolution.action_text.as_str(),
        history_result_text.as_str(),
    );
    project_story_engine_after_action(
        &previous_game_state,
        &mut game_state,
        resolution.action_text.as_str(),
        history_result_text.as_str(),
        function_id.as_str(),
        resolution
            .battle
            .as_ref()
            .and_then(|battle| battle.outcome.as_deref()),
    );

    let mut patches = vec![RuntimeStoryPatch::StoryHistoryAppend {
        action_text: resolution.action_text.clone(),
        result_text: history_result_text.clone(),
    }];
    patches.extend(resolution.patches);

    snapshot.saved_at = None;
    snapshot.game_state = game_state;
    snapshot.current_story = Some(saved_current_story);
    write_runtime_npc_interaction_view(&mut snapshot.game_state);

    let view_model = build_runtime_story_view_model(&snapshot.game_state, &options);
    let presentation = RuntimeStoryPresentation {
        action_text: resolution.action_text,
        result_text: resolution.result_text,
        story_text: story_text.clone(),
        options,
        toast: resolution.toast,
        battle: resolution.battle,
    };

    Ok(StoryRuntimeActionResolveOutput {
        server_version,
        narrative_text: story_text,
        choice_function_id: Some(function_id),
        view_model,
        presentation,
        patches,
        snapshot,
    })
}

fn validate_action_request(request: &ResolveStoryRuntimeActionRequest) -> Result<(), String> {
    if normalize_required_string(request.function_id.as_str()).is_none() {
        return Err("action.functionId 不能为空".to_string());
    }
    if normalize_required_string(request.action_text.as_str()).is_none() {
        return Err("actionText 不能为空".to_string());
    }
    Ok(())
}

fn runtime_action_request_from_story_request(
    runtime_session_id: &str,
    request: ResolveStoryRuntimeActionRequest,
) -> RuntimeStoryActionRequest {
    let mut payload = request.payload.unwrap_or_else(|| json!({}));
    if let Some(object) = payload.as_object_mut() {
        object
            .entry("optionText".to_string())
            .or_insert_with(|| Value::String(request.action_text.clone()));
    } else {
        payload = json!({ "optionText": request.action_text });
    }

    RuntimeStoryActionRequest {
        session_id: runtime_session_id.to_string(),
        client_version: request.client_version,
        action: RuntimeStoryChoiceAction {
            action_type: "story_choice".to_string(),
            function_id: request.function_id,
            target_id: request.target_id,
            payload: Some(payload),
        },
    }
}

fn resolve_runtime_story_choice_action(
    game_state: &mut Value,
    current_story: Option<&Value>,
    request: &RuntimeStoryActionRequest,
    function_id: &str,
) -> Result<StoryResolution, String> {
    match function_id {
        CONTINUE_ADVENTURE_FUNCTION_ID => resolve_continue_adventure_action(current_story),
        "idle_call_out" => Ok(simple_story_resolution(
            game_state,
            resolve_action_text("主动出声试探", request),
            "你的喊话打破了当前静场，周围潜着的动静也更难继续藏住。",
        )),
        "idle_explore_forward" => Ok(simple_story_resolution(
            game_state,
            resolve_action_text("继续向前探索", request),
            "你没有停在原地，而是继续向前压，把下一段遭遇主动推到自己面前。",
        )),
        "idle_observe_signs" => Ok(simple_story_resolution(
            game_state,
            resolve_action_text("观察周围迹象", request),
            "你先压住动作，把风向、脚印和气味这些细节重新读了一遍。",
        )),
        "idle_rest_focus" => {
            restore_player_resource(game_state, 8, 6);
            Ok(simple_story_resolution(
                game_state,
                resolve_action_text("原地调息", request),
                "你把呼吸慢下来重新稳住节奏，生命和灵力都回上来一点。",
            ))
        }
        "npc_leave" => {
            let npc_name = current_encounter_name(game_state);
            clear_encounter_state(game_state);
            Ok(StoryResolution {
                action_text: resolve_action_text("离开当前角色", request),
                result_text: format!("你结束了与 {npc_name} 的这一轮接触，把注意力重新放回旅途。"),
                story_text: None,
                presentation_options: None,
                saved_current_story: None,
                patches: vec![
                    build_status_patch(game_state),
                    RuntimeStoryPatch::EncounterChanged { encounter_id: None },
                ],
                battle: None,
                toast: None,
            })
        }
        "npc_preview_talk" => resolve_npc_preview_talk_action(game_state, request),
        "npc_chat" | "story_opening_camp_dialogue" => resolve_npc_chat_action(game_state, request),
        "npc_help" => resolve_npc_help_action(game_state, request),
        "npc_recruit" => resolve_npc_recruit_action(game_state, request),
        "npc_trade" => resolve_npc_trade_action(game_state, request),
        "npc_gift" => resolve_npc_gift_action(game_state, request),
        "npc_fight" | "npc_spar" => {
            resolve_npc_battle_start_action(game_state, request, function_id)
        }
        "npc_chat_quest_offer_view" => resolve_npc_quest_offer_view_action(game_state, request),
        "npc_chat_quest_offer_replace" => {
            resolve_npc_quest_offer_replace_action(game_state, request)
        }
        "npc_chat_quest_offer_abandon" => {
            resolve_npc_quest_offer_abandon_action(game_state, request)
        }
        "npc_quest_accept" => resolve_npc_quest_accept_action(current_story, game_state, request),
        "npc_quest_turn_in" => resolve_npc_quest_turn_in_action(game_state, request),
        "equipment_equip" => resolve_equipment_equip_action(game_state, request),
        "equipment_unequip" => resolve_equipment_unequip_action(game_state, request),
        "forge_craft" => resolve_forge_craft_action(game_state, request),
        "forge_dismantle" => resolve_forge_dismantle_action(game_state, request),
        "forge_reforge" => resolve_forge_reforge_action(game_state, request),
        "battle_attack_basic"
        | "battle_use_skill"
        | "battle_all_in_crush"
        | "battle_escape_breakout"
        | "battle_feint_step"
        | "battle_finisher_window"
        | "battle_guard_break"
        | "battle_probe_pressure"
        | "battle_recover_breath"
        | "inventory_use" => resolve_battle_action(game_state, request, function_id),
        _ => Err(format!("暂不支持的 runtime action：{function_id}")),
    }
}

fn resolve_continue_adventure_action(
    current_story: Option<&Value>,
) -> Result<StoryResolution, String> {
    let deferred_options = current_story
        .map(|story| {
            read_array_field(story, "deferredOptions")
                .into_iter()
                .filter_map(build_runtime_story_option_from_story_option)
                .collect::<Vec<_>>()
        })
        .unwrap_or_default();
    let options = (!deferred_options.is_empty()).then_some(deferred_options);

    Ok(StoryResolution {
        action_text: "继续推进冒险".to_string(),
        result_text: "你没有把节奏停下来，而是顺着当前局势继续向前推进了这一段故事。".to_string(),
        story_text: None,
        presentation_options: options,
        saved_current_story: None,
        patches: Vec::new(),
        battle: None,
        toast: None,
    })
}

fn resolve_npc_preview_talk_action(
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
) -> Result<StoryResolution, String> {
    let npc = current_npc_context(game_state)?;
    write_bool_field(game_state, "npcInteractionActive", true);
    let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
    let previous_affinity = read_i32_field(state, "affinity").unwrap_or(0);
    increment_npc_state_i32_field(state, "chattedCount", 1);
    write_bool_field(state, "firstMeaningfulContactResolved", true);
    adjust_npc_affinity_state(state, 2, "npc_chat");
    let next_affinity = read_i32_field(state, "affinity").unwrap_or(previous_affinity);
    write_runtime_npc_interaction_view(game_state);

    Ok(StoryResolution {
        action_text: resolve_action_text(&format!("转向{}", npc.name), request),
        result_text: format!(
            "你把注意力转向 {name}，这一轮交流已经正式接上。",
            name = npc.name
        ),
        story_text: None,
        presentation_options: Some(build_npc_interaction_options(npc.id.as_str())),
        saved_current_story: None,
        patches: vec![
            RuntimeStoryPatch::NpcAffinityChanged {
                npc_id: npc.id,
                previous_affinity,
                next_affinity,
            },
            build_status_patch(game_state),
        ],
        battle: None,
        toast: Some("已进入角色交互".to_string()),
    })
}

fn resolve_npc_chat_action(
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
) -> Result<StoryResolution, String> {
    let npc = current_npc_context(game_state)?;
    write_bool_field(game_state, "npcInteractionActive", true);
    let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
    let previous_affinity = read_i32_field(state, "affinity").unwrap_or(0);
    increment_npc_state_i32_field(state, "chattedCount", 1);
    write_bool_field(state, "firstMeaningfulContactResolved", true);
    adjust_npc_affinity_state(state, 4, "npc_chat");
    let next_affinity = read_i32_field(state, "affinity").unwrap_or(previous_affinity);
    write_runtime_npc_interaction_view(game_state);

    Ok(StoryResolution {
        action_text: resolve_action_text(&format!("和{}继续交谈", npc.name), request),
        result_text: format!(
            "{name} 接住了你的话头，态度比刚才更松动了一些。",
            name = npc.name
        ),
        story_text: None,
        presentation_options: Some(build_npc_interaction_options(npc.id.as_str())),
        saved_current_story: None,
        patches: vec![
            RuntimeStoryPatch::NpcAffinityChanged {
                npc_id: npc.id,
                previous_affinity,
                next_affinity,
            },
            build_status_patch(game_state),
        ],
        battle: None,
        toast: Some(format!("{} 好感 +4", npc.name)),
    })
}

fn resolve_npc_help_action(
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
) -> Result<StoryResolution, String> {
    let npc = current_npc_context(game_state)?;
    write_bool_field(game_state, "npcInteractionActive", true);
    let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
    let previous_affinity = read_i32_field(state, "affinity").unwrap_or(0);
    let help_used = read_bool_field(state, "helpUsed").unwrap_or(false);
    if help_used {
        return Err(format!("{} 本轮已经帮过你。", npc.name));
    }
    write_bool_field(state, "helpUsed", true);
    adjust_npc_affinity_state(state, 8, "npc_help");
    let next_affinity = read_i32_field(state, "affinity").unwrap_or(previous_affinity);

    Ok(StoryResolution {
        action_text: resolve_action_text(&format!("请求{}援手", npc.name), request),
        result_text: format!("{name} 衡量片刻后点头帮你搭了一把手。", name = npc.name),
        story_text: None,
        presentation_options: Some(build_npc_interaction_options(npc.id.as_str())),
        saved_current_story: None,
        patches: vec![
            RuntimeStoryPatch::NpcAffinityChanged {
                npc_id: npc.id,
                previous_affinity,
                next_affinity,
            },
            build_status_patch(game_state),
        ],
        battle: None,
        toast: Some(format!("{} 好感 +8", npc.name)),
    })
}

fn resolve_npc_recruit_action(
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
) -> Result<StoryResolution, String> {
    let npc = current_npc_context(game_state)?;
    write_bool_field(game_state, "npcInteractionActive", true);
    let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
    let affinity = read_i32_field(state, "affinity").unwrap_or(0);
    if affinity < NPC_RECRUIT_AFFINITY {
        return Err(format!("{} 当前好感不足，暂时不能招募入队。", npc.name));
    }
    let release_npc_id = request
        .action
        .payload
        .as_ref()
        .and_then(|payload| read_optional_string_field(payload, "releaseNpcId"));
    let released_name = recruit_companion_to_party(
        game_state,
        npc.id.as_str(),
        affinity,
        release_npc_id.as_deref(),
    )?;
    let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
    write_bool_field(state, "recruited", true);
    adjust_npc_stance_for_action(state, "npc_recruit", 0, true);
    let release_text = released_name
        .map(|name| format!("，{name} 暂时离队"))
        .unwrap_or_default();

    Ok(StoryResolution {
        action_text: resolve_action_text(&format!("邀请{}入队", npc.name), request),
        result_text: format!("{} 正式答应与你同行{release_text}。", npc.name),
        story_text: None,
        presentation_options: Some(build_npc_interaction_options(npc.id.as_str())),
        saved_current_story: None,
        patches: vec![build_status_patch(game_state)],
        battle: None,
        toast: Some(format!("{} 已加入队伍", npc.name)),
    })
}

fn resolve_npc_trade_action(
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
) -> Result<StoryResolution, String> {
    let npc = current_npc_context(game_state)?;
    let payload = request
        .action
        .payload
        .as_ref()
        .ok_or_else(|| "npc_trade 缺少 payload".to_string())?;
    let mode = read_optional_string_field(payload, "mode")
        .ok_or_else(|| "npc_trade 缺少 mode".to_string())?;
    let item_id = read_optional_string_field(payload, "itemId")
        .ok_or_else(|| "npc_trade 缺少 itemId".to_string())?;
    let quantity = read_i32_field(payload, "quantity").unwrap_or(1).max(1);
    let affinity = {
        let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
        read_i32_field(state, "affinity").unwrap_or(0)
    };
    let (item_name, total_price, result_text) = if mode == "buy" {
        let item = {
            let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
            find_npc_inventory_item(state, item_id.as_str())
                .ok_or_else(|| "NPC 库存中没有目标物品。".to_string())?
        };
        let stock = read_i32_field(&item, "quantity").unwrap_or(0).max(0);
        if stock < quantity {
            return Err("NPC 库存不足。".to_string());
        }
        let unit_price = npc_purchase_price(&item, affinity);
        let total_price = unit_price.saturating_mul(quantity);
        let currency = read_i32_field(game_state, "playerCurrency")
            .unwrap_or(0)
            .max(0);
        if currency < total_price {
            return Err("当前钱币不足。".to_string());
        }
        let item_name = read_inventory_item_name(&item);
        let next_npc_inventory = {
            let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
            remove_inventory_item_from_list(
                read_npc_inventory_values(state),
                item_id.as_str(),
                quantity,
            )
        };
        let next_player_inventory = add_inventory_items_to_list(
            read_player_inventory_values(game_state),
            vec![clone_inventory_item_with_quantity(&item, quantity)],
        );
        write_i32_field(game_state, "playerCurrency", currency - total_price);
        write_player_inventory_values(game_state, next_player_inventory);
        let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
        write_npc_inventory_values(state, next_npc_inventory);
        (
            item_name.clone(),
            total_price,
            format!(
                "你从 {} 手中买下{}{}，花费 {}。",
                npc.name,
                item_name,
                trade_quantity_suffix_local(quantity),
                total_price
            ),
        )
    } else if mode == "sell" {
        let item = find_player_inventory_entry(game_state, item_id.as_str())
            .cloned()
            .ok_or_else(|| "背包里没有目标物品。".to_string())?;
        let owned = read_i32_field(&item, "quantity").unwrap_or(0).max(0);
        if owned < quantity {
            return Err("背包数量不足。".to_string());
        }
        let unit_price = npc_buyback_price(&item, affinity);
        let total_price = unit_price.saturating_mul(quantity);
        let item_name = read_inventory_item_name(&item);
        let currency = read_i32_field(game_state, "playerCurrency")
            .unwrap_or(0)
            .max(0);
        let next_player_inventory = remove_inventory_item_from_list(
            read_player_inventory_values(game_state),
            item_id.as_str(),
            quantity,
        );
        let next_npc_inventory = {
            let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
            add_inventory_items_to_list(
                read_npc_inventory_values(state),
                vec![clone_inventory_item_with_quantity(&item, quantity)],
            )
        };
        write_i32_field(game_state, "playerCurrency", currency + total_price);
        write_player_inventory_values(game_state, next_player_inventory);
        let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
        write_npc_inventory_values(state, next_npc_inventory);
        (
            item_name.clone(),
            total_price,
            format!(
                "你把{}{}交给 {}，换回 {}。",
                item_name,
                trade_quantity_suffix_local(quantity),
                npc.name,
                total_price
            ),
        )
    } else {
        return Err("npc_trade.mode 只支持 buy 或 sell".to_string());
    };
    write_runtime_npc_interaction_view(game_state);

    Ok(StoryResolution {
        action_text: resolve_action_text(&format!("与{}交易", npc.name), request),
        result_text,
        story_text: None,
        presentation_options: Some(build_npc_interaction_options(npc.id.as_str())),
        saved_current_story: None,
        patches: vec![build_status_patch(game_state)],
        battle: None,
        toast: Some(format!("{item_name} 交易完成，金额 {total_price}")),
    })
}

fn resolve_npc_gift_action(
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
) -> Result<StoryResolution, String> {
    let npc = current_npc_context(game_state)?;
    let item_id = request
        .action
        .payload
        .as_ref()
        .and_then(|payload| read_optional_string_field(payload, "itemId"))
        .ok_or_else(|| "npc_gift 缺少 itemId".to_string())?;
    let item = find_player_inventory_entry(game_state, item_id.as_str())
        .cloned()
        .ok_or_else(|| "背包里没有目标礼物。".to_string())?;
    if read_i32_field(&item, "quantity").unwrap_or(0) <= 0 {
        return Err("背包里没有目标礼物。".to_string());
    }
    write_player_inventory_values(
        game_state,
        remove_inventory_item_from_list(
            read_player_inventory_values(game_state),
            item_id.as_str(),
            1,
        ),
    );
    let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
    let previous_affinity = read_i32_field(state, "affinity").unwrap_or(0);
    let affinity_gain = resolve_npc_gift_affinity_gain(&item);
    increment_npc_state_i32_field(state, "giftsGiven", 1);
    adjust_npc_affinity_state(state, affinity_gain, "npc_gift");
    let next_affinity = read_i32_field(state, "affinity").unwrap_or(previous_affinity);
    let result_text =
        build_npc_gift_result_text(npc.name.as_str(), &item, affinity_gain, next_affinity);
    write_runtime_npc_interaction_view(game_state);

    Ok(StoryResolution {
        action_text: resolve_action_text(
            &format!("赠送{}", read_inventory_item_name(&item)),
            request,
        ),
        result_text,
        story_text: None,
        presentation_options: Some(build_npc_interaction_options(npc.id.as_str())),
        saved_current_story: None,
        patches: vec![
            RuntimeStoryPatch::NpcAffinityChanged {
                npc_id: npc.id,
                previous_affinity,
                next_affinity,
            },
            build_status_patch(game_state),
        ],
        battle: None,
        toast: Some(format!("{} 好感 +{}", npc.name, affinity_gain)),
    })
}

fn resolve_npc_battle_start_action(
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
    function_id: &str,
) -> Result<StoryResolution, String> {
    let npc = current_npc_context(game_state)?;
    let mode = if function_id == "npc_spar" {
        "spar"
    } else {
        "fight"
    };
    let target_hp = if mode == "spar" {
        12
    } else {
        read_i32_field(&npc.encounter, "targetMaxHp")
            .or_else(|| read_i32_field(&npc.encounter, "maxHp"))
            .unwrap_or_else(|| {
                80 + read_npc_affinity(game_state, npc.id.as_str(), npc.name.as_str()).max(0)
            })
            .max(12)
    };
    let mut encounter = npc.encounter.clone();
    write_bool_field(&mut encounter, "hostile", true);
    write_i32_field(&mut encounter, "hp", target_hp);
    write_i32_field(&mut encounter, "maxHp", target_hp);
    let hostile = json!({
        "id": format!("npc-opponent-{}", npc.id),
        "name": npc.name,
        "action": if mode == "spar" { "抱拳行礼，准备点到为止地切磋武艺" } else { "摆开架势，随时准备出手" },
        "description": read_optional_string_field(&encounter, "npcDescription").unwrap_or_default(),
        "animation": "idle",
        "xMeters": read_number_field(&encounter, "xMeters").unwrap_or(3.2),
        "yOffset": 0,
        "facing": "left",
        "attackRange": 1.8,
        "speed": 7,
        "hp": target_hp,
        "maxHp": target_hp,
        "renderKind": "npc",
        "levelProfile": read_field(&encounter, "levelProfile").cloned(),
        "experienceReward": read_i32_field(&encounter, "experienceReward").unwrap_or(0).max(0),
        "encounter": encounter
    });
    ensure_json_object(game_state).insert("currentEncounter".to_string(), encounter);
    ensure_json_object(game_state).insert("sceneHostileNpcs".to_string(), json!([hostile]));
    write_bool_field(game_state, "inBattle", true);
    write_bool_field(game_state, "npcInteractionActive", false);
    write_string_field(game_state, "currentBattleNpcId", npc.id.as_str());
    write_string_field(game_state, "currentNpcBattleMode", mode);
    write_null_field(game_state, "currentNpcBattleOutcome");

    Ok(StoryResolution {
        action_text: resolve_action_text(
            if mode == "spar" {
                "点到为止切磋"
            } else {
                "与对方战斗"
            },
            request,
        ),
        result_text: if mode == "spar" {
            format!("{} 与你拉开架势，这场切磋正式开始。", npc.name)
        } else {
            format!("{} 已经进入战斗姿态，你必须立刻应对。", npc.name)
        },
        story_text: None,
        presentation_options: Some(build_battle_runtime_story_options(game_state)),
        saved_current_story: None,
        patches: vec![build_status_patch(game_state)],
        battle: Some(RuntimeBattlePresentation {
            target_id: Some(npc.id),
            target_name: Some(npc.name),
            damage_dealt: Some(0),
            damage_taken: Some(0),
            outcome: Some("ongoing".to_string()),
        }),
        toast: Some(
            if mode == "spar" {
                "切磋开始"
            } else {
                "战斗开始"
            }
            .to_string(),
        ),
    })
}

fn resolve_npc_quest_offer_view_action(
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
) -> Result<StoryResolution, String> {
    let npc = current_npc_context(game_state)?;
    Ok(StoryResolution {
        action_text: resolve_action_text("查看委托", request),
        result_text: format!("你把 {} 提到的委托细节重新梳理了一遍。", npc.name),
        story_text: None,
        presentation_options: Some(build_npc_interaction_options(npc.id.as_str())),
        saved_current_story: None,
        patches: vec![build_status_patch(game_state)],
        battle: None,
        toast: None,
    })
}

fn resolve_npc_quest_offer_replace_action(
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
) -> Result<StoryResolution, String> {
    let npc = current_npc_context(game_state)?;
    let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
    adjust_npc_affinity_state(state, 2, "npc_chat");
    Ok(StoryResolution {
        action_text: resolve_action_text("更换委托", request),
        result_text: format!(
            "{} 收回原本的委托，换成了一件更适合你眼下处境的事。",
            npc.name
        ),
        story_text: None,
        presentation_options: Some(build_npc_interaction_options(npc.id.as_str())),
        saved_current_story: None,
        patches: vec![build_status_patch(game_state)],
        battle: None,
        toast: Some("委托已更换".to_string()),
    })
}

fn resolve_npc_quest_offer_abandon_action(
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
) -> Result<StoryResolution, String> {
    let npc = current_npc_context(game_state)?;
    Ok(StoryResolution {
        action_text: resolve_action_text("暂不接下委托", request),
        result_text: format!(
            "你暂时没有接下 {} 提出的委托，对方也没有继续强求。",
            npc.name
        ),
        story_text: None,
        presentation_options: Some(build_npc_interaction_options(npc.id.as_str())),
        saved_current_story: None,
        patches: vec![build_status_patch(game_state)],
        battle: None,
        toast: Some("已暂缓委托".to_string()),
    })
}

fn resolve_npc_quest_accept_action(
    current_story: Option<&Value>,
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
) -> Result<StoryResolution, String> {
    let npc = current_npc_context(game_state)?;
    let quest = request
        .action
        .payload
        .as_ref()
        .and_then(|payload| read_field(payload, "quest").cloned())
        .or_else(|| pending_quest_offer_quest(current_story))
        .unwrap_or_else(|| build_fallback_npc_quest(&npc));
    upsert_runtime_quest(game_state, quest);
    let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
    let previous_affinity = read_i32_field(state, "affinity").unwrap_or(0);
    adjust_npc_affinity_state(state, 5, "npc_quest_accept");
    let next_affinity = read_i32_field(state, "affinity").unwrap_or(previous_affinity);
    increment_runtime_stat_local(game_state, "questsAccepted", 1);

    Ok(StoryResolution {
        action_text: resolve_action_text(&format!("接下{}的委托", npc.name), request),
        result_text: format!(
            "你接下了 {} 交出的委托，这条线索已经写入当前任务。",
            npc.name
        ),
        story_text: None,
        presentation_options: Some(build_npc_interaction_options(npc.id.as_str())),
        saved_current_story: None,
        patches: vec![
            RuntimeStoryPatch::NpcAffinityChanged {
                npc_id: npc.id,
                previous_affinity,
                next_affinity,
            },
            build_status_patch(game_state),
        ],
        battle: None,
        toast: Some("已接取委托".to_string()),
    })
}

fn resolve_npc_quest_turn_in_action(
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
) -> Result<StoryResolution, String> {
    let npc = current_npc_context(game_state)?;
    let quest_id = request
        .action
        .payload
        .as_ref()
        .and_then(|payload| read_optional_string_field(payload, "questId"))
        .or_else(|| request.action.target_id.clone())
        .or_else(|| active_quest_id_for_npc(game_state, npc.id.as_str(), npc.name.as_str()))
        .ok_or_else(|| "未找到可交付的委托。".to_string())?;
    mark_quest_turned_in(game_state, quest_id.as_str())?;
    let state = ensure_npc_state(game_state, npc.id.as_str(), npc.name.as_str());
    let previous_affinity = read_i32_field(state, "affinity").unwrap_or(0);
    adjust_npc_affinity_state(state, 10, "npc_help");
    let next_affinity = read_i32_field(state, "affinity").unwrap_or(previous_affinity);

    Ok(StoryResolution {
        action_text: resolve_action_text("交付委托", request),
        result_text: format!("你把委托结果交给 {}，这件事暂时收束。", npc.name),
        story_text: None,
        presentation_options: Some(build_npc_interaction_options(npc.id.as_str())),
        saved_current_story: None,
        patches: vec![
            RuntimeStoryPatch::NpcAffinityChanged {
                npc_id: npc.id,
                previous_affinity,
                next_affinity,
            },
            build_status_patch(game_state),
        ],
        battle: None,
        toast: Some("委托已交付".to_string()),
    })
}

fn resolve_equipment_equip_action(
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
) -> Result<StoryResolution, String> {
    if read_bool_field(game_state, "inBattle").unwrap_or(false) {
        return Err("战斗中无法更换装备。".to_string());
    }
    let item_id = request
        .action
        .payload
        .as_ref()
        .and_then(|payload| read_optional_string_field(payload, "itemId"))
        .or_else(|| request.action.target_id.clone())
        .ok_or_else(|| "equipment_equip 缺少 itemId".to_string())?;
    let item = find_player_inventory_entry(game_state, item_id.as_str())
        .cloned()
        .ok_or_else(|| "背包里没有目标装备。".to_string())?;
    if read_i32_field(&item, "quantity").unwrap_or(0) <= 0 {
        return Err("背包里没有目标装备。".to_string());
    }
    let slot_id =
        resolve_equipment_slot_for_item(&item).ok_or_else(|| "该物品不能装备。".to_string())?;
    let previous_item = read_player_equipment_item(game_state, slot_id);
    let mut next_inventory = remove_inventory_item_from_list(
        read_player_inventory_values(game_state),
        item_id.as_str(),
        1,
    );
    if let Some(previous_item) = previous_item {
        next_inventory = add_inventory_items_to_list(next_inventory, vec![previous_item]);
    }
    write_player_inventory_values(game_state, next_inventory);
    write_player_equipment_item(
        game_state,
        slot_id,
        Some(clone_inventory_item_with_quantity(&item, 1)),
    );
    apply_equipment_loadout_to_state(game_state);

    Ok(StoryResolution {
        action_text: resolve_action_text(
            &format!("装备{}", read_inventory_item_name(&item)),
            request,
        ),
        result_text: format!(
            "你换上了{}，当前 Build 已经重新结算。",
            read_inventory_item_name(&item)
        ),
        story_text: None,
        presentation_options: None,
        saved_current_story: None,
        patches: vec![build_status_patch(game_state)],
        battle: None,
        toast: Some(build_current_build_toast(game_state)),
    })
}

fn resolve_equipment_unequip_action(
    game_state: &mut Value,
    request: &RuntimeStoryActionRequest,
) -> Result<StoryResolution, String> {
    if read_bool_field(game_state, "inBattle").unwrap_or(false) {
        return Err("战斗中无法更换装备。".to_string());
    }
    let slot_id = request
        .action
        .payload
        .as_ref()
        .and_then(|payload| read_optional_string_field(payload, "slotId"))
        .or_else(|| request.action.target_id.clone())
        .and_then(|value| normalize_equipment_slot_id(value.as_str()).map(str::to_string))
        .ok_or_else(|| "equipment_unequip 缺少合法 slotId".to_string())?;
    let item = read_player_equipment_item(game_state, slot_id.as_str())
        .ok_or_else(|| "目标装备槽当前为空。".to_string())?;
    write_player_equipment_item(game_state, slot_id.as_str(), None);
    write_player_inventory_values(
        game_state,
        add_inventory_items_to_list(read_player_inventory_values(game_state), vec![item.clone()]),
    );
    apply_equipment_loadout_to_state(game_state);

    Ok(StoryResolution {
        action_text: resolve_action_text(
            &format!("卸下{}", read_inventory_item_name(&item)),
            request,
        ),
        result_text: format!(
            "你卸下了{}，当前 Build 已经重新结算。",
            read_inventory_item_name(&item)
        ),
        story_text: None,
        presentation_options: None,
        saved_current_story: None,
        patches: vec![build_status_patch(game_state)],
        battle: None,
        toast: Some(build_current_build_toast(game_state)),
    })
}

#[derive(Clone, Debug)]
struct CurrentNpcContext {
    id: String,
    name: String,
    encounter: Value,
}

fn current_npc_context(game_state: &Value) -> Result<CurrentNpcContext, String> {
    let encounter = read_object_field(game_state, "currentEncounter")
        .ok_or_else(|| "当前没有可交互角色。".to_string())?;
    let name = read_optional_string_field(encounter, "npcName")
        .or_else(|| read_optional_string_field(encounter, "name"))
        .unwrap_or_else(|| "当前角色".to_string());
    let id = read_optional_string_field(encounter, "id").unwrap_or_else(|| name.clone());

    Ok(CurrentNpcContext {
        id,
        name,
        encounter: encounter.clone(),
    })
}

fn ensure_npc_state<'a>(game_state: &'a mut Value, npc_id: &str, npc_name: &str) -> &'a mut Value {
    let root = ensure_json_object(game_state);
    let npc_states = root
        .entry("npcStates".to_string())
        .or_insert_with(|| Value::Object(Map::new()));
    if !npc_states.is_object() {
        *npc_states = Value::Object(Map::new());
    }
    let states = npc_states
        .as_object_mut()
        .expect("npcStates should be object");
    let state_key = if states.contains_key(npc_id) {
        npc_id.to_string()
    } else if states.contains_key(npc_name) {
        npc_name.to_string()
    } else {
        npc_id.to_string()
    };
    states
        .entry(state_key)
        .or_insert_with(|| build_default_npc_state(npc_name))
}

fn build_default_npc_state(npc_name: &str) -> Value {
    let _ = npc_name;
    let affinity = 18;
    json!({
        "affinity": affinity,
        "chattedCount": 0,
        "helpUsed": false,
        "giftsGiven": 0,
        "inventory": [],
        "recruited": false,
        "relationState": relation_state_value(affinity),
        "revealedFacts": [],
        "knownAttributeRumors": [],
        "firstMeaningfulContactResolved": false,
        "seenBackstoryChapterIds": [],
        "tradeStockSignature": Value::Null,
        "stanceProfile": initial_stance_profile_value(affinity, false, false, "")
    })
}

fn read_npc_affinity(game_state: &mut Value, npc_id: &str, npc_name: &str) -> i32 {
    let state = ensure_npc_state(game_state, npc_id, npc_name);
    read_i32_field(state, "affinity").unwrap_or(0)
}

fn adjust_npc_affinity_state(state: &mut Value, delta: i32, action: &str) {
    let previous = read_i32_field(state, "affinity").unwrap_or(0);
    let next = previous.saturating_add(delta).clamp(-40, 100);
    write_i32_field(state, "affinity", next);
    ensure_json_object(state).insert("relationState".to_string(), relation_state_value(next));
    adjust_npc_stance_for_action(state, action, delta, false);
}

fn relation_state_value(affinity: i32) -> Value {
    json!({
        "affinity": affinity,
        "stance": relation_stance_key(affinity)
    })
}

fn relation_stance_key(affinity: i32) -> &'static str {
    if affinity < 0 {
        "hostile"
    } else if affinity < 15 {
        "guarded"
    } else if affinity < 30 {
        "neutral"
    } else if affinity < 60 {
        "cooperative"
    } else {
        "bonded"
    }
}

fn initial_stance_profile_value(
    affinity: i32,
    recruited: bool,
    hostile: bool,
    role_text: &str,
) -> Value {
    json!({
        "trust": clamp_stance_metric(42 + affinity * 55 / 100 + if recruited { 14 } else { 0 } - if hostile { 18 } else { 0 }),
        "warmth": clamp_stance_metric(36 + affinity / 2 + if recruited { 14 } else { 0 }),
        "ideologicalFit": clamp_stance_metric(48 + affinity / 4),
        "fearOrGuard": clamp_stance_metric(62 - affinity * 55 / 100 + if hostile { 18 } else { 0 }),
        "loyalty": clamp_stance_metric(24 + affinity * 35 / 100 + if recruited { 26 } else { 0 }),
        "currentConflictTag": infer_current_conflict_tag(role_text),
        "recentApprovals": [],
        "recentDisapprovals": []
    })
}

fn infer_current_conflict_tag(role_text: &str) -> Value {
    if role_text.contains("旧案") || role_text.contains("调查") || role_text.contains("追查")
    {
        json!("旧案")
    } else if role_text.contains('守') || role_text.contains('卫') || role_text.contains('巡') {
        json!("守线")
    } else if role_text.contains('商') || role_text.contains('摊') || role_text.contains("军需")
    {
        json!("交易")
    } else {
        Value::Null
    }
}

fn adjust_npc_stance_for_action(
    state: &mut Value,
    action: &str,
    affinity_gain: i32,
    recruited: bool,
) {
    let affinity = read_i32_field(state, "affinity").unwrap_or(0);
    let role_text = read_optional_string_field(state, "role").unwrap_or_default();
    let stance = ensure_json_object(state)
        .entry("stanceProfile".to_string())
        .or_insert_with(|| {
            initial_stance_profile_value(affinity, recruited, affinity < 0, role_text.as_str())
        });
    if !stance.is_object() {
        *stance =
            initial_stance_profile_value(affinity, recruited, affinity < 0, role_text.as_str());
    }
    let stance = stance
        .as_object_mut()
        .expect("stanceProfile should be object");

    match action {
        "npc_chat" => {
            bump_stance_metric(stance, "trust", 6 + affinity_gain * 2);
            bump_stance_metric(stance, "warmth", 4 + affinity_gain * 2);
            bump_stance_metric(stance, "fearOrGuard", -5 - affinity_gain);
            append_stance_note(
                stance,
                "recentApprovals",
                "你愿意先从眼前局势和试探开始说话。",
            );
        }
        "npc_help" => {
            bump_stance_metric(stance, "trust", 12);
            bump_stance_metric(stance, "warmth", 6);
            bump_stance_metric(stance, "fearOrGuard", -8);
            append_stance_note(stance, "recentApprovals", "你在对方需要的时候搭了手。");
        }
        "npc_gift" => {
            bump_stance_metric(stance, "trust", 6 + affinity_gain);
            bump_stance_metric(stance, "warmth", 10 + affinity_gain * 2);
            bump_stance_metric(stance, "fearOrGuard", -4);
            append_stance_note(
                stance,
                "recentApprovals",
                "你给出的东西回应了对方眼下的处境。",
            );
        }
        "npc_recruit" => {
            bump_stance_metric(stance, "trust", 8);
            bump_stance_metric(stance, "warmth", 6);
            bump_stance_metric(stance, "loyalty", 18);
            bump_stance_metric(stance, "fearOrGuard", -10);
            append_stance_note(stance, "recentApprovals", "你正式把对方纳入了同行关系。");
        }
        "npc_quest_accept" => {
            bump_stance_metric(stance, "trust", 7);
            bump_stance_metric(stance, "ideologicalFit", 5);
            bump_stance_metric(stance, "loyalty", 4);
            append_stance_note(stance, "recentApprovals", "你接住了对方主动交出来的事。");
        }
        _ => {}
    }
}

fn bump_stance_metric(stance: &mut Map<String, Value>, key: &str, delta: i32) {
    let current = stance
        .get(key)
        .and_then(Value::as_i64)
        .and_then(|value| i32::try_from(value).ok())
        .unwrap_or(50);
    stance.insert(key.to_string(), json!(clamp_stance_metric(current + delta)));
}

fn clamp_stance_metric(value: i32) -> i32 {
    value.clamp(0, 100)
}

fn append_stance_note(stance: &mut Map<String, Value>, key: &str, note: &str) {
    let mut notes = stance
        .get(key)
        .and_then(Value::as_array)
        .cloned()
        .unwrap_or_default();
    notes.push(Value::String(note.to_string()));
    let keep_from = notes.len().saturating_sub(3);
    stance.insert(
        key.to_string(),
        Value::Array(notes.into_iter().skip(keep_from).collect()),
    );
}

fn increment_npc_state_i32_field(state: &mut Value, key: &str, delta: i32) {
    let previous = read_i32_field(state, key).unwrap_or(0);
    write_i32_field(state, key, previous.saturating_add(delta).max(0));
}

fn build_npc_interaction_options(npc_id: &str) -> Vec<RuntimeStoryOptionView> {
    vec![
        build_npc_option("npc_chat", "继续交谈", npc_id, "chat"),
        build_npc_option("npc_help", "请求援手", npc_id, "help"),
        build_npc_option("npc_trade", "交易", npc_id, "trade"),
        build_npc_option("npc_gift", "赠礼", npc_id, "gift"),
        build_npc_option("npc_recruit", "邀请入队", npc_id, "recruit"),
        build_npc_option("npc_spar", "点到为止切磋", npc_id, "spar"),
        build_npc_option("npc_fight", "与对方战斗", npc_id, "fight"),
        build_npc_option("npc_leave", "离开当前角色", npc_id, "leave"),
    ]
}

fn find_npc_inventory_item(state: &Value, item_id: &str) -> Option<Value> {
    read_array_field(state, "inventory")
        .into_iter()
        .find(|item| read_optional_string_field(item, "id").as_deref() == Some(item_id))
        .cloned()
}

fn read_npc_inventory_values(state: &Value) -> Vec<Value> {
    read_array_field(state, "inventory")
        .into_iter()
        .cloned()
        .collect()
}

fn write_npc_inventory_values(state: &mut Value, items: Vec<Value>) {
    ensure_json_object(state).insert("inventory".to_string(), Value::Array(items));
}

fn trade_quantity_suffix_local(quantity: i32) -> String {
    if quantity > 1 {
        format!(" x{quantity}")
    } else {
        String::new()
    }
}

fn read_number_field(value: &Value, key: &str) -> Option<f64> {
    read_field(value, key).and_then(Value::as_f64)
}

fn pending_quest_offer_quest(current_story: Option<&Value>) -> Option<Value> {
    current_story
        .and_then(|story| read_object_field(story, "npcChatState"))
        .and_then(|chat| read_object_field(chat, "pendingQuestOffer"))
        .and_then(|offer| read_field(offer, "quest"))
        .cloned()
}

fn build_fallback_npc_quest(npc: &CurrentNpcContext) -> Value {
    json!({
        "id": format!("quest:npc:{}:fallback", npc.id),
        "issuerNpcId": npc.id,
        "issuerNpcName": npc.name,
        "title": format!("{}的委托", npc.name),
        "description": format!("处理 {} 交出的眼前事务。", npc.name),
        "summary": format!("完成 {} 的委托。", npc.name),
        "objective": {
            "kind": "talk_to_npc",
            "targetNpcId": npc.id,
            "requiredCount": 1
        },
        "progress": 0,
        "status": "active",
        "reward": {
            "affinityBonus": 10,
            "currency": 60,
            "experience": 30,
            "items": []
        }
    })
}

fn upsert_runtime_quest(game_state: &mut Value, quest: Value) {
    let quest_id = read_optional_string_field(&quest, "id").unwrap_or_else(|| {
        format!(
            "quest:runtime:{}",
            read_array_field(game_state, "quests").len() + 1
        )
    });
    let mut quest = quest;
    if let Some(object) = quest.as_object_mut() {
        object.insert("id".to_string(), Value::String(quest_id.clone()));
        object
            .entry("status".to_string())
            .or_insert_with(|| Value::String("active".to_string()));
    }

    let root = ensure_json_object(game_state);
    let quests = root
        .entry("quests".to_string())
        .or_insert_with(|| Value::Array(Vec::new()));
    if !quests.is_array() {
        *quests = Value::Array(Vec::new());
    }
    let items = quests.as_array_mut().expect("quests should be array");
    if let Some(existing) = items
        .iter_mut()
        .find(|item| read_optional_string_field(item, "id").as_deref() == Some(quest_id.as_str()))
    {
        *existing = quest;
    } else {
        items.push(quest);
    }
}

fn active_quest_id_for_npc(game_state: &Value, npc_id: &str, npc_name: &str) -> Option<String> {
    read_array_field(game_state, "quests")
        .into_iter()
        .find(|quest| {
            let status = read_optional_string_field(quest, "status").unwrap_or_default();
            let issuer_matches = read_optional_string_field(quest, "issuerNpcId").as_deref()
                == Some(npc_id)
                || read_optional_string_field(quest, "issuerNpcName").as_deref() == Some(npc_name);
            issuer_matches && status != "turned_in" && status != "failed" && status != "expired"
        })
        .and_then(|quest| read_optional_string_field(quest, "id"))
}

fn mark_quest_turned_in(game_state: &mut Value, quest_id: &str) -> Result<(), String> {
    let root = ensure_json_object(game_state);
    let quests = root
        .entry("quests".to_string())
        .or_insert_with(|| Value::Array(Vec::new()));
    let Some(items) = quests.as_array_mut() else {
        return Err("当前任务列表非法。".to_string());
    };
    let Some(quest) = items
        .iter_mut()
        .find(|quest| read_optional_string_field(quest, "id").as_deref() == Some(quest_id))
    else {
        return Err("未找到可交付的委托。".to_string());
    };
    ensure_json_object(quest).insert("status".to_string(), Value::String("turned_in".to_string()));
    Ok(())
}

fn increment_runtime_stat_local(game_state: &mut Value, key: &str, delta: i32) {
    let root = ensure_json_object(game_state);
    let stats = root
        .entry("runtimeStats".to_string())
        .or_insert_with(|| Value::Object(Map::new()));
    if !stats.is_object() {
        *stats = Value::Object(Map::new());
    }
    let stats = stats
        .as_object_mut()
        .expect("runtimeStats should be object");
    let previous = stats
        .get(key)
        .and_then(Value::as_i64)
        .and_then(|value| i32::try_from(value).ok())
        .unwrap_or(0);
    stats.insert(
        key.to_string(),
        json!(previous.saturating_add(delta).max(0)),
    );
}

fn build_current_story(story_text: &str, options: &[RuntimeStoryOptionView]) -> Value {
    json!({
        "text": story_text,
        "options": options.iter().map(build_story_option_from_runtime_option).collect::<Vec<_>>(),
        "streaming": false
    })
}

pub fn build_runtime_story_options(
    current_story: Option<&Value>,
    game_state: &Value,
) -> Vec<RuntimeStoryOptionView> {
    if let Some(story) = current_story {
        let prefers_deferred = read_field(story, "displayMode")
            .and_then(Value::as_str)
            .is_some_and(|value| value == "dialogue")
            && !read_array_field(story, "deferredOptions").is_empty();
        let source = if prefers_deferred {
            read_array_field(story, "deferredOptions")
        } else {
            read_array_field(story, "options")
        };
        let compiled = source
            .into_iter()
            .filter_map(build_runtime_story_option_from_story_option)
            .collect::<Vec<_>>();
        if !compiled.is_empty() {
            return compiled;
        }
    }

    build_fallback_runtime_story_options(game_state)
}

fn build_fallback_runtime_story_options(game_state: &Value) -> Vec<RuntimeStoryOptionView> {
    if read_bool_field(game_state, "inBattle").unwrap_or(false) {
        return build_battle_runtime_story_options(game_state);
    }

    if let Some(encounter) = read_object_field(game_state, "currentEncounter") {
        let npc_id = read_optional_string_field(encounter, "id")
            .or_else(|| read_optional_string_field(encounter, "npcName"))
            .unwrap_or_else(|| "npc_current".to_string());
        if read_bool_field(game_state, "npcInteractionActive").unwrap_or(false) {
            return vec![
                build_npc_option("npc_chat", "继续交谈", &npc_id, "chat"),
                build_npc_option("npc_help", "请求援手", &npc_id, "help"),
                build_npc_option("npc_spar", "点到为止切磋", &npc_id, "spar"),
                build_npc_option("npc_fight", "与对方战斗", &npc_id, "fight"),
                build_npc_option("npc_leave", "离开当前角色", &npc_id, "leave"),
            ];
        }
        return vec![
            build_npc_option("npc_preview_talk", "转向眼前角色", &npc_id, "chat"),
            build_npc_option("npc_fight", "与对方战斗", &npc_id, "fight"),
            build_npc_option("npc_leave", "离开当前角色", &npc_id, "leave"),
        ];
    }

    vec![
        build_static_runtime_story_option("idle_observe_signs", "观察周围迹象", "story"),
        build_static_runtime_story_option("idle_call_out", "主动出声试探", "story"),
        build_static_runtime_story_option("idle_rest_focus", "原地调息", "story"),
        build_static_runtime_story_option("idle_explore_forward", "继续向前探索", "story"),
        build_static_runtime_story_option(CONTINUE_ADVENTURE_FUNCTION_ID, "继续推进冒险", "story"),
    ]
}

fn build_npc_option(
    function_id: &str,
    action_text: &str,
    npc_id: &str,
    action: &str,
) -> RuntimeStoryOptionView {
    RuntimeStoryOptionView {
        interaction: Some(
            shared_contracts::runtime_story::RuntimeStoryOptionInteraction::Npc {
                npc_id: npc_id.to_string(),
                action: action.to_string(),
                quest_id: None,
            },
        ),
        ..build_static_runtime_story_option(function_id, action_text, "npc")
    }
}

pub fn build_runtime_story_state_response_parts(
    requested_session_id: &str,
    client_version: Option<u32>,
    mut snapshot: StoryRuntimeSnapshotPayload,
) -> (
    u32,
    RuntimeStoryViewModel,
    RuntimeStoryPresentation,
    Vec<RuntimeStoryPatch>,
    StoryRuntimeSnapshotPayload,
) {
    write_runtime_npc_interaction_view(&mut snapshot.game_state);
    let session_id = read_runtime_session_id(&snapshot.game_state)
        .unwrap_or_else(|| requested_session_id.to_string());
    let options =
        build_runtime_story_options(snapshot.current_story.as_ref(), &snapshot.game_state);
    let story_text = read_story_text(snapshot.current_story.as_ref())
        .unwrap_or_else(|| build_fallback_story_text(&snapshot.game_state));
    let server_version = read_u32_field(&snapshot.game_state, "runtimeActionVersion")
        .or(client_version)
        .unwrap_or(0);

    let view_model = build_runtime_story_view_model(&snapshot.game_state, &options);
    let presentation = RuntimeStoryPresentation {
        action_text: String::new(),
        result_text: String::new(),
        story_text,
        options,
        toast: None,
        battle: None::<RuntimeBattlePresentation>,
    };
    let _ = session_id;

    (
        server_version,
        view_model,
        presentation,
        Vec::new(),
        snapshot,
    )
}

fn read_story_text(current_story: Option<&Value>) -> Option<String> {
    current_story.and_then(|story| read_optional_string_field(story, "text"))
}

fn build_fallback_story_text(game_state: &Value) -> String {
    if read_bool_field(game_state, "inBattle").unwrap_or(false) {
        let encounter_name = read_object_field(game_state, "currentEncounter")
            .and_then(|encounter| read_optional_string_field(encounter, "npcName"))
            .unwrap_or_else(|| "眼前的敌人".to_string());
        return format!("战斗还没有结束，{encounter_name} 仍在逼你立刻做出下一步判断。");
    }

    if let Some(encounter) = read_object_field(game_state, "currentEncounter")
        && let Some(npc_name) = read_optional_string_field(encounter, "npcName")
    {
        return format!("{npc_name} 正在等你表态，当前局势已经可以继续推进。");
    }

    "当前故事状态已经同步，可以继续推进这一轮运行时动作。".to_string()
}

#[cfg(test)]
mod tests {
    use serde_json::json;

    use super::*;

    #[test]
    fn story_session_scoped_action_updates_snapshot_version() {
        let output = resolve_story_runtime_action(StoryRuntimeActionResolveInput {
            story_session_id: "storysess-1".to_string(),
            runtime_session_id: "runtime-1".to_string(),
            snapshot: StoryRuntimeSnapshotPayload {
                saved_at: None,
                bottom_tab: "adventure".to_string(),
                game_state: json!({
                    "runtimeSessionId": "runtime-1",
                    "runtimeActionVersion": 1,
                    "playerHp": 30,
                    "playerMaxHp": 40,
                    "playerMana": 10,
                    "playerMaxMana": 20,
                    "playerCurrency": 0,
                    "playerInventory": [],
                    "playerEquipment": { "weapon": null, "armor": null, "relic": null },
                    "inBattle": false,
                    "npcInteractionActive": false,
                    "storyHistory": []
                }),
                current_story: None,
            },
            request: ResolveStoryRuntimeActionRequest {
                story_session_id: "storysess-1".to_string(),
                client_version: Some(1),
                function_id: "idle_rest_focus".to_string(),
                action_text: "原地调息".to_string(),
                target_id: None,
                payload: None,
            },
        })
        .expect("action should resolve");

        assert_eq!(output.server_version, 2);
        assert_eq!(
            output.snapshot.game_state["storySessionId"],
            json!("storysess-1")
        );
        assert_eq!(output.snapshot.game_state["runtimeActionVersion"], json!(2));
        assert_eq!(output.presentation.action_text, "原地调息");
        assert!(output.snapshot.current_story.is_some());
    }

    #[test]
    fn story_session_scoped_action_rejects_runtime_session_mismatch() {
        let error = resolve_story_runtime_action(StoryRuntimeActionResolveInput {
            story_session_id: "storysess-1".to_string(),
            runtime_session_id: "runtime-expected".to_string(),
            snapshot: StoryRuntimeSnapshotPayload {
                saved_at: None,
                bottom_tab: "adventure".to_string(),
                game_state: json!({ "runtimeSessionId": "runtime-other" }),
                current_story: None,
            },
            request: ResolveStoryRuntimeActionRequest {
                story_session_id: "storysess-1".to_string(),
                client_version: None,
                function_id: "idle_call_out".to_string(),
                action_text: "主动出声试探".to_string(),
                target_id: None,
                payload: None,
            },
        })
        .expect_err("mismatch should fail");

        assert!(error.contains("不匹配"));
    }
}