pub(crate) mod tables;
mod types;

pub use tables::*;
pub use types::*;

use crate::{ProcedureContext, ReducerContext, SpacetimeType, Table, Timestamp};
use module_jump_hop::{
    JumpHopDifficulty, JumpHopPath, JumpHopRunSnapshot, apply_jump, generate_jump_hop_path,
    normalize_jump_hop_seed, parse_jump_hop_difficulty, restart_run, start_run,
};
use serde::Serialize;
use serde::de::DeserializeOwned;
use spacetimedb::AnonymousViewContext;

#[spacetimedb::view(accessor = jump_hop_gallery_view, public)]
pub fn jump_hop_gallery_view(ctx: &AnonymousViewContext) -> Vec<JumpHopGalleryViewRow> {
    let mut items = ctx
        .db
        .jump_hop_work_profile()
        .by_jump_hop_work_publication_status()
        .filter(JUMP_HOP_PUBLICATION_PUBLISHED)
        .filter_map(|row| match build_gallery_view_row(&row) {
            Ok(item) => Some(item),
            Err(error) => {
                log::warn!(
                    "跳一跳公开广场 view 跳过损坏的作品投影 profile_id={}: {}",
                    row.profile_id,
                    error
                );
                None
            }
        })
        .collect::<Vec<_>>();
    items.sort_by(|left, right| {
        right
            .updated_at_micros
            .cmp(&left.updated_at_micros)
            .then_with(|| left.profile_id.cmp(&right.profile_id))
    });
    items
}

#[spacetimedb::view(accessor = jump_hop_gallery_card_view, public)]
pub fn jump_hop_gallery_card_view(ctx: &AnonymousViewContext) -> Vec<JumpHopGalleryCardViewRow> {
    jump_hop_gallery_view(ctx)
        .into_iter()
        .map(|row| JumpHopGalleryCardViewRow {
            public_work_code: build_jump_hop_public_work_code(&row.profile_id),
            work_id: row.work_id,
            profile_id: row.profile_id,
            owner_user_id: row.owner_user_id,
            author_display_name: row.author_display_name,
            work_title: row.work_title,
            work_description: row.work_description,
            theme_tags: row.theme_tags,
            difficulty: row.difficulty,
            style_preset: row.style_preset,
            cover_image_src: row.cover_image_src,
            publication_status: row.publication_status,
            play_count: row.play_count,
            updated_at_micros: row.updated_at_micros,
            published_at_micros: row.published_at_micros,
            generation_status: row.generation_status,
        })
        .collect()
}

#[derive(Clone, Debug, PartialEq, SpacetimeType)]
pub struct JumpHopGalleryViewRow {
    pub work_id: String,
    pub profile_id: String,
    pub owner_user_id: String,
    pub source_session_id: String,
    pub author_display_name: String,
    pub work_title: String,
    pub work_description: String,
    pub theme_tags: Vec<String>,
    pub difficulty: String,
    pub style_preset: String,
    pub character_prompt: String,
    pub tile_prompt: String,
    pub end_mood_prompt: Option<String>,
    pub character_asset: Option<JumpHopCharacterAssetSnapshot>,
    pub tile_atlas_asset: Option<JumpHopCharacterAssetSnapshot>,
    pub tile_assets: Vec<JumpHopTileAssetSnapshot>,
    pub path: JumpHopPath,
    pub cover_image_src: String,
    pub cover_composite: Option<String>,
    pub publication_status: String,
    pub publish_ready: bool,
    pub play_count: u32,
    pub generation_status: String,
    pub updated_at_micros: i64,
    pub published_at_micros: Option<i64>,
}

#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
pub struct JumpHopGalleryCardViewRow {
    pub public_work_code: String,
    pub work_id: String,
    pub profile_id: String,
    pub owner_user_id: String,
    pub author_display_name: String,
    pub work_title: String,
    pub work_description: String,
    pub theme_tags: Vec<String>,
    pub difficulty: String,
    pub style_preset: String,
    pub cover_image_src: String,
    pub publication_status: String,
    pub play_count: u32,
    pub updated_at_micros: i64,
    pub published_at_micros: Option<i64>,
    pub generation_status: String,
}

#[spacetimedb::procedure]
pub fn create_jump_hop_agent_session(
    ctx: &mut ProcedureContext,
    input: JumpHopAgentSessionCreateInput,
) -> JumpHopAgentSessionProcedureResult {
    match ctx.try_with_tx(|tx| create_jump_hop_agent_session_tx(tx, input.clone())) {
        Ok(session) => session_result(session),
        Err(message) => session_error(message),
    }
}

#[spacetimedb::procedure]
pub fn get_jump_hop_agent_session(
    ctx: &mut ProcedureContext,
    input: JumpHopAgentSessionGetInput,
) -> JumpHopAgentSessionProcedureResult {
    match ctx.try_with_tx(|tx| get_jump_hop_agent_session_tx(tx, input.clone())) {
        Ok(session) => session_result(session),
        Err(message) => session_error(message),
    }
}

#[spacetimedb::procedure]
pub fn compile_jump_hop_draft(
    ctx: &mut ProcedureContext,
    input: JumpHopDraftCompileInput,
) -> JumpHopAgentSessionProcedureResult {
    match ctx.try_with_tx(|tx| compile_jump_hop_draft_tx(tx, input.clone())) {
        Ok(session) => session_result(session),
        Err(message) => session_error(message),
    }
}

#[spacetimedb::procedure]
pub fn get_jump_hop_work_profile(
    ctx: &mut ProcedureContext,
    input: JumpHopWorkGetInput,
) -> JumpHopWorkProcedureResult {
    match ctx.try_with_tx(|tx| get_jump_hop_work_profile_tx(tx, input.clone())) {
        Ok(work) => work_result(work),
        Err(message) => work_error(message),
    }
}

#[spacetimedb::procedure]
pub fn update_jump_hop_work(
    ctx: &mut ProcedureContext,
    input: JumpHopWorkUpdateInput,
) -> JumpHopWorkProcedureResult {
    match ctx.try_with_tx(|tx| update_jump_hop_work_tx(tx, input.clone())) {
        Ok(work) => work_result(work),
        Err(message) => work_error(message),
    }
}

#[spacetimedb::procedure]
pub fn publish_jump_hop_work(
    ctx: &mut ProcedureContext,
    input: JumpHopWorkPublishInput,
) -> JumpHopWorkProcedureResult {
    match ctx.try_with_tx(|tx| publish_jump_hop_work_tx(tx, input.clone())) {
        Ok(work) => work_result(work),
        Err(message) => work_error(message),
    }
}

#[spacetimedb::procedure]
pub fn list_jump_hop_works(
    ctx: &mut ProcedureContext,
    input: JumpHopWorksListInput,
) -> JumpHopWorksProcedureResult {
    match ctx.try_with_tx(|tx| list_jump_hop_works_tx(tx, input.clone())) {
        Ok(items) => JumpHopWorksProcedureResult {
            ok: true,
            items,
            error_message: None,
        },
        Err(message) => JumpHopWorksProcedureResult {
            ok: false,
            items: Vec::new(),
            error_message: Some(message),
        },
    }
}

#[spacetimedb::procedure]
pub fn start_jump_hop_run(
    ctx: &mut ProcedureContext,
    input: JumpHopRunStartInput,
) -> JumpHopRunProcedureResult {
    match ctx.try_with_tx(|tx| start_jump_hop_run_tx(tx, input.clone())) {
        Ok(run) => run_result(run),
        Err(message) => run_error(message),
    }
}

#[spacetimedb::procedure]
pub fn get_jump_hop_run(
    ctx: &mut ProcedureContext,
    input: JumpHopRunGetInput,
) -> JumpHopRunProcedureResult {
    match ctx.try_with_tx(|tx| get_jump_hop_run_tx(tx, input.clone())) {
        Ok(run) => run_result(run),
        Err(message) => run_error(message),
    }
}

#[spacetimedb::procedure]
pub fn jump_hop_jump(
    ctx: &mut ProcedureContext,
    input: JumpHopRunJumpInput,
) -> JumpHopRunProcedureResult {
    match ctx.try_with_tx(|tx| jump_hop_jump_tx(tx, input.clone())) {
        Ok(run) => run_result(run),
        Err(message) => run_error(message),
    }
}

#[spacetimedb::procedure]
pub fn restart_jump_hop_run(
    ctx: &mut ProcedureContext,
    input: JumpHopRunRestartInput,
) -> JumpHopRunProcedureResult {
    match ctx.try_with_tx(|tx| restart_jump_hop_run_tx(tx, input.clone())) {
        Ok(run) => run_result(run),
        Err(message) => run_error(message),
    }
}

fn create_jump_hop_agent_session_tx(
    ctx: &ReducerContext,
    input: JumpHopAgentSessionCreateInput,
) -> Result<JumpHopAgentSessionSnapshot, String> {
    require_non_empty(&input.session_id, "jump_hop session_id")?;
    require_non_empty(&input.owner_user_id, "jump_hop owner_user_id")?;
    if ctx
        .db
        .jump_hop_agent_session()
        .session_id()
        .find(&input.session_id)
        .is_some()
    {
        return Err("jump_hop_agent_session.session_id 已存在".to_string());
    }

    let created_at = Timestamp::from_micros_since_unix_epoch(input.created_at_micros);
    let config = input
        .config_json
        .as_deref()
        .map(parse_config)
        .transpose()?
        .unwrap_or_else(|| default_config_from_seed(&input.seed_text));
    let draft = JumpHopDraftSnapshot {
        template_id: JUMP_HOP_TEMPLATE_ID.to_string(),
        template_name: JUMP_HOP_TEMPLATE_NAME.to_string(),
        profile_id: None,
        work_title: input.work_title.clone(),
        work_description: input.work_description.clone(),
        theme_tags: parse_tags(input.theme_tags_json.as_deref().unwrap_or("[]"))?,
        difficulty: config.difficulty.clone(),
        style_preset: config.style_preset.clone(),
        character_prompt: config.character_prompt.clone(),
        tile_prompt: config.tile_prompt.clone(),
        end_mood_prompt: clean_optional(&config.end_mood_prompt),
        character_asset: None,
        tile_atlas_asset: None,
        tile_assets: Vec::new(),
        path: None,
        cover_composite: None,
        generation_status: JUMP_HOP_GENERATION_DRAFT.to_string(),
    };
    ctx.db
        .jump_hop_agent_session()
        .insert(JumpHopAgentSessionRow {
            session_id: input.session_id.clone(),
            owner_user_id: input.owner_user_id.clone(),
            seed_text: input.seed_text.trim().to_string(),
            current_turn: 0,
            progress_percent: 0,
            stage: JUMP_HOP_STAGE_COLLECTING.to_string(),
            config_json: to_json_string(&config),
            draft_json: to_json_string(&draft),
            last_assistant_reply: input.welcome_message_text.trim().to_string(),
            published_profile_id: String::new(),
            created_at,
            updated_at: created_at,
        });

    get_jump_hop_agent_session_tx(
        ctx,
        JumpHopAgentSessionGetInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
        },
    )
}

fn get_jump_hop_agent_session_tx(
    ctx: &ReducerContext,
    input: JumpHopAgentSessionGetInput,
) -> Result<JumpHopAgentSessionSnapshot, String> {
    let row = find_owned_session(ctx, &input.session_id, &input.owner_user_id)?;
    build_session_snapshot(&row)
}

fn compile_jump_hop_draft_tx(
    ctx: &ReducerContext,
    input: JumpHopDraftCompileInput,
) -> Result<JumpHopAgentSessionSnapshot, String> {
    require_non_empty(&input.profile_id, "jump_hop profile_id")?;
    let session = find_owned_session(ctx, &input.session_id, &input.owner_user_id)?;
    let mut config = parse_config(&session.config_json)?;
    apply_compile_overrides(&mut config, &input)?;

    let seed = normalize_jump_hop_seed(&input.seed_text, &session.seed_text);
    let path = generate_jump_hop_path(&seed, parse_jump_hop_difficulty(&config.difficulty));
    let tags = parse_tags(input.theme_tags_json.as_deref().unwrap_or("[]"))?;
    let draft = JumpHopDraftSnapshot {
        template_id: JUMP_HOP_TEMPLATE_ID.to_string(),
        template_name: JUMP_HOP_TEMPLATE_NAME.to_string(),
        profile_id: Some(input.profile_id.clone()),
        work_title: clean_string(&input.work_title, "跳一跳作品"),
        work_description: input.work_description.trim().to_string(),
        theme_tags: tags.clone(),
        difficulty: config.difficulty.clone(),
        style_preset: config.style_preset.clone(),
        character_prompt: config.character_prompt.clone(),
        tile_prompt: config.tile_prompt.clone(),
        end_mood_prompt: clean_optional(&config.end_mood_prompt),
        character_asset: input
            .character_asset_json
            .as_deref()
            .map(parse_json)
            .transpose()?,
        tile_atlas_asset: input
            .tile_atlas_asset_json
            .as_deref()
            .map(parse_json)
            .transpose()?,
        tile_assets: input
            .tile_assets_json
            .as_deref()
            .map(parse_json)
            .transpose()?
            .unwrap_or_default(),
        path: Some(path.clone()),
        cover_composite: input.cover_composite.as_deref().and_then(clean_optional),
        generation_status: input
            .generation_status
            .clone()
            .unwrap_or_else(|| JUMP_HOP_GENERATION_READY.to_string()),
    };
    let compiled_at = Timestamp::from_micros_since_unix_epoch(input.compiled_at_micros);
    let row = JumpHopWorkProfileRow {
        profile_id: input.profile_id.clone(),
        work_id: input.profile_id.clone(),
        owner_user_id: input.owner_user_id.clone(),
        source_session_id: input.session_id.clone(),
        author_display_name: clean_string(&input.author_display_name, "跳一跳玩家"),
        work_title: draft.work_title.clone(),
        work_description: draft.work_description.clone(),
        theme_tags_json: to_json_string(&tags),
        difficulty: draft.difficulty.clone(),
        style_preset: draft.style_preset.clone(),
        character_prompt: draft.character_prompt.clone(),
        tile_prompt: draft.tile_prompt.clone(),
        end_mood_prompt: draft.end_mood_prompt.clone().unwrap_or_default(),
        character_asset_json: draft
            .character_asset
            .as_ref()
            .map(to_json_string)
            .unwrap_or_default(),
        tile_atlas_asset_json: draft
            .tile_atlas_asset
            .as_ref()
            .map(to_json_string)
            .unwrap_or_default(),
        tile_assets_json: to_json_string(&draft.tile_assets),
        path_json: to_json_string(&path),
        cover_image_src: draft.cover_composite.clone().unwrap_or_default(),
        cover_composite: draft.cover_composite.clone().unwrap_or_default(),
        generation_status: draft.generation_status.clone(),
        publication_status: JUMP_HOP_PUBLICATION_DRAFT.to_string(),
        play_count: 0,
        updated_at: compiled_at,
        published_at: None,
    };
    upsert_work(ctx, row);
    replace_session(
        ctx,
        &session,
        JumpHopAgentSessionRow {
            progress_percent: 100,
            stage: JUMP_HOP_STAGE_DRAFT_COMPILED.to_string(),
            config_json: to_json_string(&config),
            draft_json: to_json_string(&draft),
            published_profile_id: input.profile_id,
            last_assistant_reply: "跳一跳草稿已生成，可以进入结果页试玩和发布。".to_string(),
            updated_at: compiled_at,
            ..clone_session(&session)
        },
    );

    get_jump_hop_agent_session_tx(
        ctx,
        JumpHopAgentSessionGetInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
        },
    )
}

fn get_jump_hop_work_profile_tx(
    ctx: &ReducerContext,
    input: JumpHopWorkGetInput,
) -> Result<JumpHopWorkSnapshot, String> {
    let row = find_work(ctx, &input.profile_id)?;
    if !input.owner_user_id.trim().is_empty() && row.owner_user_id != input.owner_user_id {
        return Err("无权访问该 jump_hop work".to_string());
    }
    build_work_snapshot(&row)
}

fn update_jump_hop_work_tx(
    ctx: &ReducerContext,
    input: JumpHopWorkUpdateInput,
) -> Result<JumpHopWorkSnapshot, String> {
    let row = find_owned_work(ctx, &input.profile_id, &input.owner_user_id)?;
    let updated_at = Timestamp::from_micros_since_unix_epoch(input.updated_at_micros);
    let mut next = clone_work(&row);
    next.work_title = clean_string(&input.work_title, &row.work_title);
    next.work_description = input.work_description.trim().to_string();
    next.theme_tags_json = input.theme_tags_json.clone();
    if let Some(difficulty) = input.difficulty.as_deref().and_then(clean_optional) {
        next.difficulty = difficulty;
        let path = generate_jump_hop_path(
            &normalize_jump_hop_seed(&row.profile_id, &row.source_session_id),
            parse_jump_hop_difficulty(&next.difficulty),
        );
        next.path_json = to_json_string(&path);
    }
    if let Some(style_preset) = input.style_preset.as_deref().and_then(clean_optional) {
        next.style_preset = style_preset;
    }
    if let Some(cover) = input.cover_image_src.as_deref().and_then(clean_optional) {
        next.cover_image_src = cover;
    }
    if let Some(cover) = input.cover_composite.as_deref().and_then(clean_optional) {
        next.cover_composite = cover;
    }
    next.updated_at = updated_at;
    replace_work(ctx, &row, next);
    let updated = find_work(ctx, &row.profile_id)?;
    sync_session_from_work_update(ctx, &updated, updated_at)?;
    build_work_snapshot(&updated)
}

fn publish_jump_hop_work_tx(
    ctx: &ReducerContext,
    input: JumpHopWorkPublishInput,
) -> Result<JumpHopWorkSnapshot, String> {
    let row = find_owned_work(ctx, &input.profile_id, &input.owner_user_id)?;
    let published_at = Timestamp::from_micros_since_unix_epoch(input.published_at_micros);
    replace_work(
        ctx,
        &row,
        JumpHopWorkProfileRow {
            publication_status: JUMP_HOP_PUBLICATION_PUBLISHED.to_string(),
            updated_at: published_at,
            published_at: Some(published_at),
            ..clone_work(&row)
        },
    );
    if let Some(session) = ctx
        .db
        .jump_hop_agent_session()
        .session_id()
        .find(&row.source_session_id)
    {
        replace_session(
            ctx,
            &session,
            JumpHopAgentSessionRow {
                stage: JUMP_HOP_STAGE_PUBLISHED.to_string(),
                updated_at: published_at,
                ..clone_session(&session)
            },
        );
    }
    let updated = find_work(ctx, &row.profile_id)?;
    build_work_snapshot(&updated)
}

fn list_jump_hop_works_tx(
    ctx: &ReducerContext,
    input: JumpHopWorksListInput,
) -> Result<Vec<JumpHopWorkSnapshot>, String> {
    let mut rows = if input.owner_user_id.trim().is_empty() {
        ctx.db.jump_hop_work_profile().iter().collect::<Vec<_>>()
    } else {
        ctx.db
            .jump_hop_work_profile()
            .by_jump_hop_work_owner_user_id()
            .filter(input.owner_user_id.as_str())
            .collect::<Vec<_>>()
    };
    if input.published_only {
        rows.retain(|row| row.publication_status == JUMP_HOP_PUBLICATION_PUBLISHED);
    }
    rows.sort_by(|left, right| {
        right
            .updated_at
            .cmp(&left.updated_at)
            .then_with(|| left.profile_id.cmp(&right.profile_id))
    });
    rows.into_iter()
        .map(|row| build_work_snapshot(&row))
        .collect()
}

fn start_jump_hop_run_tx(
    ctx: &ReducerContext,
    input: JumpHopRunStartInput,
) -> Result<JumpHopRunSnapshot, String> {
    require_non_empty(&input.run_id, "jump_hop run_id")?;
    let work = find_work(ctx, &input.profile_id)?;
    let path = parse_json::<JumpHopPath>(&work.path_json)?;
    let domain_run = start_run(
        input.run_id.clone(),
        input.owner_user_id.clone(),
        input.profile_id.clone(),
        path,
        input.started_at_ms as u64,
    )
    .map_err(|error| error.to_string())?;
    let snapshot = domain_run;
    upsert_run(ctx, &snapshot, input.started_at_ms);
    increment_work_play_count(ctx, &work, input.started_at_ms);
    insert_event(
        ctx,
        input.client_event_id,
        input.owner_user_id,
        input.profile_id,
        input.run_id,
        JUMP_HOP_EVENT_RUN_STARTED,
        None,
        input.started_at_ms,
    );
    Ok(snapshot)
}

fn get_jump_hop_run_tx(
    ctx: &ReducerContext,
    input: JumpHopRunGetInput,
) -> Result<JumpHopRunSnapshot, String> {
    let row = find_owned_run(ctx, &input.run_id, &input.owner_user_id)?;
    parse_json(&row.snapshot_json)
}

fn jump_hop_jump_tx(
    ctx: &ReducerContext,
    input: JumpHopRunJumpInput,
) -> Result<JumpHopRunSnapshot, String> {
    let row = find_owned_run(ctx, &input.run_id, &input.owner_user_id)?;
    let snapshot = parse_json::<JumpHopRunSnapshot>(&row.snapshot_json)?;
    let domain_next = apply_jump(&snapshot, input.charge_ms, input.jumped_at_ms as u64)
        .map_err(|error| error.to_string())?;
    let next = domain_next;
    replace_run(ctx, &row, &next, input.jumped_at_ms);
    insert_event(
        ctx,
        input.client_event_id,
        input.owner_user_id,
        next.profile_id.clone(),
        input.run_id,
        JUMP_HOP_EVENT_JUMP,
        next.last_jump
            .as_ref()
            .map(|jump| jump.result.as_str().to_string())
            .or_else(|| Some(next.status.as_str().to_string())),
        input.jumped_at_ms,
    );
    Ok(next)
}

fn restart_jump_hop_run_tx(
    ctx: &ReducerContext,
    input: JumpHopRunRestartInput,
) -> Result<JumpHopRunSnapshot, String> {
    let source = find_owned_run(ctx, &input.source_run_id, &input.owner_user_id)?;
    let snapshot = parse_json::<JumpHopRunSnapshot>(&source.snapshot_json)?;
    let domain_next = restart_run(
        &snapshot,
        input.next_run_id.clone(),
        input.restarted_at_ms as u64,
    )
    .map_err(|error| error.to_string())?;
    let next = domain_next;
    upsert_run(ctx, &next, input.restarted_at_ms);
    insert_event(
        ctx,
        input.client_action_id,
        input.owner_user_id,
        next.profile_id.clone(),
        input.next_run_id,
        JUMP_HOP_EVENT_RUN_RESTARTED,
        None,
        input.restarted_at_ms,
    );
    Ok(next)
}

fn build_gallery_view_row(row: &JumpHopWorkProfileRow) -> Result<JumpHopGalleryViewRow, String> {
    let work = build_work_snapshot(row)?;
    Ok(JumpHopGalleryViewRow {
        work_id: work.work_id,
        profile_id: work.profile_id,
        owner_user_id: work.owner_user_id,
        source_session_id: work.source_session_id,
        author_display_name: work.author_display_name,
        work_title: work.work_title,
        work_description: work.work_description,
        theme_tags: work.theme_tags,
        difficulty: work.difficulty,
        style_preset: work.style_preset,
        character_prompt: work.character_prompt,
        tile_prompt: work.tile_prompt,
        end_mood_prompt: work.end_mood_prompt,
        character_asset: work.character_asset,
        tile_atlas_asset: work.tile_atlas_asset,
        tile_assets: work.tile_assets,
        path: work.path,
        cover_image_src: work.cover_image_src,
        cover_composite: work.cover_composite,
        publication_status: work.publication_status,
        publish_ready: work.publish_ready,
        play_count: work.play_count,
        generation_status: work.generation_status,
        updated_at_micros: work.updated_at_micros,
        published_at_micros: work.published_at_micros,
    })
}

fn build_jump_hop_public_work_code(profile_id: &str) -> String {
    let normalized = profile_id
        .chars()
        .filter(|character| character.is_ascii_alphanumeric())
        .flat_map(|character| character.to_uppercase())
        .collect::<String>();
    let fallback = if normalized.is_empty() {
        "00000000".to_string()
    } else {
        normalized
    };
    let suffix = if fallback.len() > 8 {
        fallback[fallback.len() - 8..].to_string()
    } else {
        format!("{fallback:0>8}")
    };
    format!("JH-{suffix}")
}

fn build_session_snapshot(
    row: &JumpHopAgentSessionRow,
) -> Result<JumpHopAgentSessionSnapshot, String> {
    Ok(JumpHopAgentSessionSnapshot {
        session_id: row.session_id.clone(),
        owner_user_id: row.owner_user_id.clone(),
        seed_text: row.seed_text.clone(),
        current_turn: row.current_turn,
        progress_percent: row.progress_percent,
        stage: row.stage.clone(),
        config: parse_config(&row.config_json)?,
        draft: clean_optional(&row.draft_json)
            .map(|value| parse_json(&value))
            .transpose()?,
        last_assistant_reply: row.last_assistant_reply.clone(),
        published_profile_id: clean_optional(&row.published_profile_id),
        created_at_micros: row.created_at.to_micros_since_unix_epoch(),
        updated_at_micros: row.updated_at.to_micros_since_unix_epoch(),
    })
}

fn build_work_snapshot(row: &JumpHopWorkProfileRow) -> Result<JumpHopWorkSnapshot, String> {
    let path = parse_json(&row.path_json)?;
    Ok(JumpHopWorkSnapshot {
        work_id: row.work_id.clone(),
        profile_id: row.profile_id.clone(),
        owner_user_id: row.owner_user_id.clone(),
        source_session_id: row.source_session_id.clone(),
        author_display_name: row.author_display_name.clone(),
        work_title: row.work_title.clone(),
        work_description: row.work_description.clone(),
        theme_tags: parse_tags(&row.theme_tags_json)?,
        difficulty: row.difficulty.clone(),
        style_preset: row.style_preset.clone(),
        character_prompt: row.character_prompt.clone(),
        tile_prompt: row.tile_prompt.clone(),
        end_mood_prompt: clean_optional(&row.end_mood_prompt),
        character_asset: clean_optional(&row.character_asset_json)
            .map(|value| parse_json(&value))
            .transpose()?,
        tile_atlas_asset: clean_optional(&row.tile_atlas_asset_json)
            .map(|value| parse_json(&value))
            .transpose()?,
        tile_assets: parse_json_or_default(&row.tile_assets_json),
        path,
        cover_image_src: row.cover_image_src.clone(),
        cover_composite: clean_optional(&row.cover_composite),
        publication_status: row.publication_status.clone(),
        publish_ready: is_publish_ready(row),
        play_count: row.play_count,
        generation_status: row.generation_status.clone(),
        updated_at_micros: row.updated_at.to_micros_since_unix_epoch(),
        published_at_micros: row
            .published_at
            .map(|value| value.to_micros_since_unix_epoch()),
    })
}

fn sync_session_from_work_update(
    ctx: &ReducerContext,
    work: &JumpHopWorkProfileRow,
    updated_at: Timestamp,
) -> Result<(), String> {
    let Some(session) = ctx
        .db
        .jump_hop_agent_session()
        .session_id()
        .find(&work.source_session_id)
    else {
        return Ok(());
    };

    let mut config = parse_config(&session.config_json)?;
    config.theme_text = work.work_title.clone();
    config.difficulty = work.difficulty.clone();
    config.style_preset = work.style_preset.clone();
    config.character_prompt = work.character_prompt.clone();
    config.tile_prompt = work.tile_prompt.clone();
    config.end_mood_prompt = work.end_mood_prompt.clone();

    let draft = JumpHopDraftSnapshot {
        template_id: JUMP_HOP_TEMPLATE_ID.to_string(),
        template_name: JUMP_HOP_TEMPLATE_NAME.to_string(),
        profile_id: Some(work.profile_id.clone()),
        work_title: work.work_title.clone(),
        work_description: work.work_description.clone(),
        theme_tags: parse_tags(&work.theme_tags_json)?,
        difficulty: work.difficulty.clone(),
        style_preset: work.style_preset.clone(),
        character_prompt: work.character_prompt.clone(),
        tile_prompt: work.tile_prompt.clone(),
        end_mood_prompt: clean_optional(&work.end_mood_prompt),
        character_asset: clean_optional(&work.character_asset_json)
            .map(|value| parse_json(&value))
            .transpose()?,
        tile_atlas_asset: clean_optional(&work.tile_atlas_asset_json)
            .map(|value| parse_json(&value))
            .transpose()?,
        tile_assets: parse_json_or_default(&work.tile_assets_json),
        path: Some(parse_json(&work.path_json)?),
        cover_composite: clean_optional(&work.cover_composite),
        generation_status: work.generation_status.clone(),
    };

    replace_session(
        ctx,
        &session,
        JumpHopAgentSessionRow {
            config_json: to_json_string(&config),
            draft_json: to_json_string(&draft),
            updated_at,
            ..clone_session(&session)
        },
    );
    Ok(())
}

fn find_owned_session(
    ctx: &ReducerContext,
    session_id: &str,
    owner_user_id: &str,
) -> Result<JumpHopAgentSessionRow, String> {
    let row = ctx
        .db
        .jump_hop_agent_session()
        .session_id()
        .find(&session_id.to_string())
        .ok_or_else(|| "jump_hop_agent_session 不存在".to_string())?;
    if row.owner_user_id != owner_user_id {
        return Err("无权访问该 jump_hop session".to_string());
    }
    Ok(row)
}

fn find_work(ctx: &ReducerContext, profile_id: &str) -> Result<JumpHopWorkProfileRow, String> {
    ctx.db
        .jump_hop_work_profile()
        .profile_id()
        .find(&profile_id.to_string())
        .ok_or_else(|| "jump_hop_work_profile 不存在".to_string())
}

fn find_owned_work(
    ctx: &ReducerContext,
    profile_id: &str,
    owner_user_id: &str,
) -> Result<JumpHopWorkProfileRow, String> {
    let row = find_work(ctx, profile_id)?;
    if row.owner_user_id != owner_user_id {
        return Err("无权访问该 jump_hop work".to_string());
    }
    Ok(row)
}

fn find_owned_run(
    ctx: &ReducerContext,
    run_id: &str,
    owner_user_id: &str,
) -> Result<JumpHopRuntimeRunRow, String> {
    let row = ctx
        .db
        .jump_hop_runtime_run()
        .run_id()
        .find(&run_id.to_string())
        .ok_or_else(|| "jump_hop_runtime_run 不存在".to_string())?;
    if row.owner_user_id != owner_user_id {
        return Err("无权访问该 jump_hop run".to_string());
    }
    Ok(row)
}

fn upsert_work(ctx: &ReducerContext, row: JumpHopWorkProfileRow) {
    if let Some(old) = ctx
        .db
        .jump_hop_work_profile()
        .profile_id()
        .find(&row.profile_id)
    {
        ctx.db.jump_hop_work_profile().delete(old);
    }
    ctx.db.jump_hop_work_profile().insert(row);
}

fn replace_work(ctx: &ReducerContext, old: &JumpHopWorkProfileRow, next: JumpHopWorkProfileRow) {
    ctx.db.jump_hop_work_profile().delete(clone_work(old));
    ctx.db.jump_hop_work_profile().insert(next);
}

fn replace_session(
    ctx: &ReducerContext,
    old: &JumpHopAgentSessionRow,
    next: JumpHopAgentSessionRow,
) {
    ctx.db.jump_hop_agent_session().delete(clone_session(old));
    ctx.db.jump_hop_agent_session().insert(next);
}

fn upsert_run(ctx: &ReducerContext, snapshot: &JumpHopRunSnapshot, updated_at_ms: i64) {
    if let Some(old) = ctx
        .db
        .jump_hop_runtime_run()
        .run_id()
        .find(&snapshot.run_id)
    {
        ctx.db.jump_hop_runtime_run().delete(old);
    }
    let created_at = Timestamp::from_micros_since_unix_epoch(updated_at_ms.saturating_mul(1000));
    ctx.db
        .jump_hop_runtime_run()
        .insert(run_row_from_snapshot(snapshot, created_at, created_at));
}

fn replace_run(
    ctx: &ReducerContext,
    old: &JumpHopRuntimeRunRow,
    snapshot: &JumpHopRunSnapshot,
    updated_at_ms: i64,
) {
    ctx.db.jump_hop_runtime_run().delete(clone_run(old));
    ctx.db.jump_hop_runtime_run().insert(run_row_from_snapshot(
        snapshot,
        old.created_at,
        Timestamp::from_micros_since_unix_epoch(updated_at_ms.saturating_mul(1000)),
    ));
}

fn run_row_from_snapshot(
    snapshot: &JumpHopRunSnapshot,
    created_at: Timestamp,
    updated_at: Timestamp,
) -> JumpHopRuntimeRunRow {
    JumpHopRuntimeRunRow {
        run_id: snapshot.run_id.clone(),
        owner_user_id: snapshot.owner_user_id.clone(),
        profile_id: snapshot.profile_id.clone(),
        status: snapshot.status.as_str().to_string(),
        started_at_ms: snapshot.started_at_ms as i64,
        finished_at_ms: snapshot
            .finished_at_ms
            .map(|value| value as i64)
            .unwrap_or(0),
        current_platform_index: snapshot.current_platform_index,
        score: snapshot.score,
        combo: snapshot.combo,
        snapshot_json: to_json_string(snapshot),
        created_at,
        updated_at,
    }
}

fn increment_work_play_count(ctx: &ReducerContext, row: &JumpHopWorkProfileRow, played_at_ms: i64) {
    replace_work(
        ctx,
        row,
        JumpHopWorkProfileRow {
            play_count: row.play_count.saturating_add(1),
            updated_at: Timestamp::from_micros_since_unix_epoch(played_at_ms.saturating_mul(1000)),
            ..clone_work(row)
        },
    );
}

fn insert_event(
    ctx: &ReducerContext,
    event_id: String,
    owner_user_id: String,
    profile_id: String,
    run_id: String,
    event_type: &str,
    result: Option<String>,
    occurred_at_ms: i64,
) {
    let event_id = clean_optional(&event_id).unwrap_or_else(|| {
        format!(
            "jump-hop-event-{}-{}-{}",
            run_id, event_type, occurred_at_ms
        )
    });
    if ctx.db.jump_hop_event().event_id().find(&event_id).is_some() {
        return;
    }
    ctx.db.jump_hop_event().insert(JumpHopEventRow {
        event_id,
        owner_user_id,
        profile_id,
        run_id,
        event_type: event_type.to_string(),
        result: result.unwrap_or_default(),
        occurred_at: Timestamp::from_micros_since_unix_epoch(occurred_at_ms.saturating_mul(1000)),
    });
}

fn is_publish_ready(row: &JumpHopWorkProfileRow) -> bool {
    !row.work_title.trim().is_empty()
        && !row.character_asset_json.trim().is_empty()
        && !row.tile_atlas_asset_json.trim().is_empty()
        && !row.tile_assets_json.trim().is_empty()
        && !row.path_json.trim().is_empty()
}

fn default_config_from_seed(seed_text: &str) -> JumpHopCreatorConfigSnapshot {
    let seed = clean_string(seed_text, "跳一跳");
    JumpHopCreatorConfigSnapshot {
        theme_text: seed.clone(),
        difficulty: JumpHopDifficulty::Standard.as_str().to_string(),
        style_preset: JUMP_HOP_STYLE_MINIMAL_BLOCKS.to_string(),
        character_prompt: format!("{seed}的俯视角主角，透明背景，全身可见"),
        tile_prompt: format!("{seed}的等距地块图集，包含起点、普通、目标和终点地块"),
        end_mood_prompt: String::new(),
    }
}

fn apply_compile_overrides(
    config: &mut JumpHopCreatorConfigSnapshot,
    input: &JumpHopDraftCompileInput,
) -> Result<(), String> {
    if let Some(value) = input.theme_text.as_deref().and_then(clean_optional) {
        config.theme_text = value;
    }
    if let Some(value) = input.difficulty.as_deref().and_then(clean_optional) {
        config.difficulty = value;
    }
    if let Some(value) = input.style_preset.as_deref().and_then(clean_optional) {
        config.style_preset = value;
    }
    if let Some(value) = input.character_prompt.as_deref().and_then(clean_optional) {
        config.character_prompt = value;
    }
    if let Some(value) = input.tile_prompt.as_deref().and_then(clean_optional) {
        config.tile_prompt = value;
    }
    if let Some(value) = input.end_mood_prompt.as_deref().and_then(clean_optional) {
        config.end_mood_prompt = value;
    }
    require_non_empty(&config.theme_text, "jump_hop theme_text")?;
    require_non_empty(&config.character_prompt, "jump_hop character_prompt")?;
    require_non_empty(&config.tile_prompt, "jump_hop tile_prompt")?;
    Ok(())
}

fn require_non_empty(value: &str, label: &str) -> Result<(), String> {
    if value.trim().is_empty() {
        Err(format!("{label} 不能为空"))
    } else {
        Ok(())
    }
}

fn clean_optional(value: &str) -> Option<String> {
    let value = value.trim();
    if value.is_empty() {
        None
    } else {
        Some(value.to_string())
    }
}

fn clean_string(value: &str, fallback: &str) -> String {
    clean_optional(value).unwrap_or_else(|| fallback.to_string())
}

fn parse_config(value: &str) -> Result<JumpHopCreatorConfigSnapshot, String> {
    parse_json(value)
}

fn parse_tags(value: &str) -> Result<Vec<String>, String> {
    Ok(parse_json_or_default::<Vec<String>>(value)
        .into_iter()
        .map(|tag| tag.trim().to_string())
        .filter(|tag| !tag.is_empty())
        .take(8)
        .collect())
}

fn parse_json<T>(value: &str) -> Result<T, String>
where
    T: DeserializeOwned,
{
    serde_json::from_str(value).map_err(|error| error.to_string())
}

fn parse_json_or_default<T>(value: &str) -> T
where
    T: DeserializeOwned + Default,
{
    serde_json::from_str(value).unwrap_or_default()
}

fn to_json_string<T>(value: &T) -> String
where
    T: Serialize,
{
    serde_json::to_string(value).unwrap_or_else(|_| "{}".to_string())
}

fn session_result(session: JumpHopAgentSessionSnapshot) -> JumpHopAgentSessionProcedureResult {
    JumpHopAgentSessionProcedureResult {
        ok: true,
        session: Some(session),
        error_message: None,
    }
}

fn session_error(message: String) -> JumpHopAgentSessionProcedureResult {
    JumpHopAgentSessionProcedureResult {
        ok: false,
        session: None,
        error_message: Some(message),
    }
}

fn work_result(work: JumpHopWorkSnapshot) -> JumpHopWorkProcedureResult {
    JumpHopWorkProcedureResult {
        ok: true,
        work: Some(work),
        error_message: None,
    }
}

fn work_error(message: String) -> JumpHopWorkProcedureResult {
    JumpHopWorkProcedureResult {
        ok: false,
        work: None,
        error_message: Some(message),
    }
}

fn run_result(run: JumpHopRunSnapshot) -> JumpHopRunProcedureResult {
    JumpHopRunProcedureResult {
        ok: true,
        run: Some(run),
        error_message: None,
    }
}

fn run_error(message: String) -> JumpHopRunProcedureResult {
    JumpHopRunProcedureResult {
        ok: false,
        run: None,
        error_message: Some(message),
    }
}

fn clone_session(row: &JumpHopAgentSessionRow) -> JumpHopAgentSessionRow {
    JumpHopAgentSessionRow {
        session_id: row.session_id.clone(),
        owner_user_id: row.owner_user_id.clone(),
        seed_text: row.seed_text.clone(),
        current_turn: row.current_turn,
        progress_percent: row.progress_percent,
        stage: row.stage.clone(),
        config_json: row.config_json.clone(),
        draft_json: row.draft_json.clone(),
        last_assistant_reply: row.last_assistant_reply.clone(),
        published_profile_id: row.published_profile_id.clone(),
        created_at: row.created_at,
        updated_at: row.updated_at,
    }
}

fn clone_work(row: &JumpHopWorkProfileRow) -> JumpHopWorkProfileRow {
    JumpHopWorkProfileRow {
        profile_id: row.profile_id.clone(),
        work_id: row.work_id.clone(),
        owner_user_id: row.owner_user_id.clone(),
        source_session_id: row.source_session_id.clone(),
        author_display_name: row.author_display_name.clone(),
        work_title: row.work_title.clone(),
        work_description: row.work_description.clone(),
        theme_tags_json: row.theme_tags_json.clone(),
        difficulty: row.difficulty.clone(),
        style_preset: row.style_preset.clone(),
        character_prompt: row.character_prompt.clone(),
        tile_prompt: row.tile_prompt.clone(),
        end_mood_prompt: row.end_mood_prompt.clone(),
        character_asset_json: row.character_asset_json.clone(),
        tile_atlas_asset_json: row.tile_atlas_asset_json.clone(),
        tile_assets_json: row.tile_assets_json.clone(),
        path_json: row.path_json.clone(),
        cover_image_src: row.cover_image_src.clone(),
        cover_composite: row.cover_composite.clone(),
        generation_status: row.generation_status.clone(),
        publication_status: row.publication_status.clone(),
        play_count: row.play_count,
        updated_at: row.updated_at,
        published_at: row.published_at,
    }
}

fn clone_run(row: &JumpHopRuntimeRunRow) -> JumpHopRuntimeRunRow {
    JumpHopRuntimeRunRow {
        run_id: row.run_id.clone(),
        owner_user_id: row.owner_user_id.clone(),
        profile_id: row.profile_id.clone(),
        status: row.status.clone(),
        started_at_ms: row.started_at_ms,
        finished_at_ms: row.finished_at_ms,
        current_platform_index: row.current_platform_index,
        score: row.score,
        combo: row.combo,
        snapshot_json: row.snapshot_json.clone(),
        created_at: row.created_at,
        updated_at: row.updated_at,
    }
}