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

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

pub const NPC_STATE_ID_PREFIX: &str = "npcstate_";
pub const MAX_STANCE_NOTES: usize = 3;
pub const NPC_RECRUIT_AFFINITY_THRESHOLD: i32 = 60;
pub const NPC_PREVIEW_TALK_FUNCTION_ID: &str = "npc_preview_talk";
pub const NPC_CHAT_FUNCTION_ID: &str = "npc_chat";
pub const NPC_HELP_FUNCTION_ID: &str = "npc_help";
pub const NPC_RECRUIT_FUNCTION_ID: &str = "npc_recruit";
pub const NPC_FIGHT_FUNCTION_ID: &str = "npc_fight";
pub const NPC_SPAR_FUNCTION_ID: &str = "npc_spar";
pub const NPC_LEAVE_FUNCTION_ID: &str = "npc_leave";

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum NpcRelationStance {
    Hostile,
    Guarded,
    Neutral,
    Cooperative,
    Bonded,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum NpcSocialActionKind {
    Chat,
    Help,
    Gift,
    Recruit,
    QuestAccept,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum NpcInteractionStatus {
    Previewed,
    Dialogue,
    Resolved,
    Recruited,
    BattlePending,
    Left,
}

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

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct NpcRelationState {
    pub affinity: i32,
    pub stance: NpcRelationStance,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct NpcStanceProfile {
    pub trust: u8,
    pub warmth: u8,
    pub ideological_fit: u8,
    pub fear_or_guard: u8,
    pub loyalty: u8,
    pub current_conflict_tag: Option<String>,
    pub recent_approvals: Vec<String>,
    pub recent_disapprovals: Vec<String>,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct NpcStateSnapshot {
    pub npc_state_id: String,
    pub runtime_session_id: String,
    pub npc_id: String,
    pub npc_name: String,
    pub affinity: i32,
    pub relation_state: NpcRelationState,
    pub help_used: bool,
    pub chatted_count: u32,
    pub gifts_given: u32,
    pub recruited: bool,
    pub trade_stock_signature: Option<String>,
    pub revealed_facts: Vec<String>,
    pub known_attribute_rumors: Vec<String>,
    pub first_meaningful_contact_resolved: bool,
    pub seen_backstory_chapter_ids: Vec<String>,
    pub stance_profile: NpcStanceProfile,
    pub created_at_micros: i64,
    pub updated_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct NpcStateUpsertInput {
    pub runtime_session_id: String,
    pub npc_id: String,
    pub npc_name: String,
    pub affinity: i32,
    pub help_used: bool,
    pub chatted_count: u32,
    pub gifts_given: u32,
    pub recruited: bool,
    pub trade_stock_signature: Option<String>,
    pub revealed_facts: Vec<String>,
    pub known_attribute_rumors: Vec<String>,
    pub first_meaningful_contact_resolved: bool,
    pub seen_backstory_chapter_ids: Vec<String>,
    pub stance_profile: Option<NpcStanceProfile>,
    pub updated_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResolveNpcSocialActionInput {
    pub runtime_session_id: String,
    pub npc_id: String,
    pub npc_name: String,
    pub action_kind: NpcSocialActionKind,
    pub affinity_gain_override: Option<i32>,
    pub note: Option<String>,
    pub updated_at_micros: i64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResolveNpcInteractionInput {
    pub runtime_session_id: String,
    pub npc_id: String,
    pub npc_name: String,
    pub interaction_function_id: String,
    pub release_npc_id: Option<String>,
    pub updated_at_micros: i64,
}

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

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct NpcInteractionResult {
    pub npc_state: NpcStateSnapshot,
    pub interaction_status: NpcInteractionStatus,
    pub action_text: String,
    pub result_text: String,
    pub story_text: Option<String>,
    pub battle_mode: Option<NpcInteractionBattleMode>,
    pub encounter_closed: bool,
    pub affinity_changed: bool,
    pub previous_affinity: i32,
    pub next_affinity: i32,
}

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

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum NpcStateFieldError {
    MissingRuntimeSessionId,
    MissingNpcId,
    MissingNpcName,
    MissingInteractionFunctionId,
    HelpAlreadyUsed,
    RecruitAffinityTooLow,
    UnsupportedInteractionFunctionId,
}

pub fn generate_npc_state_id(runtime_session_id: &str, npc_id: &str) -> String {
    format!(
        "{}{}:{}",
        NPC_STATE_ID_PREFIX,
        runtime_session_id.trim(),
        npc_id.trim()
    )
}

pub fn build_relation_state(affinity: i32) -> NpcRelationState {
    NpcRelationState {
        affinity,
        stance: if affinity < 0 {
            NpcRelationStance::Hostile
        } else if affinity < 15 {
            NpcRelationStance::Guarded
        } else if affinity < 30 {
            NpcRelationStance::Neutral
        } else if affinity < NPC_RECRUIT_AFFINITY_THRESHOLD {
            NpcRelationStance::Cooperative
        } else {
            NpcRelationStance::Bonded
        },
    }
}

pub fn build_initial_stance_profile(
    affinity: i32,
    recruited: bool,
    hostile: bool,
    role_text: Option<&str>,
) -> NpcStanceProfile {
    let recruited_bonus = if recruited { 14.0 } else { 0.0 };
    let hostile_penalty = if hostile { 18.0 } else { 0.0 };
    let current_conflict_tag = role_text.and_then(infer_conflict_tag);

    NpcStanceProfile {
        trust: clamp_stance_metric(
            42.0 + affinity as f32 * 0.55 + recruited_bonus - hostile_penalty,
        ),
        warmth: clamp_stance_metric(36.0 + affinity as f32 * 0.5 + recruited_bonus),
        ideological_fit: clamp_stance_metric(48.0 + affinity as f32 * 0.25),
        fear_or_guard: clamp_stance_metric(62.0 - affinity as f32 * 0.55 + hostile_penalty),
        loyalty: clamp_stance_metric(
            24.0 + affinity as f32 * 0.35 + if recruited { 26.0 } else { 0.0 },
        ),
        current_conflict_tag,
        recent_approvals: Vec::new(),
        recent_disapprovals: Vec::new(),
    }
}

pub fn normalize_npc_state_snapshot(
    input: NpcStateUpsertInput,
    existing_created_at_micros: Option<i64>,
) -> Result<NpcStateSnapshot, NpcStateFieldError> {
    validate_required_identity_fields(&input.runtime_session_id, &input.npc_id, &input.npc_name)?;

    let affinity = input.affinity;
    let stance_profile = normalize_stance_profile(
        input.stance_profile,
        affinity,
        input.recruited,
        affinity < 0,
        None,
    );
    let created_at_micros = existing_created_at_micros.unwrap_or(input.updated_at_micros);

    Ok(NpcStateSnapshot {
        npc_state_id: generate_npc_state_id(&input.runtime_session_id, &input.npc_id),
        runtime_session_id: normalize_required_string(input.runtime_session_id).unwrap_or_default(),
        npc_id: normalize_required_string(input.npc_id).unwrap_or_default(),
        npc_name: normalize_required_string(input.npc_name).unwrap_or_default(),
        affinity,
        relation_state: build_relation_state(affinity),
        help_used: input.help_used,
        chatted_count: input.chatted_count,
        gifts_given: input.gifts_given,
        recruited: input.recruited,
        trade_stock_signature: normalize_optional_value(input.trade_stock_signature),
        revealed_facts: normalize_string_list(input.revealed_facts),
        known_attribute_rumors: normalize_string_list(input.known_attribute_rumors),
        first_meaningful_contact_resolved: input.first_meaningful_contact_resolved,
        seen_backstory_chapter_ids: normalize_string_list(input.seen_backstory_chapter_ids),
        stance_profile,
        created_at_micros,
        updated_at_micros: input.updated_at_micros,
    })
}

pub fn apply_npc_social_action(
    current: NpcStateSnapshot,
    input: ResolveNpcSocialActionInput,
) -> Result<NpcStateSnapshot, NpcStateFieldError> {
    validate_required_identity_fields(&input.runtime_session_id, &input.npc_id, &input.npc_name)?;

    let note = normalize_optional_value(input.note);
    let mut next = current;

    match input.action_kind {
        NpcSocialActionKind::Chat => {
            let affinity_gain = input
                .affinity_gain_override
                .unwrap_or_else(|| (6 - next.chatted_count as i32).max(2));
            next.affinity += affinity_gain;
            next.chatted_count += 1;
            next.first_meaningful_contact_resolved = true;
            next.stance_profile = apply_story_choice_to_stance_profile(
                &next.stance_profile,
                input.action_kind,
                affinity_gain,
                next.recruited,
                note.as_deref(),
            );
        }
        NpcSocialActionKind::Help => {
            if next.help_used {
                return Err(NpcStateFieldError::HelpAlreadyUsed);
            }
            let affinity_gain = input.affinity_gain_override.unwrap_or(4);
            next.affinity += affinity_gain;
            next.help_used = true;
            next.stance_profile = apply_story_choice_to_stance_profile(
                &next.stance_profile,
                input.action_kind,
                affinity_gain,
                next.recruited,
                note.as_deref(),
            );
        }
        NpcSocialActionKind::Gift => {
            let affinity_gain = input.affinity_gain_override.unwrap_or(4);
            next.affinity += affinity_gain;
            next.gifts_given += 1;
            next.stance_profile = apply_story_choice_to_stance_profile(
                &next.stance_profile,
                input.action_kind,
                affinity_gain,
                next.recruited,
                note.as_deref(),
            );
        }
        NpcSocialActionKind::Recruit => {
            if next.affinity < NPC_RECRUIT_AFFINITY_THRESHOLD {
                return Err(NpcStateFieldError::RecruitAffinityTooLow);
            }
            next.recruited = true;
            next.first_meaningful_contact_resolved = true;
            next.stance_profile = apply_story_choice_to_stance_profile(
                &next.stance_profile,
                input.action_kind,
                input.affinity_gain_override.unwrap_or(0),
                true,
                note.as_deref(),
            );
        }
        NpcSocialActionKind::QuestAccept => {
            let affinity_gain = input.affinity_gain_override.unwrap_or(3);
            next.affinity += affinity_gain;
            next.stance_profile = apply_story_choice_to_stance_profile(
                &next.stance_profile,
                input.action_kind,
                affinity_gain,
                next.recruited,
                note.as_deref(),
            );
        }
    }

    next.affinity = next.affinity.clamp(-100, 100);
    next.npc_name = normalize_required_string(input.npc_name).unwrap_or_default();
    next.relation_state = build_relation_state(next.affinity);
    next.updated_at_micros = input.updated_at_micros;

    Ok(next)
}

pub fn resolve_npc_interaction(
    current: NpcStateSnapshot,
    input: ResolveNpcInteractionInput,
) -> Result<NpcInteractionResult, NpcStateFieldError> {
    validate_required_identity_fields(&input.runtime_session_id, &input.npc_id, &input.npc_name)?;

    let interaction_function_id = normalize_optional_value(Some(input.interaction_function_id))
        .ok_or(NpcStateFieldError::MissingInteractionFunctionId)?;
    if !is_supported_npc_interaction_function_id(&interaction_function_id) {
        return Err(NpcStateFieldError::UnsupportedInteractionFunctionId);
    }

    let previous_affinity = current.affinity;
    let mut next_state = current.clone();

    let (interaction_status, action_text, result_text, story_text, battle_mode, encounter_closed) =
        match interaction_function_id.as_str() {
            NPC_PREVIEW_TALK_FUNCTION_ID => (
                NpcInteractionStatus::Previewed,
                format!("转向{}", current.npc_name),
                format!(
                    "你把注意力真正收回到{}身上，接下来可以围绕这名角色做正式交互了。",
                    current.npc_name
                ),
                None,
                None,
                false,
            ),
            NPC_CHAT_FUNCTION_ID => {
                next_state = apply_npc_social_action(
                    current,
                    ResolveNpcSocialActionInput {
                        runtime_session_id: input.runtime_session_id,
                        npc_id: input.npc_id,
                        npc_name: input.npc_name,
                        action_kind: NpcSocialActionKind::Chat,
                        affinity_gain_override: None,
                        note: None,
                        updated_at_micros: input.updated_at_micros,
                    },
                )?;
                (
                    NpcInteractionStatus::Dialogue,
                    format!("继续和{}交谈", next_state.npc_name),
                    format!(
                        "{}愿意把话接下去，态度比刚才明显松动了一些。",
                        next_state.npc_name
                    ),
                    Some(format!(
                        "{}看起来已经愿意继续把话题往下接。",
                        next_state.npc_name
                    )),
                    None,
                    false,
                )
            }
            NPC_HELP_FUNCTION_ID => {
                next_state = apply_npc_social_action(
                    current,
                    ResolveNpcSocialActionInput {
                        runtime_session_id: input.runtime_session_id,
                        npc_id: input.npc_id,
                        npc_name: input.npc_name,
                        action_kind: NpcSocialActionKind::Help,
                        affinity_gain_override: None,
                        note: None,
                        updated_at_micros: input.updated_at_micros,
                    },
                )?;
                (
                    NpcInteractionStatus::Resolved,
                    format!("向{}请求援手", next_state.npc_name),
                    format!(
                        "{}给了你一次及时支援，关系也顺势拉近了一点。",
                        next_state.npc_name
                    ),
                    None,
                    None,
                    false,
                )
            }
            NPC_RECRUIT_FUNCTION_ID => {
                next_state = apply_npc_social_action(
                    current,
                    ResolveNpcSocialActionInput {
                        runtime_session_id: input.runtime_session_id,
                        npc_id: input.npc_id,
                        npc_name: input.npc_name,
                        action_kind: NpcSocialActionKind::Recruit,
                        affinity_gain_override: None,
                        note: None,
                        updated_at_micros: input.updated_at_micros,
                    },
                )?;
                (
                    NpcInteractionStatus::Recruited,
                    format!("邀请{}加入队伍", next_state.npc_name),
                    format!("{}接受了你的邀请。", next_state.npc_name),
                    Some(format!(
                        "{}已经明确接受了与你同行的关系。",
                        next_state.npc_name
                    )),
                    None,
                    true,
                )
            }
            NPC_FIGHT_FUNCTION_ID => (
                NpcInteractionStatus::BattlePending,
                format!("与{}正面开战", current.npc_name),
                format!(
                    "{}已经不再保留余地，当前冲突正式转入战斗结算。",
                    current.npc_name
                ),
                None,
                Some(NpcInteractionBattleMode::Fight),
                false,
            ),
            NPC_SPAR_FUNCTION_ID => (
                NpcInteractionStatus::BattlePending,
                format!("与{}点到为止切磋", current.npc_name),
                format!(
                    "{}摆开架势，准备和你来一场点到为止的切磋。",
                    current.npc_name
                ),
                None,
                Some(NpcInteractionBattleMode::Spar),
                false,
            ),
            NPC_LEAVE_FUNCTION_ID => (
                NpcInteractionStatus::Left,
                format!("离开{}", current.npc_name),
                format!(
                    "你暂时没有继续和{}纠缠，把注意力重新拉回了前路。",
                    current.npc_name
                ),
                None,
                None,
                true,
            ),
            _ => return Err(NpcStateFieldError::UnsupportedInteractionFunctionId),
        };

    Ok(NpcInteractionResult {
        npc_state: next_state.clone(),
        interaction_status,
        action_text,
        result_text,
        story_text,
        battle_mode,
        encounter_closed,
        affinity_changed: previous_affinity != next_state.affinity,
        previous_affinity,
        next_affinity: next_state.affinity,
    })
}

pub fn normalize_optional_value(value: Option<String>) -> Option<String> {
    normalize_shared_optional_string(value)
}

pub fn normalize_string_list(values: Vec<String>) -> Vec<String> {
    normalize_shared_string_list(values)
}

pub fn is_supported_npc_interaction_function_id(function_id: &str) -> bool {
    matches!(
        function_id,
        NPC_PREVIEW_TALK_FUNCTION_ID
            | NPC_CHAT_FUNCTION_ID
            | NPC_HELP_FUNCTION_ID
            | NPC_RECRUIT_FUNCTION_ID
            | NPC_FIGHT_FUNCTION_ID
            | NPC_SPAR_FUNCTION_ID
            | NPC_LEAVE_FUNCTION_ID
    )
}

fn validate_required_identity_fields(
    runtime_session_id: &str,
    npc_id: &str,
    npc_name: &str,
) -> Result<(), NpcStateFieldError> {
    if normalize_required_string(runtime_session_id).is_none() {
        return Err(NpcStateFieldError::MissingRuntimeSessionId);
    }
    if normalize_required_string(npc_id).is_none() {
        return Err(NpcStateFieldError::MissingNpcId);
    }
    if normalize_required_string(npc_name).is_none() {
        return Err(NpcStateFieldError::MissingNpcName);
    }

    Ok(())
}

fn normalize_stance_profile(
    stance_profile: Option<NpcStanceProfile>,
    affinity: i32,
    recruited: bool,
    hostile: bool,
    role_text: Option<&str>,
) -> NpcStanceProfile {
    let Some(stance_profile) = stance_profile else {
        return build_initial_stance_profile(affinity, recruited, hostile, role_text);
    };

    NpcStanceProfile {
        trust: clamp_stance_metric(stance_profile.trust as f32),
        warmth: clamp_stance_metric(stance_profile.warmth as f32),
        ideological_fit: clamp_stance_metric(stance_profile.ideological_fit as f32),
        fear_or_guard: clamp_stance_metric(stance_profile.fear_or_guard as f32),
        loyalty: clamp_stance_metric(stance_profile.loyalty as f32),
        current_conflict_tag: normalize_optional_value(stance_profile.current_conflict_tag),
        recent_approvals: trim_recent_notes(stance_profile.recent_approvals),
        recent_disapprovals: trim_recent_notes(stance_profile.recent_disapprovals),
    }
}

fn apply_story_choice_to_stance_profile(
    stance_profile: &NpcStanceProfile,
    action_kind: NpcSocialActionKind,
    affinity_gain: i32,
    recruited: bool,
    note: Option<&str>,
) -> NpcStanceProfile {
    let mut next = stance_profile.clone();

    match action_kind {
        NpcSocialActionKind::Chat => {
            next.trust = clamp_stance_metric(next.trust as f32 + 6.0 + affinity_gain as f32 * 2.0);
            next.warmth =
                clamp_stance_metric(next.warmth as f32 + 4.0 + affinity_gain as f32 * 2.0);
            next.fear_or_guard =
                clamp_stance_metric(next.fear_or_guard as f32 - 5.0 - affinity_gain as f32);
            if affinity_gain >= 0 {
                push_recent_note(
                    &mut next.recent_approvals,
                    note.unwrap_or("你愿意先从眼前局势和试探开始说话。"),
                );
            } else {
                push_recent_note(
                    &mut next.recent_disapprovals,
                    note.unwrap_or("这轮交流没能真正对上节奏。"),
                );
            }
        }
        NpcSocialActionKind::Help => {
            next.trust = clamp_stance_metric(next.trust as f32 + 12.0);
            next.warmth = clamp_stance_metric(next.warmth as f32 + 6.0);
            next.fear_or_guard = clamp_stance_metric(next.fear_or_guard as f32 - 8.0);
            push_recent_note(
                &mut next.recent_approvals,
                note.unwrap_or("你在对方需要的时候搭了手。"),
            );
        }
        NpcSocialActionKind::Gift => {
            next.trust = clamp_stance_metric(next.trust as f32 + 6.0 + affinity_gain as f32);
            next.warmth =
                clamp_stance_metric(next.warmth as f32 + 10.0 + affinity_gain as f32 * 2.0);
            next.fear_or_guard = clamp_stance_metric(next.fear_or_guard as f32 - 4.0);
            push_recent_note(
                &mut next.recent_approvals,
                note.unwrap_or("你给出的东西回应了对方眼下的处境。"),
            );
        }
        NpcSocialActionKind::Recruit => {
            next.trust = clamp_stance_metric(next.trust as f32 + 8.0);
            next.warmth = clamp_stance_metric(next.warmth as f32 + 6.0);
            next.loyalty =
                clamp_stance_metric(next.loyalty as f32 + 18.0 + if recruited { 4.0 } else { 0.0 });
            next.fear_or_guard = clamp_stance_metric(next.fear_or_guard as f32 - 10.0);
            push_recent_note(
                &mut next.recent_approvals,
                note.unwrap_or("你正式把对方纳入了同行关系。"),
            );
        }
        NpcSocialActionKind::QuestAccept => {
            next.trust = clamp_stance_metric(next.trust as f32 + 7.0);
            next.ideological_fit = clamp_stance_metric(next.ideological_fit as f32 + 5.0);
            next.loyalty = clamp_stance_metric(next.loyalty as f32 + 4.0);
            push_recent_note(
                &mut next.recent_approvals,
                note.unwrap_or("你接住了对方主动交出来的事。"),
            );
        }
    }

    next
}

fn infer_conflict_tag(value: &str) -> Option<String> {
    let trimmed = value.trim();
    if trimmed.is_empty() {
        None
    } else if trimmed.contains("旧案") || trimmed.contains("调查") || trimmed.contains("追查")
    {
        Some("旧案".to_string())
    } else if trimmed.contains('守') || trimmed.contains('卫') || trimmed.contains('巡') {
        Some("守线".to_string())
    } else if trimmed.contains('商') || trimmed.contains('摊') || trimmed.contains("军需") {
        Some("交易".to_string())
    } else {
        None
    }
}

fn trim_recent_notes(values: Vec<String>) -> Vec<String> {
    let mut values = normalize_string_list(values);
    if values.len() > MAX_STANCE_NOTES {
        values = values.split_off(values.len() - MAX_STANCE_NOTES);
    }
    values
}

fn push_recent_note(target: &mut Vec<String>, note: &str) {
    let trimmed = note.trim();
    if trimmed.is_empty() {
        return;
    }

    target.push(trimmed.to_string());
    if target.len() > MAX_STANCE_NOTES {
        let drain_len = target.len() - MAX_STANCE_NOTES;
        target.drain(0..drain_len);
    }
}

fn clamp_stance_metric(value: f32) -> u8 {
    value.round().clamp(0.0, 100.0) as u8
}

impl fmt::Display for NpcStateFieldError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::MissingRuntimeSessionId => f.write_str("npc_state.runtime_session_id 不能为空"),
            Self::MissingNpcId => f.write_str("npc_state.npc_id 不能为空"),
            Self::MissingNpcName => f.write_str("npc_state.npc_name 不能为空"),
            Self::MissingInteractionFunctionId => {
                f.write_str("resolve_npc_interaction.interaction_function_id 不能为空")
            }
            Self::HelpAlreadyUsed => f.write_str("npc_state.help_used 已经消耗，不能重复援手"),
            Self::RecruitAffinityTooLow => {
                f.write_str("npc_state.affinity 未达到招募阈值，不能执行招募动作")
            }
            Self::UnsupportedInteractionFunctionId => {
                f.write_str("resolve_npc_interaction.interaction_function_id 当前不受支持")
            }
        }
    }
}

impl Error for NpcStateFieldError {}

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

    fn build_base_state() -> NpcStateSnapshot {
        normalize_npc_state_snapshot(
            NpcStateUpsertInput {
                runtime_session_id: "runtime_001".to_string(),
                npc_id: "npc_001".to_string(),
                npc_name: "宁霜".to_string(),
                affinity: 18,
                help_used: false,
                chatted_count: 0,
                gifts_given: 0,
                recruited: false,
                trade_stock_signature: None,
                revealed_facts: vec![],
                known_attribute_rumors: vec![],
                first_meaningful_contact_resolved: false,
                seen_backstory_chapter_ids: vec![],
                stance_profile: None,
                updated_at_micros: 10,
            },
            None,
        )
        .expect("base npc state should be valid")
    }

    #[test]
    fn relation_state_uses_expected_thresholds() {
        assert_eq!(build_relation_state(-1).stance, NpcRelationStance::Hostile);
        assert_eq!(build_relation_state(0).stance, NpcRelationStance::Guarded);
        assert_eq!(build_relation_state(15).stance, NpcRelationStance::Neutral);
        assert_eq!(
            build_relation_state(30).stance,
            NpcRelationStance::Cooperative
        );
        assert_eq!(build_relation_state(60).stance, NpcRelationStance::Bonded);
    }

    #[test]
    fn normalize_npc_state_snapshot_builds_primary_fields() {
        let snapshot = build_base_state();

        assert_eq!(snapshot.npc_state_id, "npcstate_runtime_001:npc_001");
        assert_eq!(snapshot.relation_state.stance, NpcRelationStance::Neutral);
        assert_eq!(snapshot.created_at_micros, 10);
        assert_eq!(snapshot.updated_at_micros, 10);
    }

    #[test]
    fn chat_action_increases_affinity_and_marks_first_contact() {
        let next = apply_npc_social_action(
            build_base_state(),
            ResolveNpcSocialActionInput {
                runtime_session_id: "runtime_001".to_string(),
                npc_id: "npc_001".to_string(),
                npc_name: "宁霜".to_string(),
                action_kind: NpcSocialActionKind::Chat,
                affinity_gain_override: None,
                note: None,
                updated_at_micros: 20,
            },
        )
        .expect("chat should succeed");

        assert_eq!(next.affinity, 24);
        assert_eq!(next.chatted_count, 1);
        assert!(next.first_meaningful_contact_resolved);
        assert_eq!(next.updated_at_micros, 20);
    }

    #[test]
    fn help_action_rejects_second_use() {
        let used_state = NpcStateSnapshot {
            help_used: true,
            ..build_base_state()
        };

        let error = apply_npc_social_action(
            used_state,
            ResolveNpcSocialActionInput {
                runtime_session_id: "runtime_001".to_string(),
                npc_id: "npc_001".to_string(),
                npc_name: "宁霜".to_string(),
                action_kind: NpcSocialActionKind::Help,
                affinity_gain_override: None,
                note: None,
                updated_at_micros: 20,
            },
        )
        .expect_err("help should fail once used");

        assert_eq!(error, NpcStateFieldError::HelpAlreadyUsed);
    }

    #[test]
    fn recruit_requires_threshold() {
        let error = apply_npc_social_action(
            build_base_state(),
            ResolveNpcSocialActionInput {
                runtime_session_id: "runtime_001".to_string(),
                npc_id: "npc_001".to_string(),
                npc_name: "宁霜".to_string(),
                action_kind: NpcSocialActionKind::Recruit,
                affinity_gain_override: None,
                note: None,
                updated_at_micros: 20,
            },
        )
        .expect_err("recruit should require threshold");

        assert_eq!(error, NpcStateFieldError::RecruitAffinityTooLow);
    }

    #[test]
    fn recruit_marks_state_when_affinity_is_high_enough() {
        let recruitable = NpcStateSnapshot {
            affinity: 66,
            relation_state: build_relation_state(66),
            ..build_base_state()
        };

        let next = apply_npc_social_action(
            recruitable,
            ResolveNpcSocialActionInput {
                runtime_session_id: "runtime_001".to_string(),
                npc_id: "npc_001".to_string(),
                npc_name: "宁霜".to_string(),
                action_kind: NpcSocialActionKind::Recruit,
                affinity_gain_override: None,
                note: None,
                updated_at_micros: 20,
            },
        )
        .expect("recruit should succeed");

        assert!(next.recruited);
        assert!(next.first_meaningful_contact_resolved);
    }

    #[test]
    fn resolve_preview_talk_keeps_affinity_unchanged() {
        let result = resolve_npc_interaction(
            build_base_state(),
            ResolveNpcInteractionInput {
                runtime_session_id: "runtime_001".to_string(),
                npc_id: "npc_001".to_string(),
                npc_name: "宁霜".to_string(),
                interaction_function_id: NPC_PREVIEW_TALK_FUNCTION_ID.to_string(),
                release_npc_id: None,
                updated_at_micros: 20,
            },
        )
        .expect("preview talk should succeed");

        assert_eq!(result.interaction_status, NpcInteractionStatus::Previewed);
        assert!(!result.affinity_changed);
        assert_eq!(result.previous_affinity, 18);
        assert_eq!(result.next_affinity, 18);
    }

    #[test]
    fn resolve_chat_updates_npc_state_and_returns_dialogue_status() {
        let result = resolve_npc_interaction(
            build_base_state(),
            ResolveNpcInteractionInput {
                runtime_session_id: "runtime_001".to_string(),
                npc_id: "npc_001".to_string(),
                npc_name: "宁霜".to_string(),
                interaction_function_id: NPC_CHAT_FUNCTION_ID.to_string(),
                release_npc_id: None,
                updated_at_micros: 20,
            },
        )
        .expect("chat interaction should succeed");

        assert_eq!(result.interaction_status, NpcInteractionStatus::Dialogue);
        assert!(result.affinity_changed);
        assert_eq!(result.next_affinity, 24);
        assert!(result.npc_state.first_meaningful_contact_resolved);
    }

    #[test]
    fn resolve_fight_returns_battle_pending_without_affinity_change() {
        let result = resolve_npc_interaction(
            build_base_state(),
            ResolveNpcInteractionInput {
                runtime_session_id: "runtime_001".to_string(),
                npc_id: "npc_001".to_string(),
                npc_name: "宁霜".to_string(),
                interaction_function_id: NPC_FIGHT_FUNCTION_ID.to_string(),
                release_npc_id: None,
                updated_at_micros: 20,
            },
        )
        .expect("fight interaction should succeed");

        assert_eq!(
            result.interaction_status,
            NpcInteractionStatus::BattlePending
        );
        assert_eq!(result.battle_mode, Some(NpcInteractionBattleMode::Fight));
        assert!(!result.affinity_changed);
    }
}