use platform_llm::{LlmClient, LlmMessage, LlmTextRequest};
use serde_json::{Map as JsonMap, Value as JsonValue};
use shared_contracts::runtime::ExecuteCustomWorldAgentActionRequest;
use spacetime_client::CustomWorldAgentSessionRecord;

const CUSTOM_WORLD_AGENT_CHARACTER_EXPANSION_SYSTEM_PROMPT: &str =
    "你负责为当前游戏世界底稿补 1 到 3 个新角色。只能输出 JSON 数组，不要输出任何额外说明。";
const CUSTOM_WORLD_AGENT_LANDMARK_EXPANSION_SYSTEM_PROMPT: &str =
    "你负责为当前游戏世界底稿补 1 到 3 个新地点。只能输出 JSON 数组，不要输出任何额外说明。";

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct CustomWorldGeneratedEntitiesResult {
    pub payload_json: String,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CustomWorldGeneratedEntitiesPayloadError {
    SerializePayload(String),
    InvalidPayloadShape,
}

pub async fn generate_custom_world_agent_entities(
    llm_client: &LlmClient,
    session: &CustomWorldAgentSessionRecord,
    payload: &ExecuteCustomWorldAgentActionRequest,
) -> Result<CustomWorldGeneratedEntitiesResult, String> {
    let action = payload.action.trim();
    let draft_profile = session
        .draft_profile
        .as_object()
        .ok_or_else(|| format!("{action} requires an existing draft foundation"))?;
    let count = ensure_count(payload.count);
    let prompt_seed = payload
        .prompt_text
        .as_deref()
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .unwrap_or("没有额外要求，围绕当前底稿自然扩展。");
    let anchor_summary = build_anchor_summary(
        draft_profile,
        payload.anchor_card_ids.as_deref().unwrap_or(&[]),
    );
    let creator_intent_summary = session
        .anchor_pack
        .get("creatorIntentSummary")
        .and_then(JsonValue::as_str)
        .or_else(|| {
            session
                .creator_intent
                .get("worldHook")
                .and_then(JsonValue::as_str)
        })
        .or_else(|| draft_profile.get("summary").and_then(JsonValue::as_str))
        .unwrap_or_default();
    let world_name = draft_profile
        .get("name")
        .and_then(JsonValue::as_str)
        .unwrap_or("未命名世界");
    let world_summary = draft_profile
        .get("summary")
        .and_then(JsonValue::as_str)
        .unwrap_or_default();

    let (system_prompt, user_prompt, result_key) = match action {
        "generate_characters" => (
            CUSTOM_WORLD_AGENT_CHARACTER_EXPANSION_SYSTEM_PROMPT,
            build_custom_world_agent_character_expansion_prompt(ExpansionPromptParams {
                world_name,
                world_summary,
                creator_intent_summary,
                anchor_summary: anchor_summary.as_str(),
                existing_names: existing_character_names(draft_profile),
                count,
                prompt_seed,
            }),
            "generatedCharacters",
        ),
        "generate_landmarks" => (
            CUSTOM_WORLD_AGENT_LANDMARK_EXPANSION_SYSTEM_PROMPT,
            build_custom_world_agent_landmark_expansion_prompt(ExpansionPromptParams {
                world_name,
                world_summary,
                creator_intent_summary,
                anchor_summary: anchor_summary.as_str(),
                existing_names: existing_landmark_names(draft_profile),
                count,
                prompt_seed,
            }),
            "generatedLandmarks",
        ),
        _ => return Err(format!("unsupported generated entity action: {action}")),
    };

    let response = llm_client
        .request_text(LlmTextRequest::new(vec![
            LlmMessage::system(system_prompt),
            LlmMessage::user(user_prompt),
        ]))
        .await
        .map_err(|error| format!("{action} LLM 请求失败：{error}"))?;
    let generated_entities = parse_json_array_response(response.content.as_str())
        .map_err(|error| format!("{action} JSON 解析失败：{error}"))?;
    let normalized_entities =
        normalize_generated_entities(action, generated_entities, draft_profile, count);
    let payload_json =
        build_generated_entities_action_payload_json(payload, result_key, normalized_entities)
            .map_err(|error| match error {
                CustomWorldGeneratedEntitiesPayloadError::SerializePayload(message) => message,
                CustomWorldGeneratedEntitiesPayloadError::InvalidPayloadShape => {
                    "action payload 必须是 object".to_string()
                }
            })?;

    Ok(CustomWorldGeneratedEntitiesResult { payload_json })
}

pub fn build_generated_entities_action_payload_json(
    payload: &ExecuteCustomWorldAgentActionRequest,
    result_key: &str,
    generated_entities: Vec<JsonValue>,
) -> Result<String, CustomWorldGeneratedEntitiesPayloadError> {
    let mut payload_value = serde_json::to_value(payload).map_err(|error| {
        CustomWorldGeneratedEntitiesPayloadError::SerializePayload(format!(
            "action payload JSON 序列化失败：{error}"
        ))
    })?;
    let payload_object = payload_value
        .as_object_mut()
        .ok_or(CustomWorldGeneratedEntitiesPayloadError::InvalidPayloadShape)?;
    if payload.action.trim() == "generate_characters" {
        payload_object.insert(
            "roleType".to_string(),
            JsonValue::String(resolve_role_type(payload.role_type.as_deref()).to_string()),
        );
    }
    payload_object.insert(result_key.to_string(), JsonValue::Array(generated_entities));
    serde_json::to_string(&payload_value).map_err(|error| {
        CustomWorldGeneratedEntitiesPayloadError::SerializePayload(format!(
            "action payload JSON 序列化失败：{error}"
        ))
    })
}

struct ExpansionPromptParams<'a> {
    world_name: &'a str,
    world_summary: &'a str,
    creator_intent_summary: &'a str,
    anchor_summary: &'a str,
    existing_names: Vec<String>,
    count: u32,
    prompt_seed: &'a str,
}

fn build_custom_world_agent_character_expansion_prompt(
    params: ExpansionPromptParams<'_>,
) -> String {
    [
        format!("当前世界：{}", params.world_name),
        format!("世界摘要：{}", params.world_summary),
        format!("创作意图摘要：{}", params.creator_intent_summary),
        format!("参考锚点：{}", params.anchor_summary),
        format!(
            "已有角色：{}",
            if params.existing_names.is_empty() {
                "暂无".to_string()
            } else {
                params.existing_names.join("、")
            }
        ),
        format!("数量：{}", params.count),
        format!(
            "补充要求：{}",
            if params.prompt_seed.trim().is_empty() {
                "没有额外要求，围绕当前底稿自然扩展。"
            } else {
                params.prompt_seed
            }
        ),
        "返回 JSON 数组。每个对象字段只允许包含：name, role, publicMask, hiddenHook, relationToPlayer, summary, threadIds。".to_string(),
        "threadIds 必须优先引用现有线程 id。".to_string(),
    ]
    .join("\n")
}

fn build_custom_world_agent_landmark_expansion_prompt(params: ExpansionPromptParams<'_>) -> String {
    [
        format!("当前世界：{}", params.world_name),
        format!("世界摘要：{}", params.world_summary),
        format!("创作意图摘要：{}", params.creator_intent_summary),
        format!("参考锚点：{}", params.anchor_summary),
        format!(
            "已有地点：{}",
            if params.existing_names.is_empty() {
                "暂无".to_string()
            } else {
                params.existing_names.join("、")
            }
        ),
        format!("数量：{}", params.count),
        format!(
            "补充要求：{}",
            if params.prompt_seed.trim().is_empty() {
                "没有额外要求，围绕当前底稿自然扩展。"
            } else {
                params.prompt_seed
            }
        ),
        "返回 JSON 数组。每个对象字段只允许包含：name, purpose, mood, secret, summary, threadIds, characterIds。".to_string(),
        "threadIds / characterIds 必须优先引用现有对象 id。".to_string(),
    ]
    .join("\n")
}

fn ensure_count(count: Option<u32>) -> u32 {
    count.unwrap_or(1).clamp(1, 3)
}

fn resolve_role_type(role_type: Option<&str>) -> &'static str {
    match role_type.map(str::trim) {
        Some("playable") => "playable",
        _ => "story",
    }
}

fn parse_json_array_response(text: &str) -> Result<Vec<JsonValue>, serde_json::Error> {
    let trimmed = text.trim();
    if let Some(start) = trimmed.find('[')
        && let Some(end) = trimmed.rfind(']')
        && end >= start
    {
        return serde_json::from_str::<Vec<JsonValue>>(&trimmed[start..=end]);
    }
    serde_json::from_str::<Vec<JsonValue>>(trimmed)
}

fn normalize_generated_entities(
    action: &str,
    entities: Vec<JsonValue>,
    draft_profile: &JsonMap<String, JsonValue>,
    count: u32,
) -> Vec<JsonValue> {
    let mut existing_names = if action == "generate_characters" {
        existing_character_names(draft_profile)
    } else {
        existing_landmark_names(draft_profile)
    };
    entities
        .into_iter()
        .filter_map(|entry| entry.as_object().cloned())
        .filter_map(|mut object| {
            let name = object
                .get("name")
                .and_then(JsonValue::as_str)
                .map(str::trim)
                .filter(|value| !value.is_empty())?
                .to_string();
            if existing_names.iter().any(|entry| entry == &name) {
                return None;
            }
            existing_names.push(name.clone());
            let prefix = if action == "generate_characters" {
                "character"
            } else {
                "landmark"
            };
            object.entry("id".to_string()).or_insert_with(|| {
                JsonValue::String(create_stable_id(
                    prefix,
                    name.as_str(),
                    existing_names.len(),
                ))
            });
            normalize_generated_entity_profile_fields(action, &mut object);
            Some(JsonValue::Object(object))
        })
        .take(count as usize)
        .collect()
}

fn normalize_generated_entity_profile_fields(
    action: &str,
    object: &mut JsonMap<String, JsonValue>,
) {
    if action == "generate_characters" {
        normalize_generated_character_profile_fields(object);
    } else {
        normalize_generated_landmark_profile_fields(object);
    }
}

fn normalize_generated_character_profile_fields(object: &mut JsonMap<String, JsonValue>) {
    let name = read_object_text(object, "name").unwrap_or_else(|| "新场景角色".to_string());
    let role = read_object_text(object, "role").unwrap_or_else(|| "场景角色".to_string());
    let summary = read_first_object_text(object, &["description", "summary", "publicMask"])
        .unwrap_or_else(|| format!("{name}是围绕当前世界新补出的{role}。"));
    let hidden_hook = read_object_text(object, "hiddenHook").unwrap_or_else(|| summary.clone());

    insert_text_if_missing(object, "title", role.as_str());
    insert_text_if_missing(object, "description", summary.as_str());
    insert_text_if_missing(object, "backstory", hidden_hook.as_str());
    insert_text_if_missing(object, "personality", "待在后续互动中揭示");
    insert_text_if_missing(object, "motivation", hidden_hook.as_str());
    insert_text_if_missing(object, "combatStyle", "围绕自身身份采取行动");
    object
        .entry("initialAffinity".to_string())
        .or_insert_with(|| JsonValue::Number(6.into()));

    if !object
        .get("relationshipHooks")
        .is_some_and(JsonValue::is_array)
    {
        let mut hooks = Vec::new();
        if let Some(relation) = read_object_text(object, "relationToPlayer") {
            hooks.push(JsonValue::String(relation));
        }
        if hooks.is_empty() {
            hooks.push(JsonValue::String("等待玩家接触".to_string()));
        }
        object.insert("relationshipHooks".to_string(), JsonValue::Array(hooks));
    }

    if !object.get("tags").is_some_and(JsonValue::is_array) {
        object.insert(
            "tags".to_string(),
            JsonValue::Array(vec![JsonValue::String(role)]),
        );
    }
}

fn normalize_generated_landmark_profile_fields(object: &mut JsonMap<String, JsonValue>) {
    let name = read_object_text(object, "name").unwrap_or_else(|| "新场景".to_string());
    let description = read_first_object_text(object, &["description", "summary", "purpose"])
        .unwrap_or_else(|| format!("{name}是围绕当前世界新补出的关键场景。"));
    let mut description_parts = vec![description];
    for key in ["mood", "secret"] {
        if let Some(text) = read_object_text(object, key)
            && !description_parts.iter().any(|entry| entry == &text)
        {
            description_parts.push(text);
        }
    }

    insert_text_if_missing(object, "description", description_parts.join(" ").as_str());
    object
        .entry("connections".to_string())
        .or_insert_with(|| JsonValue::Array(Vec::new()));

    if !object.get("sceneNpcIds").is_some_and(JsonValue::is_array) {
        let npc_ids = object
            .get("characterIds")
            .and_then(JsonValue::as_array)
            .map(|items| {
                items
                    .iter()
                    .filter_map(JsonValue::as_str)
                    .map(str::trim)
                    .filter(|value| !value.is_empty())
                    .map(|value| JsonValue::String(value.to_string()))
                    .collect::<Vec<_>>()
            })
            .unwrap_or_default();
        object.insert("sceneNpcIds".to_string(), JsonValue::Array(npc_ids));
    }
}

fn read_object_text(object: &JsonMap<String, JsonValue>, key: &str) -> Option<String> {
    object
        .get(key)
        .and_then(JsonValue::as_str)
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .map(ToOwned::to_owned)
}

fn read_first_object_text(object: &JsonMap<String, JsonValue>, keys: &[&str]) -> Option<String> {
    keys.iter().find_map(|key| read_object_text(object, key))
}

fn insert_text_if_missing(object: &mut JsonMap<String, JsonValue>, key: &str, value: &str) {
    if read_object_text(object, key).is_none() {
        object.insert(key.to_string(), JsonValue::String(value.to_string()));
    }
}

fn existing_character_names(draft_profile: &JsonMap<String, JsonValue>) -> Vec<String> {
    ["playableNpcs", "storyNpcs"]
        .into_iter()
        .flat_map(|key| object_array_names(draft_profile.get(key)))
        .take(10)
        .collect()
}

fn existing_landmark_names(draft_profile: &JsonMap<String, JsonValue>) -> Vec<String> {
    object_array_names(draft_profile.get("landmarks"))
        .into_iter()
        .take(10)
        .collect()
}

fn object_array_names(value: Option<&JsonValue>) -> Vec<String> {
    value
        .and_then(JsonValue::as_array)
        .into_iter()
        .flatten()
        .filter_map(|entry| entry.get("name").and_then(JsonValue::as_str))
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .map(ToOwned::to_owned)
        .collect()
}

fn build_anchor_summary(
    draft_profile: &JsonMap<String, JsonValue>,
    anchor_card_ids: &[String],
) -> String {
    let selected = anchor_card_ids
        .iter()
        .filter_map(|card_id| find_anchor_summary(draft_profile, card_id))
        .collect::<Vec<_>>();
    if !selected.is_empty() {
        return selected.join("；");
    }
    draft_profile
        .get("summary")
        .and_then(JsonValue::as_str)
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .unwrap_or("围绕当前世界底稿自然扩展。")
        .to_string()
}

fn find_anchor_summary(
    draft_profile: &JsonMap<String, JsonValue>,
    card_id: &str,
) -> Option<String> {
    for key in ["playableNpcs", "storyNpcs", "landmarks", "threads"] {
        for entry in draft_profile.get(key)?.as_array()? {
            let object = entry.as_object()?;
            let id = object
                .get("id")
                .and_then(JsonValue::as_str)
                .unwrap_or_default();
            if id != card_id {
                continue;
            }
            let name = object
                .get("name")
                .and_then(JsonValue::as_str)
                .unwrap_or_default();
            let summary = object
                .get("summary")
                .or_else(|| object.get("description"))
                .or_else(|| object.get("publicMask"))
                .and_then(JsonValue::as_str)
                .unwrap_or_default();
            return Some(format!("{name}：{summary}"));
        }
    }
    None
}

fn create_stable_id(prefix: &str, name: &str, index: usize) -> String {
    let slug = name
        .trim()
        .to_lowercase()
        .chars()
        .map(|ch| {
            if ch.is_ascii_alphanumeric() || ('\u{4e00}'..='\u{9fa5}').contains(&ch) {
                ch
            } else {
                '-'
            }
        })
        .collect::<String>()
        .trim_matches('-')
        .to_string();
    format!(
        "{prefix}-{}-{index}",
        if slug.is_empty() {
            "entry"
        } else {
            slug.as_str()
        }
    )
}

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

    #[test]
    fn character_expansion_prompt_keeps_node_contract_text() {
        let prompt = build_custom_world_agent_character_expansion_prompt(ExpansionPromptParams {
            world_name: "雾港归航",
            world_summary: "守灯人追查旧案。",
            creator_intent_summary: "悬疑航海",
            anchor_summary: "旧灯塔：灯火错位",
            existing_names: vec!["岑灯".to_string()],
            count: 2,
            prompt_seed: "补一个敌对角色",
        });

        assert!(prompt.contains("返回 JSON 数组。每个对象字段只允许包含：name, role, publicMask, hiddenHook, relationToPlayer, summary, threadIds。"));
        assert!(prompt.contains("threadIds 必须优先引用现有线程 id。"));
    }

    #[test]
    fn generated_entities_payload_injects_expected_key() {
        let payload = ExecuteCustomWorldAgentActionRequest {
            action: "generate_landmarks".to_string(),
            profile_id: None,
            draft_profile: None,
            legacy_result_profile: None,
            setting_text: None,
            card_id: None,
            sections: None,
            profile: None,
            count: Some(1),
            role_type: None,
            prompt_text: Some("补地点".to_string()),
            anchor_card_ids: None,
            role_ids: None,
            role_id: None,
            portrait_path: None,
            generated_visual_asset_id: None,
            generated_animation_set_id: None,
            animation_map: None,
            scene_ids: None,
            scene_id: None,
            scene_kind: None,
            image_src: None,
            generated_scene_asset_id: None,
            generated_scene_prompt: None,
            generated_scene_model: None,
            checkpoint_id: None,
        };

        let payload_json = build_generated_entities_action_payload_json(
            &payload,
            "generatedLandmarks",
            vec![json!({ "name": "沉船湾" })],
        )
        .expect("payload should build");
        let value = serde_json::from_str::<JsonValue>(&payload_json).expect("payload should parse");

        assert_eq!(value.get("action"), Some(&json!("generate_landmarks")));
        assert_eq!(
            value
                .get("generatedLandmarks")
                .and_then(JsonValue::as_array)
                .map(Vec::len),
            Some(1)
        );
    }

    #[test]
    fn generated_character_payload_fills_result_profile_fields() {
        let draft_profile = json!({
            "playableNpcs": [],
            "storyNpcs": [],
            "landmarks": []
        });
        let entities = normalize_generated_entities(
            "generate_characters",
            vec![json!({
                "name": "潮雾证人",
                "role": "旧案目击者",
                "publicMask": "总在码头边缘售卖旧航图。",
                "hiddenHook": "他记得沉钟第一次响起时失踪的人。",
                "relationToPlayer": "掌握玩家亲族旧案线索"
            })],
            draft_profile
                .as_object()
                .expect("draft profile should be object"),
            1,
        );
        let character = entities[0]
            .as_object()
            .expect("generated character should be object");

        assert_eq!(
            character.get("description").and_then(JsonValue::as_str),
            Some("总在码头边缘售卖旧航图。")
        );
        assert_eq!(
            character.get("backstory").and_then(JsonValue::as_str),
            Some("他记得沉钟第一次响起时失踪的人。")
        );
        assert_eq!(
            character
                .get("relationshipHooks")
                .and_then(JsonValue::as_array)
                .and_then(|items| items.first())
                .and_then(JsonValue::as_str),
            Some("掌握玩家亲族旧案线索")
        );
    }

    #[test]
    fn generated_landmark_payload_fills_scene_profile_fields() {
        let draft_profile = json!({
            "playableNpcs": [],
            "storyNpcs": [{ "id": "character-witness", "name": "潮雾证人" }],
            "landmarks": []
        });
        let entities = normalize_generated_entities(
            "generate_landmarks",
            vec![json!({
                "name": "沉钟码头",
                "purpose": "玩家第一次追查沉钟旧案的入口。",
                "mood": "潮湿、压抑、灯火忽明忽暗。",
                "secret": "码头木桩下藏着改写航道的符牌。",
                "characterIds": ["character-witness"]
            })],
            draft_profile
                .as_object()
                .expect("draft profile should be object"),
            1,
        );
        let landmark = entities[0]
            .as_object()
            .expect("generated landmark should be object");

        assert!(
            landmark
                .get("description")
                .and_then(JsonValue::as_str)
                .is_some_and(|text| text.contains("沉钟旧案") && text.contains("符牌"))
        );
        assert_eq!(
            landmark
                .get("sceneNpcIds")
                .and_then(JsonValue::as_array)
                .and_then(|items| items.first())
                .and_then(JsonValue::as_str),
            Some("character-witness")
        );
    }
}