steel_core/

config.rs

//! Server configuration types used at runtime.
//!
//! The full deserialization struct lives in the `steel` crate. Steel-core only
//! defines `RuntimeConfig` (the subset kept after startup) and the world/domain
//! configuration types that both crates share.

use rustc_hash::{FxHashMap, FxHashSet};
use serde::{Deserialize, Deserializer, de::Error as DeError};
use std::{
    collections::BTreeMap,
    path::{Component, Path, PathBuf},
};
pub use steel_protocol::packet_traits::CompressionInfo;
use steel_protocol::packets::config::{CServerLinks, Link, ServerLinksType};
use steel_registry::vanilla_dimension_types;
use steel_utils::Identifier;
use steel_utils::codec::Or;
use steel_utils::types::{Difficulty, GameType};
use text_components::TextComponent;
use toml::map::Map;

use crate::chunk_saver::registry::WorldStorageRegistry;
use crate::worldgen::registry::{ValidatedWorldGeneratorConfig, WorldGeneratorRegistry};

/// Error returned when online mode is configured without its authentication handshake.
pub const ONLINE_MODE_REQUIRES_ENCRYPTION: &str =
    "encryption must be true when online_mode is enabled";

/// Vanilla chat and command spam threshold window, in seconds.
pub const DEFAULT_SPAM_THRESHOLD_SECONDS: i32 = 10;

/// Default cap on queued neighbor-update tasks in one chained run.
pub const DEFAULT_MAX_CHAINED_NEIGHBOR_UPDATES: i32 = 1_000_000;

/// Validates the login settings that establish a player's authenticated identity.
///
/// # Errors
///
/// Returns an error when online mode could accept a client-supplied UUID without
/// completing the encryption-backed `hasJoined` flow.
pub const fn validate_login_security(
    online_mode: bool,
    encryption: bool,
) -> Result<(), &'static str> {
    if online_mode && !encryption {
        Err(ONLINE_MODE_REQUIRES_ENCRYPTION)
    } else {
        Ok(())
    }
}

/// Runtime server configuration — the subset of settings needed after startup.
///
/// Stored on `Server` and accessed by game logic at runtime.
#[derive(Debug, Clone)]
pub struct RuntimeConfig {
    /// The maximum number of players that can be on the server at once.
    pub max_players: u32,
    /// The view distance of the server.
    pub view_distance: u8,
    /// The simulation distance of the server.
    pub simulation_distance: u8,
    /// Maximum queued neighbor-update tasks in one chained run; negative means unlimited.
    pub max_chained_neighbor_updates: i32,
    /// Whether the server is in online mode.
    pub online_mode: bool,
    /// Optional authentication endpoint for online-mode `hasJoined` checks.
    pub auth_server: Option<String>,
    /// Optional endpoint for online-mode player name-to-profile lookups.
    pub profile_server: Option<String>,
    /// Optional endpoint for Mojang-compatible service public keys.
    pub services_server: Option<String>,
    /// Whether the server should use encryption. Required in online mode.
    pub encryption: bool,
    /// Whether vanilla floating/flying movement checks permit unauthorized flight.
    pub allow_flight: bool,
    /// The message of the day.
    pub motd: String,
    /// Whether to use a favicon.
    pub use_favicon: bool,
    /// The path to the favicon.
    pub favicon: String,
    /// Whether to enforce secure chat.
    pub enforce_secure_chat: bool,
    /// Vanilla chat spam threshold window in seconds
    pub chat_spam_threshold_seconds: i32,
    /// Vanilla command spam threshold window in seconds
    pub command_spam_threshold_seconds: i32,
    /// The compression settings for the server.
    pub compression: Option<CompressionInfo>,
    /// All settings and configurations for server links.
    pub server_links: Option<ServerLinks>,
    /// Optional count of persistent inter-tick gameplay packet workers.
    pub packet_workers: Option<usize>,
    /// Optional worker count for the Rayon chunk generation pool.
    pub chunk_generation_threads: Option<usize>,
    /// Optional worker count for the Rayon chunk encoding pool.
    pub chunk_encoding_threads: Option<usize>,
}

impl Default for RuntimeConfig {
    /// The settings a freshly packaged server ships, leaving the optional service
    /// endpoints and server links unset.
    fn default() -> Self {
        Self {
            max_players: 20,
            view_distance: 10,
            simulation_distance: 10,
            max_chained_neighbor_updates: DEFAULT_MAX_CHAINED_NEIGHBOR_UPDATES,
            online_mode: true,
            auth_server: None,
            profile_server: None,
            services_server: None,
            encryption: true,
            allow_flight: false,
            motd: "A Steel Server".to_owned(),
            use_favicon: true,
            favicon: "config/favicon.png".to_owned(),
            enforce_secure_chat: false,
            chat_spam_threshold_seconds: DEFAULT_SPAM_THRESHOLD_SECONDS,
            command_spam_threshold_seconds: DEFAULT_SPAM_THRESHOLD_SECONDS,
            compression: Some(CompressionInfo::default()),
            server_links: None,
            packet_workers: None,
            chunk_generation_threads: None,
            chunk_encoding_threads: None,
        }
    }
}

impl RuntimeConfig {
    /// Builds the `CServerLinks` packet from config, if server links are enabled.
    #[must_use]
    pub fn server_links_packet(&self) -> Option<CServerLinks> {
        let server_links = self.server_links.as_ref()?;

        if !server_links.enable || server_links.links.is_empty() {
            return None;
        }

        let links: Vec<Link> = server_links
            .links
            .iter()
            .map(|config_link| {
                let label = match &config_link.label {
                    ConfigLabel::BuiltIn(link_type) => Or::Left(*link_type),
                    ConfigLabel::Custom(text_component) => Or::Right(text_component.clone()),
                };
                Link::new(label, config_link.url.clone())
            })
            .collect();

        Some(CServerLinks { links })
    }
}

/// Label type for server links — either built-in string or custom `TextComponent`.
#[derive(Debug, Clone, Deserialize)]
#[serde(untagged)]
#[expect(
    clippy::large_enum_variant,
    reason = "TextComponent variant is common; boxing would add indirection for every use"
)]
pub enum ConfigLabel {
    /// Built-in server link type (e.g., "`bug_report`", "website")
    BuiltIn(ServerLinksType),
    /// Custom text component with formatting
    Custom(TextComponent),
}

/// A single server link configuration entry.
#[derive(Debug, Clone, Deserialize)]
pub struct ConfigLink {
    /// The label for this link (built-in type or custom `TextComponent`)
    pub label: ConfigLabel,
    /// The URL for this link
    pub url: String,
}

/// Server links configuration.
#[derive(Debug, Clone, Deserialize, Default)]
#[serde(default)]
pub struct ServerLinks {
    /// Enable the server links feature
    pub enable: bool,
    /// List of server links to display
    #[serde(default)]
    pub links: Vec<ConfigLink>,
}

/// Configuration for world storage.
#[derive(Debug, Clone)]
pub enum WorldStorageConfig {
    /// Standard disk persistence using region files.
    Disk {
        /// Path to the world directory (e.g., "world/overworld").
        path: String,
    },
    /// RAM-only storage with empty chunks created on demand.
    /// No data is persisted — useful for testing and minigames.
    RamOnly,
}

/// Parsed `worlds.toml` root.
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct WorldsConfig {
    /// Root directory for save data.
    #[serde(default = "default_save_path")]
    pub save_path: String,
    /// Root seed default. Empty or omitted means random.
    #[serde(default)]
    pub seed: Option<String>,
    /// Root default game mode for first-visit player data.
    #[serde(default, deserialize_with = "deserialize_optional_game_type")]
    pub default_gamemode: Option<GameType>,
    /// Root default difficulty for new level data.
    #[serde(default, deserialize_with = "deserialize_optional_difficulty")]
    pub difficulty: Option<Difficulty>,
    /// Root world storage default.
    #[serde(default)]
    pub storage: Option<StorageSelection>,
    /// Global player data storage selection.
    #[serde(default)]
    pub player_storage: Option<StorageSelection>,
    /// Domain declarations keyed by domain name.
    pub domains: BTreeMap<String, DomainConfig>,
}

/// Parsed domain config inside `worlds.toml`.
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DomainConfig {
    /// Whether this is the server's default domain.
    #[serde(default)]
    pub default: bool,
    /// Domain seed override. Empty means random for this domain.
    #[serde(default)]
    pub seed: Option<String>,
    /// Domain default game mode override.
    #[serde(default, deserialize_with = "deserialize_optional_game_type")]
    pub default_gamemode: Option<GameType>,
    /// Domain difficulty override for new level data.
    #[serde(default, deserialize_with = "deserialize_optional_difficulty")]
    pub difficulty: Option<Difficulty>,
    /// Domain storage override.
    #[serde(default)]
    pub storage: Option<StorageSelection>,
    /// Worlds declared in this domain.
    #[serde(default)]
    pub worlds: Vec<WorldEntryConfig>,
}

/// Parsed world entry inside a domain.
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct WorldEntryConfig {
    /// Path part of the loaded world identifier. The domain table key supplies the namespace.
    pub name: String,
    /// Generator factory identifier.
    pub generator: Identifier,
    /// Whether this is the domain's default world.
    #[serde(default)]
    pub default: bool,
    /// World seed override. Empty means random for this world.
    #[serde(default)]
    pub seed: Option<String>,
    /// World default game mode override.
    #[serde(default, deserialize_with = "deserialize_optional_game_type")]
    pub default_gamemode: Option<GameType>,
    /// World difficulty override for new level data.
    #[serde(default, deserialize_with = "deserialize_optional_difficulty")]
    pub difficulty: Option<Difficulty>,
    /// World storage override.
    #[serde(default)]
    pub storage: Option<StorageSelection>,
    /// Same-domain world name used by Nether portals from this world.
    #[serde(default)]
    pub nether_portal_target: Option<String>,
    /// Same-domain world name used by End portals from non-End worlds.
    #[serde(default)]
    pub end_portal_target: Option<String>,
    /// Generator-specific config. The selected generator validates this strictly.
    #[serde(default)]
    pub config: Option<toml::Value>,
}

/// Registry-backed storage selection from config.
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StorageSelection {
    /// Storage backend identifier.
    #[serde(rename = "type")]
    pub kind: Identifier,
    /// Storage-specific config. The selected storage backend validates this strictly.
    #[serde(default)]
    pub config: Option<toml::Value>,
}

impl StorageSelection {
    /// Default disk world storage.
    #[must_use]
    pub fn default_world_disk() -> Self {
        Self {
            kind: Identifier::from_steel("disk"),
            config: None,
        }
    }

    /// Default file-backed player storage.
    #[must_use]
    pub fn default_player_file() -> Self {
        Self {
            kind: Identifier::from_steel("file"),
            config: None,
        }
    }

    /// Returns the config table or an empty table if omitted.
    #[must_use]
    pub fn config_value(&self) -> toml::Value {
        self.config
            .clone()
            .unwrap_or_else(|| toml::Value::Table(Map::new()))
    }
}

/// Fully validated and cascaded worlds config.
#[derive(Debug, Clone)]
pub struct ResolvedWorldsConfig {
    /// Root directory for save data.
    pub save_path: PathBuf,
    /// Default domain name.
    pub default_domain: String,
    /// Resolved domain configs.
    pub domains: Vec<ResolvedDomainConfig>,
    /// Resolved world configs in startup creation order.
    pub worlds: Vec<ResolvedWorldConfig>,
    /// Player data storage selection.
    pub player_storage: StorageSelection,
}

/// Validated domain config.
#[derive(Debug, Clone)]
pub struct ResolvedDomainConfig {
    /// Domain name.
    pub name: String,
    /// Default world identifier in this domain.
    pub default_world: Identifier,
    /// World identifiers in this domain.
    pub worlds: Vec<Identifier>,
}

/// Validated world startup config.
#[derive(Debug, Clone)]
pub struct ResolvedWorldConfig {
    /// Loaded world identifier (`domain:world`).
    pub key: Identifier,
    /// Domain name.
    pub domain: String,
    /// World path/name inside the domain.
    pub name: String,
    /// Generator factory identifier.
    pub generator: Identifier,
    /// Strictly validated generator config.
    pub generator_config: ValidatedWorldGeneratorConfig,
    /// Resolved world seed.
    pub seed: i64,
    /// Default game mode for first-visit player data in this world.
    pub default_gamemode: GameType,
    /// Difficulty for new level data in this world.
    pub difficulty: Difficulty,
    /// Resolved world storage selection.
    pub storage: StorageSelection,
    /// Explicit same-domain Nether portal target, if configured.
    pub nether_portal_target: Option<Identifier>,
    /// Explicit same-domain End portal entry target, if configured.
    pub end_portal_target: Option<Identifier>,
}

impl WorldsConfig {
    /// Validates `worlds.toml` and resolves cascaded defaults.
    ///
    /// # Errors
    /// Returns a human-readable startup error if any invariant is violated.
    pub fn validate_and_resolve(
        &self,
        generator_registry: &WorldGeneratorRegistry,
        storage_registry: &WorldStorageRegistry,
    ) -> Result<ResolvedWorldsConfig, String> {
        // Stays on validate_clean_path: an embedded server cannot chdir per world, so its
        // save root may be absolute.
        validate_clean_path(&self.save_path, "save_path")?;

        if self.domains.is_empty() {
            return Err("worlds.toml must declare at least one domain".to_owned());
        }

        let root_defaults = RootWorldDefaults {
            seed: seed_from_config(self.seed.as_deref().unwrap_or("")),
            gamemode: self.default_gamemode.unwrap_or(GameType::Survival),
            difficulty: self.difficulty.unwrap_or(Difficulty::Normal),
        };
        let root_storage = self
            .storage
            .clone()
            .unwrap_or_else(StorageSelection::default_world_disk);
        storage_registry.validate_selection(&root_storage)?;

        let player_storage = self
            .player_storage
            .clone()
            .unwrap_or_else(StorageSelection::default_player_file);
        validate_player_storage_selection(&player_storage)?;

        let mut default_domain = None;
        let mut resolved_domains = Vec::with_capacity(self.domains.len());
        let mut resolved_worlds = Vec::new();

        for (domain_name, domain) in &self.domains {
            if domain.default && default_domain.replace(domain_name.clone()).is_some() {
                return Err("worlds.toml must declare exactly one default domain".to_owned());
            }
            let (resolved_domain, mut domain_worlds) = resolve_domain_config(
                domain_name,
                domain,
                root_defaults,
                &root_storage,
                generator_registry,
                storage_registry,
            )?;
            resolved_domains.push(resolved_domain);
            resolved_worlds.append(&mut domain_worlds);
        }

        if resolved_worlds.is_empty() {
            return Err("worlds.toml must declare at least one world".to_owned());
        }

        let Some(default_domain) = default_domain else {
            return Err("worlds.toml must declare exactly one default domain".to_owned());
        };

        Ok(ResolvedWorldsConfig {
            save_path: PathBuf::from(&self.save_path),
            default_domain,
            domains: resolved_domains,
            worlds: resolved_worlds,
            player_storage,
        })
    }
}

fn resolve_domain_config(
    domain_name: &str,
    domain: &DomainConfig,
    root_defaults: RootWorldDefaults,
    root_storage: &StorageSelection,
    generator_registry: &WorldGeneratorRegistry,
    storage_registry: &WorldStorageRegistry,
) -> Result<(ResolvedDomainConfig, Vec<ResolvedWorldConfig>), String> {
    validate_domain_name(domain_name)?;
    if domain.worlds.is_empty() {
        return Err(format!(
            "domain {domain_name} must declare at least one world"
        ));
    }

    let domain_defaults = DomainWorldDefaults::from_config(domain, root_defaults);
    let domain_storage = domain
        .storage
        .clone()
        .unwrap_or_else(|| root_storage.clone());
    storage_registry.validate_selection(&domain_storage)?;

    let mut seen_world_names = FxHashSet::default();
    let mut default_world = None;
    let mut domain_world_ids = Vec::with_capacity(domain.worlds.len());
    let mut resolved_worlds = Vec::with_capacity(domain.worlds.len());

    for world in &domain.worlds {
        let resolved_world = resolve_world_config(
            domain_name,
            world,
            domain_defaults,
            &domain_storage,
            generator_registry,
            storage_registry,
        )?;

        if !seen_world_names.insert(world.name.clone()) {
            return Err(format!(
                "domain {domain_name} declares duplicate world {}",
                world.name
            ));
        }
        if world.default && default_world.replace(resolved_world.key.clone()).is_some() {
            return Err(format!(
                "domain {domain_name} must declare exactly one default world"
            ));
        }

        domain_world_ids.push(resolved_world.key.clone());
        resolved_worlds.push(resolved_world);
    }

    validate_explicit_portal_targets(domain_name, &resolved_worlds, &seen_world_names)?;

    let Some(default_world) = default_world else {
        return Err(format!(
            "domain {domain_name} must declare exactly one default world"
        ));
    };

    Ok((
        ResolvedDomainConfig {
            name: domain_name.to_owned(),
            default_world,
            worlds: domain_world_ids,
        },
        resolved_worlds,
    ))
}

fn resolve_world_config(
    domain_name: &str,
    world: &WorldEntryConfig,
    domain_defaults: DomainWorldDefaults,
    domain_storage: &StorageSelection,
    generator_registry: &WorldGeneratorRegistry,
    storage_registry: &WorldStorageRegistry,
) -> Result<ResolvedWorldConfig, String> {
    validate_world_name(&world.name, domain_name)?;
    let world_key = Identifier::new(domain_name.to_owned(), world.name.clone());

    let raw_generator_config = world
        .config
        .clone()
        .unwrap_or_else(|| toml::Value::Table(Map::new()));
    let generator_config =
        generator_registry.validate_config(&world.generator, &raw_generator_config)?;

    let storage = world
        .storage
        .clone()
        .unwrap_or_else(|| domain_storage.clone());
    storage_registry.validate_selection(&storage)?;
    let nether_portal_target = resolve_explicit_portal_target(
        domain_name,
        &world.name,
        world.nether_portal_target.as_deref(),
        "nether_portal_target",
    )?;
    let end_portal_target = resolve_explicit_portal_target(
        domain_name,
        &world.name,
        world.end_portal_target.as_deref(),
        "end_portal_target",
    )?;
    validate_end_portal_target_dimension(
        domain_name,
        &world.name,
        end_portal_target.as_ref(),
        &generator_config,
    )?;

    Ok(ResolvedWorldConfig {
        key: world_key,
        domain: domain_name.to_owned(),
        name: world.name.clone(),
        generator: world.generator.clone(),
        generator_config,
        seed: world
            .seed
            .as_deref()
            .map_or(domain_defaults.seed, seed_from_config),
        default_gamemode: world.default_gamemode.unwrap_or(domain_defaults.gamemode),
        difficulty: world.difficulty.unwrap_or(domain_defaults.difficulty),
        storage,
        nether_portal_target,
        end_portal_target,
    })
}

fn resolve_explicit_portal_target(
    domain_name: &str,
    source_world_name: &str,
    target_world_name: Option<&str>,
    field: &str,
) -> Result<Option<Identifier>, String> {
    let Some(target_world_name) = target_world_name else {
        return Ok(None);
    };
    if target_world_name.is_empty()
        || target_world_name.contains('/')
        || !Identifier::validate_path(target_world_name)
    {
        return Err(format!(
            "invalid {field} {target_world_name} for world {domain_name}:{source_world_name}"
        ));
    }
    if target_world_name == source_world_name {
        return Err(format!(
            "world {domain_name}:{source_world_name} {field} must not target itself"
        ));
    }

    Ok(Some(Identifier::new(
        domain_name.to_owned(),
        target_world_name.to_owned(),
    )))
}

fn validate_end_portal_target_dimension(
    domain_name: &str,
    source_world_name: &str,
    end_portal_target: Option<&Identifier>,
    generator_config: &ValidatedWorldGeneratorConfig,
) -> Result<(), String> {
    if end_portal_target.is_some()
        && generator_config.dimension_type() == &vanilla_dimension_types::THE_END
    {
        return Err(format!(
            "world {domain_name}:{source_world_name} end_portal_target is invalid on End-dimension worlds; End portal returns use respawn data"
        ));
    }

    Ok(())
}

fn validate_explicit_portal_targets(
    domain_name: &str,
    worlds: &[ResolvedWorldConfig],
    world_names: &FxHashSet<String>,
) -> Result<(), String> {
    let worlds_by_name = worlds
        .iter()
        .map(|world| (world.name.as_str(), world))
        .collect::<FxHashMap<_, _>>();
    for world in worlds {
        validate_explicit_portal_target(
            domain_name,
            &world.key,
            world.nether_portal_target.as_ref(),
            "nether_portal_target",
            world_names,
        )?;
        validate_explicit_portal_target(
            domain_name,
            &world.key,
            world.end_portal_target.as_ref(),
            "end_portal_target",
            world_names,
        )?;
        validate_end_portal_target_target_dimension(domain_name, world, &worlds_by_name)?;
    }

    Ok(())
}

fn validate_explicit_portal_target(
    domain_name: &str,
    source_world: &Identifier,
    target: Option<&Identifier>,
    field: &str,
    world_names: &FxHashSet<String>,
) -> Result<(), String> {
    let Some(target) = target else {
        return Ok(());
    };
    if world_names.contains(target.path.as_ref()) {
        return Ok(());
    }

    Err(format!(
        "world {source_world} {field} target {} is not declared in domain {domain_name}",
        target.path
    ))
}

fn validate_end_portal_target_target_dimension(
    domain_name: &str,
    source_world: &ResolvedWorldConfig,
    worlds_by_name: &FxHashMap<&str, &ResolvedWorldConfig>,
) -> Result<(), String> {
    let Some(target) = &source_world.end_portal_target else {
        return Ok(());
    };
    let Some(target_world) = worlds_by_name.get(target.path.as_ref()) else {
        return Ok(());
    };

    if target_world.generator_config.dimension_type() == &vanilla_dimension_types::THE_END {
        return Ok(());
    }

    Err(format!(
        "world {domain_name}:{} end_portal_target {} must target an End-dimension world",
        source_world.name, target.path
    ))
}

#[derive(Clone, Copy)]
struct RootWorldDefaults {
    seed: i64,
    gamemode: GameType,
    difficulty: Difficulty,
}

#[derive(Clone, Copy)]
struct DomainWorldDefaults {
    seed: i64,
    gamemode: GameType,
    difficulty: Difficulty,
}

impl DomainWorldDefaults {
    fn from_config(domain: &DomainConfig, root: RootWorldDefaults) -> Self {
        Self {
            seed: domain.seed.as_deref().map_or(root.seed, seed_from_config),
            gamemode: domain.default_gamemode.unwrap_or(root.gamemode),
            difficulty: domain.difficulty.unwrap_or(root.difficulty),
        }
    }
}

fn default_save_path() -> String {
    "saves".to_owned()
}

fn validate_domain_name(name: &str) -> Result<(), String> {
    if name == "global" {
        return Err("domain name global is reserved".to_owned());
    }
    if name.is_empty() || !Identifier::validate_namespace(name) {
        return Err(format!("invalid domain name {name}"));
    }
    Ok(())
}

fn validate_world_name(name: &str, domain: &str) -> Result<(), String> {
    if name.is_empty() || name.contains('/') || !Identifier::validate_path(name) {
        return Err(format!("invalid world name {name} in domain {domain}"));
    }
    Ok(())
}

/// Validates a config path, rejecting `.` and `..` components.
///
/// Absolute paths are accepted. Use [`validate_relative_path`] for paths that have to stay
/// under a Steel-owned root.
pub fn validate_clean_path(path: &str, field: &str) -> Result<(), String> {
    let path = Path::new(path);
    if path.as_os_str().is_empty() {
        return Err(format!("{field} must not be empty"));
    }
    let absolute = path.is_absolute();
    let clean = path.components().all(|component| match component {
        Component::Normal(_) => true,
        Component::RootDir | Component::Prefix(_) => absolute,
        Component::CurDir | Component::ParentDir => false,
    });
    if !clean {
        return Err(format!("{field} must be a clean path"));
    }
    Ok(())
}

/// Validates a config path as a relative path under a Steel-owned root.
pub fn validate_relative_path(path: &str, field: &str) -> Result<(), String> {
    if Path::new(path).is_absolute() {
        return Err(format!("{field} must be relative"));
    }
    validate_clean_path(path, field)
}

fn validate_player_storage_selection(selection: &StorageSelection) -> Result<(), String> {
    if selection.kind != Identifier::from_steel("file")
        && selection.kind != Identifier::from_steel("ram")
    {
        return Err(format!("unknown player storage {}", selection.kind));
    }
    if selection.config.is_some() {
        return Err(format!(
            "{} player storage does not accept config yet",
            selection.kind
        ));
    }
    Ok(())
}

fn seed_from_config(seed: &str) -> i64 {
    if seed.is_empty() {
        rand::random()
    } else {
        seed.parse().unwrap_or_else(|_| {
            let mut hash: i64 = 0;
            for byte in seed.bytes() {
                hash = hash.wrapping_mul(31).wrapping_add(i64::from(byte));
            }
            hash
        })
    }
}

fn deserialize_optional_game_type<'de, D>(deserializer: D) -> Result<Option<GameType>, D::Error>
where
    D: Deserializer<'de>,
{
    let Some(value) = Option::<String>::deserialize(deserializer)? else {
        return Ok(None);
    };
    parse_game_type(&value).map(Some).map_err(DeError::custom)
}

fn parse_game_type(value: &str) -> Result<GameType, String> {
    match value {
        "survival" => Ok(GameType::Survival),
        "creative" => Ok(GameType::Creative),
        "adventure" => Ok(GameType::Adventure),
        "spectator" => Ok(GameType::Spectator),
        _ => Err(format!("invalid gamemode {value}")),
    }
}

fn deserialize_optional_difficulty<'de, D>(deserializer: D) -> Result<Option<Difficulty>, D::Error>
where
    D: Deserializer<'de>,
{
    let Some(value) = Option::<String>::deserialize(deserializer)? else {
        return Ok(None);
    };
    parse_difficulty(&value).map(Some).map_err(DeError::custom)
}

fn parse_difficulty(value: &str) -> Result<Difficulty, String> {
    match value {
        "peaceful" => Ok(Difficulty::Peaceful),
        "easy" => Ok(Difficulty::Easy),
        "normal" => Ok(Difficulty::Normal),
        "hard" => Ok(Difficulty::Hard),
        _ => Err(format!("invalid difficulty {value}")),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::env::temp_dir;
    use steel_registry::init_vanilla_registry;

    #[test]
    fn online_mode_requires_the_authenticated_encryption_flow() {
        assert_eq!(validate_login_security(true, true), Ok(()));
        assert_eq!(
            validate_login_security(true, false),
            Err(ONLINE_MODE_REQUIRES_ENCRYPTION)
        );
        assert_eq!(validate_login_security(false, true), Ok(()));
        assert_eq!(validate_login_security(false, false), Ok(()));
    }

    fn registries() -> (WorldGeneratorRegistry, WorldStorageRegistry) {
        init_vanilla_registry();
        let generators = WorldGeneratorRegistry::new_with_builtins()
            .expect("built-in generator registry should initialize");
        let storage = WorldStorageRegistry::new_with_builtins()
            .expect("built-in storage registry should initialize");
        (generators, storage)
    }

    fn resolve(input: &str) -> Result<ResolvedWorldsConfig, String> {
        let config: WorldsConfig = toml::from_str(input).expect("worlds config should parse");
        let (generators, storage) = registries();
        config.validate_and_resolve(&generators, &storage)
    }

    #[test]
    fn resolves_cascaded_world_defaults() {
        let resolved = resolve(
            r#"
save_path = "saves"
seed = "1"
default_gamemode = "survival"
difficulty = "normal"

[storage]
type = "steel:disk"

[domains.minecraft]
default = true
seed = "2"
default_gamemode = "adventure"
difficulty = "peaceful"

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:overworld"
default = true

[[domains.minecraft.worlds]]
name = "the_nether"
generator = "minecraft:the_nether"
seed = "3"
default_gamemode = "creative"
difficulty = "hard"
"#,
        )
        .expect("valid worlds config should resolve");

        assert_eq!(resolved.default_domain, "minecraft");
        assert_eq!(resolved.worlds.len(), 2);
        let overworld = resolved
            .worlds
            .iter()
            .find(|world| world.name == "overworld")
            .expect("overworld should exist");
        assert_eq!(overworld.seed, 2);
        assert_eq!(overworld.default_gamemode, GameType::Adventure);
        assert_eq!(overworld.difficulty, Difficulty::Peaceful);

        let nether = resolved
            .worlds
            .iter()
            .find(|world| world.name == "the_nether")
            .expect("nether should exist");
        assert_eq!(nether.seed, 3);
        assert_eq!(nether.default_gamemode, GameType::Creative);
        assert_eq!(nether.difficulty, Difficulty::Hard);
    }

    #[test]
    fn resolves_selectable_player_storage_backends() {
        const WORLDS: &str = r#"
[player_storage]
type = "%KIND%"

[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:overworld"
default = true
"#;

        for kind in ["steel:file", "steel:ram"] {
            let resolved = resolve(&WORLDS.replace("%KIND%", kind))
                .unwrap_or_else(|error| panic!("{kind} player storage should resolve: {error}"));
            assert_eq!(resolved.player_storage.kind.to_string(), kind);
        }

        assert_eq!(
            resolve(&WORLDS.replace("%KIND%", "steel:elsewhere")).err(),
            Some("unknown player storage steel:elsewhere".to_owned())
        );
    }

    #[test]
    fn resolves_explicit_portal_targets() {
        let resolved = resolve(
            r#"
[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld2"
generator = "minecraft:overworld"
default = true
nether_portal_target = "the_nether2"
end_portal_target = "the_end2"

[[domains.minecraft.worlds]]
name = "the_nether2"
generator = "minecraft:the_nether"
nether_portal_target = "overworld2"

[[domains.minecraft.worlds]]
name = "the_end2"
generator = "minecraft:the_end"
"#,
        )
        .expect("explicit portal targets should resolve");

        let overworld = resolved
            .worlds
            .iter()
            .find(|world| world.name == "overworld2")
            .expect("overworld2 should exist");
        assert_eq!(
            overworld.nether_portal_target,
            Some(Identifier::new("minecraft", "the_nether2"))
        );
        assert_eq!(
            overworld.end_portal_target,
            Some(Identifier::new("minecraft", "the_end2"))
        );

        let nether = resolved
            .worlds
            .iter()
            .find(|world| world.name == "the_nether2")
            .expect("the_nether2 should exist");
        assert_eq!(
            nether.nether_portal_target,
            Some(Identifier::new("minecraft", "overworld2"))
        );
        assert_eq!(nether.end_portal_target, None);
    }

    #[test]
    fn rejects_missing_explicit_portal_target() {
        let error = resolve(
            r#"
[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:overworld"
default = true
nether_portal_target = "missing"
"#,
        )
        .expect_err("missing explicit portal target should be rejected");
        assert!(error.contains("nether_portal_target"));
        assert!(error.contains("missing"));
    }

    #[test]
    fn rejects_self_explicit_portal_target() {
        let error = resolve(
            r#"
[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:overworld"
default = true
end_portal_target = "overworld"
"#,
        )
        .expect_err("self explicit portal target should be rejected");
        assert!(error.contains("end_portal_target"));
        assert!(error.contains("must not target itself"));
    }

    #[test]
    fn rejects_end_portal_target_on_end_dimension_world() {
        let error = resolve(
            r#"
[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:overworld"
default = true

[[domains.minecraft.worlds]]
name = "the_end"
generator = "minecraft:the_end"
end_portal_target = "overworld"
"#,
        )
        .expect_err("End-dimension world end_portal_target should be rejected");
        assert!(error.contains("end_portal_target"));
        assert!(error.contains("End-dimension worlds"));
    }

    #[test]
    fn rejects_end_portal_target_on_flat_end_dimension_world() {
        let error = resolve(
            r#"
[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:overworld"
default = true

[[domains.minecraft.worlds]]
name = "flat_end"
generator = "minecraft:flat"
end_portal_target = "overworld"

[domains.minecraft.worlds.config]
dimension_type = "minecraft:the_end"
"#,
        )
        .expect_err("flat End-dimension world end_portal_target should be rejected");
        assert!(error.contains("end_portal_target"));
        assert!(error.contains("End-dimension worlds"));
    }

    #[test]
    fn rejects_end_portal_target_to_non_end_dimension_world() {
        let error = resolve(
            r#"
[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:overworld"
default = true
end_portal_target = "other_overworld"

[[domains.minecraft.worlds]]
name = "other_overworld"
generator = "minecraft:overworld"
"#,
        )
        .expect_err("end_portal_target should require an End-dimension target");
        assert!(error.contains("end_portal_target"));
        assert!(error.contains("End-dimension world"));
    }

    #[test]
    fn accepts_end_portal_target_to_flat_end_dimension_world() {
        let resolved = resolve(
            r#"
[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:overworld"
default = true
end_portal_target = "flat_end"

[[domains.minecraft.worlds]]
name = "flat_end"
generator = "minecraft:flat"

[domains.minecraft.worlds.config]
dimension_type = "minecraft:the_end"
"#,
        )
        .expect("flat End-dimension end_portal_target should resolve");
        let overworld = resolved
            .worlds
            .iter()
            .find(|world| world.name == "overworld")
            .expect("overworld should exist");
        assert_eq!(
            overworld.end_portal_target,
            Some(Identifier::new("minecraft", "flat_end"))
        );
    }

    #[test]
    fn rejects_cross_domain_explicit_portal_target() {
        let error = resolve(
            r#"
[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:overworld"
default = true
nether_portal_target = "other:the_nether"
"#,
        )
        .expect_err("cross-domain-looking portal target should be rejected");
        assert!(error.contains("nether_portal_target"));
    }

    #[test]
    fn rejects_reserved_global_domain() {
        let error = resolve(
            r#"
[domains.global]
default = true

[[domains.global.worlds]]
name = "overworld"
generator = "minecraft:overworld"
default = true
"#,
        )
        .expect_err("global domain should be rejected");
        assert!(error.contains("reserved"));
    }

    #[test]
    fn rejects_duplicate_world_names() {
        let error = resolve(
            r#"
[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:overworld"
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:overworld"
"#,
        )
        .expect_err("duplicate world names should be rejected");
        assert!(error.contains("duplicate world"));
    }

    #[test]
    fn rejects_missing_default_world() {
        let error = resolve(
            r#"
[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:overworld"
"#,
        )
        .expect_err("missing default world should be rejected");
        assert!(error.contains("default world"));
    }

    #[test]
    fn rejects_unknown_generator() {
        let error = resolve(
            r#"
[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "example:unknown"
default = true
"#,
        )
        .expect_err("unknown generator should be rejected");
        assert!(error.contains("unknown world generator"));
    }

    #[test]
    fn flat_generator_config_is_optional() {
        let resolved = resolve(
            r#"
[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:flat"
default = true
"#,
        )
        .expect("flat generator should default its config");

        assert_eq!(
            resolved.worlds[0].generator,
            Identifier::vanilla_static("flat")
        );
    }

    fn worlds_config_with_save_path(save_path: &str) -> Result<ResolvedWorldsConfig, String> {
        resolve(&format!(
            r#"
save_path = '{save_path}'

[domains.minecraft]
default = true

[[domains.minecraft.worlds]]
name = "overworld"
generator = "minecraft:flat"
default = true
"#
        ))
    }

    #[test]
    fn resolves_an_absolute_save_path() {
        let root = temp_dir().join("steel-absolute-save-root");
        let resolved = worlds_config_with_save_path(&root.display().to_string())
            .expect("an absolute save path should resolve");

        assert_eq!(resolved.save_path, root);
    }

    #[test]
    fn rejects_traversal_in_a_save_path() {
        let relative = worlds_config_with_save_path("../saves")
            .expect_err("a relative save path with .. should be rejected");
        assert!(relative.contains("save_path must be a clean path"));

        let absolute = temp_dir().join("..").join("saves");
        let absolute = worlds_config_with_save_path(&absolute.display().to_string())
            .expect_err("an absolute save path with .. should be rejected");
        assert!(absolute.contains("save_path must be a clean path"));
    }

    #[test]
    fn rejects_an_empty_save_path() {
        let error = worlds_config_with_save_path("").expect_err("an empty save path is not a root");
        assert!(error.contains("save_path must not be empty"));
    }

    #[test]
    fn world_storage_paths_stay_relative_to_the_save_root() {
        let absolute = temp_dir().display().to_string();
        assert_eq!(
            validate_relative_path(&absolute, "storage.config.path"),
            Err("storage.config.path must be relative".to_owned())
        );
        assert_eq!(
            validate_relative_path("region", "storage.config.path"),
            Ok(())
        );
    }
}