using System;
using System.Collections.Generic;
using Core;
using Godot;
using Models;

public partial class CampusController : Node2D {
    private const int GridSearchRadius = 6;

    private static readonly CampusTaskType[] TaskTypePool = {
        CampusTaskType.Experiment,
        CampusTaskType.Writing,
        CampusTaskType.Administration,
        CampusTaskType.Exercise,
        CampusTaskType.Coding,
        CampusTaskType.Social
    };

    private readonly List<Vector2I> _astarWalkableCells = new();
    private readonly List<CampusBehaviorAgent> _behaviorAgents = new();
    private readonly CampusBehaviorWorld _behaviorWorld = new();

    private readonly Dictionary<CampusLocationId, CampusBuilding> _buildings = new() {
        {
            CampusLocationId.Laboratory,
            new CampusBuilding("Laboratory", new Rect2I(48, 72, 192, 160), new Vector2I(150, 196))
        }, {
            CampusLocationId.Library,
            new CampusBuilding("Library", new Rect2I(312, 64, 256, 160), new Vector2I(440, 196))
        }, {
            CampusLocationId.Canteen,
            new CampusBuilding("Canteen", new Rect2I(640, 64, 128, 96), new Vector2I(745, 166))
        }, {
            CampusLocationId.Dormitory,
            new CampusBuilding("Dormitory", new Rect2I(800, 64, 96, 96), new Vector2I(848, 192))
        },
        { CampusLocationId.ArtificialLake, new CampusBuilding("ArtificialLake", new Rect2I(), new Vector2I(943, 179)) },
        { CampusLocationId.CoffeeShop, new CampusBuilding("CoffeeShop", new Rect2I(), new Vector2I(160, 395)) }, {
            CampusLocationId.AdminBuilding,
            new CampusBuilding("AdminBuilding", new Rect2I(234, 312, 128, 96), new Vector2I(296, 452))
        }, {
            CampusLocationId.FootballField,
            new CampusBuilding("FootballField", new Rect2I(568, 320, 160, 160), new Vector2I(560, 300))
        }
    };

    private readonly List<Vector2> _coveragePoints = new();
    private readonly CampusLocationRegistry _locationRegistry = new();
    private List<string> _archetypeIds = new();
    private AStarGrid2D _astarGrid;
    private Rid _astarMap;
    private int _astarMapIteration;
    private Rect2I _astarRegion;
    private CampusBehaviorConfig _behaviorConfig;
    private GameContentDatabase _contentDatabase;
    private DebugGridOverlay _debugGridOverlay;
    private List<string> _disciplineIds = new();
    private Control _logContainer;
    private RichTextLabel _logLabel;
    private Button _logToggle;
    private uint _navBakeIterationId;
    private Rid _navBakeMap;
    private bool _navBakePending;
    private bool _navBakeReady;

    private NavigationRegion2D _navigationRegion;
    private Random _random;
    private List<string> _roleIds = new();
    private bool _roundActive;
    private float _roundElapsed;
    private int _roundIndex;
    private bool _spawnPending = true;
    private Node2D _studentsRoot;
    private Control _taskContainer;
    private Button _taskToggle;
    private TopBar _topBar;
    private List<string> _traitIds = new();

    [Export] public PackedScene StudentScene { get; set; }
    [Export] public int StudentCount { get; set; } = 5;
    [Export] public float CoverageStep { get; set; } = 48.0f;
    [Export] public int MaxCoveragePoints { get; set; } = 200;
    [Export] public string BehaviorConfigPath { get; set; } = "res://resources/definitions/campus_behavior.json";
    [Export] public int RandomSeed { get; set; }
    [Export] public int AssignedTaskChancePercent { get; set; } = 60;
    [Export] public float RoundDurationSeconds { get; set; } = 30.0f;
    [Export] public float AgentMoveSpeed { get; set; } = 180.0f;
    [Export] public float GridCellSize { get; set; } = 8.0f;
    [Export] public float GridWalkableTolerance { get; set; } = 2.0f;
    [Export] public bool DebugGridEnabled { get; set; }
    [Export] public Key DebugGridToggleKey { get; set; } = Key.G;
    [Export] public bool DebugLogGrid { get; set; }

    // Called when the node enters the scene tree for the first time.
    public override void _Ready() {
        SetProcessUnhandledInput(true);
        _taskContainer = GetNode<Control>("Task");
        _logContainer = GetNode<Control>("Log");

        // Path to buttons based on scene structure
        _taskToggle = GetNode<Button>("TopBar/HBox/CC1/TaskToggle");
        _logToggle = GetNode<Button>("TopBar/HBox/CC2/LogToggle");

        // Sync initial state
        _taskToggle.ButtonPressed = _taskContainer.Visible;
        _logToggle.ButtonPressed = _logContainer.Visible;

        _taskToggle.Toggled += OnTaskToggled;
        _logToggle.Toggled += OnLogToggled;

        _topBar = GetNodeOrNull<TopBar>("TopBar");
        if (_topBar != null) _topBar.ResetRound(RoundDurationSeconds);

        _logLabel = GetNodeOrNull<RichTextLabel>("Log/VBoxContainer/RichTextLabel");
        if (_logLabel != null) _logLabel.Text = string.Empty;

        InitializeBehaviorAssets();

        // 导航区域与学生容器初始化
        _navigationRegion = GetNodeOrNull<NavigationRegion2D>("Sprite2D/NavigationRegion2D");
        _studentsRoot = GetNodeOrNull<Node2D>("Students");
        if (_studentsRoot == null) {
            _studentsRoot = new Node2D { Name = "Students" };
            AddChild(_studentsRoot);
        }

        EnsureDebugGridOverlay();

        // 使用可视化轮廓重新烘焙导航多边形，确保洞被正确识别
        RebakeNavigationPolygonFromOutlines();

        // 等待导航地图同步完成后再生成学生
        _spawnPending = true;
    }

    // Called every frame. 'delta' is the elapsed time since the previous frame.
    public override void _Process(double delta) {
        TrySpawnStudents();
        UpdateRoundTimer((float)delta);
        UpdateBehaviorAgents((float)delta);
        if (DebugGridEnabled) RequestDebugGridRedraw();
    }

    public override void _UnhandledInput(InputEvent @event) {
        if (@event is not InputEventKey keyEvent) return;

        if (!keyEvent.Pressed || keyEvent.Echo || keyEvent.Keycode != DebugGridToggleKey) return;

        DebugGridEnabled = !DebugGridEnabled;
        RequestDebugGridRedraw();
    }

    private void InitializeBehaviorAssets() {
        _behaviorConfig = CampusBehaviorConfig.Load(BehaviorConfigPath);
        _random = RandomSeed == 0 ? new Random() : new Random(RandomSeed);
        LoadContentDatabase();
        CacheLocations();
    }

    private void LoadContentDatabase() {
        var registry = new ContentRegistry();
        var jsonSource = new JsonContentSource(0);
        jsonSource.DataPaths.Add("res://resources/definitions/disciplines.json");
        jsonSource.DataPaths.Add("res://resources/definitions/archetypes.json");
        jsonSource.DataPaths.Add("res://resources/definitions/roles.json");
        jsonSource.DataPaths.Add("res://resources/definitions/traits.json");
        registry.RegisterSource(jsonSource);

        _contentDatabase = registry.BuildDatabase();
        _archetypeIds = new List<string>(_contentDatabase.Archetypes.Keys);
        _roleIds = new List<string>(_contentDatabase.Roles.Keys);
        _traitIds = new List<string>(_contentDatabase.Traits.Keys);
        _disciplineIds = new List<string>(_contentDatabase.Disciplines.Keys);

        if (_archetypeIds.Count == 0 || _roleIds.Count == 0 || _traitIds.Count == 0)
            GD.PushWarning("Behavior content definitions are missing; random tags will be limited.");
    }

    private void CacheLocations() {
        var locationsRoot = GetNodeOrNull<Node2D>("Locations");
        if (locationsRoot == null) {
            GD.PushWarning("Campus scene is missing Locations root; agents will wander only.");
            return;
        }

        RegisterLocation(locationsRoot, "Location_Lab", CampusLocationId.Laboratory);
        RegisterLocation(locationsRoot, "Location_Library", CampusLocationId.Library);
        RegisterLocation(locationsRoot, "Location_Canteen", CampusLocationId.Canteen);
        RegisterLocation(locationsRoot, "Location_Dorm", CampusLocationId.Dormitory);
        RegisterLocation(locationsRoot, "Location_Lake", CampusLocationId.ArtificialLake);
        RegisterLocation(locationsRoot, "Location_Coffee", CampusLocationId.CoffeeShop);
        RegisterLocation(locationsRoot, "Location_Admin", CampusLocationId.AdminBuilding);
        RegisterLocation(locationsRoot, "Location_Field", CampusLocationId.FootballField);
    }

    private void RegisterLocation(Node2D root, string nodeName, CampusLocationId id) {
        var node = root.GetNodeOrNull<Node2D>(nodeName);
        if (node == null) {
            GD.PushWarning($"Campus location marker not found: {nodeName}");
            return;
        }

        _locationRegistry.Register(id, node.GlobalPosition);
    }

    private void UpdateBehaviorAgents(float delta) {
        if (_behaviorAgents.Count == 0) return;

        _behaviorWorld.Clear();
        foreach (var agent in _behaviorAgents) _behaviorWorld.AddOccupant(agent.Runtime.CurrentLocationId);

        foreach (var agent in _behaviorAgents) agent.Tick(delta);
    }

    private void UpdateRoundTimer(float delta) {
        if (_behaviorAgents.Count == 0 || _spawnPending) return;

        if (!_roundActive) StartRound();

        if (!_roundActive) return;

        _roundElapsed += delta;
        _topBar?.UpdateRoundProgress(_roundElapsed, RoundDurationSeconds);

        if (_roundElapsed >= RoundDurationSeconds) EndRound();
    }

    private void StartRound() {
        _roundActive = true;
        _roundElapsed = 0.0f;
        _roundIndex += 1;
        _topBar?.ResetRound(RoundDurationSeconds);
        AppendLog($"第{_roundIndex}轮开始");

        foreach (var agent in _behaviorAgents) {
            EnsureRoundTask(agent.Runtime);
            agent.StartRound(RoundDurationSeconds);
        }
    }

    private void EndRound() {
        _roundActive = false;
        foreach (var agent in _behaviorAgents) agent.EndRound();

        AppendLog($"第{_roundIndex}轮结束");
    }

    private void EnsureRoundTask(CampusAgentRuntime runtime) {
        if (runtime.AssignedTask != null) return;
        if (TaskTypePool.Length == 0) return;

        var rng = _random ?? Random.Shared;
        if (rng.Next(0, 100) >= AssignedTaskChancePercent) return;

        var taskType = TaskTypePool[rng.Next(0, TaskTypePool.Length)];
        var maxDuration = Math.Max(10, (int)RoundDurationSeconds - 5);
        var duration = rng.Next(8, Math.Max(9, maxDuration));
        runtime.AssignedTask = new CampusTask(taskType, duration);
    }

    private void AppendLog(string message) {
        if (_logLabel == null || string.IsNullOrWhiteSpace(message)) return;
        _logLabel.AppendText(message + "\n");
    }

    private void OnTaskToggled(bool pressed) {
        AnimateVisibility(_taskContainer, pressed);
    }

    private void OnLogToggled(bool pressed) {
        AnimateVisibility(_logContainer, pressed);
    }

    private void AnimateVisibility(Control container, bool visible) {
        var tween = CreateTween();
        if (visible) {
            if (!container.Visible) {
                var col = container.Modulate;
                col.A = 0;
                container.Modulate = col;
                container.Visible = true;
            }

            tween.TweenProperty(container, "modulate:a", 1.0f, 0.2f);
        }
        else {
            tween.TweenProperty(container, "modulate:a", 0.0f, 0.2f);
            tween.TweenCallback(Callable.From(() => container.Visible = false));
        }
    }

    private void TrySpawnStudents() {
        if (!_spawnPending) return;

        if (_navBakePending || !_navBakeReady) return;

        // 已生成过学生则不重复生成
        if (_studentsRoot != null && _studentsRoot.GetChildCount() > 0) {
            _spawnPending = false;
            return;
        }

        if (StudentScene == null)
            StudentScene = ResourceLoader.Load<PackedScene>("res://scenes/student_16_native.tscn");

        if (_navigationRegion == null || _navigationRegion.NavigationPolygon == null) {
            GD.PushWarning("校园导航区域未配置或缺失导航多边形，无法生成巡游学生。");
            _spawnPending = false;
            return;
        }

        // 导航地图可能还未就绪，需要等待同步完成后再采样
        var map = GetNavigationMap();
        if (!map.IsValid) return;

        var iterationId = NavigationServer2D.MapGetIterationId(map);
        if (iterationId == 0) return;

        // 等待导航图完成新一轮同步，避免采样到旧的/空的地图
        if (_navBakeMap.IsValid) {
            if (map == _navBakeMap && iterationId == _navBakeIterationId) return;

            if (NavigationServer2D.MapGetRegions(map).Count == 0) return;
        }

        if (!EnsureAStarGrid() || _astarWalkableCells.Count == 0) return;

        if (SpawnStudents()) _spawnPending = false;
    }

    private bool SpawnStudents() {
        _coveragePoints.Clear();
        _coveragePoints.AddRange(BuildCoveragePoints());
        if (_coveragePoints.Count == 0) {
            GD.PushWarning("未采样到可行走区域，跳过学生生成。");
            return false;
        }

        for (var i = 0; i < StudentCount; i++) {
            var instance = StudentScene.Instantiate();
            if (instance is not CampusStudent student) {
                GD.PushWarning("student_16_native.tscn 需要挂载 CampusStudent 脚本。");
                instance.QueueFree();
                continue;
            }

            _studentsRoot.AddChild(student);
            student.MoveSpeed = AgentMoveSpeed;

            // 随机放置在可行走区域，并交给行为系统控制
            if (!TryGetRandomWalkableGridPoint(out var gridPoint)) {
                GD.PushWarning("AStarGrid2D 未准备好，无法放置学生。");
                return false;
            }

            student.GlobalPosition = gridPoint;
            student.ApplyRandomTheme();

            var runtime = BuildRandomAgentRuntime(i);
            student.Name = runtime.Name;

            var agent = new CampusBehaviorAgent(
                student,
                runtime,
                _behaviorConfig,
                _locationRegistry,
                _behaviorWorld,
                _random,
                _coveragePoints,
                AppendLog);

            _behaviorAgents.Add(agent);
            LogSpawn(runtime);
        }

        return true;
    }

    private CampusAgentRuntime BuildRandomAgentRuntime(int index) {
        var rng = _random ?? Random.Shared;
        var name = $"Agent_{index + 1}";
        var student = new StudentModel(name, rng);
        AssignRandomTags(student.Core, rng);
        ApplyRandomStatus(student, rng);

        var needs = new CampusAgentNeeds(
            rng.Next(20, 100),
            rng.Next(20, 100),
            rng.Next(20, 100),
            rng.Next(60, 100));

        var runtime = new CampusAgentRuntime(student, needs);

        if (rng.Next(0, 100) < AssignedTaskChancePercent && TaskTypePool.Length > 0) {
            var taskType = TaskTypePool[rng.Next(0, TaskTypePool.Length)];
            var duration = rng.Next(8, 16);
            runtime.AssignedTask = new CampusTask(taskType, duration);
        }

        return runtime;
    }

    private void AssignRandomTags(UnitModel unit, Random rng) {
        unit.Tags.ArchetypeIds.Clear();
        unit.Tags.RoleIds.Clear();
        unit.Tags.TraitIds.Clear();

        var archetypeId = PickRandomId(_archetypeIds, rng);
        if (!string.IsNullOrWhiteSpace(archetypeId)) unit.Tags.ArchetypeIds.Add(archetypeId);

        var roleId = PickRandomId(_roleIds, rng);
        if (!string.IsNullOrWhiteSpace(roleId)) unit.Tags.RoleIds.Add(roleId);

        var traitCount = _traitIds.Count == 0 ? 0 : rng.Next(1, Math.Min(3, _traitIds.Count + 1));
        for (var i = 0; i < traitCount; i++) {
            var traitId = PickRandomId(_traitIds, rng);
            if (!string.IsNullOrWhiteSpace(traitId) && !unit.Tags.TraitIds.Contains(traitId))
                unit.Tags.TraitIds.Add(traitId);
        }

        var disciplineId = PickRandomId(_disciplineIds, rng);
        if (!string.IsNullOrWhiteSpace(disciplineId)) unit.Tags.DisciplineId = disciplineId;
    }

    private void ApplyRandomStatus(StudentModel student, Random rng) {
        var unit = student.Core;
        unit.Statuses.Stress.Current.Value = rng.Next(0, 60);
        unit.Statuses.Sanity.Current.Value = rng.Next(50, 100);
        unit.Statuses.Mood.Value = rng.Next(30, 90);
        student.Progress.Stamina.Current.Value = rng.Next(25, 100);
    }

    private static string PickRandomId(List<string> ids, Random rng) {
        if (ids == null || ids.Count == 0) return null;
        return ids[rng.Next(0, ids.Count)];
    }

    private void LogSpawn(CampusAgentRuntime runtime) {
        var unit = runtime.Unit;
        var archetypes = unit.Tags.ArchetypeIds.Count == 0 ? "none" : string.Join(",", unit.Tags.ArchetypeIds);
        var roles = unit.Tags.RoleIds.Count == 0 ? "none" : string.Join(",", unit.Tags.RoleIds);
        var traits = unit.Tags.TraitIds.Count == 0 ? "none" : string.Join(",", unit.Tags.TraitIds);
        var taskInfo = runtime.AssignedTask != null
            ? $"{runtime.AssignedTask.Type} ({runtime.AssignedTask.RemainingSeconds:0}s)"
            : "none";
        var attributes =
            $"A:{unit.Attributes.Academic.DisplayInt()} " +
            $"E:{unit.Attributes.Engineering.DisplayInt()} " +
            $"W:{unit.Attributes.Writing.DisplayInt()} " +
            $"F:{unit.Attributes.Financial.DisplayInt()} " +
            $"S:{unit.Attributes.Social.DisplayInt()} " +
            $"Act:{unit.Attributes.Activation.DisplayInt()}";

        GD.Print(
            $"[CampusAI] Spawned {runtime.Name} archetype={archetypes} role={roles} traits={traits} task={taskInfo} attrs={attributes}");
    }

    private List<Vector2> BuildCoveragePoints() {
        var points = new List<Vector2>();
        var polygon = _navigationRegion.NavigationPolygon;
        if (polygon == null || polygon.Vertices.Length == 0) return points;

        var outlineCount = polygon.GetOutlineCount();
        var outer = polygon.GetOutline(0);
        if (outer.Length == 0) return points;

        var holes = new List<Vector2[]>();
        for (var i = 1; i < outlineCount; i++) {
            var hole = polygon.GetOutline(i);
            if (hole.Length > 0) holes.Add(hole);
        }

        // 根据外轮廓计算采样范围
        var min = outer[0];
        var max = outer[0];
        foreach (var v in outer) {
            min = new Vector2(Mathf.Min(min.X, v.X), Mathf.Min(min.Y, v.Y));
            max = new Vector2(Mathf.Max(max.X, v.X), Mathf.Max(max.Y, v.Y));
        }

        var step = Mathf.Max(8.0f, CoverageStep);
        var minDistance = step * 0.45f;
        for (var x = min.X; x <= max.X; x += step)
        for (var y = min.Y; y <= max.Y; y += step) {
            var local = new Vector2(x, y);
            if (!Geometry2D.IsPointInPolygon(local, outer)) continue;

            var insideHole = false;
            for (var i = 0; i < holes.Count; i++)
                if (Geometry2D.IsPointInPolygon(local, holes[i])) {
                    insideHole = true;
                    break;
                }

            if (insideHole) continue;

            var global = _navigationRegion.ToGlobal(local);
            if (!HasNearbyPoint(points, global, minDistance)) {
                points.Add(global);
                if (points.Count >= MaxCoveragePoints) return points;
            }
        }

        // 补充采样轮廓顶点，避免狭窄区域缺少巡游点
        foreach (var vertex in outer) {
            var global = _navigationRegion.ToGlobal(vertex);
            if (!HasNearbyPoint(points, global, minDistance)) {
                points.Add(global);
                if (points.Count >= MaxCoveragePoints) return points;
            }
        }

        // 兜底：至少给一个可行走点
        if (points.Count == 0) {
            var centerLocal = (min + max) * 0.5f;
            points.Add(_navigationRegion.ToGlobal(centerLocal));
        }

        return points;
    }

    private Rid GetNavigationMap() {
        if (_navigationRegion == null) return new Rid();

        var map = NavigationServer2D.RegionGetMap(_navigationRegion.GetRid());
        if (!map.IsValid) {
            var world = GetWorld2D();
            if (world != null) map = world.NavigationMap;
        }

        return map;
    }

    public List<Vector2> RequestGridPath(Vector2 start, Vector2 target) {
        if (!EnsureAStarGrid()) return null;

        var startCell = WorldToGrid(start);
        var targetCell = WorldToGrid(target);
        if (!IsCellInBounds(startCell) || !IsCellInBounds(targetCell)) {
            if (DebugLogGrid)
                GD.Print($"[AStarGrid] out_of_bounds start={startCell} target={targetCell} region={_astarRegion}");
            return null;
        }

        startCell = FindNearestOpenCell(startCell, GridSearchRadius);
        targetCell = FindNearestOpenCell(targetCell, GridSearchRadius);
        if (!IsCellInBounds(startCell) || !IsCellInBounds(targetCell)) {
            if (DebugLogGrid) GD.Print($"[AStarGrid] no_open_cell start={startCell} target={targetCell}");
            return null;
        }

        if (_astarGrid.IsPointSolid(startCell) || _astarGrid.IsPointSolid(targetCell)) {
            if (DebugLogGrid) GD.Print($"[AStarGrid] solid start={startCell} target={targetCell}");
            return null;
        }

        var path = _astarGrid.GetIdPath(startCell, targetCell);
        if (path.Count == 0) {
            if (DebugLogGrid) GD.Print($"[AStarGrid] empty_path start={startCell} target={targetCell}");
            return null;
        }

        var result = new List<Vector2>(path.Count);
        foreach (var cell in path) result.Add(GridToWorld(cell));

        if (result.Count > 0) result.RemoveAt(0);

        return result;
    }

    private bool TryGetRandomWalkableGridPoint(out Vector2 point) {
        point = Vector2.Zero;
        if (!EnsureAStarGrid() || _astarWalkableCells.Count == 0) return false;

        var index = _random != null
            ? _random.Next(0, _astarWalkableCells.Count)
            : GD.RandRange(0, _astarWalkableCells.Count - 1);
        point = GridToWorld(_astarWalkableCells[index]);
        return true;
    }

    private bool EnsureAStarGrid() {
        if (!IsNavigationMapReady(out var map)) return false;

        var region = BuildGridRegion();
        if (region.Size.X <= 0 || region.Size.Y <= 0) return false;

        var cellSize = new Vector2(Mathf.Max(1.0f, GridCellSize), Mathf.Max(1.0f, GridCellSize));
        var mapIteration = (int)NavigationServer2D.MapGetIterationId(map);
        var needsRebuild = _astarGrid == null
                           || _astarMapIteration != mapIteration
                           || _astarMap != map
                           || _astarRegion.Position != region.Position
                           || _astarRegion.Size != region.Size
                           || _astarGrid.CellSize != cellSize;

        if (!needsRebuild) return _astarGrid != null;

        _astarGrid ??= new AStarGrid2D();
        _astarGrid.DefaultComputeHeuristic = AStarGrid2D.Heuristic.Manhattan;
        _astarGrid.DefaultEstimateHeuristic = AStarGrid2D.Heuristic.Manhattan;
        _astarGrid.Region = region;
        _astarGrid.CellSize = cellSize;
        _astarGrid.Offset = Vector2.Zero;
        _astarGrid.DiagonalMode = AStarGrid2D.DiagonalModeEnum.Never;
        _astarGrid.Update();

        _astarWalkableCells.Clear();
        for (var x = region.Position.X; x < region.Position.X + region.Size.X; x++)
        for (var y = region.Position.Y; y < region.Position.Y + region.Size.Y; y++) {
            var cell = new Vector2I(x, y);
            var center = GridToWorld(cell);
            var walkable = IsCellWalkable(center, map);
            _astarGrid.SetPointSolid(cell, !walkable);
            if (walkable) _astarWalkableCells.Add(cell);
        }

        _astarRegion = region;
        _astarMapIteration = mapIteration;
        _astarMap = map;
        if (DebugLogGrid) GD.Print($"[AStarGrid] region={region} cell={cellSize}");

        return true;
    }

    private bool IsNavigationMapReady(out Rid map) {
        map = GetNavigationMap();
        return map.IsValid && NavigationServer2D.MapGetIterationId(map) > 0;
    }

    private Rect2I BuildGridRegion() {
        var bounds = BuildWorldBounds();
        var cell = Mathf.Max(1.0f, GridCellSize);
        var minX = Mathf.FloorToInt(bounds.Position.X / cell);
        var minY = Mathf.FloorToInt(bounds.Position.Y / cell);
        var maxX = Mathf.CeilToInt((bounds.Position.X + bounds.Size.X) / cell);
        var maxY = Mathf.CeilToInt((bounds.Position.Y + bounds.Size.Y) / cell);
        var sizeX = Math.Max(1, maxX - minX);
        var sizeY = Math.Max(1, maxY - minY);
        return new Rect2I(new Vector2I(minX, minY), new Vector2I(sizeX, sizeY));
    }

    private Rect2 BuildWorldBounds() {
        var viewport = GetViewportRect();
        var bounds = new Rect2(viewport.Position, viewport.Size);

        if (_navigationRegion == null || _navigationRegion.NavigationPolygon == null) return bounds;

        var polygon = _navigationRegion.NavigationPolygon;
        var outlineCount = polygon.GetOutlineCount();
        if (outlineCount == 0) return bounds;

        var min = Vector2.Zero;
        var max = Vector2.Zero;
        var hasPoint = false;

        for (var i = 0; i < outlineCount; i++) {
            var outline = polygon.GetOutline(i);
            for (var j = 0; j < outline.Length; j++) {
                var world = _navigationRegion.ToGlobal(outline[j]);
                if (!hasPoint) {
                    min = world;
                    max = world;
                    hasPoint = true;
                    continue;
                }

                min = new Vector2(Mathf.Min(min.X, world.X), Mathf.Min(min.Y, world.Y));
                max = new Vector2(Mathf.Max(max.X, world.X), Mathf.Max(max.Y, world.Y));
            }
        }

        if (!hasPoint) return bounds;

        var navBounds = new Rect2(min, max - min);
        return bounds.Merge(navBounds);
    }

    private bool IsCellInRegion(Vector2I cell) {
        return cell.X >= _astarRegion.Position.X
               && cell.X < _astarRegion.Position.X + _astarRegion.Size.X
               && cell.Y >= _astarRegion.Position.Y
               && cell.Y < _astarRegion.Position.Y + _astarRegion.Size.Y;
    }

    private bool IsCellInBounds(Vector2I cell) {
        if (_astarGrid != null) return _astarGrid.IsInBounds(cell.X, cell.Y);

        return IsCellInRegion(cell);
    }

    private Vector2I WorldToGrid(Vector2 world) {
        var size = Mathf.Max(1.0f, GridCellSize);
        return new Vector2I(
            Mathf.FloorToInt(world.X / size),
            Mathf.FloorToInt(world.Y / size));
    }

    private Vector2 GridToWorld(Vector2I grid) {
        var size = Mathf.Max(1.0f, GridCellSize);
        return new Vector2((grid.X + 0.5f) * size, (grid.Y + 0.5f) * size);
    }

    private Vector2I FindNearestOpenCell(Vector2I origin, int radius) {
        if (_astarGrid == null) return origin;
        if (IsCellInBounds(origin) && !_astarGrid.IsPointSolid(origin)) return origin;

        for (var r = 1; r <= radius; r++)
        for (var dx = -r; dx <= r; dx++) {
            var dy = r - Math.Abs(dx);
            var candidateA = new Vector2I(origin.X + dx, origin.Y + dy);
            if (IsCellInBounds(candidateA) && !_astarGrid.IsPointSolid(candidateA)) return candidateA;

            if (dy == 0) continue;
            var candidateB = new Vector2I(origin.X + dx, origin.Y - dy);
            if (IsCellInBounds(candidateB) && !_astarGrid.IsPointSolid(candidateB)) return candidateB;
        }

        return origin;
    }

    private bool IsWorldWalkable(Vector2 world, Rid map) {
        if (!map.IsValid) return false;
        var closest = NavigationServer2D.MapGetClosestPoint(map, world);
        return closest.DistanceTo(world) <= GetGridTolerance();
    }

    private bool IsCellWalkable(Vector2 center, Rid map) {
        if (!IsWorldWalkable(center, map)) return false;

        var half = Mathf.Max(1.0f, GridCellSize * 0.45f);
        var offsets = new[] {
            new Vector2(half, 0),
            new Vector2(-half, 0),
            new Vector2(0, half),
            new Vector2(0, -half),
            new Vector2(half, half),
            new Vector2(half, -half),
            new Vector2(-half, half),
            new Vector2(-half, -half)
        };

        for (var i = 0; i < offsets.Length; i++)
            if (!IsWorldWalkable(center + offsets[i], map))
                return false;

        return true;
    }

    private float GetGridTolerance() {
        return Mathf.Max(1.0f, GridWalkableTolerance);
    }

    private static bool HasNearbyPoint(List<Vector2> points, Vector2 candidate, float minDistance) {
        for (var i = 0; i < points.Count; i++)
            if (points[i].DistanceTo(candidate) <= minDistance)
                return true;

        return false;
    }

    private void RebakeNavigationPolygonFromOutlines() {
        if (_navigationRegion == null || _navigationRegion.NavigationPolygon == null) return;

        var navPolygon = _navigationRegion.NavigationPolygon;
        var outlineCount = navPolygon.GetOutlineCount();
        if (outlineCount == 0) return;

        _navBakePending = true;
        _navBakeReady = false;
        _navBakeMap = GetNavigationMap();
        _navBakeIterationId = _navBakeMap.IsValid ? NavigationServer2D.MapGetIterationId(_navBakeMap) : 0;

        // 将第一个轮廓作为可通行区域，其余轮廓作为障碍洞
        var sourceGeometry = new NavigationMeshSourceGeometryData2D();
        sourceGeometry.AddTraversableOutline(navPolygon.GetOutline(0));
        for (var i = 1; i < outlineCount; i++) sourceGeometry.AddObstructionOutline(navPolygon.GetOutline(i));

        NavigationServer2D.BakeFromSourceGeometryData(navPolygon, sourceGeometry, Callable.From(() => {
            // 烘焙完成后再刷新导航区域，避免用旧的多边形生成地图
            _navigationRegion.NavigationPolygon = navPolygon;
            _astarGrid = null;
            _astarMap = new Rid();
            _astarMapIteration = 0;
            _astarWalkableCells.Clear();
            _navBakePending = false;
            _navBakeReady = true;
            RequestDebugGridRedraw();
        }));
    }

    private void EnsureDebugGridOverlay() {
        if (_debugGridOverlay != null) return;

        var sprite = GetNodeOrNull<Node2D>("Sprite2D");
        _debugGridOverlay = new DebugGridOverlay {
            Name = "DebugGridOverlay",
            ZIndex = 1
        };
        (sprite ?? this).AddChild(_debugGridOverlay);
        _debugGridOverlay.CampusOwner = this;
        _debugGridOverlay.Visible = DebugGridEnabled;
    }

    private void RequestDebugGridRedraw() {
        if (_debugGridOverlay == null) return;

        _debugGridOverlay.Visible = DebugGridEnabled;
        if (DebugGridEnabled) _debugGridOverlay.QueueRedraw();
    }

    private void DrawDebugGrid(Node2D canvas) {
        if (!DebugGridEnabled || canvas == null) return;

        if (!EnsureAStarGrid()) return;

        var cellSize = Mathf.Max(1.0f, GridCellSize);
        var half = new Vector2(cellSize * 0.5f, cellSize * 0.5f);
        var solidFill = new Color(1.0f, 0.3f, 0.3f, 0.25f);
        var solidOutline = new Color(1.0f, 0.3f, 0.3f, 0.6f);
        var walkFill = new Color(0.2f, 0.8f, 0.3f, 0.08f);
        var walkOutline = new Color(0.2f, 0.8f, 0.3f, 0.2f);

        var minX = _astarRegion.Position.X;
        var maxX = _astarRegion.Position.X + _astarRegion.Size.X - 1;
        var minY = _astarRegion.Position.Y;
        var maxY = _astarRegion.Position.Y + _astarRegion.Size.Y - 1;

        for (var x = minX; x <= maxX; x++)
        for (var y = minY; y <= maxY; y++) {
            var cell = new Vector2I(x, y);
            var isSolid = _astarGrid.IsPointSolid(cell);
            var worldCenter = new Vector2((cell.X + 0.5f) * cellSize, (cell.Y + 0.5f) * cellSize);
            var localTopLeft = canvas.ToLocal(worldCenter) - half;
            var rect = new Rect2(localTopLeft, new Vector2(cellSize, cellSize));
            canvas.DrawRect(rect, isSolid ? solidFill : walkFill);
            canvas.DrawRect(rect, isSolid ? solidOutline : walkOutline, false, 1.0f);
        }
    }

    private class CampusBuilding(string locationId, Rect2I pRegion, Vector2I entrance) {
        public string LocationId { get; } = locationId;
        public HashSet<string> MemberIds { get; set; } = [];
        public Rect2I PortraitRegion { get; } = pRegion;
        public Vector2I EntrancePoint { get; } = entrance;
    }

    private sealed partial class DebugGridOverlay : Node2D {
        public CampusController CampusOwner { get; set; }

        public override void _Draw() {
            CampusOwner?.DrawDebugGrid(this);
        }
    }
}