// ❌ 多线程下的灾难场景
// 线程 A: if (block.type == AIR) { block.type = STONE }
// 线程 B: if (block.type == AIR) { block.type = DIRT }
// 结果: 两边都认为可以放置，数据被覆盖

// ❌ Bad: 每次存取都重新计算电网拓扑
fun getItemFromCloudWarehouse(player: Player, item: Material): ItemStack? {
    // 每次 DFS 遍历整个电网 —— O(n) 复杂度
    val grid = recalculateGrid(player.currentGridId)
    return grid.cores.firstNotNullOfOrNull { core ->
        core.inventory.findItem(item)
    }
}

// ✅ Good: 缓存电网对象
val gridCache = ConcurrentHashMap<String, PowerGrid>()

fun getItemFromCloudWarehouse(player: Player, item: Material): ItemStack? {
    // O(1) 查找，微秒级完成
    val grid = gridCache[player.currentGridId] ?: return null
    return grid.getItem(item)
}

// 仅在电网结构变更时才重新计算
fun onGridStructureChanged(gridId: String) {
    val newGrid = recalculateGrid(gridId)
    gridCache[gridId] = newGrid
}

// ❌ Bad: 每次查询都创建新列表
fun getMachinesInRange(position: Location, radius: Int): List<Machine> {
    val result = mutableListOf<Machine>() // 每次调用都分配新对象！
    for (machine in allMachines) {
        if (machine.position.distance(position) <= radius) {
            result.add(machine)
        }
    }
    return result
}

// 如果这个方法每 Tick 被调用 50 次，每次创建 100 个元素的列表...
// 结果: 每秒产生 5000 个临时 List 对象 → GC 压力爆炸

// ✅ Good: 使用空间索引，避免临时对象创建
class SpatialIndex(val cellSize: Int = 16) {
    private val cells = mutableMapOf<Long, MutableList<Machine>>()

    fun addMachine(machine: Machine) {
        val key = machine.position.toCellKey(cellSize)
        cells.getOrPut(key) { mutableListOf() }.add(machine)
    }

    fun getNearbyMachines(position: Location, radius: Int): List<Machine> {
        val cellKey = position.toCellKey(cellSize)
        val nearbyCells = getNeighborCells(cellKey, radius / cellSize)
        // 返回已有列表的视图，不创建新对象
        return nearbyCells.flatMap { it.value }
    }

    private fun getNeighborCells(centerKey: Long, range: Int): List<MutableList<Machine>> {
        val result = mutableListOf<MutableList<Machine>>()
        val (cx, cy) = decodeCellKey(centerKey)
        for (dx in -range..range) {
            for (dy in -range..range) {
                cells[encodeCellKey(cx + dx, cy + dy)]?.let { result.add(it) }
            }
        }
        return result
    }
}

// ❌ Bad: 在主线程保存配置
fun saveGridConfig(grid: PowerGrid) {
    val json = grid.toJson()
    File("grids/${grid.id}.json").writeText(json) // 阻塞主线程 5-50ms！
}

// 当电网有 100+ 个节点时，序列化 + 写入可能耗时 30ms+
// 如果同时保存 10 个电网... 主线程直接卡死

// ✅ Good: 异步保存 + 批量写入
class GridPersistenceManager(private val plugin: JavaPlugin) {

    private val saveQueue = ConcurrentLinkedQueue<PowerGrid>()
    private val saveExecutor = Executors.newSingleThreadExecutor {
        Thread(it, "pylon-grid-saver")
    }

    fun scheduleSave(grid: PowerGrid) {
        saveQueue.add(grid)
    }

    init {
        object : BukkitRunnable() {
            override fun run() {
                val gridsToSave = mutableListOf<PowerGrid>()
                // 批量取出待保存的电网（最多 100 个）
                while (saveQueue.isNotEmpty() && gridsToSave.size < 100) {
                    saveQueue.poll()?.let { gridsToSave.add(it) }
                }
                if (gridsToSave.isNotEmpty()) {
                    // 提交到独立线程执行，不阻塞主线程
                    saveExecutor.submit { batchSave(gridsToSave) }
                }
            }
        }.runTaskTimer(plugin, 600, 600) // 每 30 秒（600 tick）执行一次
    }

    private fun batchSave(grids: List<PowerGrid>) {
        try {
            for (grid in grids) {
                File("grids/${grid.id}.json").writeText(grid.toJson())
            }
        } catch (e: Exception) {
            plugin.logger.warning("批量保存电网配置失败: ${e.message}")
        }
    }
}

// ❌ Bad: 细粒度锁导致死锁
class PowerGrid {
    private val machines = mutableListOf<Machine>()
    private val cores = mutableListOf<Core>()
    private val machinesLock = Any()
    private val coresLock = Any()

    fun addMachine(machine: Machine) {
        synchronized(machinesLock) {
            machines.add(machine)
            // 尝试获取另一个锁 —— 死锁风险！
            synchronized(coresLock) {
                redistributePower()
            }
        }
    }

    fun removeCore(core: Core) {
        synchronized(coresLock) {
            cores.remove(core)
            synchronized(machinesLock) { updateConnections() } // 反向加锁顺序！
        }
    }
}

// 死锁场景:
// 线程 A: addMachine() -> 持有 machinesLock -> 等待 coresLock
// 线程 B: removeCore() -> 持有 coresLock -> 等待 machinesLock
// 结果: 永久等待，服务器卡死

// ✅ Good: 粗粒度锁 + 不可变数据结构
data class GridState(
    val machines: Map<String, Machine>,
    val cores: Map<String, Core>,
    val connections: Set<Pair<String, String>>
)

class PowerGrid(private val initialState: GridState) {
    private val lock = ReentrantReadWriteLock()
    @Volatile private var state = initialState

    fun updateMachine(machineId: String, updater: (Machine) -> Machine): Boolean {
        return lock.writeLock().withLock {
            val newMachine = updater(state[machines[machineId]] ?: return@withLock false)
            val newState = state.copy(
                machines = state.machines + (machineId to newMachine)
            )
            state = newState
            true
        }
    }

    fun getMachines(): Map<String, Machine> {
        return lock.readLock().withLock { state.machines } // 读不阻塞读
    }
}

/spark tping           # 查看 TPS 和各维度延迟
/spark profiler         # 开启性能分析器（采样 10 秒）
/spark profiler --stop  # 查看分析报告
/spark heapsummary      # 查看内存占用分布
/spark clientinfo       # 查看客户端性能信息

inline fun measureTime(operationName: String, block: () -> Unit) {
    val startTime = System.nanoTime()
    block()
    val durationMs = (System.nanoTime() - startTime) / 1_000_000
    if (durationMs > 5) {
        plugin.logger.warning("[PERF] 慢操作警告: $operationName 耗时 ${durationMs}ms")
    }
}

// 使用示例
measureTime("电网能量分发") {
    distributeEnergyToAllMachines(grid)
}