wintf 0.0.1

//! # Hit Region - 名前付きヒット領域データ
//!
//! エンティティ上の名前付きヒット領域（矩形・多角形・カラーマップ画像）を定義し、
//! マウスヒットテスト時にどの領域にヒットしたかを識別する機能を提供します。
//!
//! ## 概要
//!
//! - **矩形領域** (`Shape::Rect`): 座標ベースの矩形で領域を定義
//! - **多角形領域** (`Shape::Polygon`): 頂点リストで任意形状を定義
//! - **カラーマップ画像** (`ColorMapData`): 色分けPNG画像で領域を定義
//!
//! ## 使用例
//!
//! ```rust,ignore
//! use wintf::ecs::layout::hit_region::{HitRegionMap, HitRegionMapBuilder};
//!
//! // 矩形＋多角形の混在定義
//! let region_map = HitRegionMap::builder()
//!     .rect("head", 20.0, 0.0, 60.0, 40.0)
//!     .polygon("hand", &[(0.0, 50.0), (30.0, 80.0), (0.0, 80.0)])
//!     .build()?;
//! ```

use std::collections::HashMap;
use std::fmt;

use bevy_ecs::prelude::*;
use tracing::debug;
use windows::core::Interface;

use super::metrics::Size;
use crate::com::wic::{
    WICBitmapDecoderExt, WICBitmapSourceExt, WICFormatConverterExt, WICImagingFactoryExt,
    wic_factory,
};

// ============================================================================
// HitRegionError - バリデーションエラー
// ============================================================================

/// ヒット領域定義に関するエラー
#[derive(Debug)]
pub enum HitRegionError {
    /// 多角形の頂点数が不足（3未満）
    InsufficientVertices { vertices: usize },
    /// 矩形のサイズが不正（幅または高さが0以下）
    InvalidRectSize { width: f32, height: f32 },
    /// カラーマップ画像の読込失敗
    ImageLoadFailed(windows::core::Error),
}

impl fmt::Display for HitRegionError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            HitRegionError::InsufficientVertices { vertices } => {
                write!(f, "多角形の頂点数が不足しています: {} < 3", vertices)
            }
            HitRegionError::InvalidRectSize { width, height } => {
                write!(
                    f,
                    "矩形のサイズが不正です: width={}, height={}",
                    width, height
                )
            }
            HitRegionError::ImageLoadFailed(e) => {
                write!(f, "カラーマップ画像の読込に失敗しました: {}", e)
            }
        }
    }
}

impl std::error::Error for HitRegionError {}

impl From<windows::core::Error> for HitRegionError {
    fn from(e: windows::core::Error) -> Self {
        HitRegionError::ImageLoadFailed(e)
    }
}

// ============================================================================
// Shape / ShapeRegion - 形状定義
// ============================================================================

/// 形状定義（DIP単位、エンティティローカル座標系）
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Shape {
    /// 矩形: 左上座標 + 幅 + 高さ（DIP単位）
    Rect {
        x: f32,
        y: f32,
        width: f32,
        height: f32,
    },
    /// 多角形: 頂点リスト（DIP単位、自動的に閉じる）
    Polygon { vertices: Vec<(f32, f32)> },
}

/// 名前付き形状領域
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ShapeRegion {
    /// 領域名
    pub name: String,
    /// 形状定義
    pub shape: Shape,
}

// ============================================================================
// ColorMapData - カラーマップキャッシュデータ
// ============================================================================

/// カラーマップ画像のキャッシュデータ
///
/// 画像読込時にピクセル→リージョンIDのインデックスマップを構築します。
/// serde対象外（バイナリキャッシュ）。
#[derive(Debug, Clone)]
pub struct ColorMapData {
    /// ピクセル座標 → リージョンID（0 = 無名）のインデックスマップ
    /// index_map[y * width + x] = region_id
    index_map: Vec<u8>,
    /// リージョンID → リージョン名（ID 1 から開始）
    region_names: Vec<String>,
    /// 画像幅
    width: u32,
    /// 画像高さ
    height: u32,
}

impl ColorMapData {
    /// WIC画像読込 + インデックスマップ構築
    ///
    /// PNG画像を読み込み、各ピクセルの色値からリージョンIDへのインデックスマップを構築する。
    /// マッピング外の色はID 0（無名）として扱う。
    pub fn from_image(
        image_path: &std::path::Path,
        mapping: &HashMap<(u8, u8, u8), String>,
    ) -> windows::core::Result<Self> {
        use windows::Win32::Foundation::GENERIC_READ;
        use windows::Win32::Graphics::Imaging::*;
        use windows::core::HSTRING;

        // リージョン名リストとカラー→ID マッピングを構築
        let mut region_names = Vec::new();
        let mut color_to_id: HashMap<(u8, u8, u8), u8> = HashMap::new();

        for (color, name) in mapping {
            let id = (region_names.len() + 1) as u8; // ID 1 から開始
            region_names.push(name.clone());
            color_to_id.insert(*color, id);
        }

        // WIC で PNG を読み込む
        let factory = wic_factory()?;
        let path_str = image_path.to_string_lossy();
        let path_hstring = HSTRING::from(path_str.as_ref());
        let decoder = factory.create_decoder_from_filename(
            &path_hstring,
            None,
            GENERIC_READ,
            WICDecodeMetadataCacheOnDemand,
        )?;
        let frame = decoder.frame(0)?;

        // PBGRA32 に変換
        let converter = factory.create_format_converter()?;
        converter.init(
            &frame.cast::<IWICBitmapSource>()?,
            &GUID_WICPixelFormat32bppPBGRA,
            WICBitmapDitherTypeNone,
            None,
            0.0,
            WICBitmapPaletteTypeCustom,
        )?;
        let converted: IWICBitmapSource = converter.cast()?;

        // サイズ取得
        let (width, height) = converted.get_size()?;
        let stride = width * 4; // PBGRA32: 4 bytes per pixel
        let buffer_size = (stride * height) as usize;
        let mut buffer = vec![0u8; buffer_size];

        // ピクセルデータをコピー
        converted.copy_pixels(None, stride, &mut buffer)?;

        // インデックスマップ構築（RGB→リージョンID変換）
        let pixel_count = (width * height) as usize;
        let mut index_map = vec![0u8; pixel_count];

        for i in 0..pixel_count {
            let offset = i * 4;
            // PBGRA32: B, G, R, A の順
            let b = buffer[offset];
            let g = buffer[offset + 1];
            let r = buffer[offset + 2];
            // アルファは無視

            if let Some(&id) = color_to_id.get(&(r, g, b)) {
                index_map[i] = id;
            }
            // マッピング外は 0（無名）のまま
        }

        debug!(
            width = width,
            height = height,
            regions = region_names.len(),
            "カラーマップ画像読込完了"
        );

        Ok(Self {
            index_map,
            region_names,
            width,
            height,
        })
    }

    /// ピクセル座標から領域名を返す
    pub fn hit_test(&self, pixel_x: u32, pixel_y: u32) -> Option<&str> {
        if pixel_x >= self.width || pixel_y >= self.height {
            return None;
        }
        let index = (pixel_y * self.width + pixel_x) as usize;
        let region_id = self.index_map[index];
        if region_id == 0 {
            None
        } else {
            self.region_names
                .get((region_id - 1) as usize)
                .map(|s| s.as_str())
        }
    }

    /// 画像幅
    pub fn width(&self) -> u32 {
        self.width
    }

    /// 画像高さ
    pub fn height(&self) -> u32 {
        self.height
    }
}

// ============================================================================
// ColorMapDef / ColorMapping - シリアライズ対象の定義構造
// ============================================================================

/// カラーマップ定義（シリアライズ対象）
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ColorMapDef {
    /// 画像ファイルパス
    pub image_path: String,
    /// RGB → 領域名マッピング
    pub mapping: Vec<ColorMapping>,
}

/// 色→領域名マッピングエントリ
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ColorMapping {
    /// RGB値 [R, G, B]
    pub color: [u8; 3],
    /// 領域名
    pub name: String,
}

// ============================================================================
// RegionKind - 排他的方式 enum
// ============================================================================

/// 領域定義の方式（排他的）
///
/// `Shapes` と `ColorMap` は同時に使用できません。
#[derive(Debug, Clone)]
enum RegionKind {
    /// 矩形/多角形の形状リスト（混在可能）
    Shapes(Vec<ShapeRegion>),
    /// カラーマップ画像ベースの領域定義
    ColorMap(ColorMapData),
}

// ============================================================================
// HitRegionMap - ECSコンポーネント
// ============================================================================

/// 名前付きヒット領域マップコンポーネント
///
/// エンティティに紐づくヒット領域データを保持します。
/// 矩形/多角形方式またはカラーマップ方式のいずれか一方を使用します。
///
/// # 使用例
/// ```rust,ignore
/// use wintf::ecs::layout::hit_region::HitRegionMap;
///
/// // ビルダーで矩形/多角形方式を構築
/// let map = HitRegionMap::builder()
///     .rect("head", 20.0, 0.0, 60.0, 40.0)
///     .build()?;
///
/// // カラーマップ方式で構築
/// let map = HitRegionMap::from_color_map(path, &mapping)?;
/// ```
#[derive(Component, Debug, Clone)]
pub struct HitRegionMap {
    kind: RegionKind,
}

impl HitRegionMap {
    /// ビルダー開始（矩形/多角形方式）
    pub fn builder() -> HitRegionMapBuilder {
        HitRegionMapBuilder::new()
    }

    /// カラーマップ方式で構築
    ///
    /// # Arguments
    /// * `image_path` - カラーマップ PNG 画像パス
    /// * `mapping` - RGB → リージョン名のマッピング
    pub fn from_color_map(
        image_path: &std::path::Path,
        mapping: &HashMap<(u8, u8, u8), String>,
    ) -> Result<Self, HitRegionError> {
        let data = ColorMapData::from_image(image_path, mapping)?;
        Ok(Self {
            kind: RegionKind::ColorMap(data),
        })
    }

    /// 正規化座標から領域名を返す（AlphaMaskパターン踏襲）
    ///
    /// # Arguments
    /// * `rel_x`, `rel_y` - 正規化座標（0.0〜1.0）
    /// * `entity_size` - エンティティの論理サイズ（DIP単位、Shapes方式で使用）
    ///
    /// # Returns
    /// 領域内→`Some("name")`、領域外→`None`
    pub fn hit_test_region(&self, rel_x: f32, rel_y: f32, entity_size: &Size) -> Option<&str> {
        match &self.kind {
            RegionKind::Shapes(regions) => {
                // 正規化座標 → DIPローカル座標に変換
                let local_x = rel_x * entity_size.width;
                let local_y = rel_y * entity_size.height;

                // 定義順の先勝ちルール: 前から順に評価
                for region in regions {
                    let hit = match &region.shape {
                        Shape::Rect {
                            x,
                            y,
                            width,
                            height,
                        } => {
                            local_x >= *x
                                && local_x <= *x + *width
                                && local_y >= *y
                                && local_y <= *y + *height
                        }
                        Shape::Polygon { vertices } => point_in_polygon(local_x, local_y, vertices),
                    };
                    if hit {
                        return Some(&region.name);
                    }
                }
                None
            }
            RegionKind::ColorMap(data) => {
                // 正規化座標 → 画像ピクセル座標に変換
                let pixel_x = (rel_x * data.width() as f32) as u32;
                let pixel_y = (rel_y * data.height() as f32) as u32;
                data.hit_test(pixel_x, pixel_y)
            }
        }
    }
}

// ============================================================================
// HitRegionMapBuilder - ビルダーパターン
// ============================================================================

/// 矩形/多角形方式のヒット領域ビルダー
pub struct HitRegionMapBuilder {
    regions: Vec<ShapeRegion>,
}

impl HitRegionMapBuilder {
    /// 新しいビルダーを作成
    pub fn new() -> Self {
        Self {
            regions: Vec::new(),
        }
    }

    /// 矩形領域を追加
    pub fn rect(mut self, name: &str, x: f32, y: f32, width: f32, height: f32) -> Self {
        self.regions.push(ShapeRegion {
            name: name.to_string(),
            shape: Shape::Rect {
                x,
                y,
                width,
                height,
            },
        });
        self
    }

    /// 多角形領域を追加
    pub fn polygon(mut self, name: &str, vertices: &[(f32, f32)]) -> Self {
        self.regions.push(ShapeRegion {
            name: name.to_string(),
            shape: Shape::Polygon {
                vertices: vertices.to_vec(),
            },
        });
        self
    }

    /// HitRegionMap を構築（バリデーション付き）
    ///
    /// # Errors
    /// - 矩形: width <= 0 または height <= 0 の場合 `InvalidRectSize`
    /// - 多角形: 頂点数 < 3 の場合 `InsufficientVertices`
    pub fn build(self) -> Result<HitRegionMap, HitRegionError> {
        // バリデーション
        for region in &self.regions {
            match &region.shape {
                Shape::Rect { width, height, .. } => {
                    if *width <= 0.0 || *height <= 0.0 {
                        return Err(HitRegionError::InvalidRectSize {
                            width: *width,
                            height: *height,
                        });
                    }
                }
                Shape::Polygon { vertices } => {
                    if vertices.len() < 3 {
                        return Err(HitRegionError::InsufficientVertices {
                            vertices: vertices.len(),
                        });
                    }
                }
            }
        }

        Ok(HitRegionMap {
            kind: RegionKind::Shapes(self.regions),
        })
    }
}

impl Default for HitRegionMapBuilder {
    fn default() -> Self {
        Self::new()
    }
}

// ============================================================================
// point_in_polygon - Ray Casting 法
// ============================================================================

/// Ray Casting法による点の多角形内外判定
///
/// 判定点から右方向に半直線を伸ばし、多角形の辺との交差回数が奇数なら内部。
/// O(n) — n: 頂点数
fn point_in_polygon(x: f32, y: f32, vertices: &[(f32, f32)]) -> bool {
    let n = vertices.len();
    if n < 3 {
        return false;
    }

    let mut inside = false;
    let mut j = n - 1;

    for i in 0..n {
        let (xi, yi) = vertices[i];
        let (xj, yj) = vertices[j];

        // 辺が判定点のY座標をまたぐかチェック
        if (yi > y) != (yj > y) {
            // 交点のX座標を計算
            let intersect_x = xj + (y - yj) / (yi - yj) * (xi - xj);
            if x < intersect_x {
                inside = !inside;
            }
        }

        j = i;
    }

    inside
}

// ============================================================================
// テスト
// ============================================================================

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

    // ========================================================================
    // point_in_polygon テスト
    // ========================================================================

    #[test]
    fn test_point_in_polygon_convex_inside() {
        // 正方形 (0,0)-(100,100)
        let vertices = vec![(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)];
        assert!(point_in_polygon(50.0, 50.0, &vertices));
    }

    #[test]
    fn test_point_in_polygon_convex_outside() {
        let vertices = vec![(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)];
        assert!(!point_in_polygon(150.0, 50.0, &vertices));
    }

    #[test]
    fn test_point_in_polygon_concave_inside() {
        // L字形（凹多角形）
        let vertices = vec![
            (0.0, 0.0),
            (100.0, 0.0),
            (100.0, 50.0),
            (50.0, 50.0),
            (50.0, 100.0),
            (0.0, 100.0),
        ];
        // L字の内部
        assert!(point_in_polygon(25.0, 75.0, &vertices));
    }

    #[test]
    fn test_point_in_polygon_concave_outside_notch() {
        // L字形の凹み部分
        let vertices = vec![
            (0.0, 0.0),
            (100.0, 0.0),
            (100.0, 50.0),
            (50.0, 50.0),
            (50.0, 100.0),
            (0.0, 100.0),
        ];
        // 凹み部分（外部）
        assert!(!point_in_polygon(75.0, 75.0, &vertices));
    }

    #[test]
    fn test_point_in_polygon_triangle() {
        let vertices = vec![(50.0, 0.0), (100.0, 100.0), (0.0, 100.0)];
        assert!(point_in_polygon(50.0, 50.0, &vertices));
        assert!(!point_in_polygon(5.0, 5.0, &vertices));
    }

    #[test]
    fn test_point_in_polygon_insufficient_vertices() {
        let vertices = vec![(0.0, 0.0), (100.0, 0.0)];
        assert!(!point_in_polygon(50.0, 0.0, &vertices));
    }

    // ========================================================================
    // ShapeRegion::Rect テスト
    // ========================================================================

    #[test]
    fn test_rect_hit_test_inside() {
        let map = HitRegionMap::builder()
            .rect("test", 10.0, 20.0, 50.0, 30.0)
            .build()
            .unwrap();

        // エンティティサイズ 100x100、正規化座標に変換
        let entity_size = Size {
            width: 100.0,
            height: 100.0,
        };
        // local (35, 35) → rel (0.35, 0.35)
        assert_eq!(map.hit_test_region(0.35, 0.35, &entity_size), Some("test"));
    }

    #[test]
    fn test_rect_hit_test_outside() {
        let map = HitRegionMap::builder()
            .rect("test", 10.0, 20.0, 50.0, 30.0)
            .build()
            .unwrap();

        let entity_size = Size {
            width: 100.0,
            height: 100.0,
        };
        // local (5, 5) → rel (0.05, 0.05) — 矩形外
        assert_eq!(map.hit_test_region(0.05, 0.05, &entity_size), None);
    }

    #[test]
    fn test_rect_hit_test_boundary_inclusive() {
        let map = HitRegionMap::builder()
            .rect("test", 10.0, 20.0, 50.0, 30.0)
            .build()
            .unwrap();

        let entity_size = Size {
            width: 100.0,
            height: 100.0,
        };
        // 左上角 (10, 20) → rel (0.10, 0.20)
        assert_eq!(map.hit_test_region(0.10, 0.20, &entity_size), Some("test"));
        // 内部点 (59, 49) → rel (0.59, 0.49) — 右下角の近傍
        assert_eq!(map.hit_test_region(0.59, 0.49, &entity_size), Some("test"));
    }

    // ========================================================================
    // HitRegionMapBuilder テスト
    // ========================================================================

    #[test]
    fn test_builder_build_success() {
        let result = HitRegionMap::builder()
            .rect("head", 20.0, 0.0, 60.0, 40.0)
            .polygon("hand", &[(0.0, 50.0), (30.0, 80.0), (0.0, 80.0)])
            .build();
        assert!(result.is_ok());
    }

    #[test]
    fn test_builder_invalid_rect_size_zero_width() {
        let result = HitRegionMap::builder()
            .rect("bad", 0.0, 0.0, 0.0, 10.0)
            .build();
        assert!(result.is_err());
        let err = result.unwrap_err();
        assert!(matches!(err, HitRegionError::InvalidRectSize { .. }));
    }

    #[test]
    fn test_builder_invalid_rect_size_negative() {
        let result = HitRegionMap::builder()
            .rect("bad", 0.0, 0.0, -5.0, 10.0)
            .build();
        assert!(result.is_err());
    }

    #[test]
    fn test_builder_insufficient_vertices() {
        let result = HitRegionMap::builder()
            .polygon("bad", &[(0.0, 0.0), (10.0, 0.0)])
            .build();
        assert!(result.is_err());
        let err = result.unwrap_err();
        assert!(matches!(err, HitRegionError::InsufficientVertices { .. }));
    }

    #[test]
    fn test_builder_empty_builds_ok() {
        let result = HitRegionMap::builder().build();
        assert!(result.is_ok());
    }

    // ========================================================================
    // HitRegionMap 先勝ちルール テスト
    // ========================================================================

    #[test]
    fn test_shapes_first_match_wins() {
        // 重なる2つの矩形: "first" が先に定義
        let map = HitRegionMap::builder()
            .rect("first", 0.0, 0.0, 100.0, 100.0)
            .rect("second", 0.0, 0.0, 100.0, 100.0)
            .build()
            .unwrap();

        let entity_size = Size {
            width: 100.0,
            height: 100.0,
        };
        // 両方の領域内 → 先に定義された "first" が返る
        assert_eq!(map.hit_test_region(0.5, 0.5, &entity_size), Some("first"));
    }

    #[test]
    fn test_shapes_mixed_rect_polygon() {
        let map = HitRegionMap::builder()
            .rect("rect_region", 0.0, 0.0, 50.0, 50.0)
            .polygon(
                "poly_region",
                &[(50.0, 0.0), (100.0, 0.0), (100.0, 50.0), (50.0, 50.0)],
            )
            .build()
            .unwrap();

        let entity_size = Size {
            width: 100.0,
            height: 100.0,
        };
        // 矩形内 → "rect_region"
        assert_eq!(
            map.hit_test_region(0.25, 0.25, &entity_size),
            Some("rect_region")
        );
        // 多角形内 → "poly_region"
        assert_eq!(
            map.hit_test_region(0.75, 0.25, &entity_size),
            Some("poly_region")
        );
    }

    // ========================================================================
    // Polygon hit_test_region 統一インターフェーステスト
    // ========================================================================

    #[test]
    fn test_polygon_hit_test_region_inside() {
        // 三角形 (0,0)-(100,0)-(50,100) をエンティティ 100x100 で定義
        let map = HitRegionMap::builder()
            .polygon("tri", &[(0.0, 0.0), (100.0, 0.0), (50.0, 100.0)])
            .build()
            .unwrap();

        let entity_size = Size {
            width: 100.0,
            height: 100.0,
        };
        // 三角形の重心付近 (50, 33) → rel (0.50, 0.33)
        assert_eq!(map.hit_test_region(0.50, 0.33, &entity_size), Some("tri"));
    }

    #[test]
    fn test_polygon_hit_test_region_outside() {
        let map = HitRegionMap::builder()
            .polygon("tri", &[(0.0, 0.0), (100.0, 0.0), (50.0, 100.0)])
            .build()
            .unwrap();

        let entity_size = Size {
            width: 100.0,
            height: 100.0,
        };
        // 三角形の外 (95, 90) → rel (0.95, 0.90)
        assert_eq!(map.hit_test_region(0.95, 0.90, &entity_size), None);
    }

    #[test]
    fn test_polygon_hit_test_region_non_square_entity() {
        // エンティティが非正方形 (200x100) の場合の座標変換を検証
        // 多角形: (100,0)-(200,0)-(200,100)-(100,100) — 右半分の矩形
        let map = HitRegionMap::builder()
            .polygon(
                "right_half",
                &[(100.0, 0.0), (200.0, 0.0), (200.0, 100.0), (100.0, 100.0)],
            )
            .build()
            .unwrap();

        let entity_size = Size {
            width: 200.0,
            height: 100.0,
        };
        // 左半分 (50, 50) → rel (0.25, 0.50) → local (50, 50) … 外
        assert_eq!(map.hit_test_region(0.25, 0.50, &entity_size), None);
        // 右半分 (150, 50) → rel (0.75, 0.50) → local (150, 50) … 内
        assert_eq!(
            map.hit_test_region(0.75, 0.50, &entity_size),
            Some("right_half")
        );
    }

    #[test]
    fn test_polygon_hit_test_region_multiple_regions() {
        // 4分割のポリゴンリージョン
        let map = HitRegionMap::builder()
            .polygon(
                "top-left",
                &[(0.0, 0.0), (50.0, 0.0), (50.0, 50.0), (0.0, 50.0)],
            )
            .polygon(
                "top-right",
                &[(50.0, 0.0), (100.0, 0.0), (100.0, 50.0), (50.0, 50.0)],
            )
            .polygon(
                "bottom-left",
                &[(0.0, 50.0), (50.0, 50.0), (50.0, 100.0), (0.0, 100.0)],
            )
            .polygon(
                "bottom-right",
                &[(50.0, 50.0), (100.0, 50.0), (100.0, 100.0), (50.0, 100.0)],
            )
            .build()
            .unwrap();

        let entity_size = Size {
            width: 100.0,
            height: 100.0,
        };
        assert_eq!(
            map.hit_test_region(0.25, 0.25, &entity_size),
            Some("top-left")
        );
        assert_eq!(
            map.hit_test_region(0.75, 0.25, &entity_size),
            Some("top-right")
        );
        assert_eq!(
            map.hit_test_region(0.25, 0.75, &entity_size),
            Some("bottom-left")
        );
        assert_eq!(
            map.hit_test_region(0.75, 0.75, &entity_size),
            Some("bottom-right")
        );
    }

    #[test]
    fn test_shapes_no_region_hit() {
        let map = HitRegionMap::builder()
            .rect("test", 10.0, 10.0, 30.0, 30.0)
            .build()
            .unwrap();

        let entity_size = Size {
            width: 100.0,
            height: 100.0,
        };
        // すべての領域外
        assert_eq!(map.hit_test_region(0.01, 0.01, &entity_size), None);
    }

    #[test]
    fn test_empty_shapes_returns_none() {
        let map = HitRegionMap::builder().build().unwrap();

        let entity_size = Size {
            width: 100.0,
            height: 100.0,
        };
        assert_eq!(map.hit_test_region(0.5, 0.5, &entity_size), None);
    }

    // ========================================================================
    // ColorMapData テスト (ユニットテスト用のインライン構築)
    // ========================================================================

    #[test]
    fn test_color_map_data_hit_test_mapped_color() {
        // 2x2 のテストデータを直接構築
        let data = ColorMapData {
            index_map: vec![1, 0, 0, 2], // (0,0)=頭, (1,0)=無名, (0,1)=無名, (1,1)=手
            region_names: vec!["head".to_string(), "hand".to_string()],
            width: 2,
            height: 2,
        };

        assert_eq!(data.hit_test(0, 0), Some("head"));
        assert_eq!(data.hit_test(1, 1), Some("hand"));
    }

    #[test]
    fn test_color_map_data_hit_test_unmapped_color() {
        let data = ColorMapData {
            index_map: vec![1, 0, 0, 2],
            region_names: vec!["head".to_string(), "hand".to_string()],
            width: 2,
            height: 2,
        };

        // マッピング外 → None
        assert_eq!(data.hit_test(1, 0), None);
    }

    #[test]
    fn test_color_map_data_hit_test_out_of_bounds() {
        let data = ColorMapData {
            index_map: vec![1, 0, 0, 2],
            region_names: vec!["head".to_string(), "hand".to_string()],
            width: 2,
            height: 2,
        };

        // 範囲外座標 → None
        assert_eq!(data.hit_test(5, 5), None);
    }

    // ========================================================================
    // HitRegionMap ColorMap方式テスト
    // ========================================================================

    #[test]
    fn test_color_map_hit_test_region() {
        // 4x4 カラーマップを手動構築
        // 左半分 = "left" (id=1)、右半分 = "right" (id=2)
        let mut index_map = vec![0u8; 16];
        for y in 0..4u32 {
            for x in 0..4u32 {
                let i = (y * 4 + x) as usize;
                if x < 2 {
                    index_map[i] = 1;
                } else {
                    index_map[i] = 2;
                }
            }
        }

        let map = HitRegionMap {
            kind: RegionKind::ColorMap(ColorMapData {
                index_map,
                region_names: vec!["left".to_string(), "right".to_string()],
                width: 4,
                height: 4,
            }),
        };

        let entity_size = Size {
            width: 100.0,
            height: 100.0,
        };

        // 左側 (rel_x=0.25 → pixel_x=1)
        assert_eq!(map.hit_test_region(0.25, 0.5, &entity_size), Some("left"));
        // 右側 (rel_x=0.75 → pixel_x=3)
        assert_eq!(map.hit_test_region(0.75, 0.5, &entity_size), Some("right"));
    }

    #[test]
    fn test_color_map_hit_test_region_unmapped_via_interface() {
        // 4x4 カラーマップ: 中央2x2のみマッピング、周囲は未マッピング(id=0)
        let mut index_map = vec![0u8; 16];
        // (1,1),(2,1),(1,2),(2,2) を "center" (id=1) に設定
        index_map[5] = 1; // (1,1)
        index_map[6] = 1; // (2,1)
        index_map[9] = 1; // (1,2)
        index_map[10] = 1; // (2,2)

        let map = HitRegionMap {
            kind: RegionKind::ColorMap(ColorMapData {
                index_map,
                region_names: vec!["center".to_string()],
                width: 4,
                height: 4,
            }),
        };

        let entity_size = Size {
            width: 100.0,
            height: 100.0,
        };
        // 中央 → "center"
        assert_eq!(
            map.hit_test_region(0.375, 0.375, &entity_size),
            Some("center")
        );
        // 左上隅 (0,0) → 未マッピング → None
        assert_eq!(map.hit_test_region(0.0, 0.0, &entity_size), None);
        // 右下隅 (3,3) → 未マッピング → None
        assert_eq!(map.hit_test_region(0.875, 0.875, &entity_size), None);
    }

    #[test]
    fn test_color_map_hit_test_region_non_square_entity() {
        // 4x2 カラーマップ（横長）: 左半分 "a", 右半分 "b"
        //  a a b b
        //  a a b b
        let index_map = vec![1, 1, 2, 2, 1, 1, 2, 2];

        let map = HitRegionMap {
            kind: RegionKind::ColorMap(ColorMapData {
                index_map,
                region_names: vec!["a".to_string(), "b".to_string()],
                width: 4,
                height: 2,
            }),
        };

        // エンティティが非正方形: 200x50
        let entity_size = Size {
            width: 200.0,
            height: 50.0,
        };
        // 左1/4 → pixel_x=1 → "a"
        assert_eq!(map.hit_test_region(0.25, 0.5, &entity_size), Some("a"));
        // 右3/4 → pixel_x=3 → "b"
        assert_eq!(map.hit_test_region(0.75, 0.5, &entity_size), Some("b"));
    }

    #[test]
    fn test_color_map_hit_test_region_four_quadrants() {
        // 4x4 カラーマップ: 4象限
        // TL=1, TR=2, BL=3, BR=4
        let mut index_map = vec![0u8; 16];
        for y in 0..4u32 {
            for x in 0..4u32 {
                let i = (y * 4 + x) as usize;
                index_map[i] = match (x < 2, y < 2) {
                    (true, true) => 1,   // top-left
                    (false, true) => 2,  // top-right
                    (true, false) => 3,  // bottom-left
                    (false, false) => 4, // bottom-right
                };
            }
        }

        let map = HitRegionMap {
            kind: RegionKind::ColorMap(ColorMapData {
                index_map,
                region_names: vec![
                    "top-left".to_string(),
                    "top-right".to_string(),
                    "bottom-left".to_string(),
                    "bottom-right".to_string(),
                ],
                width: 4,
                height: 4,
            }),
        };

        let entity_size = Size {
            width: 100.0,
            height: 100.0,
        };
        assert_eq!(
            map.hit_test_region(0.25, 0.25, &entity_size),
            Some("top-left")
        );
        assert_eq!(
            map.hit_test_region(0.75, 0.25, &entity_size),
            Some("top-right")
        );
        assert_eq!(
            map.hit_test_region(0.25, 0.75, &entity_size),
            Some("bottom-left")
        );
        assert_eq!(
            map.hit_test_region(0.75, 0.75, &entity_size),
            Some("bottom-right")
        );
    }

    // ========================================================================
    // HitRegionError Display テスト
    // ========================================================================

    #[test]
    fn test_error_display() {
        let err = HitRegionError::InsufficientVertices { vertices: 2 };
        assert!(err.to_string().contains("2 < 3"));

        let err = HitRegionError::InvalidRectSize {
            width: -1.0,
            height: 10.0,
        };
        assert!(err.to_string().contains("-1"));
    }
}