use serde_json::{Map, Value, json};
use shared_kernel::format_rfc3339;
use time::OffsetDateTime;

/// Runtime story 的纯 JSON 快照工具层。
///
/// 这里不允许引入 HTTP、AppState 或持久化依赖，保证后续 battle/forge/npc/quest
/// 规则迁入独立 crate 时可以继续复用同一批状态读写函数。
pub fn clear_encounter_state(game_state: &mut Value) {
    clear_encounter_only(game_state);
    write_bool_field(game_state, "inBattle", false);
    write_bool_field(game_state, "npcInteractionActive", false);
    write_null_field(game_state, "currentNpcBattleMode");
}

pub fn clear_encounter_only(game_state: &mut Value) {
    write_null_field(game_state, "currentEncounter");
    let root = ensure_json_object(game_state);
    root.insert("sceneHostileNpcs".to_string(), Value::Array(Vec::new()));
}

pub fn append_story_history(game_state: &mut Value, action_text: &str, result_text: &str) {
    let root = ensure_json_object(game_state);
    let story_history = root
        .entry("storyHistory".to_string())
        .or_insert_with(|| Value::Array(Vec::new()));
    if !story_history.is_array() {
        *story_history = Value::Array(Vec::new());
    }
    let entries = story_history
        .as_array_mut()
        .expect("storyHistory should be array");
    entries.push(json!({
        "text": action_text,
        "historyRole": "action",
    }));
    entries.push(json!({
        "text": result_text,
        "historyRole": "result",
    }));
}

pub fn increment_runtime_stat(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 + delta).max(0)));
}

pub fn add_player_currency(game_state: &mut Value, delta: i32) {
    let previous = read_i32_field(game_state, "playerCurrency").unwrap_or(0);
    write_i32_field(
        game_state,
        "playerCurrency",
        previous.saturating_add(delta.max(0)),
    );
}

pub fn add_player_inventory_items(game_state: &mut Value, additions: Vec<Value>) {
    if additions.is_empty() {
        return;
    }

    let root = ensure_json_object(game_state);
    let inventory = root
        .entry("playerInventory".to_string())
        .or_insert_with(|| Value::Array(Vec::new()));
    if !inventory.is_array() {
        *inventory = Value::Array(Vec::new());
    }
    let items = inventory
        .as_array_mut()
        .expect("playerInventory should be array");
    items.extend(additions);
}

pub fn grant_player_progression_experience(game_state: &mut Value, amount: i32, source: &str) {
    if amount <= 0 {
        return;
    }

    let root = ensure_json_object(game_state);
    let progression = root
        .entry("playerProgression".to_string())
        .or_insert_with(|| Value::Object(Map::new()));
    if !progression.is_object() {
        *progression = Value::Object(Map::new());
    }
    let progression = progression
        .as_object_mut()
        .expect("playerProgression should be object");
    let previous_total_xp = progression
        .get("totalXp")
        .and_then(Value::as_i64)
        .and_then(|value| i32::try_from(value).ok())
        .unwrap_or(0)
        .max(0);
    let next_total_xp = previous_total_xp.saturating_add(amount);
    let level = resolve_progression_level(next_total_xp);
    let current_level_xp = next_total_xp.saturating_sub(cumulative_xp_required(level));
    let xp_to_next_level = if level >= MAX_PLAYER_LEVEL {
        0
    } else {
        xp_to_next_level_for(level)
    };

    progression.insert("level".to_string(), json!(level));
    progression.insert("currentLevelXp".to_string(), json!(current_level_xp.max(0)));
    progression.insert("totalXp".to_string(), json!(next_total_xp));
    progression.insert("xpToNextLevel".to_string(), json!(xp_to_next_level.max(0)));
    progression.insert("pendingLevelUps".to_string(), json!(0));
    progression.insert(
        "lastGrantedSource".to_string(),
        Value::String(source.to_string()),
    );
}

pub const MAX_PLAYER_LEVEL: i32 = 20;

pub fn xp_to_next_level_for(level: i32) -> i32 {
    if level >= MAX_PLAYER_LEVEL {
        0
    } else {
        let scale = (level - 1).max(0);
        60 + 20 * scale + 8 * scale * scale
    }
}

pub fn cumulative_xp_required(level: i32) -> i32 {
    let mut total = 0;
    let capped_level = level.clamp(1, MAX_PLAYER_LEVEL);
    for current_level in 1..capped_level {
        total += xp_to_next_level_for(current_level);
    }
    total
}

pub fn resolve_progression_level(total_xp: i32) -> i32 {
    let normalized_total_xp = total_xp.max(0);
    let mut resolved_level = 1;
    for level in 2..=MAX_PLAYER_LEVEL {
        if normalized_total_xp < cumulative_xp_required(level) {
            break;
        }
        resolved_level = level;
    }
    resolved_level
}

pub fn append_active_build_buffs(game_state: &mut Value, additions: Vec<Value>) {
    if additions.is_empty() {
        return;
    }
    let root = ensure_json_object(game_state);
    let buffs = root
        .entry("activeBuildBuffs".to_string())
        .or_insert_with(|| Value::Array(Vec::new()));
    if !buffs.is_array() {
        *buffs = Value::Array(Vec::new());
    }
    buffs
        .as_array_mut()
        .expect("activeBuildBuffs should be array")
        .extend(additions);
}

pub fn remove_player_inventory_item(game_state: &mut Value, item_id: &str, quantity: i32) {
    if quantity <= 0 {
        return;
    }
    let root = ensure_json_object(game_state);
    let inventory = root
        .entry("playerInventory".to_string())
        .or_insert_with(|| Value::Array(Vec::new()));
    if !inventory.is_array() {
        *inventory = Value::Array(Vec::new());
    }
    let items = inventory
        .as_array_mut()
        .expect("playerInventory should be array");
    let Some(index) = items
        .iter()
        .position(|entry| read_optional_string_field(entry, "id").as_deref() == Some(item_id))
    else {
        return;
    };
    let current_quantity = read_i32_field(&items[index], "quantity")
        .unwrap_or(0)
        .max(0);
    let next_quantity = current_quantity - quantity;
    if next_quantity <= 0 {
        items.remove(index);
        return;
    }
    if let Some(item) = items[index].as_object_mut() {
        item.insert("quantity".to_string(), json!(next_quantity));
    }
}

pub fn write_current_encounter_i32_field(game_state: &mut Value, key: &str, value: i32) {
    let root = ensure_json_object(game_state);
    let Some(encounter) = root.get_mut("currentEncounter") else {
        return;
    };
    if let Some(encounter) = encounter.as_object_mut() {
        encounter.insert(key.to_string(), json!(value));
    }
}

pub fn write_first_hostile_npc_i32_field(game_state: &mut Value, key: &str, value: i32) {
    let root = ensure_json_object(game_state);
    let Some(hostiles) = root.get_mut("sceneHostileNpcs") else {
        return;
    };
    let Some(first) = hostiles.as_array_mut().and_then(|items| items.first_mut()) else {
        return;
    };
    if let Some(first) = first.as_object_mut() {
        first.insert(key.to_string(), json!(value));
    }
}

pub fn first_hostile_npc_string_field(game_state: &Value, key: &str) -> Option<String> {
    read_array_field(game_state, "sceneHostileNpcs")
        .first()
        .and_then(|target| read_optional_string_field(target, key))
}

pub fn read_runtime_session_id(game_state: &Value) -> Option<String> {
    read_optional_string_field(game_state, "runtimeSessionId")
}

pub fn read_field<'a>(value: &'a Value, key: &str) -> Option<&'a Value> {
    value.as_object()?.get(key)
}

pub fn read_object_field<'a>(value: &'a Value, key: &str) -> Option<&'a Value> {
    let field = read_field(value, key)?;
    field.is_object().then_some(field)
}

pub fn read_array_field<'a>(value: &'a Value, key: &str) -> Vec<&'a Value> {
    read_field(value, key)
        .and_then(Value::as_array)
        .map(|items| items.iter().collect())
        .unwrap_or_default()
}

pub fn read_required_string_field(value: &Value, key: &str) -> Option<String> {
    normalize_required_string(read_field(value, key)?.as_str()?)
}

pub fn read_optional_string_field(value: &Value, key: &str) -> Option<String> {
    normalize_optional_string(read_field(value, key).and_then(Value::as_str))
}

pub fn read_bool_field(value: &Value, key: &str) -> Option<bool> {
    read_field(value, key).and_then(Value::as_bool)
}

pub fn read_i32_field(value: &Value, key: &str) -> Option<i32> {
    read_field(value, key)
        .and_then(Value::as_i64)
        .and_then(|number| i32::try_from(number).ok())
}

pub fn read_u32_field(value: &Value, key: &str) -> Option<u32> {
    read_field(value, key)
        .and_then(Value::as_u64)
        .and_then(|number| u32::try_from(number).ok())
}

pub fn write_i32_field(value: &mut Value, key: &str, field_value: i32) {
    ensure_json_object(value).insert(key.to_string(), json!(field_value));
}

pub fn write_u32_field(value: &mut Value, key: &str, field_value: u32) {
    ensure_json_object(value).insert(key.to_string(), json!(field_value));
}

pub fn write_bool_field(value: &mut Value, key: &str, field_value: bool) {
    ensure_json_object(value).insert(key.to_string(), Value::Bool(field_value));
}

pub fn write_string_field(value: &mut Value, key: &str, field_value: &str) {
    ensure_json_object(value).insert(key.to_string(), Value::String(field_value.to_string()));
}

pub fn write_null_field(value: &mut Value, key: &str) {
    ensure_json_object(value).insert(key.to_string(), Value::Null);
}

pub fn ensure_json_object(value: &mut Value) -> &mut Map<String, Value> {
    if !value.is_object() {
        *value = Value::Object(Map::new());
    }
    value.as_object_mut().expect("value should be object")
}

pub fn normalize_required_string(value: &str) -> Option<String> {
    let trimmed = value.trim();
    (!trimmed.is_empty()).then(|| trimmed.to_string())
}

pub fn normalize_optional_string(value: Option<&str>) -> Option<String> {
    value.and_then(normalize_required_string)
}

pub fn format_now_rfc3339() -> String {
    format_rfc3339(OffsetDateTime::now_utc()).unwrap_or_else(|_| "1970-01-01T00:00:00Z".to_string())
}