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

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

pub const MATCH3D_SESSION_ID_PREFIX: &str = "match3d-session-";
pub const MATCH3D_MESSAGE_ID_PREFIX: &str = "match3d-message-";
pub const MATCH3D_PROFILE_ID_PREFIX: &str = "match3d-profile-";
pub const MATCH3D_WORK_ID_PREFIX: &str = "match3d-work-";
pub const MATCH3D_RUN_ID_PREFIX: &str = "match3d-run-";
pub const MATCH3D_TRAY_SLOT_COUNT: u32 = 7;
pub const MATCH3D_ITEMS_PER_CLEAR: u32 = 3;
pub const MATCH3D_MIN_DIFFICULTY: u32 = 1;
pub const MATCH3D_MAX_DIFFICULTY: u32 = 10;
pub const MATCH3D_DEFAULT_DURATION_LIMIT_MS: u64 = 10 * 60 * 1000;
pub const MATCH3D_BOARD_CENTER: f32 = 0.5;
pub const MATCH3D_BOARD_RADIUS: f32 = 0.5;
pub const MATCH3D_BOARD_SAFE_MARGIN: f32 = 0.035;

// 中文注释：首版 demo 不接真实图片生成，但水果题材必须先给出可辨认的水果内置视觉键。
const MATCH3D_FRUIT_VISUAL_KEYS: [&str; 10] = [
    "watermelon-green",
    "apple-red",
    "banana-yellow",
    "grape-purple",
    "melon-green",
    "berry-blue",
    "peach-pink",
    "plum-indigo",
    "lime-lime",
    "orange-orange",
];

// 中文注释：非水果题材使用颜色形状兜底 key；前端必须逐个渲染，不能统一兜成同一图案。
const MATCH3D_SHAPE_VISUAL_KEYS: [&str; 10] = [
    "red_circle",
    "yellow_triangle",
    "purple_diamond",
    "green_square",
    "blue_star",
    "orange_hexagon",
    "cyan_capsule",
    "pink_heart",
    "lime_leaf",
    "white_moon",
];

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum Match3DCreationStage {
    CollectingConfig,
    DraftReady,
    ReadyToPublish,
    Published,
}

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

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum Match3DRunStatus {
    Running,
    Won,
    Failed,
    Stopped,
}

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

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum Match3DItemState {
    InBoard,
    InTray,
    Cleared,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum Match3DClickRejectReason {
    RunNotActive,
    SnapshotVersionMismatch,
    ItemNotFound,
    ItemNotInBoard,
    ItemNotClickable,
    TrayFull,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Match3DCreatorConfig {
    pub theme_text: String,
    pub reference_image_src: Option<String>,
    pub clear_count: u32,
    pub difficulty: u32,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Match3DResultDraft {
    pub game_name: String,
    pub theme_text: String,
    pub summary: String,
    pub tags: Vec<String>,
    pub cover_image_src: Option<String>,
    pub reference_image_src: Option<String>,
    pub clear_count: u32,
    pub difficulty: u32,
    pub publish_ready: bool,
    pub blockers: Vec<String>,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Match3DWorkProfile {
    pub work_id: String,
    pub profile_id: String,
    pub owner_user_id: String,
    pub source_session_id: Option<String>,
    pub game_name: String,
    pub theme_text: String,
    pub summary: String,
    pub tags: Vec<String>,
    pub cover_image_src: Option<String>,
    pub reference_image_src: Option<String>,
    pub clear_count: u32,
    pub difficulty: u32,
    pub publication_status: Match3DPublicationStatus,
    pub play_count: u32,
    pub updated_at_micros: i64,
    pub published_at_micros: Option<i64>,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Match3DItemSnapshot {
    pub item_instance_id: String,
    pub item_type_id: String,
    pub visual_key: String,
    pub x: f32,
    pub y: f32,
    pub radius: f32,
    pub layer: u32,
    pub state: Match3DItemState,
    pub clickable: bool,
    pub tray_slot_index: Option<u32>,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Match3DTraySlot {
    pub slot_index: u32,
    pub item_instance_id: Option<String>,
    pub item_type_id: Option<String>,
    pub visual_key: Option<String>,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Match3DRunSnapshot {
    pub run_id: String,
    pub profile_id: String,
    pub owner_user_id: String,
    pub status: Match3DRunStatus,
    pub started_at_ms: u64,
    pub duration_limit_ms: u64,
    pub remaining_ms: u64,
    pub clear_count: u32,
    pub total_item_count: u32,
    pub cleared_item_count: u32,
    /// 领域内部权威快照版本；HTTP DTO 对外映射为 snapshotVersion。
    pub board_version: u64,
    pub items: Vec<Match3DItemSnapshot>,
    pub tray_slots: Vec<Match3DTraySlot>,
    pub failure_reason: Option<Match3DFailureReason>,
    pub last_confirmed_action_id: Option<String>,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Match3DClickInput {
    pub run_id: String,
    pub owner_user_id: String,
    pub item_instance_id: String,
    pub client_action_id: String,
    pub snapshot_version: u64,
    pub clicked_at_ms: u64,
}

#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Match3DClickConfirmation {
    pub accepted: bool,
    pub reject_reason: Option<Match3DClickRejectReason>,
    pub entered_slot_index: Option<u32>,
    pub cleared_item_instance_ids: Vec<String>,
    pub run: Match3DRunSnapshot,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Match3DFieldError {
    MissingText,
    MissingOwnerUserId,
    MissingProfileId,
    MissingRunId,
    MissingItemId,
    InvalidClearCount,
    InvalidDifficulty,
}

impl fmt::Display for Match3DFieldError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::MissingText => write!(f, "必填文本缺失"),
            Self::MissingOwnerUserId => write!(f, "owner_user_id 缺失"),
            Self::MissingProfileId => write!(f, "profile_id 缺失"),
            Self::MissingRunId => write!(f, "run_id 缺失"),
            Self::MissingItemId => write!(f, "item_instance_id 缺失"),
            Self::InvalidClearCount => write!(f, "需要消除次数必须为正整数"),
            Self::InvalidDifficulty => write!(f, "难度必须在 1 到 10 之间"),
        }
    }
}

impl Error for Match3DFieldError {}

impl Match3DCreationStage {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::CollectingConfig => "collecting_config",
            Self::DraftReady => "draft_ready",
            Self::ReadyToPublish => "ready_to_publish",
            Self::Published => "published",
        }
    }
}

impl Match3DPublicationStatus {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Draft => "draft",
            Self::Published => "published",
        }
    }
}

impl Match3DRunStatus {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Running => "running",
            Self::Won => "won",
            Self::Failed => "failed",
            Self::Stopped => "stopped",
        }
    }
}

impl Match3DFailureReason {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::TimeUp => "time_up",
            Self::TrayFull => "tray_full",
        }
    }
}

impl Match3DItemState {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::InBoard => "in_board",
            Self::InTray => "in_tray",
            Self::Cleared => "cleared",
        }
    }
}

impl Match3DClickRejectReason {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::RunNotActive => "run_not_active",
            Self::SnapshotVersionMismatch => "snapshot_version_mismatch",
            Self::ItemNotFound => "item_not_found",
            Self::ItemNotInBoard => "item_not_in_board",
            Self::ItemNotClickable => "item_not_clickable",
            Self::TrayFull => "tray_full",
        }
    }
}

pub fn build_creator_config(
    theme_text: &str,
    reference_image_src: Option<String>,
    clear_count: u32,
    difficulty: u32,
) -> Result<Match3DCreatorConfig, Match3DFieldError> {
    let theme_text = normalize_required_string(theme_text).ok_or(Match3DFieldError::MissingText)?;
    if clear_count == 0 {
        return Err(Match3DFieldError::InvalidClearCount);
    }
    if !(MATCH3D_MIN_DIFFICULTY..=MATCH3D_MAX_DIFFICULTY).contains(&difficulty) {
        return Err(Match3DFieldError::InvalidDifficulty);
    }

    Ok(Match3DCreatorConfig {
        theme_text,
        reference_image_src: normalize_optional_string(reference_image_src),
        clear_count,
        difficulty,
    })
}

/// 根据已确认的题材、消除次数和难度编译首版结果草稿。
pub fn compile_result_draft(config: &Match3DCreatorConfig) -> Match3DResultDraft {
    let game_name = format!("{}抓大鹅", config.theme_text);
    let summary = format!(
        "{}主题，{} 次消除目标，难度 {}。",
        config.theme_text, config.clear_count, config.difficulty
    );
    let tags = default_tags_for_theme(&config.theme_text);
    let mut draft = Match3DResultDraft {
        game_name,
        theme_text: config.theme_text.clone(),
        summary,
        tags,
        cover_image_src: None,
        reference_image_src: config.reference_image_src.clone(),
        clear_count: config.clear_count,
        difficulty: config.difficulty,
        publish_ready: false,
        blockers: Vec::new(),
    };
    draft.blockers = validate_result_publish_fields(&draft);
    draft.publish_ready = draft.blockers.is_empty();

    draft
}

/// 校验发布所需基础字段；试玩通关不是首版发布门槛。
pub fn validate_publish_requirements(draft: &Match3DResultDraft) -> Vec<String> {
    let mut blockers = validate_result_publish_fields(draft);
    if draft.clear_count == 0 {
        blockers.push("需要消除次数必须为正整数".to_string());
    }
    if !(MATCH3D_MIN_DIFFICULTY..=MATCH3D_MAX_DIFFICULTY).contains(&draft.difficulty) {
        blockers.push("难度必须在 1 到 10 之间".to_string());
    }
    blockers
}

/// 将结果草稿转换为可保存的作品 profile，实际持久化由 SpacetimeDB 分支负责。
pub fn create_work_profile(
    work_id: String,
    profile_id: String,
    owner_user_id: String,
    source_session_id: Option<String>,
    draft: &Match3DResultDraft,
    updated_at_micros: i64,
) -> Result<Match3DWorkProfile, Match3DFieldError> {
    let work_id = normalize_required_string(work_id).ok_or(Match3DFieldError::MissingText)?;
    let profile_id =
        normalize_required_string(profile_id).ok_or(Match3DFieldError::MissingProfileId)?;
    let owner_user_id =
        normalize_required_string(owner_user_id).ok_or(Match3DFieldError::MissingOwnerUserId)?;

    Ok(Match3DWorkProfile {
        work_id,
        profile_id,
        owner_user_id,
        source_session_id: normalize_optional_string(source_session_id),
        game_name: draft.game_name.clone(),
        theme_text: draft.theme_text.clone(),
        summary: draft.summary.clone(),
        tags: normalize_string_list(draft.tags.clone()),
        cover_image_src: draft.cover_image_src.clone(),
        reference_image_src: draft.reference_image_src.clone(),
        clear_count: draft.clear_count,
        difficulty: draft.difficulty,
        publication_status: Match3DPublicationStatus::Draft,
        play_count: 0,
        updated_at_micros,
        published_at_micros: None,
    })
}

/// 发布作品时只改变发布状态和时间戳，不在领域层写数据库。
pub fn publish_work_profile(
    profile: &Match3DWorkProfile,
    published_at_micros: i64,
) -> Result<Match3DWorkProfile, Match3DFieldError> {
    if profile.clear_count == 0 {
        return Err(Match3DFieldError::InvalidClearCount);
    }
    if !(MATCH3D_MIN_DIFFICULTY..=MATCH3D_MAX_DIFFICULTY).contains(&profile.difficulty) {
        return Err(Match3DFieldError::InvalidDifficulty);
    }

    let mut next = profile.clone();
    next.publication_status = Match3DPublicationStatus::Published;
    next.updated_at_micros = published_at_micros;
    next.published_at_micros = Some(published_at_micros);
    Ok(next)
}

/// 用确定性 seed 生成单局初始快照，便于后端权威复现和测试。
pub fn start_run_with_seed_at(
    run_id: String,
    owner_user_id: String,
    profile_id: String,
    config: &Match3DCreatorConfig,
    seed: u64,
    started_at_ms: u64,
) -> Result<Match3DRunSnapshot, Match3DFieldError> {
    let run_id = normalize_required_string(run_id).ok_or(Match3DFieldError::MissingRunId)?;
    let owner_user_id =
        normalize_required_string(owner_user_id).ok_or(Match3DFieldError::MissingOwnerUserId)?;
    let profile_id =
        normalize_required_string(profile_id).ok_or(Match3DFieldError::MissingProfileId)?;

    let total_item_count = config
        .clear_count
        .checked_mul(MATCH3D_ITEMS_PER_CLEAR)
        .ok_or(Match3DFieldError::InvalidClearCount)?;
    let mut run = Match3DRunSnapshot {
        run_id,
        profile_id,
        owner_user_id,
        status: Match3DRunStatus::Running,
        started_at_ms,
        duration_limit_ms: MATCH3D_DEFAULT_DURATION_LIMIT_MS,
        remaining_ms: MATCH3D_DEFAULT_DURATION_LIMIT_MS,
        clear_count: config.clear_count,
        total_item_count,
        cleared_item_count: 0,
        board_version: 1,
        items: build_initial_items(
            config.clear_count,
            config.difficulty,
            seed,
            &config.theme_text,
        ),
        tray_slots: empty_tray_slots(),
        failure_reason: None,
        last_confirmed_action_id: None,
    };
    refresh_clickable_flags(&mut run);
    Ok(run)
}

/// 后端权威确认一次点击：校验版本、可点击性、入槽、三消和胜负。
pub fn confirm_click_at(
    run: &Match3DRunSnapshot,
    input: &Match3DClickInput,
) -> Result<Match3DClickConfirmation, Match3DFieldError> {
    let item_instance_id = normalize_required_string(&input.item_instance_id)
        .ok_or(Match3DFieldError::MissingItemId)?;
    let client_action_id = normalize_required_string(&input.client_action_id)
        .unwrap_or_else(|| "match3d-action-unknown".to_string());

    let mut next = resolve_run_timer_at(run, input.clicked_at_ms);
    if next.status != Match3DRunStatus::Running {
        return Ok(rejected(next, Match3DClickRejectReason::RunNotActive));
    }
    if input.snapshot_version != next.board_version {
        return Ok(rejected(
            next,
            Match3DClickRejectReason::SnapshotVersionMismatch,
        ));
    }

    let Some(item_index) = next
        .items
        .iter()
        .position(|item| item.item_instance_id == item_instance_id)
    else {
        return Ok(rejected(next, Match3DClickRejectReason::ItemNotFound));
    };

    if next.items[item_index].state != Match3DItemState::InBoard {
        return Ok(rejected(next, Match3DClickRejectReason::ItemNotInBoard));
    }
    if !next.items[item_index].clickable {
        return Ok(rejected(next, Match3DClickRejectReason::ItemNotClickable));
    }

    let Some(slot_index) = first_empty_slot_index(&next.tray_slots) else {
        next = fail_run(next, Match3DFailureReason::TrayFull, client_action_id);
        return Ok(rejected(next, Match3DClickRejectReason::TrayFull));
    };

    let item_type_id = next.items[item_index].item_type_id.clone();
    next.items[item_index].state = Match3DItemState::InTray;
    next.items[item_index].clickable = false;
    next.items[item_index].tray_slot_index = Some(slot_index);
    fill_tray_slot(&mut next.tray_slots, slot_index, &next.items[item_index]);

    let cleared_item_instance_ids = clear_first_triple(&mut next, &item_type_id);
    compact_tray(&mut next);
    next.cleared_item_count = next
        .items
        .iter()
        .filter(|item| item.state == Match3DItemState::Cleared)
        .count() as u32;

    if next.cleared_item_count >= next.total_item_count {
        next.status = Match3DRunStatus::Won;
    } else if first_empty_slot_index(&next.tray_slots).is_none() {
        next.status = Match3DRunStatus::Failed;
        next.failure_reason = Some(Match3DFailureReason::TrayFull);
    }

    refresh_clickable_flags(&mut next);
    next.board_version += 1;
    next.last_confirmed_action_id = Some(client_action_id);

    Ok(Match3DClickConfirmation {
        accepted: true,
        reject_reason: None,
        entered_slot_index: Some(slot_index),
        cleared_item_instance_ids,
        run: next,
    })
}

/// 根据权威时间刷新剩余时间；前端本地倒计时归零后仍需走后端确认。
pub fn resolve_run_timer_at(run: &Match3DRunSnapshot, now_ms: u64) -> Match3DRunSnapshot {
    let mut next = run.clone();
    if next.status != Match3DRunStatus::Running {
        return next;
    }
    let elapsed_ms = now_ms.saturating_sub(next.started_at_ms);
    next.remaining_ms = next.duration_limit_ms.saturating_sub(elapsed_ms);
    if next.remaining_ms == 0 {
        next.status = Match3DRunStatus::Failed;
        next.failure_reason = Some(Match3DFailureReason::TimeUp);
        next.board_version += 1;
    }
    next
}

/// 停止当前运行态，用于试玩或玩家主动退出。
pub fn stop_run_at(run: &Match3DRunSnapshot, stopped_action_id: String) -> Match3DRunSnapshot {
    let mut next = run.clone();
    if next.status == Match3DRunStatus::Running {
        next.status = Match3DRunStatus::Stopped;
        next.board_version += 1;
        next.last_confirmed_action_id = normalize_required_string(stopped_action_id);
    }
    next
}

/// 以 2D 圆形近似判断遮挡：完全被更高层物品覆盖的物品不可点击。
pub fn refresh_clickable_flags(run: &mut Match3DRunSnapshot) {
    let board_items = run
        .items
        .iter()
        .filter(|item| item.state == Match3DItemState::InBoard)
        .cloned()
        .collect::<Vec<_>>();

    for item in &mut run.items {
        if item.state != Match3DItemState::InBoard {
            item.clickable = false;
            continue;
        }

        item.clickable = !board_items.iter().any(|cover| {
            cover.layer > item.layer
                && fully_covers(cover.x, cover.y, cover.radius, item.x, item.y, item.radius)
        });
    }
}

fn build_initial_items(
    clear_count: u32,
    difficulty: u32,
    seed: u64,
    theme_text: &str,
) -> Vec<Match3DItemSnapshot> {
    let mut rng = DeterministicRng::new(seed ^ ((clear_count as u64) << 32) ^ difficulty as u64);
    let base_radius = resolve_item_radius(difficulty);
    let visual_keys = visual_keys_for_theme(theme_text);
    let mut items = Vec::with_capacity((clear_count * MATCH3D_ITEMS_PER_CLEAR) as usize);

    for clear_index in 0..clear_count {
        let visual_index = (clear_index as usize) % visual_keys.len();
        let item_type_id = format!("match3d-type-{:02}", visual_index + 1);
        let visual_key = visual_keys[visual_index].to_string();

        for copy_index in 0..MATCH3D_ITEMS_PER_CLEAR {
            let radius =
                resolve_item_radius_variant(base_radius, &visual_key, visual_index, copy_index);
            let (x, y) = random_point_in_circle(&mut rng, max_spawn_offset(radius));
            let instance_index = clear_index * MATCH3D_ITEMS_PER_CLEAR + copy_index;
            items.push(Match3DItemSnapshot {
                item_instance_id: format!("match3d-item-{instance_index:04}"),
                item_type_id: item_type_id.clone(),
                visual_key: visual_key.clone(),
                x,
                y,
                radius,
                layer: instance_index,
                state: Match3DItemState::InBoard,
                clickable: true,
                tray_slot_index: None,
            });
        }
    }

    // 洗牌只改变层级顺序，不改变每组三个的可通关性。
    for index in (1..items.len()).rev() {
        let swap_index = (rng.next_u32() as usize) % (index + 1);
        items.swap(index, swap_index);
    }
    for (layer, item) in items.iter_mut().enumerate() {
        item.layer = layer as u32;
    }

    items
}

fn visual_keys_for_theme(theme_text: &str) -> &'static [&'static str; 10] {
    if is_fruit_theme(theme_text) {
        &MATCH3D_FRUIT_VISUAL_KEYS
    } else {
        &MATCH3D_SHAPE_VISUAL_KEYS
    }
}

fn is_fruit_theme(theme_text: &str) -> bool {
    let normalized = theme_text.trim().to_lowercase();
    [
        "水果", "果蔬", "果物", "fruit", "fruits", "苹果", "香蕉", "葡萄", "西瓜", "草莓", "桃",
        "李", "柠", "橙", "梨",
    ]
    .iter()
    .any(|marker| normalized.contains(marker))
}

fn resolve_item_radius(difficulty: u32) -> f32 {
    let clamped = difficulty.clamp(MATCH3D_MIN_DIFFICULTY, MATCH3D_MAX_DIFFICULTY);
    let radius = 0.105 - (clamped as f32 - 1.0) * 0.0055;
    radius.max(0.052)
}

fn resolve_item_radius_variant(
    base_radius: f32,
    visual_key: &str,
    visual_index: usize,
    copy_index: u32,
) -> f32 {
    let copy_delta = (copy_index as f32 - 1.0) * 0.002;
    if is_fruit_visual_key(visual_key) {
        return (base_radius * fruit_visual_size_scale(visual_key) + copy_delta).clamp(0.04, 0.13);
    }

    let type_delta = ((visual_index % 5) as f32 - 2.0) * 0.004;
    (base_radius + type_delta + copy_delta).clamp(0.045, 0.12)
}

fn is_fruit_visual_key(visual_key: &str) -> bool {
    matches!(
        visual_key,
        "watermelon-green"
            | "apple-red"
            | "banana-yellow"
            | "grape-purple"
            | "melon-green"
            | "berry-blue"
            | "peach-pink"
            | "plum-indigo"
            | "lime-lime"
            | "orange-orange"
            | "pear-cyan"
    )
}

fn fruit_visual_size_scale(visual_key: &str) -> f32 {
    match visual_key {
        "watermelon-green" => 1.24,
        "melon-green" => 1.12,
        "banana-yellow" => 1.04,
        "apple-red" | "orange-orange" | "peach-pink" | "pear-cyan" => 1.0,
        "plum-indigo" | "lime-lime" => 0.86,
        "grape-purple" | "berry-blue" => 0.78,
        _ => 1.0,
    }
}

fn max_spawn_offset(radius: f32) -> f32 {
    (MATCH3D_BOARD_RADIUS - MATCH3D_BOARD_SAFE_MARGIN - radius).max(0.0)
}

fn random_point_in_circle(rng: &mut DeterministicRng, max_radius: f32) -> (f32, f32) {
    for _ in 0..24 {
        let x = rng.next_unit_signed() * max_radius;
        let y = rng.next_unit_signed() * max_radius;
        if x * x + y * y <= max_radius * max_radius {
            return (MATCH3D_BOARD_CENTER + x, MATCH3D_BOARD_CENTER + y);
        }
    }
    (MATCH3D_BOARD_CENTER, MATCH3D_BOARD_CENTER)
}

fn fully_covers(
    cover_x: f32,
    cover_y: f32,
    cover_radius: f32,
    item_x: f32,
    item_y: f32,
    item_radius: f32,
) -> bool {
    let dx = cover_x - item_x;
    let dy = cover_y - item_y;
    let distance = (dx * dx + dy * dy).sqrt();
    distance + item_radius <= cover_radius * 0.96
}

fn empty_tray_slots() -> Vec<Match3DTraySlot> {
    (0..MATCH3D_TRAY_SLOT_COUNT)
        .map(|slot_index| Match3DTraySlot {
            slot_index,
            item_instance_id: None,
            item_type_id: None,
            visual_key: None,
        })
        .collect()
}

fn first_empty_slot_index(slots: &[Match3DTraySlot]) -> Option<u32> {
    slots
        .iter()
        .find(|slot| slot.item_instance_id.is_none())
        .map(|slot| slot.slot_index)
}

fn fill_tray_slot(slots: &mut [Match3DTraySlot], slot_index: u32, item: &Match3DItemSnapshot) {
    if let Some(slot) = slots.iter_mut().find(|slot| slot.slot_index == slot_index) {
        slot.item_instance_id = Some(item.item_instance_id.clone());
        slot.item_type_id = Some(item.item_type_id.clone());
        slot.visual_key = Some(item.visual_key.clone());
    }
}

fn clear_first_triple(run: &mut Match3DRunSnapshot, item_type_id: &str) -> Vec<String> {
    let matched_slot_item_ids = run
        .tray_slots
        .iter()
        .filter(|slot| slot.item_type_id.as_deref() == Some(item_type_id))
        .filter_map(|slot| slot.item_instance_id.clone())
        .take(MATCH3D_ITEMS_PER_CLEAR as usize)
        .collect::<Vec<_>>();

    if matched_slot_item_ids.len() < MATCH3D_ITEMS_PER_CLEAR as usize {
        return Vec::new();
    }

    for item in &mut run.items {
        if matched_slot_item_ids.contains(&item.item_instance_id) {
            item.state = Match3DItemState::Cleared;
            item.clickable = false;
            item.tray_slot_index = None;
        }
    }
    for slot in &mut run.tray_slots {
        if slot
            .item_instance_id
            .as_ref()
            .is_some_and(|id| matched_slot_item_ids.contains(id))
        {
            slot.item_instance_id = None;
            slot.item_type_id = None;
            slot.visual_key = None;
        }
    }

    matched_slot_item_ids
}

fn compact_tray(run: &mut Match3DRunSnapshot) {
    let mut occupied = run
        .tray_slots
        .iter()
        .filter_map(|slot| {
            Some((
                slot.item_instance_id.clone()?,
                slot.item_type_id.clone()?,
                slot.visual_key.clone()?,
            ))
        })
        .collect::<Vec<_>>();

    for slot in &mut run.tray_slots {
        slot.item_instance_id = None;
        slot.item_type_id = None;
        slot.visual_key = None;
    }

    for (slot_index, (item_instance_id, item_type_id, visual_key)) in occupied.drain(..).enumerate()
    {
        let slot_index = slot_index as u32;
        if let Some(slot) = run
            .tray_slots
            .iter_mut()
            .find(|slot| slot.slot_index == slot_index)
        {
            slot.item_instance_id = Some(item_instance_id.clone());
            slot.item_type_id = Some(item_type_id);
            slot.visual_key = Some(visual_key);
        }
        if let Some(item) = run
            .items
            .iter_mut()
            .find(|item| item.item_instance_id == item_instance_id)
        {
            item.tray_slot_index = Some(slot_index);
        }
    }
}

fn fail_run(
    mut run: Match3DRunSnapshot,
    reason: Match3DFailureReason,
    action_id: String,
) -> Match3DRunSnapshot {
    run.status = Match3DRunStatus::Failed;
    run.failure_reason = Some(reason);
    run.board_version += 1;
    run.last_confirmed_action_id = Some(action_id);
    run
}

fn rejected(
    run: Match3DRunSnapshot,
    reject_reason: Match3DClickRejectReason,
) -> Match3DClickConfirmation {
    Match3DClickConfirmation {
        accepted: false,
        reject_reason: Some(reject_reason),
        entered_slot_index: None,
        cleared_item_instance_ids: Vec::new(),
        run,
    }
}

fn validate_basic_publish_fields(game_name: &str, summary: &str, tags: &[String]) -> Vec<String> {
    let mut blockers = Vec::new();
    if normalize_required_string(game_name).is_none() {
        blockers.push("游戏名称不能为空".to_string());
    }
    if normalize_required_string(summary).is_none() {
        blockers.push("简介不能为空".to_string());
    }
    let normalized_tags = normalize_string_list(tags.to_vec());
    if normalized_tags.is_empty() {
        blockers.push("至少需要 1 个标签".to_string());
    }
    blockers
}

fn validate_result_publish_fields(draft: &Match3DResultDraft) -> Vec<String> {
    let mut blockers = validate_basic_publish_fields(&draft.game_name, &draft.summary, &draft.tags);
    if draft
        .cover_image_src
        .as_deref()
        .and_then(normalize_required_string)
        .is_none()
    {
        blockers.push("封面图不能为空".to_string());
    }
    blockers
}

fn default_tags_for_theme(theme_text: &str) -> Vec<String> {
    let mut tags = vec![
        "抓大鹅".to_string(),
        "经典消除".to_string(),
        theme_text.to_string(),
    ];
    tags.sort();
    tags.dedup();
    tags
}

struct DeterministicRng {
    state: u64,
}

impl DeterministicRng {
    fn new(seed: u64) -> Self {
        Self { state: seed.max(1) }
    }

    fn next_u32(&mut self) -> u32 {
        let mut value = self.state;
        value ^= value << 13;
        value ^= value >> 7;
        value ^= value << 17;
        self.state = value;
        (value >> 32) as u32
    }

    fn next_unit_signed(&mut self) -> f32 {
        let value = self.next_u32() as f32 / u32::MAX as f32;
        value * 2.0 - 1.0
    }
}

#[cfg(test)]
mod tests {
    use std::collections::BTreeMap;

    use super::*;

    fn test_config(clear_count: u32) -> Match3DCreatorConfig {
        build_creator_config("水果", None, clear_count, 4).expect("config should be valid")
    }

    fn manual_item(id: &str, type_id: &str, slot: Option<u32>) -> Match3DItemSnapshot {
        Match3DItemSnapshot {
            item_instance_id: id.to_string(),
            item_type_id: type_id.to_string(),
            visual_key: type_id.to_string(),
            x: 0.0,
            y: 0.0,
            radius: 0.08,
            layer: 0,
            state: if slot.is_some() {
                Match3DItemState::InTray
            } else {
                Match3DItemState::InBoard
            },
            clickable: slot.is_none(),
            tray_slot_index: slot,
        }
    }

    #[test]
    fn creator_config_requires_positive_clear_count() {
        let error = build_creator_config("水果", None, 0, 3).expect_err("zero should fail");
        assert_eq!(error, Match3DFieldError::InvalidClearCount);
    }

    #[test]
    fn draft_requires_cover_before_publish() {
        let mut draft = compile_result_draft(&test_config(2));

        assert!(!draft.publish_ready);
        assert!(draft.blockers.contains(&"封面图不能为空".to_string()));

        draft.cover_image_src = Some("https://example.com/cover.png".to_string());
        assert!(validate_publish_requirements(&draft).is_empty());
    }

    #[test]
    fn initial_run_generates_triples() {
        let run = start_run_with_seed_at(
            "run-1".to_string(),
            "user-1".to_string(),
            "profile-1".to_string(),
            &test_config(12),
            42,
            1_000,
        )
        .expect("run should start");

        assert_eq!(run.total_item_count, 36);
        let mut counts = BTreeMap::<String, u32>::new();
        for item in &run.items {
            *counts.entry(item.item_type_id.clone()).or_default() += 1;
        }
        assert!(counts.values().all(|count| count % 3 == 0));
    }

    #[test]
    fn initial_run_uses_slightly_different_item_sizes() {
        let run = start_run_with_seed_at(
            "run-size".to_string(),
            "user-1".to_string(),
            "profile-1".to_string(),
            &test_config(6),
            21,
            1_000,
        )
        .expect("run should start");

        let mut radii = run
            .items
            .iter()
            .map(|item| (item.radius * 1_000.0).round() as u32)
            .collect::<Vec<_>>();
        radii.sort();
        radii.dedup();

        assert!(radii.len() > 1);
    }

    #[test]
    fn fruit_theme_generates_fruit_visuals_inside_board() {
        let run = start_run_with_seed_at(
            "run-fruit".to_string(),
            "user-1".to_string(),
            "profile-1".to_string(),
            &test_config(10),
            12,
            1_000,
        )
        .expect("run should start");

        let visual_keys = run
            .items
            .iter()
            .map(|item| item.visual_key.as_str())
            .collect::<Vec<_>>();
        assert!(visual_keys.contains(&"watermelon-green"));
        assert!(visual_keys.contains(&"apple-red"));
        assert!(visual_keys.contains(&"banana-yellow"));
        assert!(!visual_keys.contains(&"red_circle"));

        for item in &run.items {
            let dx = item.x - MATCH3D_BOARD_CENTER;
            let dy = item.y - MATCH3D_BOARD_CENTER;
            let distance = (dx * dx + dy * dy).sqrt();
            assert!(
                distance + item.radius <= MATCH3D_BOARD_RADIUS - MATCH3D_BOARD_SAFE_MARGIN + 0.0001,
                "item {} should stay inside board: x={}, y={}, radius={}",
                item.item_instance_id,
                item.x,
                item.y,
                item.radius
            );
        }
    }

    #[test]
    fn fruit_theme_uses_common_sense_relative_sizes() {
        let run = start_run_with_seed_at(
            "run-fruit-size".to_string(),
            "user-1".to_string(),
            "profile-1".to_string(),
            &test_config(10),
            27,
            1_000,
        )
        .expect("run should start");

        let max_radius_for_visual = |visual_key: &str| {
            run.items
                .iter()
                .filter(|item| item.visual_key == visual_key)
                .map(|item| item.radius)
                .fold(0.0, f32::max)
        };

        let watermelon = max_radius_for_visual("watermelon-green");
        let apple = max_radius_for_visual("apple-red");
        let grape = max_radius_for_visual("grape-purple");

        assert!(watermelon > apple);
        assert!(apple > grape);
    }

    #[test]
    fn non_fruit_theme_generates_shape_visuals() {
        let config = build_creator_config("玩具", None, 3, 4).expect("config should be valid");
        let run = start_run_with_seed_at(
            "run-shapes".to_string(),
            "user-1".to_string(),
            "profile-1".to_string(),
            &config,
            13,
            1_000,
        )
        .expect("run should start");

        let visual_keys = run
            .items
            .iter()
            .map(|item| item.visual_key.as_str())
            .collect::<Vec<_>>();
        assert!(visual_keys.contains(&"red_circle"));
        assert!(visual_keys.contains(&"yellow_triangle"));
        assert!(!visual_keys.contains(&"apple-red"));
    }

    #[test]
    fn clicking_three_same_items_clears_and_wins() {
        let mut run = start_run_with_seed_at(
            "run-1".to_string(),
            "user-1".to_string(),
            "profile-1".to_string(),
            &test_config(1),
            7,
            10_000,
        )
        .expect("run should start");
        for item in &mut run.items {
            item.clickable = true;
        }

        let ids = run
            .items
            .iter()
            .map(|item| item.item_instance_id.clone())
            .collect::<Vec<_>>();

        for (index, item_id) in ids.iter().enumerate() {
            let input = Match3DClickInput {
                run_id: run.run_id.clone(),
                owner_user_id: run.owner_user_id.clone(),
                item_instance_id: item_id.clone(),
                client_action_id: format!("action-{index}"),
                snapshot_version: run.board_version,
                clicked_at_ms: 11_000 + index as u64,
            };
            run = confirm_click_at(&run, &input)
                .expect("click should confirm")
                .run;
        }

        assert_eq!(run.status, Match3DRunStatus::Won);
        assert_eq!(run.cleared_item_count, 3);
        assert!(
            run.tray_slots
                .iter()
                .all(|slot| slot.item_instance_id.is_none())
        );
    }

    #[test]
    fn tray_full_fails_when_no_triple_can_clear() {
        let mut run = Match3DRunSnapshot {
            run_id: "run-full".to_string(),
            profile_id: "profile-1".to_string(),
            owner_user_id: "user-1".to_string(),
            status: Match3DRunStatus::Running,
            started_at_ms: 0,
            duration_limit_ms: MATCH3D_DEFAULT_DURATION_LIMIT_MS,
            remaining_ms: MATCH3D_DEFAULT_DURATION_LIMIT_MS,
            clear_count: 3,
            total_item_count: 9,
            cleared_item_count: 0,
            board_version: 1,
            items: (0..8)
                .map(|index| manual_item(&format!("item-{index}"), &format!("type-{index}"), None))
                .collect(),
            tray_slots: empty_tray_slots(),
            failure_reason: None,
            last_confirmed_action_id: None,
        };

        for index in 0..7 {
            let input = Match3DClickInput {
                run_id: run.run_id.clone(),
                owner_user_id: run.owner_user_id.clone(),
                item_instance_id: format!("item-{index}"),
                client_action_id: format!("action-{index}"),
                snapshot_version: run.board_version,
                clicked_at_ms: 1_000 + index,
            };
            run = confirm_click_at(&run, &input)
                .expect("click should confirm")
                .run;
        }

        assert_eq!(run.status, Match3DRunStatus::Failed);
        assert_eq!(run.failure_reason, Some(Match3DFailureReason::TrayFull));
    }

    #[test]
    fn timer_expiration_fails_running_run() {
        let run = start_run_with_seed_at(
            "run-1".to_string(),
            "user-1".to_string(),
            "profile-1".to_string(),
            &test_config(2),
            9,
            1_000,
        )
        .expect("run should start");

        let expired = resolve_run_timer_at(&run, 1_000 + MATCH3D_DEFAULT_DURATION_LIMIT_MS);

        assert_eq!(expired.status, Match3DRunStatus::Failed);
        assert_eq!(expired.failure_reason, Some(Match3DFailureReason::TimeUp));
    }

    #[test]
    fn fully_covered_item_is_not_clickable() {
        let mut run = Match3DRunSnapshot {
            run_id: "run-cover".to_string(),
            profile_id: "profile-1".to_string(),
            owner_user_id: "user-1".to_string(),
            status: Match3DRunStatus::Running,
            started_at_ms: 0,
            duration_limit_ms: MATCH3D_DEFAULT_DURATION_LIMIT_MS,
            remaining_ms: MATCH3D_DEFAULT_DURATION_LIMIT_MS,
            clear_count: 1,
            total_item_count: 2,
            cleared_item_count: 0,
            board_version: 1,
            items: vec![
                Match3DItemSnapshot {
                    layer: 0,
                    radius: 0.04,
                    ..manual_item("bottom", "type-a", None)
                },
                Match3DItemSnapshot {
                    layer: 1,
                    radius: 0.08,
                    ..manual_item("top", "type-b", None)
                },
            ],
            tray_slots: empty_tray_slots(),
            failure_reason: None,
            last_confirmed_action_id: None,
        };

        refresh_clickable_flags(&mut run);

        let bottom = run
            .items
            .iter()
            .find(|item| item.item_instance_id == "bottom")
            .expect("bottom item should exist");
        assert!(!bottom.clickable);
    }
}