pub(crate) mod tables;
mod types;

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

use crate::{ProcedureContext, ReducerContext, SpacetimeType, Table, Timestamp};
use module_wooden_fish::{
    WoodenFishRunSnapshot, WoodenFishRunStatus, WoodenFishWordCounter, apply_run_checkpoint,
    default_floating_words, finish_run, normalize_floating_words, normalize_word_counters,
};
use serde::Serialize;
use serde::de::DeserializeOwned;
use spacetimedb::AnonymousViewContext;

#[spacetimedb::view(accessor = wooden_fish_gallery_view, public)]
pub fn wooden_fish_gallery_view(ctx: &AnonymousViewContext) -> Vec<WoodenFishGalleryViewRow> {
    let mut items = ctx
        .db
        .wooden_fish_work_profile()
        .by_wooden_fish_work_publication_status()
        .filter(WOODEN_FISH_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 = wooden_fish_gallery_card_view, public)]
pub fn wooden_fish_gallery_card_view(
    ctx: &AnonymousViewContext,
) -> Vec<WoodenFishGalleryCardViewRow> {
    wooden_fish_gallery_view(ctx)
        .into_iter()
        .map(|row| WoodenFishGalleryCardViewRow {
            public_work_code: row.public_work_code,
            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,
            cover_image_src: row.cover_image_src,
            theme_tags: row.theme_tags,
            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, Eq, SpacetimeType)]
pub struct WoodenFishGalleryViewRow {
    pub public_work_code: String,
    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 hit_object_prompt: String,
    pub hit_object_reference_image_src: Option<String>,
    pub hit_sound_prompt: Option<String>,
    pub hit_object_asset: Option<WoodenFishImageAssetSnapshot>,
    pub background_asset: Option<WoodenFishImageAssetSnapshot>,
    pub hit_sound_asset: Option<WoodenFishAudioAssetSnapshot>,
    pub floating_words: Vec<String>,
    pub cover_image_src: 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 WoodenFishGalleryCardViewRow {
    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 cover_image_src: String,
    pub theme_tags: Vec<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_wooden_fish_agent_session(
    ctx: &mut ProcedureContext,
    input: WoodenFishAgentSessionCreateInput,
) -> WoodenFishAgentSessionProcedureResult {
    match ctx.try_with_tx(|tx| create_wooden_fish_agent_session_tx(tx, input.clone())) {
        Ok(session) => session_result(session),
        Err(message) => session_error(message),
    }
}

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

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

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

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

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

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

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

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

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

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

fn create_wooden_fish_agent_session_tx(
    ctx: &ReducerContext,
    input: WoodenFishAgentSessionCreateInput,
) -> Result<WoodenFishAgentSessionSnapshot, String> {
    require_non_empty(&input.session_id, "wooden_fish session_id")?;
    require_non_empty(&input.owner_user_id, "wooden_fish owner_user_id")?;
    if ctx
        .db
        .wooden_fish_agent_session()
        .session_id()
        .find(&input.session_id)
        .is_some()
    {
        return Err("wooden_fish_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_input(&input));
    let draft = input
        .draft_json
        .as_deref()
        .map(parse_json)
        .transpose()?
        .unwrap_or_else(|| draft_from_config(&config, None, WOODEN_FISH_GENERATION_DRAFT));

    ctx.db
        .wooden_fish_agent_session()
        .insert(WoodenFishAgentSessionRow {
            session_id: input.session_id.clone(),
            owner_user_id: input.owner_user_id.clone(),
            current_turn: 0,
            progress_percent: 0,
            stage: WOODEN_FISH_STAGE_COLLECTING.to_string(),
            config_json: to_json_string(&config),
            draft_json: to_json_string(&draft),
            published_profile_id: String::new(),
            created_at,
            updated_at: created_at,
        });

    get_wooden_fish_agent_session_tx(
        ctx,
        WoodenFishAgentSessionGetInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
        },
    )
}

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

fn compile_wooden_fish_draft_tx(
    ctx: &ReducerContext,
    input: WoodenFishDraftCompileInput,
) -> Result<WoodenFishAgentSessionSnapshot, String> {
    require_non_empty(&input.profile_id, "wooden_fish profile_id")?;
    let session = find_owned_session(ctx, &input.session_id, &input.owner_user_id)?;
    let tags = parse_tags(input.theme_tags_json.as_deref().unwrap_or("[]"))?;
    let floating_words = match input
        .floating_words_json
        .as_deref()
        .map(parse_json::<Vec<String>>)
        .transpose()?
    {
        Some(words) => normalize_floating_words(&words),
        None => default_floating_words(),
    };
    let hit_object_asset = input
        .hit_object_asset_json
        .as_deref()
        .map(parse_json)
        .transpose()?;
    let hit_sound_asset = input
        .hit_sound_asset_json
        .as_deref()
        .map(parse_json)
        .transpose()?;
    let background_asset = input
        .background_asset_json
        .as_deref()
        .map(parse_json)
        .transpose()?;
    let cover_image_src = input
        .cover_image_src
        .as_deref()
        .and_then(clean_optional)
        .or_else(|| {
            hit_object_asset
                .as_ref()
                .map(|asset: &WoodenFishImageAssetSnapshot| asset.image_src.clone())
        });
    let draft = WoodenFishDraftSnapshot {
        template_id: WOODEN_FISH_TEMPLATE_ID.to_string(),
        template_name: WOODEN_FISH_TEMPLATE_NAME.to_string(),
        profile_id: Some(input.profile_id.clone()),
        work_title: clean_string(&input.work_title, WOODEN_FISH_TEMPLATE_NAME),
        work_description: input.work_description.trim().to_string(),
        theme_tags: tags.clone(),
        hit_object_prompt: clean_string(
            &input.hit_object_prompt,
            "默认敲击物图案，圆润木质质感，透明背景",
        ),
        hit_object_reference_image_src: input
            .hit_object_reference_image_src
            .as_deref()
            .and_then(clean_optional),
        hit_sound_prompt: input.hit_sound_prompt.as_deref().and_then(clean_optional),
        floating_words: floating_words.clone(),
        hit_object_asset: hit_object_asset.clone(),
        background_asset: background_asset.clone(),
        hit_sound_asset: hit_sound_asset.clone(),
        cover_image_src: cover_image_src.clone(),
        generation_status: input
            .generation_status
            .clone()
            .unwrap_or_else(|| WOODEN_FISH_GENERATION_READY.to_string()),
    };
    let compiled_at = Timestamp::from_micros_since_unix_epoch(input.compiled_at_micros);
    let row = WoodenFishWorkProfileRow {
        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),
        hit_object_prompt: draft.hit_object_prompt.clone(),
        hit_object_reference_image_src: draft
            .hit_object_reference_image_src
            .clone()
            .unwrap_or_default(),
        hit_sound_prompt: draft.hit_sound_prompt.clone().unwrap_or_default(),
        hit_object_asset_json: hit_object_asset
            .as_ref()
            .map(to_json_string)
            .unwrap_or_default(),
        hit_sound_asset_json: hit_sound_asset
            .as_ref()
            .map(to_json_string)
            .unwrap_or_default(),
        floating_words_json: to_json_string(&floating_words),
        cover_image_src: cover_image_src.unwrap_or_default(),
        generation_status: draft.generation_status.clone(),
        publication_status: WOODEN_FISH_PUBLICATION_DRAFT.to_string(),
        play_count: 0,
        updated_at: compiled_at,
        published_at: None,
        background_asset_json: background_asset.as_ref().map(to_json_string),
    };
    upsert_work(ctx, row);
    let config = config_from_draft(&draft);
    replace_session(
        ctx,
        &session,
        WoodenFishAgentSessionRow {
            progress_percent: 100,
            stage: WOODEN_FISH_STAGE_DRAFT_COMPILED.to_string(),
            config_json: to_json_string(&config),
            draft_json: to_json_string(&draft),
            published_profile_id: input.profile_id,
            updated_at: compiled_at,
            ..clone_session(&session)
        },
    );

    get_wooden_fish_agent_session_tx(
        ctx,
        WoodenFishAgentSessionGetInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
        },
    )
}

fn get_wooden_fish_work_profile_tx(
    ctx: &ReducerContext,
    input: WoodenFishWorkGetInput,
) -> Result<WoodenFishWorkSnapshot, 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("无权访问该 wooden_fish work".to_string());
    }
    build_work_snapshot(&row)
}

fn update_wooden_fish_work_tx(
    ctx: &ReducerContext,
    input: WoodenFishWorkUpdateInput,
) -> Result<WoodenFishWorkSnapshot, 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(value) = input.hit_object_prompt.as_deref().and_then(clean_optional) {
        next.hit_object_prompt = value;
    }
    if let Some(value) = input
        .hit_object_reference_image_src
        .as_deref()
        .and_then(clean_optional)
    {
        next.hit_object_reference_image_src = value;
    }
    if let Some(value) = input.hit_sound_prompt.as_deref().and_then(clean_optional) {
        next.hit_sound_prompt = value;
    }
    if let Some(value) = input
        .hit_object_asset_json
        .as_deref()
        .and_then(clean_optional)
    {
        let asset = parse_json::<WoodenFishImageAssetSnapshot>(&value)?;
        next.hit_object_asset_json = to_json_string(&asset);
        next.cover_image_src = asset.image_src;
    }
    if let Some(value) = input
        .hit_sound_asset_json
        .as_deref()
        .and_then(clean_optional)
    {
        let asset = parse_json::<WoodenFishAudioAssetSnapshot>(&value)?;
        next.hit_sound_asset_json = to_json_string(&asset);
    }
    if let Some(value) = input
        .background_asset_json
        .as_deref()
        .and_then(clean_optional)
    {
        let asset = parse_json::<WoodenFishImageAssetSnapshot>(&value)?;
        next.background_asset_json = Some(to_json_string(&asset));
    }
    if let Some(value) = input
        .floating_words_json
        .as_deref()
        .and_then(clean_optional)
    {
        let words = parse_json::<Vec<String>>(&value)?;
        next.floating_words_json = to_json_string(&normalize_floating_words(&words));
    }
    if let Some(value) = input.cover_image_src.as_deref().and_then(clean_optional) {
        next.cover_image_src = value;
    }
    if let Some(value) = input.generation_status.as_deref().and_then(clean_optional) {
        next.generation_status = value;
    }
    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_wooden_fish_work_tx(
    ctx: &ReducerContext,
    input: WoodenFishWorkPublishInput,
) -> Result<WoodenFishWorkSnapshot, String> {
    let row = find_owned_work(ctx, &input.profile_id, &input.owner_user_id)?;
    if !is_publish_ready(&row) {
        return Err("发布需要完整的敲击物图案、敲击音效和飘字配置".to_string());
    }
    let published_at = Timestamp::from_micros_since_unix_epoch(input.published_at_micros);
    replace_work(
        ctx,
        &row,
        WoodenFishWorkProfileRow {
            publication_status: WOODEN_FISH_PUBLICATION_PUBLISHED.to_string(),
            updated_at: published_at,
            published_at: Some(published_at),
            ..clone_work(&row)
        },
    );
    if let Some(session) = ctx
        .db
        .wooden_fish_agent_session()
        .session_id()
        .find(&row.source_session_id)
    {
        replace_session(
            ctx,
            &session,
            WoodenFishAgentSessionRow {
                stage: WOODEN_FISH_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_wooden_fish_works_tx(
    ctx: &ReducerContext,
    input: WoodenFishWorksListInput,
) -> Result<Vec<WoodenFishWorkSnapshot>, String> {
    let mut rows = if input.owner_user_id.trim().is_empty() {
        ctx.db.wooden_fish_work_profile().iter().collect::<Vec<_>>()
    } else {
        ctx.db
            .wooden_fish_work_profile()
            .by_wooden_fish_work_owner_user_id()
            .filter(input.owner_user_id.as_str())
            .collect::<Vec<_>>()
    };
    if input.published_only {
        rows.retain(|row| row.publication_status == WOODEN_FISH_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_wooden_fish_run_tx(
    ctx: &ReducerContext,
    input: WoodenFishRunStartInput,
) -> Result<WoodenFishRunSnapshot, String> {
    require_non_empty(&input.run_id, "wooden_fish run_id")?;
    let work = find_work(ctx, &input.profile_id)?;
    if !is_publish_ready(&work) {
        return Err("敲木鱼运行态需要完整作品配置".to_string());
    }
    let snapshot = WoodenFishRunSnapshot {
        run_id: input.run_id.clone(),
        profile_id: input.profile_id.clone(),
        owner_user_id: input.owner_user_id.clone(),
        status: WoodenFishRunStatus::Playing,
        total_tap_count: 0,
        word_counters: Vec::new(),
        started_at_ms: input.started_at_ms.max(0) as u64,
        updated_at_ms: input.started_at_ms.max(0) as u64,
        finished_at_ms: None,
    };
    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,
        WOODEN_FISH_EVENT_RUN_STARTED,
        None,
        input.started_at_ms,
    );
    Ok(snapshot)
}

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

fn checkpoint_wooden_fish_run_tx(
    ctx: &ReducerContext,
    input: WoodenFishRunCheckpointInput,
) -> Result<WoodenFishRunSnapshot, String> {
    let row = find_owned_run(ctx, &input.run_id, &input.owner_user_id)?;
    let current = parse_json::<WoodenFishRunSnapshot>(&row.snapshot_json)?;
    if current.status == WoodenFishRunStatus::Finished {
        return Err("wooden_fish run 已结束，不能 checkpoint".to_string());
    }
    let counters = parse_json::<Vec<WoodenFishWordCounter>>(&input.word_counters_json)?;
    let next = apply_run_checkpoint(
        &current,
        input.total_tap_count,
        normalize_word_counters(counters),
        input.checkpoint_at_ms.max(0) as u64,
    );
    replace_run(ctx, &row, &next, input.checkpoint_at_ms);
    insert_event(
        ctx,
        input.client_event_id,
        input.owner_user_id,
        next.profile_id.clone(),
        input.run_id,
        WOODEN_FISH_EVENT_RUN_CHECKPOINT,
        Some(next.total_tap_count.to_string()),
        input.checkpoint_at_ms,
    );
    Ok(next)
}

fn finish_wooden_fish_run_tx(
    ctx: &ReducerContext,
    input: WoodenFishRunFinishInput,
) -> Result<WoodenFishRunSnapshot, String> {
    let row = find_owned_run(ctx, &input.run_id, &input.owner_user_id)?;
    let current = parse_json::<WoodenFishRunSnapshot>(&row.snapshot_json)?;
    let counters = parse_json::<Vec<WoodenFishWordCounter>>(&input.word_counters_json)?;
    let next = finish_run(
        &current,
        input.total_tap_count,
        normalize_word_counters(counters),
        input.finished_at_ms.max(0) as u64,
    );
    replace_run(ctx, &row, &next, input.finished_at_ms);
    insert_event(
        ctx,
        input.client_event_id,
        input.owner_user_id,
        next.profile_id.clone(),
        input.run_id,
        WOODEN_FISH_EVENT_RUN_FINISHED,
        Some(next.total_tap_count.to_string()),
        input.finished_at_ms,
    );
    Ok(next)
}

fn build_gallery_view_row(
    row: &WoodenFishWorkProfileRow,
) -> Result<WoodenFishGalleryViewRow, String> {
    let work = build_work_snapshot(row)?;
    Ok(WoodenFishGalleryViewRow {
        public_work_code: build_wooden_fish_public_work_code(&work.profile_id),
        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,
        hit_object_prompt: work.hit_object_prompt,
        hit_object_reference_image_src: work.hit_object_reference_image_src,
        hit_sound_prompt: work.hit_sound_prompt,
        hit_object_asset: work.hit_object_asset,
        background_asset: work.background_asset,
        hit_sound_asset: work.hit_sound_asset,
        floating_words: work.floating_words,
        cover_image_src: work.cover_image_src,
        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_session_snapshot(
    row: &WoodenFishAgentSessionRow,
) -> Result<WoodenFishAgentSessionSnapshot, String> {
    Ok(WoodenFishAgentSessionSnapshot {
        session_id: row.session_id.clone(),
        owner_user_id: row.owner_user_id.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()?,
        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: &WoodenFishWorkProfileRow) -> Result<WoodenFishWorkSnapshot, String> {
    Ok(WoodenFishWorkSnapshot {
        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)?,
        hit_object_prompt: row.hit_object_prompt.clone(),
        hit_object_reference_image_src: clean_optional(&row.hit_object_reference_image_src),
        hit_sound_prompt: clean_optional(&row.hit_sound_prompt),
        hit_object_asset: clean_optional(&row.hit_object_asset_json)
            .map(|value| parse_json(&value))
            .transpose()?,
        background_asset: row
            .background_asset_json
            .as_deref()
            .and_then(clean_optional)
            .map(|value| parse_json(&value))
            .transpose()?,
        hit_sound_asset: clean_optional(&row.hit_sound_asset_json)
            .map(|value| parse_json(&value))
            .transpose()?,
        floating_words: normalize_floating_words(&parse_json_or_default::<Vec<String>>(
            &row.floating_words_json,
        )),
        cover_image_src: row.cover_image_src.clone(),
        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: &WoodenFishWorkProfileRow,
    updated_at: Timestamp,
) -> Result<(), String> {
    let Some(session) = ctx
        .db
        .wooden_fish_agent_session()
        .session_id()
        .find(&work.source_session_id)
    else {
        return Ok(());
    };

    let snapshot = build_work_snapshot(work)?;
    let draft = draft_from_work_snapshot(&snapshot);
    let config = config_from_draft(&draft);
    replace_session(
        ctx,
        &session,
        WoodenFishAgentSessionRow {
            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<WoodenFishAgentSessionRow, String> {
    let row = ctx
        .db
        .wooden_fish_agent_session()
        .session_id()
        .find(&session_id.to_string())
        .ok_or_else(|| "wooden_fish_agent_session 不存在".to_string())?;
    if row.owner_user_id != owner_user_id {
        return Err("无权访问该 wooden_fish session".to_string());
    }
    Ok(row)
}

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

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

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

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

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

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

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

fn replace_run(
    ctx: &ReducerContext,
    old: &WoodenFishRuntimeRunRow,
    snapshot: &WoodenFishRunSnapshot,
    updated_at_ms: i64,
) {
    ctx.db.wooden_fish_runtime_run().delete(clone_run(old));
    ctx.db
        .wooden_fish_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: &WoodenFishRunSnapshot,
    created_at: Timestamp,
    updated_at: Timestamp,
) -> WoodenFishRuntimeRunRow {
    WoodenFishRuntimeRunRow {
        run_id: snapshot.run_id.clone(),
        owner_user_id: snapshot.owner_user_id.clone(),
        profile_id: snapshot.profile_id.clone(),
        status: run_status_as_str(snapshot.status).to_string(),
        total_tap_count: snapshot.total_tap_count,
        word_counters_json: to_json_string(&snapshot.word_counters),
        started_at_ms: snapshot.started_at_ms as i64,
        updated_at_ms: snapshot.updated_at_ms as i64,
        finished_at_ms: snapshot
            .finished_at_ms
            .map(|value| value as i64)
            .unwrap_or(0),
        snapshot_json: to_json_string(snapshot),
        created_at,
        updated_at,
    }
}

fn increment_work_play_count(
    ctx: &ReducerContext,
    row: &WoodenFishWorkProfileRow,
    played_at_ms: i64,
) {
    replace_work(
        ctx,
        row,
        WoodenFishWorkProfileRow {
            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!(
            "wooden-fish-event-{}-{}-{}",
            run_id, event_type, occurred_at_ms
        )
    });
    if ctx
        .db
        .wooden_fish_event()
        .event_id()
        .find(&event_id)
        .is_some()
    {
        return;
    }
    ctx.db.wooden_fish_event().insert(WoodenFishEventRow {
        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: &WoodenFishWorkProfileRow) -> bool {
    !row.work_title.trim().is_empty()
        && !row.hit_object_asset_json.trim().is_empty()
        && row
            .background_asset_json
            .as_deref()
            .and_then(clean_optional)
            .is_some()
        && !row.hit_sound_asset_json.trim().is_empty()
        && !row.floating_words_json.trim().is_empty()
        && row.generation_status == WOODEN_FISH_GENERATION_READY
}

fn default_config_from_input(
    input: &WoodenFishAgentSessionCreateInput,
) -> WoodenFishCreatorConfigSnapshot {
    WoodenFishCreatorConfigSnapshot {
        work_title: clean_string(&input.work_title, WOODEN_FISH_TEMPLATE_NAME),
        work_description: input.work_description.trim().to_string(),
        theme_tags: parse_tags(input.theme_tags_json.as_deref().unwrap_or("[]"))
            .unwrap_or_default(),
        hit_object_prompt: "默认敲击物图案，圆润木质质感，透明背景".to_string(),
        hit_object_reference_image_src: None,
        hit_sound_prompt: Some("清脆短促的木鱼敲击声".to_string()),
        floating_words: default_floating_words(),
    }
}

fn draft_from_config(
    config: &WoodenFishCreatorConfigSnapshot,
    profile_id: Option<String>,
    generation_status: &str,
) -> WoodenFishDraftSnapshot {
    WoodenFishDraftSnapshot {
        template_id: WOODEN_FISH_TEMPLATE_ID.to_string(),
        template_name: WOODEN_FISH_TEMPLATE_NAME.to_string(),
        profile_id,
        work_title: config.work_title.clone(),
        work_description: config.work_description.clone(),
        theme_tags: config.theme_tags.clone(),
        hit_object_prompt: config.hit_object_prompt.clone(),
        hit_object_reference_image_src: config.hit_object_reference_image_src.clone(),
        hit_sound_prompt: config.hit_sound_prompt.clone(),
        floating_words: normalize_floating_words(&config.floating_words),
        hit_object_asset: None,
        background_asset: None,
        hit_sound_asset: None,
        cover_image_src: None,
        generation_status: generation_status.to_string(),
    }
}

fn draft_from_work_snapshot(work: &WoodenFishWorkSnapshot) -> WoodenFishDraftSnapshot {
    WoodenFishDraftSnapshot {
        template_id: WOODEN_FISH_TEMPLATE_ID.to_string(),
        template_name: WOODEN_FISH_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: work.theme_tags.clone(),
        hit_object_prompt: work.hit_object_prompt.clone(),
        hit_object_reference_image_src: work.hit_object_reference_image_src.clone(),
        hit_sound_prompt: work.hit_sound_prompt.clone(),
        floating_words: work.floating_words.clone(),
        hit_object_asset: work.hit_object_asset.clone(),
        background_asset: work.background_asset.clone(),
        hit_sound_asset: work.hit_sound_asset.clone(),
        cover_image_src: clean_optional(&work.cover_image_src),
        generation_status: work.generation_status.clone(),
    }
}

fn config_from_draft(draft: &WoodenFishDraftSnapshot) -> WoodenFishCreatorConfigSnapshot {
    WoodenFishCreatorConfigSnapshot {
        work_title: draft.work_title.clone(),
        work_description: draft.work_description.clone(),
        theme_tags: draft.theme_tags.clone(),
        hit_object_prompt: draft.hit_object_prompt.clone(),
        hit_object_reference_image_src: draft.hit_object_reference_image_src.clone(),
        hit_sound_prompt: draft.hit_sound_prompt.clone(),
        floating_words: normalize_floating_words(&draft.floating_words),
    }
}

fn build_wooden_fish_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!("WF-{suffix}")
}

fn run_status_as_str(status: WoodenFishRunStatus) -> &'static str {
    match status {
        WoodenFishRunStatus::Playing => "playing",
        WoodenFishRunStatus::Finished => "finished",
    }
}

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<WoodenFishCreatorConfigSnapshot, 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: WoodenFishAgentSessionSnapshot,
) -> WoodenFishAgentSessionProcedureResult {
    WoodenFishAgentSessionProcedureResult {
        ok: true,
        session: Some(session),
        error_message: None,
    }
}

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

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

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

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

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

fn clone_session(row: &WoodenFishAgentSessionRow) -> WoodenFishAgentSessionRow {
    WoodenFishAgentSessionRow {
        session_id: row.session_id.clone(),
        owner_user_id: row.owner_user_id.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(),
        published_profile_id: row.published_profile_id.clone(),
        created_at: row.created_at,
        updated_at: row.updated_at,
    }
}

fn clone_work(row: &WoodenFishWorkProfileRow) -> WoodenFishWorkProfileRow {
    WoodenFishWorkProfileRow {
        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(),
        hit_object_prompt: row.hit_object_prompt.clone(),
        hit_object_reference_image_src: row.hit_object_reference_image_src.clone(),
        hit_sound_prompt: row.hit_sound_prompt.clone(),
        hit_object_asset_json: row.hit_object_asset_json.clone(),
        background_asset_json: row.background_asset_json.clone(),
        hit_sound_asset_json: row.hit_sound_asset_json.clone(),
        floating_words_json: row.floating_words_json.clone(),
        cover_image_src: row.cover_image_src.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: &WoodenFishRuntimeRunRow) -> WoodenFishRuntimeRunRow {
    WoodenFishRuntimeRunRow {
        run_id: row.run_id.clone(),
        owner_user_id: row.owner_user_id.clone(),
        profile_id: row.profile_id.clone(),
        status: row.status.clone(),
        total_tap_count: row.total_tap_count,
        word_counters_json: row.word_counters_json.clone(),
        started_at_ms: row.started_at_ms,
        updated_at_ms: row.updated_at_ms,
        finished_at_ms: row.finished_at_ms,
        snapshot_json: row.snapshot_json.clone(),
        created_at: row.created_at,
        updated_at: row.updated_at,
    }
}