rakata_generics/

are.rs

//! ARE (`.are`) typed generic wrapper.
//!
//! ARE resources are GFF-backed area metadata containers.
//!
//! ## Scope
//! - Typed access for all engine-read area fields (identity, scripts, map, core flags,
//!   weather, lighting, grass, stealth/transition save-state, and MiniGame struct).
//! - Deterministic lossless conversion back to [`Gff`].
//!
//! ## Field Layout (simplified)
//! ```text
//! ARE root struct
//! +-- Tag              (CExoString)
//! +-- Name             (CExoLocString)
//! +-- Comments         (CExoString)
//! +-- AlphaTest        (FLOAT)
//! +-- CameraStyle      (INT)
//! +-- DefaultEnvMap    (CResRef)
//! +-- RestrictMode     (BYTE)
//! +-- OnEnter/Exit/... (CResRef)
//! +-- Flags            (DWORD)
//! +-- Version          (DWORD)
//! +-- LoadScreenID     (WORD)
//! +-- ChanceRain/Snow/Lightning/Fog (INT)
//! +-- StealthXPCurrent (DWORD)
//! +-- TransPending/TransPendNextID/TransPendCurrID (BYTE)
//! +-- Expansion_List   (List<Struct>)
//! |   +-- Expansion_Name (CExoLocString)
//! |   `-- Expansion_ID   (INT)
//! +-- MiniGame         (Struct -> AreMiniGame)
//! |   +-- Type / MovementPerSec / LateralAccel / Bump_Plane
//! |   +-- DoBumping / UseInertia / DOF / Music
//! |   +-- Far_Clip / Near_Clip / CameraViewAngle
//! |   `-- Player        (Struct -> AreMiniGamePlayer)
//! |       +-- Models    (List<AreMiniGameModel>)
//! |       +-- Track / Camera / CameraRotate
//! |       +-- Mouse     (Struct -> AreMiniGameMouse)
//! |       +-- Enemies   (List<AreMiniGameEnemy>)
//! |       `-- Obstacles (List<AreMiniGameObstacle>)
//! +-- Map              (Struct)
//! |   +-- NorthAxis / MapZoom / MapResX
//! |   +-- MapPt{1,2}{X,Y} / WorldPt{1,2}{X,Y}
//! +-- Rooms            (List<Struct>)
//!     +-- RoomName / AmbientScale / EnvAudio / ForceRating / DisableWeather
//!     `-- PartSounds   (List<Struct>)
//!         +-- Looping / ModelPart / OmenEvent / Sound
//! ```

use std::io::{Cursor, Read, Write};

use crate::gff_helpers::{
    get_bool, get_f32, get_i32, get_locstring, get_resref, get_string, get_u16, get_u32, get_u8,
    upsert_field,
};
use rakata_core::{ResRef, StrRef};
use rakata_formats::{
    gff_schema::{FieldConstraint, FieldSchema, GffSchema, GffType},
    read_gff, read_gff_from_bytes, write_gff, Gff, GffBinaryError, GffLocalizedString, GffStruct,
    GffValue,
};
use thiserror::Error;

/// Typed ARE model built from/to [`Gff`] data.
#[derive(Debug, Clone, PartialEq)]
pub struct Are {
    /// Legacy area id (`ID`).
    pub unused_id: i32,
    /// Legacy creator id (`Creator_ID`).
    pub creator_id: i32,
    /// Area format version (`Version`).
    pub version: u32,
    /// Area tag (`Tag`).
    pub tag: String,
    /// Localized area name (`Name`).
    pub name: GffLocalizedString,
    /// Toolset/comment field (`Comments`).
    pub comment: String,
    /// Alpha test threshold (`AlphaTest`).
    pub alpha_test: f32,
    /// Camera style ID (`CameraStyle`).
    pub camera_style: i32,
    /// Default environment map resref (`DefaultEnvMap`).
    pub default_envmap: ResRef,
    /// Restrict mode (`RestrictMode`) - triggers `UnstealthParty` on non-zero change.
    pub restrict_mode: u8,
    /// Grass texture resref (`Grass_TexName`).
    pub grass_texture: ResRef,
    /// Grass density (`Grass_Density`).
    pub grass_density: f32,
    /// Grass quad size (`Grass_QuadSize`).
    pub grass_size: f32,
    /// Grass probability lower-left (`Grass_Prob_LL`).
    pub grass_prob_ll: f32,
    /// Grass probability lower-right (`Grass_Prob_LR`).
    pub grass_prob_lr: f32,
    /// Grass probability upper-left (`Grass_Prob_UL`).
    pub grass_prob_ul: f32,
    /// Grass probability upper-right (`Grass_Prob_UR`).
    pub grass_prob_ur: f32,
    /// Sun fog enabled (`SunFogOn`).
    pub fog_enabled: bool,
    /// Sun fog near distance (`SunFogNear`).
    pub fog_near: f32,
    /// Sun fog far distance (`SunFogFar`).
    pub fog_far: f32,
    /// Sun shadows enabled (`SunShadows`).
    pub shadows: bool,
    /// Shadow opacity (`ShadowOpacity`).
    pub shadow_opacity: u8,
    /// Wind power (`WindPower`).
    pub wind_power: i32,
    /// Unescapable area flag (`Unescapable`).
    pub unescapable: bool,
    /// Disable transit flag (`DisableTransit`).
    pub disable_transit: bool,
    /// Stealth XP enabled (`StealthXPEnabled`).
    pub stealth_xp: bool,
    /// Stealth XP loss (`StealthXPLoss`).
    pub stealth_xp_loss: u32,
    /// Stealth XP max (`StealthXPMax`).
    pub stealth_xp_max: u32,
    /// Current stealth XP counter (`StealthXPCurrent`, save-state).
    pub stealth_xp_current: u32,
    /// Enter script resref (`OnEnter`).
    pub on_enter: ResRef,
    /// Exit script resref (`OnExit`).
    pub on_exit: ResRef,
    /// Heartbeat script resref (`OnHeartbeat`).
    pub on_heartbeat: ResRef,
    /// User-defined event script resref (`OnUserDefined`).
    pub on_user_defined: ResRef,
    /// Area flags (`Flags`).
    pub flags: u32,
    /// Load screen ID (`LoadScreenID`).
    pub loadscreen_id: u16,
    /// Chance of rain (`ChanceRain`, K2).
    pub chance_rain: i32,
    /// Chance of snow (`ChanceSnow`, K2).
    pub chance_snow: i32,
    /// Chance of lightning (`ChanceLightning`, K2).
    pub chance_lightning: i32,
    /// Chance of fog (`ChanceFog`).
    pub chance_fog: i32,
    /// Mod spot-check modifier (`ModSpotCheck`).
    pub mod_spot_check: i32,
    /// Mod listen-check modifier (`ModListenCheck`).
    pub mod_listen_check: i32,
    /// Moon ambient color (`MoonAmbientColor`).
    pub moon_ambient_color: u32,
    /// Moon diffuse color (`MoonDiffuseColor`).
    pub moon_diffuse_color: u32,
    /// Moon fog enabled (`MoonFogOn`).
    pub moon_fog_enabled: bool,
    /// Moon fog near distance (`MoonFogNear`).
    pub moon_fog_near: f32,
    /// Moon fog far distance (`MoonFogFar`).
    pub moon_fog_far: f32,
    /// Moon fog color (`MoonFogColor`).
    pub moon_fog_color: u32,
    /// Moon shadows enabled (`MoonShadows`).
    pub moon_shadows: bool,
    /// Sun ambient color (`SunAmbientColor`).
    pub sun_ambient_color: u32,
    /// Sun diffuse color (`SunDiffuseColor`).
    pub sun_diffuse_color: u32,
    /// Dynamic ambient color (`DynAmbientColor`).
    pub dynamic_ambient_color: u32,
    /// Sun fog color (`SunFogColor`).
    pub sun_fog_color: u32,
    /// Grass ambient color (`Grass_Ambient`).
    pub grass_ambient_color: u32,
    /// Grass diffuse color (`Grass_Diffuse`).
    pub grass_diffuse_color: u32,
    /// Grass emissive color (`Grass_Emissive`).
    pub grass_emissive_color: u32,
    /// Dirty overlay color one (`DirtyARGBOne`).
    pub dirty_argb_one: i32,
    /// Dirty overlay size one (`DirtySizeOne`).
    pub dirty_size_one: i32,
    /// Dirty overlay formula one (`DirtyFormulaOne`).
    pub dirty_formula_one: i32,
    /// Dirty overlay func one (`DirtyFuncOne`).
    pub dirty_func_one: i32,
    /// Dirty overlay color two (`DirtyARGBTwo`).
    pub dirty_argb_two: i32,
    /// Dirty overlay size two (`DirtySizeTwo`).
    pub dirty_size_two: i32,
    /// Dirty overlay formula two (`DirtyFormulaTwo`).
    pub dirty_formula_two: i32,
    /// Dirty overlay func two (`DirtyFuncTwo`).
    pub dirty_func_two: i32,
    /// Dirty overlay color three (`DirtyARGBThree`).
    pub dirty_argb_three: i32,
    /// Dirty overlay size three (`DirtySizeThree`).
    pub dirty_size_three: i32,
    /// Dirty overlay formula three (`DirtyFormulaThre`).
    pub dirty_formula_three: i32,
    /// Dirty overlay func three (`DirtyFuncThree`).
    pub dirty_func_three: i32,
    /// Is-night flag (`IsNight`).
    pub is_night: bool,
    /// Lighting scheme (`LightingScheme`).
    pub lighting_scheme: u8,
    /// Day/night cycle flag (`DayNightCycle`).
    pub day_night_cycle: u8,
    /// No-rest flag (`NoRest`).
    pub no_rest: bool,
    /// No-hang-back flag (`NoHangBack`).
    pub no_hang_back: bool,
    /// Player-only flag (`PlayerOnly`).
    pub player_only: bool,
    /// Player-vs-player mode (`PlayerVsPlayer`).
    pub player_vs_player: u8,
    /// Transition pending flag (`TransPending`, save-state).
    pub trans_pending: u8,
    /// Transition pending next ID (`TransPendNextID`, save-state).
    pub trans_pend_next_id: u8,
    /// Transition pending current ID (`TransPendCurrID`, save-state).
    pub trans_pend_curr_id: u8,
    /// Embedded map metadata (`Map` struct).
    pub map: AreMap,
    /// Embedded room metadata (`Rooms` list).
    pub rooms: Vec<AreRoom>,
    /// Area expansion entries (`Expansion_List` list).
    pub expansion_list: Vec<AreExpansionEntry>,
    /// MiniGame struct (`MiniGame`).
    pub mini_game: Option<AreMiniGame>,
}

/// Typed view over the ARE `MiniGame` nested struct.
#[derive(Debug, Clone, PartialEq)]
pub struct AreMiniGame {
    /// Mini-game type (`Type`): 1 = swoop, 2 = turret.
    pub mini_game_type: u32,
    /// Movement speed (`MovementPerSec`).
    pub movement_per_sec: f32,
    /// Lateral acceleration (`LateralAccel`).
    pub lateral_accel: f32,
    /// Bump plane index (`Bump_Plane`).
    pub bump_plane: u32,
    /// Bumping enabled (`DoBumping`).
    pub do_bumping: bool,
    /// Inertia enabled (`UseInertia`).
    pub use_inertia: bool,
    /// Degrees of freedom (`DOF`).
    pub dof: u32,
    /// Music resref (`Music`).
    pub music: ResRef,
    /// Far clip distance (`Far_Clip`).
    pub far_clip: f32,
    /// Near clip distance (`Near_Clip`).
    pub near_clip: f32,
    /// Camera view angle (`CameraViewAngle`).
    pub camera_view_angle: f32,
    /// Player sub-struct (`Player`).
    pub player: Option<AreMiniGamePlayer>,
}

impl Default for AreMiniGame {
    fn default() -> Self {
        Self {
            mini_game_type: 0,
            movement_per_sec: 0.0,
            lateral_accel: 60.0,
            bump_plane: 0,
            do_bumping: false,
            use_inertia: false,
            dof: 0,
            music: ResRef::blank(),
            far_clip: 100.0,
            near_clip: 0.1,
            camera_view_angle: 65.0,
            player: None,
        }
    }
}

impl AreMiniGame {
    fn from_struct(structure: &GffStruct) -> Result<Self, AreError> {
        let player = match structure.field("Player") {
            Some(GffValue::Struct(s)) => Some(AreMiniGamePlayer::from_struct(s)?),
            Some(_) => {
                return Err(AreError::TypeMismatch {
                    field: "MiniGame.Player",
                    expected: "Struct",
                });
            }
            None => None,
        };

        Ok(Self {
            mini_game_type: get_u32(structure, "Type").unwrap_or(0),
            movement_per_sec: get_f32(structure, "MovementPerSec").unwrap_or(0.0),
            lateral_accel: get_f32(structure, "LateralAccel").unwrap_or(60.0),
            bump_plane: get_u32(structure, "Bump_Plane").unwrap_or(0),
            do_bumping: get_bool(structure, "DoBumping").unwrap_or(false),
            use_inertia: get_bool(structure, "UseInertia").unwrap_or(false),
            dof: get_u32(structure, "DOF").unwrap_or(0),
            music: get_resref(structure, "Music").unwrap_or_default(),
            far_clip: get_f32(structure, "Far_Clip").unwrap_or(100.0),
            near_clip: get_f32(structure, "Near_Clip").unwrap_or(0.1),
            camera_view_angle: get_f32(structure, "CameraViewAngle").unwrap_or(65.0),
            player,
        })
    }

    fn to_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(0);
        upsert_field(&mut s, "Type", GffValue::UInt32(self.mini_game_type));
        upsert_field(
            &mut s,
            "MovementPerSec",
            GffValue::Single(self.movement_per_sec),
        );
        upsert_field(&mut s, "LateralAccel", GffValue::Single(self.lateral_accel));
        upsert_field(&mut s, "Bump_Plane", GffValue::UInt32(self.bump_plane));
        upsert_field(
            &mut s,
            "DoBumping",
            GffValue::UInt8(u8::from(self.do_bumping)),
        );
        upsert_field(
            &mut s,
            "UseInertia",
            GffValue::UInt8(u8::from(self.use_inertia)),
        );
        upsert_field(&mut s, "DOF", GffValue::UInt32(self.dof));
        upsert_field(&mut s, "Music", GffValue::ResRef(self.music));
        upsert_field(&mut s, "Far_Clip", GffValue::Single(self.far_clip));
        upsert_field(&mut s, "Near_Clip", GffValue::Single(self.near_clip));
        upsert_field(
            &mut s,
            "CameraViewAngle",
            GffValue::Single(self.camera_view_angle),
        );
        if let Some(player) = &self.player {
            upsert_field(
                &mut s,
                "Player",
                GffValue::Struct(Box::new(player.to_struct())),
            );
        }
        s
    }
}

/// Typed view over the `MiniGame.Player` sub-struct.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct AreMiniGamePlayer {
    /// Player model list (`Models`).
    pub models: Vec<AreMiniGameModel>,
    /// Track resref (`Track`).
    pub track: ResRef,
    /// Camera resref (`Camera`) - only used for turret type (type 2).
    pub camera: ResRef,
    /// Camera rotation flag (`CameraRotate`).
    pub camera_rotate: bool,
    /// Mouse axis settings (`Mouse`).
    pub mouse: AreMiniGameMouse,
    /// Enemy list (`Enemies`).
    pub enemies: Vec<AreMiniGameEnemy>,
    /// Obstacle list (`Obstacles`).
    pub obstacles: Vec<AreMiniGameObstacle>,
}

impl AreMiniGamePlayer {
    fn from_struct(structure: &GffStruct) -> Result<Self, AreError> {
        let models = match structure.field("Models") {
            Some(GffValue::List(items)) => items
                .iter()
                .map(AreMiniGameModel::from_struct)
                .collect::<Vec<_>>(),
            Some(_) => {
                return Err(AreError::TypeMismatch {
                    field: "MiniGame.Player.Models",
                    expected: "List",
                });
            }
            None => Vec::new(),
        };

        let mouse = match structure.field("Mouse") {
            Some(GffValue::Struct(s)) => AreMiniGameMouse::from_struct(s),
            Some(_) => {
                return Err(AreError::TypeMismatch {
                    field: "MiniGame.Player.Mouse",
                    expected: "Struct",
                });
            }
            None => AreMiniGameMouse::default(),
        };

        let enemies = match structure.field("Enemies") {
            Some(GffValue::List(items)) => items
                .iter()
                .map(AreMiniGameEnemy::from_struct)
                .collect::<Result<Vec<_>, _>>()?,
            Some(_) => {
                return Err(AreError::TypeMismatch {
                    field: "MiniGame.Player.Enemies",
                    expected: "List",
                });
            }
            None => Vec::new(),
        };

        let obstacles = match structure.field("Obstacles") {
            Some(GffValue::List(items)) => items
                .iter()
                .map(AreMiniGameObstacle::from_struct)
                .collect::<Vec<_>>(),
            Some(_) => {
                return Err(AreError::TypeMismatch {
                    field: "MiniGame.Player.Obstacles",
                    expected: "List",
                });
            }
            None => Vec::new(),
        };

        Ok(Self {
            models,
            track: get_resref(structure, "Track").unwrap_or_default(),
            camera: get_resref(structure, "Camera").unwrap_or_default(),
            camera_rotate: get_bool(structure, "CameraRotate").unwrap_or(false),
            mouse,
            enemies,
            obstacles,
        })
    }

    fn to_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(0);
        let model_structs: Vec<GffStruct> = self
            .models
            .iter()
            .map(AreMiniGameModel::to_struct)
            .collect();
        upsert_field(&mut s, "Models", GffValue::List(model_structs));
        upsert_field(&mut s, "Track", GffValue::ResRef(self.track));
        upsert_field(&mut s, "Camera", GffValue::ResRef(self.camera));
        upsert_field(
            &mut s,
            "CameraRotate",
            GffValue::UInt8(u8::from(self.camera_rotate)),
        );
        upsert_field(
            &mut s,
            "Mouse",
            GffValue::Struct(Box::new(self.mouse.to_struct())),
        );
        let enemy_structs: Vec<GffStruct> = self
            .enemies
            .iter()
            .map(AreMiniGameEnemy::to_struct)
            .collect();
        upsert_field(&mut s, "Enemies", GffValue::List(enemy_structs));
        let obstacle_structs: Vec<GffStruct> = self
            .obstacles
            .iter()
            .map(AreMiniGameObstacle::to_struct)
            .collect();
        upsert_field(&mut s, "Obstacles", GffValue::List(obstacle_structs));
        s
    }
}

/// Typed view over one model entry in a mini-game model list.
#[derive(Debug, Clone, PartialEq)]
pub struct AreMiniGameModel {
    /// Model resref (`Model`).
    pub model: ResRef,
    /// Whether the model rotates (`RotatingModel`).
    pub rotating_model: bool,
}

impl Default for AreMiniGameModel {
    fn default() -> Self {
        Self {
            model: ResRef::blank(),
            rotating_model: true,
        }
    }
}

impl AreMiniGameModel {
    fn from_struct(structure: &GffStruct) -> Self {
        Self {
            model: get_resref(structure, "Model").unwrap_or_default(),
            rotating_model: get_bool(structure, "RotatingModel").unwrap_or(true),
        }
    }

    fn to_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(0);
        upsert_field(&mut s, "Model", GffValue::ResRef(self.model));
        upsert_field(
            &mut s,
            "RotatingModel",
            GffValue::UInt8(u8::from(self.rotating_model)),
        );
        s
    }
}

/// Typed view over the `MiniGame.Player.Mouse` sub-struct.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct AreMiniGameMouse {
    /// X axis index (`AxisX`).
    pub axis_x: u32,
    /// Y axis index (`AxisY`).
    pub axis_y: u32,
    /// Flip X axis (`FlipAxisX`).
    pub flip_axis_x: bool,
    /// Flip Y axis (`FlipAxisY`).
    pub flip_axis_y: bool,
}

impl AreMiniGameMouse {
    fn from_struct(structure: &GffStruct) -> Self {
        Self {
            axis_x: get_u32(structure, "AxisX").unwrap_or(0),
            axis_y: get_u32(structure, "AxisY").unwrap_or(0),
            flip_axis_x: get_bool(structure, "FlipAxisX").unwrap_or(false),
            flip_axis_y: get_bool(structure, "FlipAxisY").unwrap_or(false),
        }
    }

    fn to_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(0);
        upsert_field(&mut s, "AxisX", GffValue::UInt32(self.axis_x));
        upsert_field(&mut s, "AxisY", GffValue::UInt32(self.axis_y));
        upsert_field(
            &mut s,
            "FlipAxisX",
            GffValue::UInt8(u8::from(self.flip_axis_x)),
        );
        upsert_field(
            &mut s,
            "FlipAxisY",
            GffValue::UInt8(u8::from(self.flip_axis_y)),
        );
        s
    }
}

/// Typed view over one enemy entry in `MiniGame.Player.Enemies`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct AreMiniGameEnemy {
    /// Enemy model list (`Models`).
    pub models: Vec<AreMiniGameModel>,
    /// Enemy track resref (`Track`).
    pub track: ResRef,
}

impl AreMiniGameEnemy {
    fn from_struct(structure: &GffStruct) -> Result<Self, AreError> {
        let models = match structure.field("Models") {
            Some(GffValue::List(items)) => items
                .iter()
                .map(AreMiniGameModel::from_struct)
                .collect::<Vec<_>>(),
            Some(_) => {
                return Err(AreError::TypeMismatch {
                    field: "MiniGame.Player.Enemies[].Models",
                    expected: "List",
                });
            }
            None => Vec::new(),
        };

        Ok(Self {
            models,
            track: get_resref(structure, "Track").unwrap_or_default(),
        })
    }

    fn to_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(0);
        let model_structs: Vec<GffStruct> = self
            .models
            .iter()
            .map(AreMiniGameModel::to_struct)
            .collect();
        upsert_field(&mut s, "Models", GffValue::List(model_structs));
        upsert_field(&mut s, "Track", GffValue::ResRef(self.track));
        s
    }
}

/// Typed view over one obstacle entry in `MiniGame.Player.Obstacles`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct AreMiniGameObstacle {
    /// Obstacle name resref (`Name`).
    pub name: ResRef,
}

impl AreMiniGameObstacle {
    fn from_struct(structure: &GffStruct) -> Self {
        Self {
            name: get_resref(structure, "Name").unwrap_or_default(),
        }
    }

    fn to_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(0);
        upsert_field(&mut s, "Name", GffValue::ResRef(self.name));
        s
    }
}

impl Default for Are {
    fn default() -> Self {
        Self {
            unused_id: 0,
            creator_id: 0,
            version: 0,
            tag: String::new(),
            name: GffLocalizedString::new(StrRef::invalid()),
            comment: String::new(),
            alpha_test: 0.0,
            camera_style: 0,
            default_envmap: ResRef::blank(),
            restrict_mode: 0,
            grass_texture: ResRef::blank(),
            grass_density: 0.0,
            grass_size: 0.0,
            grass_prob_ll: 0.0,
            grass_prob_lr: 0.0,
            grass_prob_ul: 0.0,
            grass_prob_ur: 0.0,
            fog_enabled: false,
            fog_near: 0.0,
            fog_far: 0.0,
            shadows: false,
            shadow_opacity: 0,
            wind_power: 0,
            unescapable: false,
            disable_transit: false,
            stealth_xp: false,
            stealth_xp_loss: 0,
            stealth_xp_max: 0,
            stealth_xp_current: 0,
            on_enter: ResRef::blank(),
            on_exit: ResRef::blank(),
            on_heartbeat: ResRef::blank(),
            on_user_defined: ResRef::blank(),
            flags: 0,
            loadscreen_id: 0,
            chance_rain: 0,
            chance_snow: 0,
            chance_lightning: 0,
            chance_fog: 0,
            mod_spot_check: 0,
            mod_listen_check: 0,
            moon_ambient_color: 0,
            moon_diffuse_color: 0,
            moon_fog_enabled: false,
            moon_fog_near: 0.0,
            moon_fog_far: 0.0,
            moon_fog_color: 0,
            moon_shadows: false,
            sun_ambient_color: 0,
            sun_diffuse_color: 0,
            dynamic_ambient_color: 0,
            sun_fog_color: 0,
            grass_ambient_color: 0,
            grass_diffuse_color: 0,
            grass_emissive_color: 0,
            dirty_argb_one: 0,
            dirty_size_one: 0,
            dirty_formula_one: 0,
            dirty_func_one: 0,
            dirty_argb_two: 0,
            dirty_size_two: 0,
            dirty_formula_two: 0,
            dirty_func_two: 0,
            dirty_argb_three: 0,
            dirty_size_three: 0,
            dirty_formula_three: 0,
            dirty_func_three: 0,
            is_night: false,
            lighting_scheme: 0,
            day_night_cycle: 0,
            no_rest: false,
            no_hang_back: false,
            player_only: false,
            player_vs_player: 0,
            trans_pending: 0,
            trans_pend_next_id: 0,
            trans_pend_curr_id: 0,
            map: AreMap::default(),
            rooms: Vec::new(),
            expansion_list: Vec::new(),
            mini_game: None,
        }
    }
}

impl Are {
    /// Creates an empty ARE value.
    pub fn new() -> Self {
        Self::default()
    }

    /// Builds typed ARE data from a parsed GFF container.
    pub fn from_gff(gff: &Gff) -> Result<Self, AreError> {
        if gff.file_type != *b"ARE " && gff.file_type != *b"GFF " {
            return Err(AreError::UnsupportedFileType(gff.file_type));
        }

        let root = &gff.root;

        let map = match root.field("Map") {
            Some(GffValue::Struct(map_struct)) => AreMap::from_struct(map_struct),
            Some(_) => {
                return Err(AreError::TypeMismatch {
                    field: "Map",
                    expected: "Struct",
                });
            }
            None => AreMap::default(),
        };

        let rooms = match root.field("Rooms") {
            Some(GffValue::List(room_structs)) => room_structs
                .iter()
                .map(AreRoom::from_struct)
                .collect::<Result<Vec<_>, _>>()?,
            Some(_) => {
                return Err(AreError::TypeMismatch {
                    field: "Rooms",
                    expected: "List",
                });
            }
            None => Vec::new(),
        };

        let expansion_list = match root.field("Expansion_List") {
            Some(GffValue::List(expansion_structs)) => expansion_structs
                .iter()
                .map(AreExpansionEntry::from_struct)
                .collect::<Result<Vec<_>, _>>()?,
            Some(_) => {
                return Err(AreError::TypeMismatch {
                    field: "Expansion_List",
                    expected: "List",
                });
            }
            None => Vec::new(),
        };

        let mini_game = match root.field("MiniGame") {
            Some(GffValue::Struct(s)) => Some(AreMiniGame::from_struct(s)?),
            Some(_) => {
                return Err(AreError::TypeMismatch {
                    field: "MiniGame",
                    expected: "Struct",
                });
            }
            None => None,
        };

        Ok(Self {
            unused_id: get_i32(root, "ID").unwrap_or(0),
            creator_id: get_i32(root, "Creator_ID").unwrap_or(0),
            version: get_u32(root, "Version").unwrap_or(0),
            tag: get_string(root, "Tag").unwrap_or_default(),
            name: get_locstring(root, "Name")
                .cloned()
                .unwrap_or_else(|| GffLocalizedString::new(StrRef::invalid())),
            comment: get_string(root, "Comments").unwrap_or_default(),
            alpha_test: get_f32(root, "AlphaTest").unwrap_or(0.0),
            camera_style: get_i32(root, "CameraStyle").unwrap_or(0),
            default_envmap: get_resref(root, "DefaultEnvMap").unwrap_or_default(),
            restrict_mode: get_u8(root, "RestrictMode").unwrap_or(0),
            grass_texture: get_resref(root, "Grass_TexName").unwrap_or_default(),
            grass_density: get_f32(root, "Grass_Density").unwrap_or(0.0),
            grass_size: get_f32(root, "Grass_QuadSize").unwrap_or(0.0),
            grass_prob_ll: get_f32(root, "Grass_Prob_LL").unwrap_or(0.0),
            grass_prob_lr: get_f32(root, "Grass_Prob_LR").unwrap_or(0.0),
            grass_prob_ul: get_f32(root, "Grass_Prob_UL").unwrap_or(0.0),
            grass_prob_ur: get_f32(root, "Grass_Prob_UR").unwrap_or(0.0),
            fog_enabled: get_bool(root, "SunFogOn").unwrap_or(false),
            fog_near: get_f32(root, "SunFogNear").unwrap_or(0.0),
            fog_far: get_f32(root, "SunFogFar").unwrap_or(0.0),
            shadows: get_bool(root, "SunShadows").unwrap_or(false),
            shadow_opacity: get_u8(root, "ShadowOpacity").unwrap_or(0),
            wind_power: get_i32(root, "WindPower").unwrap_or(0),
            unescapable: get_bool(root, "Unescapable").unwrap_or(false),
            disable_transit: get_bool(root, "DisableTransit").unwrap_or(false),
            stealth_xp: get_bool(root, "StealthXPEnabled").unwrap_or(false),
            stealth_xp_loss: get_u32(root, "StealthXPLoss").unwrap_or(0),
            stealth_xp_max: get_u32(root, "StealthXPMax").unwrap_or(0),
            stealth_xp_current: get_u32(root, "StealthXPCurrent").unwrap_or(0),
            on_enter: get_resref(root, "OnEnter").unwrap_or_default(),
            on_exit: get_resref(root, "OnExit").unwrap_or_default(),
            on_heartbeat: get_resref(root, "OnHeartbeat").unwrap_or_default(),
            on_user_defined: get_resref(root, "OnUserDefined").unwrap_or_default(),
            flags: get_u32(root, "Flags").unwrap_or(0),
            loadscreen_id: get_u16(root, "LoadScreenID").unwrap_or(0),
            chance_rain: get_i32(root, "ChanceRain").unwrap_or(0),
            chance_snow: get_i32(root, "ChanceSnow").unwrap_or(0),
            chance_lightning: get_i32(root, "ChanceLightning").unwrap_or(0),
            chance_fog: get_i32(root, "ChanceFog").unwrap_or(0),
            mod_spot_check: get_i32(root, "ModSpotCheck").unwrap_or(0),
            mod_listen_check: get_i32(root, "ModListenCheck").unwrap_or(0),
            moon_ambient_color: get_u32(root, "MoonAmbientColor").unwrap_or(0),
            moon_diffuse_color: get_u32(root, "MoonDiffuseColor").unwrap_or(0),
            moon_fog_enabled: get_bool(root, "MoonFogOn").unwrap_or(false),
            moon_fog_near: get_f32(root, "MoonFogNear").unwrap_or(0.0),
            moon_fog_far: get_f32(root, "MoonFogFar").unwrap_or(0.0),
            moon_fog_color: get_u32(root, "MoonFogColor").unwrap_or(0),
            moon_shadows: get_bool(root, "MoonShadows").unwrap_or(false),
            sun_ambient_color: get_u32(root, "SunAmbientColor").unwrap_or(0),
            sun_diffuse_color: get_u32(root, "SunDiffuseColor").unwrap_or(0),
            dynamic_ambient_color: get_u32(root, "DynAmbientColor").unwrap_or(0),
            sun_fog_color: get_u32(root, "SunFogColor").unwrap_or(0),
            grass_ambient_color: get_u32(root, "Grass_Ambient").unwrap_or(0),
            grass_diffuse_color: get_u32(root, "Grass_Diffuse").unwrap_or(0),
            grass_emissive_color: get_u32(root, "Grass_Emissive").unwrap_or(0),
            dirty_argb_one: get_i32(root, "DirtyARGBOne").unwrap_or(0),
            dirty_size_one: get_i32(root, "DirtySizeOne").unwrap_or(0),
            dirty_formula_one: get_i32(root, "DirtyFormulaOne").unwrap_or(0),
            dirty_func_one: get_i32(root, "DirtyFuncOne").unwrap_or(0),
            dirty_argb_two: get_i32(root, "DirtyARGBTwo").unwrap_or(0),
            dirty_size_two: get_i32(root, "DirtySizeTwo").unwrap_or(0),
            dirty_formula_two: get_i32(root, "DirtyFormulaTwo").unwrap_or(0),
            dirty_func_two: get_i32(root, "DirtyFuncTwo").unwrap_or(0),
            dirty_argb_three: get_i32(root, "DirtyARGBThree").unwrap_or(0),
            dirty_size_three: get_i32(root, "DirtySizeThree").unwrap_or(0),
            dirty_formula_three: get_i32(root, "DirtyFormulaThre").unwrap_or(0),
            dirty_func_three: get_i32(root, "DirtyFuncThree").unwrap_or(0),
            is_night: get_bool(root, "IsNight").unwrap_or(false),
            lighting_scheme: get_u8(root, "LightingScheme").unwrap_or(0),
            day_night_cycle: get_u8(root, "DayNightCycle").unwrap_or(0),
            no_rest: get_bool(root, "NoRest").unwrap_or(false),
            no_hang_back: get_bool(root, "NoHangBack").unwrap_or(false),
            player_only: get_bool(root, "PlayerOnly").unwrap_or(false),
            player_vs_player: get_u8(root, "PlayerVsPlayer").unwrap_or(0),
            trans_pending: get_u8(root, "TransPending").unwrap_or(0),
            trans_pend_next_id: get_u8(root, "TransPendNextID").unwrap_or(0),
            trans_pend_curr_id: get_u8(root, "TransPendCurrID").unwrap_or(0),
            map,
            rooms,
            expansion_list,
            mini_game,
        })
    }

    /// Converts this typed ARE value into a GFF container.
    pub fn to_gff(&self) -> Gff {
        let mut root = GffStruct::new(-1);

        upsert_field(&mut root, "ID", GffValue::Int32(self.unused_id));
        upsert_field(&mut root, "Creator_ID", GffValue::Int32(self.creator_id));
        upsert_field(&mut root, "Version", GffValue::UInt32(self.version));
        upsert_field(&mut root, "Tag", GffValue::String(self.tag.clone()));
        upsert_field(
            &mut root,
            "Name",
            GffValue::LocalizedString(self.name.clone()),
        );
        upsert_field(
            &mut root,
            "Comments",
            GffValue::String(self.comment.clone()),
        );
        upsert_field(&mut root, "AlphaTest", GffValue::Single(self.alpha_test));
        upsert_field(&mut root, "CameraStyle", GffValue::Int32(self.camera_style));
        upsert_field(
            &mut root,
            "DefaultEnvMap",
            GffValue::ResRef(self.default_envmap),
        );
        upsert_field(
            &mut root,
            "RestrictMode",
            GffValue::UInt8(self.restrict_mode),
        );
        upsert_field(
            &mut root,
            "Grass_TexName",
            GffValue::ResRef(self.grass_texture),
        );
        upsert_field(
            &mut root,
            "Grass_Density",
            GffValue::Single(self.grass_density),
        );
        upsert_field(
            &mut root,
            "Grass_QuadSize",
            GffValue::Single(self.grass_size),
        );
        upsert_field(
            &mut root,
            "Grass_Prob_LL",
            GffValue::Single(self.grass_prob_ll),
        );
        upsert_field(
            &mut root,
            "Grass_Prob_LR",
            GffValue::Single(self.grass_prob_lr),
        );
        upsert_field(
            &mut root,
            "Grass_Prob_UL",
            GffValue::Single(self.grass_prob_ul),
        );
        upsert_field(
            &mut root,
            "Grass_Prob_UR",
            GffValue::Single(self.grass_prob_ur),
        );
        upsert_field(
            &mut root,
            "SunFogOn",
            GffValue::UInt8(u8::from(self.fog_enabled)),
        );
        upsert_field(&mut root, "SunFogNear", GffValue::Single(self.fog_near));
        upsert_field(&mut root, "SunFogFar", GffValue::Single(self.fog_far));
        upsert_field(
            &mut root,
            "SunShadows",
            GffValue::UInt8(u8::from(self.shadows)),
        );
        upsert_field(
            &mut root,
            "ShadowOpacity",
            GffValue::UInt8(self.shadow_opacity),
        );
        upsert_field(&mut root, "WindPower", GffValue::Int32(self.wind_power));
        upsert_field(
            &mut root,
            "Unescapable",
            GffValue::UInt8(u8::from(self.unescapable)),
        );
        upsert_field(
            &mut root,
            "DisableTransit",
            GffValue::UInt8(u8::from(self.disable_transit)),
        );
        upsert_field(
            &mut root,
            "StealthXPEnabled",
            GffValue::UInt8(u8::from(self.stealth_xp)),
        );
        upsert_field(
            &mut root,
            "StealthXPLoss",
            GffValue::UInt32(self.stealth_xp_loss),
        );
        upsert_field(
            &mut root,
            "StealthXPMax",
            GffValue::UInt32(self.stealth_xp_max),
        );
        upsert_field(
            &mut root,
            "StealthXPCurrent",
            GffValue::UInt32(self.stealth_xp_current),
        );
        upsert_field(&mut root, "OnEnter", GffValue::ResRef(self.on_enter));
        upsert_field(&mut root, "OnExit", GffValue::ResRef(self.on_exit));
        upsert_field(
            &mut root,
            "OnHeartbeat",
            GffValue::ResRef(self.on_heartbeat),
        );
        upsert_field(
            &mut root,
            "OnUserDefined",
            GffValue::ResRef(self.on_user_defined),
        );
        upsert_field(&mut root, "Flags", GffValue::UInt32(self.flags));
        upsert_field(
            &mut root,
            "LoadScreenID",
            GffValue::UInt16(self.loadscreen_id),
        );
        upsert_field(&mut root, "ChanceRain", GffValue::Int32(self.chance_rain));
        upsert_field(&mut root, "ChanceSnow", GffValue::Int32(self.chance_snow));
        upsert_field(
            &mut root,
            "ChanceLightning",
            GffValue::Int32(self.chance_lightning),
        );
        upsert_field(&mut root, "ChanceFog", GffValue::Int32(self.chance_fog));
        upsert_field(
            &mut root,
            "ModSpotCheck",
            GffValue::Int32(self.mod_spot_check),
        );
        upsert_field(
            &mut root,
            "ModListenCheck",
            GffValue::Int32(self.mod_listen_check),
        );
        upsert_field(
            &mut root,
            "MoonAmbientColor",
            GffValue::UInt32(self.moon_ambient_color),
        );
        upsert_field(
            &mut root,
            "MoonDiffuseColor",
            GffValue::UInt32(self.moon_diffuse_color),
        );
        upsert_field(
            &mut root,
            "MoonFogOn",
            GffValue::UInt8(u8::from(self.moon_fog_enabled)),
        );
        upsert_field(
            &mut root,
            "MoonFogNear",
            GffValue::Single(self.moon_fog_near),
        );
        upsert_field(&mut root, "MoonFogFar", GffValue::Single(self.moon_fog_far));
        upsert_field(
            &mut root,
            "MoonFogColor",
            GffValue::UInt32(self.moon_fog_color),
        );
        upsert_field(
            &mut root,
            "MoonShadows",
            GffValue::UInt8(u8::from(self.moon_shadows)),
        );
        upsert_field(
            &mut root,
            "SunAmbientColor",
            GffValue::UInt32(self.sun_ambient_color),
        );
        upsert_field(
            &mut root,
            "SunDiffuseColor",
            GffValue::UInt32(self.sun_diffuse_color),
        );
        upsert_field(
            &mut root,
            "DynAmbientColor",
            GffValue::UInt32(self.dynamic_ambient_color),
        );
        upsert_field(
            &mut root,
            "SunFogColor",
            GffValue::UInt32(self.sun_fog_color),
        );
        upsert_field(
            &mut root,
            "Grass_Ambient",
            GffValue::UInt32(self.grass_ambient_color),
        );
        upsert_field(
            &mut root,
            "Grass_Diffuse",
            GffValue::UInt32(self.grass_diffuse_color),
        );
        upsert_field(
            &mut root,
            "Grass_Emissive",
            GffValue::UInt32(self.grass_emissive_color),
        );
        upsert_field(
            &mut root,
            "DirtyARGBOne",
            GffValue::Int32(self.dirty_argb_one),
        );
        upsert_field(
            &mut root,
            "DirtySizeOne",
            GffValue::Int32(self.dirty_size_one),
        );
        upsert_field(
            &mut root,
            "DirtyFormulaOne",
            GffValue::Int32(self.dirty_formula_one),
        );
        upsert_field(
            &mut root,
            "DirtyFuncOne",
            GffValue::Int32(self.dirty_func_one),
        );
        upsert_field(
            &mut root,
            "DirtyARGBTwo",
            GffValue::Int32(self.dirty_argb_two),
        );
        upsert_field(
            &mut root,
            "DirtySizeTwo",
            GffValue::Int32(self.dirty_size_two),
        );
        upsert_field(
            &mut root,
            "DirtyFormulaTwo",
            GffValue::Int32(self.dirty_formula_two),
        );
        upsert_field(
            &mut root,
            "DirtyFuncTwo",
            GffValue::Int32(self.dirty_func_two),
        );
        upsert_field(
            &mut root,
            "DirtyARGBThree",
            GffValue::Int32(self.dirty_argb_three),
        );
        upsert_field(
            &mut root,
            "DirtySizeThree",
            GffValue::Int32(self.dirty_size_three),
        );
        upsert_field(
            &mut root,
            "DirtyFormulaThre",
            GffValue::Int32(self.dirty_formula_three),
        );
        upsert_field(
            &mut root,
            "DirtyFuncThree",
            GffValue::Int32(self.dirty_func_three),
        );
        upsert_field(
            &mut root,
            "IsNight",
            GffValue::UInt8(u8::from(self.is_night)),
        );
        upsert_field(
            &mut root,
            "LightingScheme",
            GffValue::UInt8(self.lighting_scheme),
        );
        upsert_field(
            &mut root,
            "DayNightCycle",
            GffValue::UInt8(self.day_night_cycle),
        );
        upsert_field(&mut root, "NoRest", GffValue::UInt8(u8::from(self.no_rest)));
        upsert_field(
            &mut root,
            "NoHangBack",
            GffValue::UInt8(u8::from(self.no_hang_back)),
        );
        upsert_field(
            &mut root,
            "PlayerOnly",
            GffValue::UInt8(u8::from(self.player_only)),
        );
        upsert_field(
            &mut root,
            "PlayerVsPlayer",
            GffValue::UInt8(self.player_vs_player),
        );
        upsert_field(
            &mut root,
            "TransPending",
            GffValue::UInt8(self.trans_pending),
        );
        upsert_field(
            &mut root,
            "TransPendNextID",
            GffValue::UInt8(self.trans_pend_next_id),
        );
        upsert_field(
            &mut root,
            "TransPendCurrID",
            GffValue::UInt8(self.trans_pend_curr_id),
        );

        let map_struct = self.map.to_struct();
        upsert_field(&mut root, "Map", GffValue::Struct(Box::new(map_struct)));

        let room_structs = self
            .rooms
            .iter()
            .map(AreRoom::to_struct)
            .collect::<Vec<GffStruct>>();
        upsert_field(&mut root, "Rooms", GffValue::List(room_structs));
        let expansion_structs = self
            .expansion_list
            .iter()
            .map(AreExpansionEntry::to_struct)
            .collect::<Vec<GffStruct>>();
        upsert_field(
            &mut root,
            "Expansion_List",
            GffValue::List(expansion_structs),
        );

        if let Some(mg) = &self.mini_game {
            upsert_field(
                &mut root,
                "MiniGame",
                GffValue::Struct(Box::new(mg.to_struct())),
            );
        }

        Gff::new(*b"ARE ", root)
    }
}

/// Typed view over the ARE `Map` nested struct.
#[derive(Debug, Clone, PartialEq)]
pub struct AreMap {
    /// Map north-axis selection (`NorthAxis`).
    pub north_axis: i32,
    /// Map zoom level (`MapZoom`).
    pub map_zoom: i32,
    /// Horizontal map resolution (`MapResX`).
    pub map_res_x: i32,
    /// UI map point 1 (`MapPt1X`, `MapPt1Y`).
    pub map_point_1: [f32; 2],
    /// UI map point 2 (`MapPt2X`, `MapPt2Y`).
    pub map_point_2: [f32; 2],
    /// World point 1 (`WorldPt1X`, `WorldPt1Y`).
    pub world_point_1: [f32; 2],
    /// World point 2 (`WorldPt2X`, `WorldPt2Y`).
    pub world_point_2: [f32; 2],
}

impl Default for AreMap {
    fn default() -> Self {
        Self {
            north_axis: 0,
            map_zoom: 0,
            map_res_x: 0,
            map_point_1: [0.0, 0.0],
            map_point_2: [0.0, 0.0],
            world_point_1: [0.0, 0.0],
            world_point_2: [0.0, 0.0],
        }
    }
}

impl AreMap {
    fn from_struct(structure: &GffStruct) -> Self {
        Self {
            north_axis: get_i32(structure, "NorthAxis").unwrap_or(0),
            map_zoom: get_i32(structure, "MapZoom").unwrap_or(0),
            map_res_x: get_i32(structure, "MapResX").unwrap_or(0),
            map_point_1: [
                get_map_point_f32(structure, "MapPt1X").unwrap_or(0.0),
                get_map_point_f32(structure, "MapPt1Y").unwrap_or(0.0),
            ],
            map_point_2: [
                get_map_point_f32(structure, "MapPt2X").unwrap_or(0.0),
                get_map_point_f32(structure, "MapPt2Y").unwrap_or(0.0),
            ],
            world_point_1: [
                get_f32(structure, "WorldPt1X").unwrap_or(0.0),
                get_f32(structure, "WorldPt1Y").unwrap_or(0.0),
            ],
            world_point_2: [
                get_f32(structure, "WorldPt2X").unwrap_or(0.0),
                get_f32(structure, "WorldPt2Y").unwrap_or(0.0),
            ],
        }
    }

    fn to_struct(&self) -> GffStruct {
        let mut structure = GffStruct::new(0);
        upsert_field(
            &mut structure,
            "NorthAxis",
            GffValue::Int32(self.north_axis),
        );
        upsert_field(&mut structure, "MapZoom", GffValue::Int32(self.map_zoom));
        upsert_field(&mut structure, "MapResX", GffValue::Int32(self.map_res_x));
        upsert_field(
            &mut structure,
            "MapPt1X",
            GffValue::Single(self.map_point_1[0]),
        );
        upsert_field(
            &mut structure,
            "MapPt1Y",
            GffValue::Single(self.map_point_1[1]),
        );
        upsert_field(
            &mut structure,
            "MapPt2X",
            GffValue::Single(self.map_point_2[0]),
        );
        upsert_field(
            &mut structure,
            "MapPt2Y",
            GffValue::Single(self.map_point_2[1]),
        );
        upsert_field(
            &mut structure,
            "WorldPt1X",
            GffValue::Single(self.world_point_1[0]),
        );
        upsert_field(
            &mut structure,
            "WorldPt1Y",
            GffValue::Single(self.world_point_1[1]),
        );
        upsert_field(
            &mut structure,
            "WorldPt2X",
            GffValue::Single(self.world_point_2[0]),
        );
        upsert_field(
            &mut structure,
            "WorldPt2Y",
            GffValue::Single(self.world_point_2[1]),
        );
        structure
    }
}

/// Typed view over one ARE room entry in the `Rooms` list.
#[derive(Debug, Clone, PartialEq)]
pub struct AreRoom {
    /// Room name (`RoomName`).
    pub room_name: String,
    /// Ambient scale (`AmbientScale`).
    pub ambient_scale: f32,
    /// Environment audio ID (`EnvAudio`).
    pub env_audio: i32,
    /// Force-rating value (`ForceRating`, K2).
    pub force_rating: i32,
    /// Weather-disable flag (`DisableWeather`, K2).
    pub disable_weather: bool,
    /// Per-room part sound definitions (`PartSounds` list).
    pub part_sounds: Vec<ArePartSound>,
}

impl AreRoom {
    fn from_struct(structure: &GffStruct) -> Result<Self, AreError> {
        let part_sounds = match structure.field("PartSounds") {
            Some(GffValue::List(part_sound_structs)) => part_sound_structs
                .iter()
                .map(ArePartSound::from_struct)
                .collect::<Result<Vec<_>, _>>()?,
            Some(_) => {
                return Err(AreError::TypeMismatch {
                    field: "Rooms[].PartSounds",
                    expected: "List",
                });
            }
            None => Vec::new(),
        };

        Ok(Self {
            room_name: get_string(structure, "RoomName").unwrap_or_default(),
            ambient_scale: get_f32(structure, "AmbientScale").unwrap_or(0.0),
            env_audio: get_i32(structure, "EnvAudio").unwrap_or(0),
            force_rating: get_i32(structure, "ForceRating").unwrap_or(0),
            disable_weather: get_bool(structure, "DisableWeather").unwrap_or(false),
            part_sounds,
        })
    }

    fn to_struct(&self) -> GffStruct {
        let mut structure = GffStruct::new(0);
        upsert_field(
            &mut structure,
            "RoomName",
            GffValue::String(self.room_name.clone()),
        );
        upsert_field(
            &mut structure,
            "AmbientScale",
            GffValue::Single(self.ambient_scale),
        );
        upsert_field(&mut structure, "EnvAudio", GffValue::Int32(self.env_audio));
        upsert_field(
            &mut structure,
            "ForceRating",
            GffValue::Int32(self.force_rating),
        );
        upsert_field(
            &mut structure,
            "DisableWeather",
            GffValue::UInt8(u8::from(self.disable_weather)),
        );
        let part_sound_structs = self
            .part_sounds
            .iter()
            .map(ArePartSound::to_struct)
            .collect::<Vec<GffStruct>>();
        upsert_field(
            &mut structure,
            "PartSounds",
            GffValue::List(part_sound_structs),
        );
        structure
    }
}

/// Typed view over one ARE expansion-list entry.
#[derive(Debug, Clone, PartialEq)]
pub struct AreExpansionEntry {
    /// Localized expansion name (`Expansion_Name`).
    pub expansion_name: GffLocalizedString,
    /// Expansion identifier (`Expansion_ID`).
    pub expansion_id: i32,
}

impl AreExpansionEntry {
    fn from_struct(structure: &GffStruct) -> Result<Self, AreError> {
        let expansion_name = match structure.field("Expansion_Name") {
            Some(GffValue::LocalizedString(value)) => value.clone(),
            Some(_) => {
                return Err(AreError::TypeMismatch {
                    field: "Expansion_List[].Expansion_Name",
                    expected: "LocalizedString",
                });
            }
            None => GffLocalizedString::new(StrRef::invalid()),
        };

        Ok(Self {
            expansion_name,
            expansion_id: get_i32(structure, "Expansion_ID").unwrap_or(0),
        })
    }

    fn to_struct(&self) -> GffStruct {
        let mut structure = GffStruct::new(0);
        upsert_field(
            &mut structure,
            "Expansion_Name",
            GffValue::LocalizedString(self.expansion_name.clone()),
        );
        upsert_field(
            &mut structure,
            "Expansion_ID",
            GffValue::Int32(self.expansion_id),
        );
        structure
    }
}

/// Typed view over one room part-sound entry (`Rooms[].PartSounds[]`).
#[derive(Debug, Clone, PartialEq)]
pub struct ArePartSound {
    /// Looping flag (`Looping`).
    pub looping: bool,
    /// Model part identifier (`ModelPart`).
    pub model_part: String,
    /// Optional omen event token (`OmenEvent`).
    pub omen_event: String,
    /// Sound resref (`Sound`).
    pub sound: ResRef,
}

impl ArePartSound {
    fn from_struct(structure: &GffStruct) -> Result<Self, AreError> {
        let looping = match structure.field("Looping") {
            Some(GffValue::UInt8(value)) => *value != 0,
            Some(GffValue::Int8(value)) => *value != 0,
            Some(GffValue::UInt16(value)) => *value != 0,
            Some(GffValue::Int16(value)) => *value != 0,
            Some(GffValue::UInt32(value)) => *value != 0,
            Some(GffValue::Int32(value)) => *value != 0,
            Some(_) => {
                return Err(AreError::TypeMismatch {
                    field: "Rooms[].PartSounds[].Looping",
                    expected: "numeric bool",
                });
            }
            None => false,
        };

        Ok(Self {
            looping,
            model_part: get_string(structure, "ModelPart").unwrap_or_default(),
            omen_event: get_string(structure, "OmenEvent").unwrap_or_default(),
            sound: get_resref(structure, "Sound").unwrap_or_default(),
        })
    }

    fn to_struct(&self) -> GffStruct {
        let mut structure = GffStruct::new(0);
        upsert_field(
            &mut structure,
            "Looping",
            GffValue::UInt8(u8::from(self.looping)),
        );
        upsert_field(
            &mut structure,
            "ModelPart",
            GffValue::String(self.model_part.clone()),
        );
        upsert_field(
            &mut structure,
            "OmenEvent",
            GffValue::String(self.omen_event.clone()),
        );
        upsert_field(&mut structure, "Sound", GffValue::ResRef(self.sound));
        structure
    }
}

/// Errors produced while reading or writing typed ARE data.
#[derive(Debug, Error)]
pub enum AreError {
    /// Source file type is not supported by this parser.
    #[error("unsupported ARE file type: {0:?}")]
    UnsupportedFileType([u8; 4]),
    /// A required container field had an unexpected runtime type.
    #[error("ARE field `{field}` has incompatible type (expected {expected})")]
    TypeMismatch {
        /// Field label where mismatch occurred.
        field: &'static str,
        /// Expected runtime value kind.
        expected: &'static str,
    },
    /// Underlying GFF parser/writer error.
    #[error(transparent)]
    Gff(#[from] GffBinaryError),
}

/// Reads typed ARE data from a reader at the current stream position.
#[cfg_attr(
    feature = "tracing",
    tracing::instrument(level = "debug", skip(reader))
)]
pub fn read_are<R: Read>(reader: &mut R) -> Result<Are, AreError> {
    let gff = read_gff(reader)?;
    Are::from_gff(&gff)
}

/// Reads typed ARE data directly from bytes.
#[cfg_attr(
    feature = "tracing",
    tracing::instrument(level = "debug", skip(bytes), fields(bytes_len = bytes.len()))
)]
pub fn read_are_from_bytes(bytes: &[u8]) -> Result<Are, AreError> {
    let gff = read_gff_from_bytes(bytes)?;
    Are::from_gff(&gff)
}

/// Writes typed ARE data to an output writer.
#[cfg_attr(
    feature = "tracing",
    tracing::instrument(level = "debug", skip(writer, are))
)]
pub fn write_are<W: Write>(writer: &mut W, are: &Are) -> Result<(), AreError> {
    let gff = are.to_gff();
    write_gff(writer, &gff)?;
    Ok(())
}

/// Serializes typed ARE data into a byte vector.
#[cfg_attr(feature = "tracing", tracing::instrument(level = "debug", skip(are)))]
pub fn write_are_to_vec(are: &Are) -> Result<Vec<u8>, AreError> {
    let mut cursor = Cursor::new(Vec::new());
    write_are(&mut cursor, are)?;
    Ok(cursor.into_inner())
}

fn get_map_point_f32(structure: &GffStruct, label: &str) -> Option<f32> {
    match structure.field(label) {
        Some(GffValue::Single(value)) => Some(*value),
        // Intentional precision loss: GFF fields may store coordinates as
        // Double/Int32/UInt32 but map points are always f32 in practice.
        #[allow(clippy::cast_possible_truncation, clippy::as_conversions)]
        Some(GffValue::Double(value)) => Some(*value as f32),
        #[allow(clippy::cast_precision_loss, clippy::as_conversions)]
        Some(GffValue::Int32(value)) => Some(*value as f32),
        #[allow(clippy::cast_precision_loss, clippy::as_conversions)]
        Some(GffValue::UInt32(value)) => Some(*value as f32),
        Some(GffValue::Int16(value)) => Some(f32::from(*value)),
        Some(GffValue::UInt16(value)) => Some(f32::from(*value)),
        Some(GffValue::Int8(value)) => Some(f32::from(*value)),
        Some(GffValue::UInt8(value)) => Some(f32::from(*value)),
        _ => None,
    }
}

/// ARE `Rooms` list entry child schema.
static ROOMS_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "RoomName",
        expected_type: GffType::String,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "EnvAudio",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "AmbientScale",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "ForceRating",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "DisableWeather",
        expected_type: GffType::UInt8,
        required: false,
        children: None,
        constraint: None,
    },
];

/// ARE `Map` struct child schema.
static MAP_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "MapResX",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "NorthAxis",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "MapZoom",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "MapPt1X",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "MapPt1Y",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "MapPt2X",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "MapPt2Y",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "WorldPt1X",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "WorldPt1Y",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "WorldPt2X",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "WorldPt2Y",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
];

/// ARE `Expansion_List` entry child schema.
static EXPANSION_LIST_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "Expansion_Name",
        expected_type: GffType::LocalizedString,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Expansion_ID",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
];

/// ARE `MiniGame` struct child schema.
static MINI_GAME_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "Type",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "MovementPerSec",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "LateralAccel",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Bump_Plane",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "DoBumping",
        expected_type: GffType::UInt8,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "UseInertia",
        expected_type: GffType::UInt8,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "DOF",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Music",
        expected_type: GffType::ResRef,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Far_Clip",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Near_Clip",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "CameraViewAngle",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Player",
        expected_type: GffType::Struct,
        required: false,
        children: None,
        constraint: None,
    },
];

impl GffSchema for Are {
    fn schema() -> &'static [FieldSchema] {
        static SCHEMA: &[FieldSchema] = &[
            // ===== Identity =====
            FieldSchema {
                label: "ID",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Creator_ID",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Version",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Comments",
                expected_type: GffType::String,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Name",
                expected_type: GffType::LocalizedString,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Tag",
                expected_type: GffType::String,
                required: false,
                children: None,
                constraint: None,
            },
            // ===== Scripts (4) =====
            FieldSchema {
                label: "OnHeartbeat",
                expected_type: GffType::ResRef,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "OnUserDefined",
                expected_type: GffType::ResRef,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "OnEnter",
                expected_type: GffType::ResRef,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "OnExit",
                expected_type: GffType::ResRef,
                required: false,
                children: None,
                constraint: None,
            },
            // ===== Flags & mode =====
            FieldSchema {
                label: "Flags",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "CameraStyle",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DefaultEnvMap",
                expected_type: GffType::ResRef,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Unescapable",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "RestrictMode",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            // ===== Weather (5) =====
            FieldSchema {
                label: "ChanceRain",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: Some(FieldConstraint::RangeInt(0, 100)),
            },
            FieldSchema {
                label: "ChanceSnow",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: Some(FieldConstraint::RangeInt(0, 100)),
            },
            FieldSchema {
                label: "ChanceLightning",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: Some(FieldConstraint::RangeInt(0, 100)),
            },
            FieldSchema {
                label: "WindPower",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: Some(FieldConstraint::RangeInt(0, 2)),
            },
            FieldSchema {
                label: "ChanceFog",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            // ===== Lighting (20) =====
            FieldSchema {
                label: "MoonAmbientColor",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "MoonDiffuseColor",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "MoonFogColor",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "SunAmbientColor",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "SunDiffuseColor",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "SunFogColor",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DynAmbientColor",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "MoonFogNear",
                expected_type: GffType::Single,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "MoonFogFar",
                expected_type: GffType::Single,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "SunFogNear",
                expected_type: GffType::Single,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "SunFogFar",
                expected_type: GffType::Single,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "MoonFogOn",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "SunFogOn",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "MoonShadows",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "SunShadows",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DayNightCycle",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "IsNight",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "ShadowOpacity",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "LightingScheme",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "NoRest",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            // ===== Skill modifiers (2) =====
            FieldSchema {
                label: "ModSpotCheck",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "ModListenCheck",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            // ===== Grass (10) =====
            FieldSchema {
                label: "Grass_Diffuse",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Grass_Ambient",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Grass_Density",
                expected_type: GffType::Single,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Grass_QuadSize",
                expected_type: GffType::Single,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Grass_TexName",
                expected_type: GffType::ResRef,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Grass_Prob_LL",
                expected_type: GffType::Single,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Grass_Prob_LR",
                expected_type: GffType::Single,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Grass_Prob_UL",
                expected_type: GffType::Single,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Grass_Prob_UR",
                expected_type: GffType::Single,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "AlphaTest",
                expected_type: GffType::Single,
                required: false,
                children: None,
                constraint: None,
            },
            // ===== Stealth / transition (save-state) (7) =====
            FieldSchema {
                label: "StealthXPMax",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "StealthXPCurrent",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "StealthXPLoss",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "StealthXPEnabled",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "TransPending",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "TransPendNextID",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "TransPendCurrID",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            // ===== Other =====
            FieldSchema {
                label: "LoadScreenID",
                expected_type: GffType::UInt16,
                required: false,
                children: None,
                constraint: None,
            },
            // ===== Lists (2) + Structs (2) =====
            FieldSchema {
                label: "Rooms",
                expected_type: GffType::List,
                required: false,
                children: Some(ROOMS_CHILDREN),
                constraint: None,
            },
            FieldSchema {
                label: "Expansion_List",
                expected_type: GffType::List,
                required: false,
                children: Some(EXPANSION_LIST_CHILDREN),
                constraint: None,
            },
            FieldSchema {
                label: "Map",
                expected_type: GffType::Struct,
                required: false,
                children: Some(MAP_CHILDREN),
                constraint: None,
            },
            FieldSchema {
                label: "MiniGame",
                expected_type: GffType::Struct,
                required: false,
                children: Some(MINI_GAME_CHILDREN),
                constraint: None,
            },
            // ===== Toolset / K2 / NWN fields =====
            FieldSchema {
                label: "DisableTransit",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "NoHangBack",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "PlayerOnly",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "PlayerVsPlayer",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "Grass_Emissive",
                expected_type: GffType::UInt32,
                required: false,
                children: None,
                constraint: None,
            },
            // ===== Dirty overlays (12) =====
            FieldSchema {
                label: "DirtyARGBOne",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DirtySizeOne",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DirtyFormulaOne",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DirtyFuncOne",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DirtyARGBTwo",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DirtySizeTwo",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DirtyFormulaTwo",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DirtyFuncTwo",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DirtyARGBThree",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DirtySizeThree",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DirtyFormulaThre",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "DirtyFuncThree",
                expected_type: GffType::Int32,
                required: false,
                children: None,
                constraint: None,
            },
        ];
        SCHEMA
    }
}

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

    const TEST_ARE: &[u8] = include_bytes!(concat!(
        env!("CARGO_MANIFEST_DIR"),
        "/../../fixtures/test.are"
    ));

    #[test]
    fn reads_core_are_fields_from_fixture() {
        let are = read_are_from_bytes(TEST_ARE).expect("fixture must parse");

        assert_eq!(are.unused_id, 0);
        assert_eq!(are.creator_id, 0);
        assert_eq!(are.tag, "Untitled");
        assert_eq!(are.name.string_ref.raw(), 75_101);
        assert_eq!(are.comment, "comments");
        assert_eq!(are.version, 88);
        assert_eq!(are.flags, 0);
        assert_eq!(are.mod_spot_check, 0);
        assert_eq!(are.mod_listen_check, 0);
        assert_eq!(are.camera_style, 1);
        assert_eq!(are.default_envmap, "defaultenvmap");
        assert_eq!(are.grass_texture, "grasstexture");
        assert!((are.grass_density - 1.0).abs() < f32::EPSILON);
        assert!((are.grass_size - 1.0).abs() < f32::EPSILON);
        assert!((are.grass_prob_ll - 0.25).abs() < f32::EPSILON);
        assert!((are.grass_prob_lr - 0.25).abs() < f32::EPSILON);
        assert!((are.grass_prob_ul - 0.25).abs() < f32::EPSILON);
        assert!((are.grass_prob_ur - 0.25).abs() < f32::EPSILON);
        assert_eq!(are.sun_ambient_color, 16_777_215);
        assert_eq!(are.sun_diffuse_color, 16_777_215);
        assert_eq!(are.dynamic_ambient_color, 16_777_215);
        assert_eq!(are.sun_fog_color, 16_777_215);
        assert_eq!(are.grass_ambient_color, 16_777_215);
        assert_eq!(are.grass_diffuse_color, 16_777_215);
        assert_eq!(are.grass_emissive_color, 16_777_215);
        assert!(are.fog_enabled);
        assert!((are.fog_near - 99.0).abs() < f32::EPSILON);
        assert!((are.fog_far - 100.0).abs() < f32::EPSILON);
        assert!(are.shadows);
        assert_eq!(are.shadow_opacity, 205);
        assert_eq!(are.wind_power, 1);
        assert!(are.unescapable);
        assert!(are.disable_transit);
        assert!(are.stealth_xp);
        assert_eq!(are.stealth_xp_loss, 25);
        assert_eq!(are.stealth_xp_max, 25);
        assert_eq!(are.on_enter, "k_on_enter");
        assert_eq!(are.on_exit, "onexit");
        assert_eq!(are.on_heartbeat, "onheartbeat");
        assert_eq!(are.on_user_defined, "onuserdefined");
        assert!((are.alpha_test - 0.2).abs() < f32::EPSILON);
        assert_eq!(are.chance_rain, 99);
        assert_eq!(are.chance_snow, 99);
        assert_eq!(are.chance_lightning, 99);
        assert_eq!(are.moon_ambient_color, 0);
        assert_eq!(are.moon_diffuse_color, 0);
        assert!(!are.moon_fog_enabled);
        assert!((are.moon_fog_near - 99.0).abs() < f32::EPSILON);
        assert!((are.moon_fog_far - 100.0).abs() < f32::EPSILON);
        assert_eq!(are.moon_fog_color, 0);
        assert!(!are.moon_shadows);
        assert_eq!(are.dirty_argb_one, 123);
        assert_eq!(are.dirty_size_one, 1);
        assert_eq!(are.dirty_formula_one, 1);
        assert_eq!(are.dirty_func_one, 1);
        assert_eq!(are.dirty_argb_two, 1234);
        assert_eq!(are.dirty_size_two, 1);
        assert_eq!(are.dirty_formula_two, 1);
        assert_eq!(are.dirty_func_two, 1);
        assert_eq!(are.dirty_argb_three, 12_345);
        assert_eq!(are.dirty_size_three, 1);
        assert_eq!(are.dirty_formula_three, 1);
        assert_eq!(are.dirty_func_three, 1);
        assert!(!are.is_night);
        assert_eq!(are.lighting_scheme, 0);
        assert_eq!(are.day_night_cycle, 0);
        assert!(!are.no_rest);
        assert!(!are.no_hang_back);
        assert!(!are.player_only);
        assert_eq!(are.player_vs_player, 3);
        assert_eq!(are.map.map_zoom, 1);
        assert_eq!(are.map.map_res_x, 18);
        assert_eq!(are.rooms.len(), 2);
        assert!(are.expansion_list.is_empty());
        assert_eq!(are.rooms[0].room_name, "002ebo");
        assert!(are.rooms[0].disable_weather);
        assert!(are.rooms[0].part_sounds.is_empty());
    }

    #[test]
    fn all_fields_survive_typed_roundtrip() {
        let are = read_are_from_bytes(TEST_ARE).expect("fixture must parse");
        let encoded = write_are_to_vec(&are).expect("encode must succeed");
        let reparsed = read_are_from_bytes(&encoded).expect("decode must succeed");
        assert_eq!(are, reparsed);
    }

    #[test]
    fn typed_edits_roundtrip_through_gff_writer() {
        let mut are = read_are_from_bytes(TEST_ARE).expect("fixture must parse");
        are.tag = "m01aa".into();
        are.on_enter = ResRef::new("k_on_newenter").expect("valid test resref");
        are.grass_texture = ResRef::new("new_grass").expect("valid test resref");
        are.fog_enabled = false;
        are.fog_near = 50.0;
        are.shadow_opacity = 180;
        are.stealth_xp_loss = 33;
        are.dirty_formula_three = 9;
        are.player_vs_player = 2;
        are.restrict_mode = 1;
        are.chance_fog = 42;
        are.stealth_xp_current = 10;
        are.trans_pending = 1;
        are.trans_pend_next_id = 3;
        are.trans_pend_curr_id = 2;
        are.map.map_zoom = 7;
        are.rooms[0].ambient_scale = 0.5;
        are.expansion_list.push(AreExpansionEntry {
            expansion_name: GffLocalizedString::new(StrRef::from_raw(321)),
            expansion_id: 42,
        });
        are.rooms[0].part_sounds.push(ArePartSound {
            looping: true,
            model_part: "ROOM_A".into(),
            omen_event: "ON_ENTER".into(),
            sound: ResRef::new("amb_rooma").expect("valid test resref"),
        });

        let encoded = write_are_to_vec(&are).expect("encode");
        let reparsed = read_are_from_bytes(&encoded).expect("decode");

        assert_eq!(reparsed.tag, "m01aa");
        assert_eq!(reparsed.on_enter, "k_on_newenter");
        assert_eq!(reparsed.grass_texture, "new_grass");
        assert!(!reparsed.fog_enabled);
        assert!((reparsed.fog_near - 50.0).abs() < f32::EPSILON);
        assert_eq!(reparsed.shadow_opacity, 180);
        assert_eq!(reparsed.stealth_xp_loss, 33);
        assert_eq!(reparsed.dirty_formula_three, 9);
        assert_eq!(reparsed.player_vs_player, 2);
        assert_eq!(reparsed.restrict_mode, 1);
        assert_eq!(reparsed.chance_fog, 42);
        assert_eq!(reparsed.stealth_xp_current, 10);
        assert_eq!(reparsed.trans_pending, 1);
        assert_eq!(reparsed.trans_pend_next_id, 3);
        assert_eq!(reparsed.trans_pend_curr_id, 2);
        assert_eq!(reparsed.map.map_zoom, 7);
        assert_eq!(reparsed.rooms[0].ambient_scale, 0.5);
        assert_eq!(reparsed.expansion_list.len(), 1);
        assert_eq!(reparsed.expansion_list[0].expansion_id, 42);
        assert_eq!(
            reparsed.expansion_list[0].expansion_name.string_ref.raw(),
            321
        );
        assert_eq!(reparsed.rooms[0].part_sounds.len(), 1);
        assert!(reparsed.rooms[0].part_sounds[0].looping);
        assert_eq!(reparsed.rooms[0].part_sounds[0].model_part, "ROOM_A");
        assert_eq!(reparsed.rooms[0].part_sounds[0].omen_event, "ON_ENTER");
        assert_eq!(reparsed.rooms[0].part_sounds[0].sound, "amb_rooma");
        assert_eq!(reparsed.rooms.len(), 2);
    }

    #[test]
    fn rejects_non_are_file_type() {
        let gff = Gff::new(*b"DLG ", GffStruct::new(-1));
        let err = Are::from_gff(&gff).expect_err("must fail");
        assert!(matches!(err, AreError::UnsupportedFileType(file_type) if file_type == *b"DLG "));
    }

    #[test]
    fn read_are_from_reader_matches_bytes_path() {
        let mut cursor = Cursor::new(TEST_ARE);
        let via_reader = read_are(&mut cursor).expect("reader parse");
        let via_bytes = read_are_from_bytes(TEST_ARE).expect("bytes parse");
        assert_eq!(via_reader.tag, via_bytes.tag);
        assert_eq!(via_reader.rooms.len(), via_bytes.rooms.len());
    }

    #[test]
    fn type_mismatch_on_rooms_field_is_error() {
        let mut root = GffStruct::new(-1);
        root.push_field("Rooms", GffValue::UInt32(7));
        let gff = Gff::new(*b"ARE ", root);
        let err = Are::from_gff(&gff).expect_err("must fail");
        assert!(matches!(
            err,
            AreError::TypeMismatch {
                field: "Rooms",
                expected: "List"
            }
        ));
    }

    #[test]
    fn map_points_accept_int_encoding_for_k1_parity() {
        let mut root = GffStruct::new(-1);
        let mut map = GffStruct::new(0);
        map.push_field("MapPt1X", GffValue::Int32(10));
        map.push_field("MapPt1Y", GffValue::Int32(20));
        map.push_field("MapPt2X", GffValue::UInt16(30));
        map.push_field("MapPt2Y", GffValue::UInt8(40));
        root.push_field("Map", GffValue::Struct(Box::new(map)));
        let gff = Gff::new(*b"ARE ", root);

        let are = Are::from_gff(&gff).expect("must parse");
        assert_eq!(are.map.map_point_1, [10.0, 20.0]);
        assert_eq!(are.map.map_point_2, [30.0, 40.0]);
    }

    #[test]
    fn type_mismatch_on_expansion_list_field_is_error() {
        let mut root = GffStruct::new(-1);
        root.push_field("Expansion_List", GffValue::UInt32(7));
        let gff = Gff::new(*b"ARE ", root);
        let err = Are::from_gff(&gff).expect_err("must fail");
        assert!(matches!(
            err,
            AreError::TypeMismatch {
                field: "Expansion_List",
                expected: "List"
            }
        ));
    }

    #[test]
    fn type_mismatch_on_room_part_sounds_field_is_error() {
        let mut root = GffStruct::new(-1);
        let mut room = GffStruct::new(0);
        room.push_field("PartSounds", GffValue::UInt32(7));
        root.push_field("Rooms", GffValue::List(vec![room]));
        let gff = Gff::new(*b"ARE ", root);
        let err = Are::from_gff(&gff).expect_err("must fail");
        assert!(matches!(
            err,
            AreError::TypeMismatch {
                field: "Rooms[].PartSounds",
                expected: "List"
            }
        ));
    }

    #[test]
    fn type_mismatch_on_part_sound_looping_field_is_error() {
        let mut root = GffStruct::new(-1);
        let mut room = GffStruct::new(0);
        let mut part_sound = GffStruct::new(0);
        part_sound.push_field("Looping", GffValue::String("yes".into()));
        room.push_field("PartSounds", GffValue::List(vec![part_sound]));
        root.push_field("Rooms", GffValue::List(vec![room]));
        let gff = Gff::new(*b"ARE ", root);
        let err = Are::from_gff(&gff).expect_err("must fail");
        assert!(matches!(
            err,
            AreError::TypeMismatch {
                field: "Rooms[].PartSounds[].Looping",
                expected: "numeric bool"
            }
        ));
    }

    #[test]
    fn write_are_matches_direct_gff_writer() {
        let are = read_are_from_bytes(TEST_ARE).expect("fixture parse");
        let from_are = write_are_to_vec(&are).expect("are encode");

        let gff = are.to_gff();
        let from_gff = rakata_formats::write_gff_to_vec(&gff).expect("gff encode");
        assert_eq!(from_are, from_gff);
    }

    #[test]
    fn schema_field_count() {
        assert_eq!(Are::schema().len(), 81);
    }

    #[test]
    fn schema_no_duplicate_labels() {
        let schema = Are::schema();
        let mut labels: Vec<&str> = schema.iter().map(|f| f.label).collect();
        labels.sort();
        let before = labels.len();
        labels.dedup();
        assert_eq!(before, labels.len(), "duplicate labels in ARE schema");
    }

    #[test]
    fn schema_rooms_has_children() {
        let rooms = Are::schema()
            .iter()
            .find(|f| f.label == "Rooms")
            .expect("Rooms field must exist in schema");
        assert!(rooms.children.is_some());
        assert_eq!(
            rooms
                .children
                .expect("Rooms children must be present")
                .len(),
            5
        );
    }

    #[test]
    fn schema_map_has_children() {
        let map = Are::schema()
            .iter()
            .find(|f| f.label == "Map")
            .expect("Map field must exist in schema");
        assert!(map.children.is_some());
        assert_eq!(
            map.children.expect("Map children must be present").len(),
            11
        );
    }

    #[test]
    fn type_mismatch_on_mini_game_field_is_error() {
        let mut root = GffStruct::new(-1);
        root.push_field("MiniGame", GffValue::UInt32(7));
        let gff = Gff::new(*b"ARE ", root);
        let err = Are::from_gff(&gff).expect_err("must fail");
        assert!(matches!(
            err,
            AreError::TypeMismatch {
                field: "MiniGame",
                expected: "Struct"
            }
        ));
    }

    #[test]
    fn mini_game_struct_roundtrips() {
        let mg = AreMiniGame {
            mini_game_type: 1,
            movement_per_sec: 25.0,
            lateral_accel: 45.0,
            bump_plane: 2,
            do_bumping: true,
            use_inertia: true,
            dof: 3,
            music: ResRef::new("mus_swoop").expect("valid test resref"),
            far_clip: 200.0,
            near_clip: 0.5,
            camera_view_angle: 70.0,
            player: Some(AreMiniGamePlayer {
                models: vec![AreMiniGameModel {
                    model: ResRef::new("swoopbike").expect("valid test resref"),
                    rotating_model: false,
                }],
                track: ResRef::new("trk_race01").expect("valid test resref"),
                camera: ResRef::new("cam_swoop").expect("valid test resref"),
                camera_rotate: true,
                mouse: AreMiniGameMouse {
                    axis_x: 1,
                    axis_y: 2,
                    flip_axis_x: true,
                    flip_axis_y: false,
                },
                enemies: vec![AreMiniGameEnemy {
                    models: Vec::new(),
                    track: ResRef::new("trk_enemy01").expect("valid test resref"),
                }],
                obstacles: vec![AreMiniGameObstacle {
                    name: ResRef::new("obs_rock").expect("valid test resref"),
                }],
            }),
        };

        let mut are = Are::new();
        are.mini_game = Some(mg);

        let encoded = write_are_to_vec(&are).expect("encode");
        let reparsed = read_are_from_bytes(&encoded).expect("decode");

        let mg_out = reparsed.mini_game.expect("MiniGame must survive roundtrip");
        assert_eq!(mg_out.mini_game_type, 1);
        assert!((mg_out.movement_per_sec - 25.0).abs() < f32::EPSILON);
        assert!((mg_out.lateral_accel - 45.0).abs() < f32::EPSILON);
        assert_eq!(mg_out.bump_plane, 2);
        assert!(mg_out.do_bumping);
        assert!(mg_out.use_inertia);
        assert_eq!(mg_out.dof, 3);
        assert_eq!(mg_out.music, "mus_swoop");
        assert!((mg_out.far_clip - 200.0).abs() < f32::EPSILON);
        assert!((mg_out.near_clip - 0.5).abs() < f32::EPSILON);
        assert!((mg_out.camera_view_angle - 70.0).abs() < f32::EPSILON);

        let player = mg_out.player.expect("Player must survive roundtrip");
        assert_eq!(player.models.len(), 1);
        assert_eq!(player.models[0].model, "swoopbike");
        assert!(!player.models[0].rotating_model);
        assert_eq!(player.track, "trk_race01");
        assert_eq!(player.camera, "cam_swoop");
        assert!(player.camera_rotate);
        assert_eq!(player.mouse.axis_x, 1);
        assert_eq!(player.mouse.axis_y, 2);
        assert!(player.mouse.flip_axis_x);
        assert!(!player.mouse.flip_axis_y);
        assert_eq!(player.enemies.len(), 1);
        assert!(player.enemies[0].models.is_empty());
        assert_eq!(player.enemies[0].track, "trk_enemy01");
        assert_eq!(player.obstacles.len(), 1);
        assert_eq!(player.obstacles[0].name, "obs_rock");
    }
}