const level = GwLevel.getPlayerLevel(player);
// 返回: String - 玩家等级

const success = GwLevel.setPlayerLevel(player, 10);
// 返回: Boolean - 是否成功

const success = GwLevel.addPlayerLevel(player, 5);
// 返回: Boolean - 是否成功

const success = GwLevel.reducePlayerLevel(player, 2);
// 返回: Boolean - 是否成功

const success = GwLevel.levelUp(player);
// 返回: Boolean - 是否成功升级

const exp = GwLevel.getPlayerExp(player);
// 返回: String - 当前经验值

const success = GwLevel.addPlayerExp(player, 100);
// 返回: Boolean - 是否成功

const success = GwLevel.reducePlayerExp(player, 50);
// 返回: Boolean - 是否成功

const success = GwLevel.setPlayerExp(player, 500);
// 返回: Boolean - 是否成功

const totalExp = GwLevel.getPlayerTotalExp(player);
// 返回: String - 总经验值

const required = GwLevel.getExpRequiredForNextLevel(player);
// 返回: String - 升级所需经验

const success = GwLevel.resetPlayerLevel(player);
// 返回: Boolean - 是否成功

const success = GwLevel.resetAllPlayerData();
// 返回: Boolean - 是否成功

const success = GwLevel.removePlayerData(player);
// 返回: Boolean - 是否成功

// 获取当前配置
const config = GwLevel.getConfig();
console.log(config);
/* 返回:
{
    baseExpToLevelUp: 100,
    expIncreaseRate: 1.1,
    maxLevel: 100,
    saveIntervalMinutes: 5,
    enableModSystem: true,
    manualLevelUp: false,
    PAPI: true
}
*/

// 更新配置
const newConfig = {
    maxLevel: 200,
    expIncreaseRate: 1.2,
    manualLevelUp: true
};
GwLevel.updateConfig(newConfig);

// 重新加载配置文件
GwLevel.reloadConfig();

// 手动保存所有玩家数据
GwLevel.saveAllData();

const exists = GwLevel.playerExists(player);
// 返回: Boolean - 是否存在

const data = GwLevel.getPlayerData(player);
/* 返回:
{
    name: "PlayerName",
    level: 10,
    exp: 250,
    totalExp: 1500,
    lastOnline: 1234567890000
}
*/

const allData = GwLevel.getAllPlayerData();
// 返回: Object - 所有玩家数据的映射表 { xuid: playerData }

const progress = GwLevel.getPlayerLevelProgress(player);
// 返回: String - 进度百分比 (0-100)

// 获取等级排行榜前10名
const topByLevel = GwLevel.getTopPlayers(10, "level");

// 获取总经验排行榜前10名
const topByExp = GwLevel.getTopPlayers(10, "totalExp");

/* 返回格式:
[
    {
        xuid: "1234567890",
        name: "Player1",
        level: 50,
        exp: 1200,
        totalExp: 45000
    },
    ...
]
*/

// 获取等级排名
const levelRank = GwLevel.getPlayerRank(player, "level");

// 获取经验排名
const expRank = GwLevel.getPlayerRank(player, "exp");

// 获取总经验排名
const totalExpRank = GwLevel.getPlayerRank(player, "totalExp");

// 返回: Number - 排名（从1开始），如果玩家不存在返回 -1

// 查询 20-30 级的玩家
const midLevelPlayers = GwLevel.getPlayersByLevelRange(20, 30);

// 查询 50 级以上的玩家
const highLevelPlayers = GwLevel.getPlayersByLevelRange(50, 100);

const distribution = GwLevel.getLevelDistribution();
/* 返回格式:
{
    "1": 15,   // 1级有15个玩家
    "2": 8,    // 2级有8个玩家
    "3": 12,
    ...
}
*/

const players = mc.getOnlinePlayers();
const success = GwLevel.batchSetLevel(players, 20);
// 返回: Boolean - 是否成功

const players = mc.getOnlinePlayers();
const success = GwLevel.batchAddExp(players, 100);
// 返回: Boolean - 是否成功

// 全服奖励
GwLevel.addExpToAllOnline(500);
mc.broadcast("§a全服玩家获得 500 经验奖励！");

// 获取指定等级所需的经验
const expForLevel10 = GwLevel.getExpForLevel(10);

// 计算累计到某等级需要的总经验
const totalExpToLevel50 = GwLevel.getTotalExpToLevel(50);

// 根据总经验计算等级
const result = GwLevel.getLevelByExp(5000);
// 返回: { level: 15, currentExp: 250 }

// 设置系统参数
GwLevel.setMaxLevel(200);           // 设置最大等级
GwLevel.setExpIncreaseRate(1.2);    // 设置经验增长率
GwLevel.setBaseExp(150);            // 设置基础经验值

GwLevel.on("beforeExpAdd", (data) => {
    // data.player - 玩家对象
    // data.xuid - 玩家 XUID
    // data.amount - 即将获得的经验值（可修改）
    // data.currentExp - 当前经验
    // data.currentLevel - 当前等级
    
    // 示例：VIP 双倍经验
    const player = data.player;
    if (player.hasTag("vip")) {
        data.amount *= 2;
        player.tell("§6VIP 双倍经验生效！");
    }
    
    // 返回 false 阻止获得经验
    return true;
});

GwLevel.on("afterExpAdd", (data) => {
    // data.player - 玩家对象
    // data.xuid - 玩家 XUID
    // data.addedAmount - 实际添加的经验值
    // data.currentExp - 当前经验
    // data.currentLevel - 当前等级
    // data.levelChanged - 是否发生了升级
    
    const player = data.player;
    
    // 经验获取提示
    player.tell(`§a+${data.addedAmount} 经验`, 5);
    
    // 播放音效
    player.playSound("random.orb");
});

GwLevel.on("beforeExpReduce", (data) => {
    const player = data.player;
    
    // 死亡保护符
    if (player.hasTag("death_protection")) {
        player.tell("§a死亡保护符生效，免除经验损失！");
        player.removeTag("death_protection");
        return false; // 阻止经验减少
    }
    
    // 减少惩罚
    if (player.hasTag("reduce_penalty")) {
        data.amount = Math.floor(data.amount * 0.5); // 减半惩罚
    }
    
    return true;
});

// 设置前
GwLevel.on("beforeExpSet", (data) => {
    // 记录日志
    logger.log(`设置玩家 ${data.xuid} 经验: ${data.currentExp} -> ${data.amount}`);
    return true;
});

// 设置后
GwLevel.on("afterExpSet", (data) => {
    // data.previousExp - 之前的经验值
    // data.currentExp - 当前的经验值
    
    if (data.currentExp > data.previousExp) {
        const gained = data.currentExp - data.previousExp;
        data.player.tell(`§a经验增加 ${gained}`);
    }
});

GwLevel.on("onLevelUp", (data) => {
    const { player, xuid, newLevel, oldLevel } = data;
    
    // 升级特效
    mc.spawnParticle(player.pos, "minecraft:totem_particle");
    player.playSound("random.levelup");
    
    // 升级奖励
    const levelRewards = {
        10: { item: "minecraft:diamond", count: 5 },
        20: { item: "minecraft:netherite_ingot", count: 1 },
        30: { item: "minecraft:elytra", count: 1 },
        50: { item: "minecraft:beacon", count: 1 }
    };
    
    const reward = levelRewards[newLevel];
    if (reward) {
        player.giveItem(mc.newItem(reward.item, reward.count));
        player.tell(`§6恭喜达到 ${newLevel} 级！获得特殊奖励！`);
    }
    
    // 全服公告
    if (newLevel % 10 === 0) {
        mc.broadcast(`§e玩家 §b${player.name} §e升级到了 §6${newLevel} §e级！`);
    }
});

GwLevel.on("beforeLevelChange", (data) => {
    const { player, xuid, newLevel, oldLevel } = data;
    
    // 防止等级倒退
    if (newLevel < oldLevel && !player.isOP()) {
        player.tell("§c等级不能倒退！");
        return false;
    }
    
    return true;
});

GwLevel.on("afterLevelChange", (data) => {
    const { player, newLevel, oldLevel } = data;
    
    if (newLevel > oldLevel) {
        player.tell(`§a等级提升至 ${newLevel} 级！`);
    } else {
        player.tell(`§c等级降至 ${newLevel} 级`);
    }
});

GwLevel.on("beforeLevelAdd", (data) => {
    // 可以修改增加的等级数
    if (data.player.hasTag("double_level")) {
        data.levels *= 2;
        data.player.tell("§6双倍等级加成生效！");
    }
    return true;
});

GwLevel.on("beforeReset", (data) => {
    const { player, xuid } = data;
    
    // 保存重置前的数据
    const currentData = GwLevel.getPlayerData(xuid);
    player.setExtraData("lastLevelData", currentData);
    
    return true;
});

GwLevel.on("afterReset", (data) => {
    const { player, xuid } = data;
    player.tell("§c您的等级数据已被重置");
    
    // 给予补偿
    player.giveItem(mc.newItem("minecraft:experience_bottle", 64));
});

GwLevel.on("onConfigUpdate", (data) => {
    const { oldConfig, newConfig } = data;
    
    // 检测关键配置变化
    if (oldConfig.maxLevel !== newConfig.maxLevel) {
        mc.broadcast(`§e最高等级已调整为 ${newConfig.maxLevel} 级`);
    }
    
    if (oldConfig.manualLevelUp !== newConfig.manualLevelUp) {
        const mode = newConfig.manualLevelUp ? "手动" : "自动";
        mc.broadcast(`§e升级模式已切换为${mode}升级`);
    }
    
    logger.log("配置已更新", newConfig);
});

GwLevel.on("beforeResetAll", (data) => {
    // 发送警告
    mc.broadcast("§4警告：服务器等级数据将在 10 秒后重置！");
    
    // 可以返回 false 阻止重置
    return true;
});

GwLevel.on("afterResetAll", (data) => {
    mc.broadcast("§a服务器等级数据已重置，所有玩家重新开始！");
    
    // 给所有在线玩家补偿
    mc.getOnlinePlayers().forEach(player => {
        player.giveItem(mc.newItem("minecraft:diamond", 10));
        player.tell("§a您获得了重置补偿");
    });
});

GwLevel.on("beforeRemove", (data) => {
    const { player, xuid } = data;
    
    // 记录删除日志
    logger.warn(`准备删除玩家数据: ${xuid}`);
    
    return true;
});

GwLevel.on("afterRemove", (data) => {
    logger.log(`玩家数据已删除: ${data.xuid}`);
});

{
    "baseExpToLevelUp": 100,
    "expIncreaseRate": 1.1,
    "maxLevel": 100,
    "saveIntervalMinutes": 5,
    "enableModSystem": true,
    "manualLevelUp": false,
    "PAPI": true
}

GwLevel.registerMainFormButton({
    text: "按钮文本",
    image: "图标路径", // 可选
    id: "唯一标识符", // 可选，自动生成
    requireOP: false, // 是否需要 OP 权限
    permissionCheck: (player) => { // 自定义权限检查
        return player.hasTag("vip");
    },
    callback: (player) => {
        // 按钮点击处理
    }
});

// 在其他地方调用主表单
GwLevel.showMainForm(player);

// 基础击杀经验系统
mc.listen("onMobDie", (mob, source) => {
    if (!source || !source.isPlayer()) return;
    
    const player = source.toPlayer();
    let exp = 10; // 默认经验
    
    // 根据怪物类型给予不同经验
    const mobExp = {
        "minecraft:zombie": 15,
        "minecraft:skeleton": 20,
        "minecraft:creeper": 25,
        "minecraft:enderman": 30,
        "minecraft:witch": 35,
        "minecraft:blaze": 40,
        "minecraft:wither_skeleton": 50,
        "minecraft:wither": 500,
        "minecraft:ender_dragon": 1000
    };
    
    if (mobExp[mob.type]) {
        exp = mobExp[mob.type];
    }
    
    // 添加经验
    GwLevel.addPlayerExp(player, exp);
    
    // 显示获得的经验
    player.tell(`§a+${exp} 经验`, 5);
});

// 挖矿经验系统
mc.listen("onDestroyBlock", (player, block) => {
    const blockExp = {
        // 矿石类
        "minecraft:coal_ore": 5,
        "minecraft:deepslate_coal_ore": 5,
        "minecraft:iron_ore": 10,
        "minecraft:deepslate_iron_ore": 10,
        "minecraft:copper_ore": 8,
        "minecraft:deepslate_copper_ore": 8,
        "minecraft:gold_ore": 15,
        "minecraft:deepslate_gold_ore": 15,
        "minecraft:redstone_ore": 12,
        "minecraft:deepslate_redstone_ore": 12,
        "minecraft:emerald_ore": 50,
        "minecraft:deepslate_emerald_ore": 50,
        "minecraft:lapis_ore": 20,
        "minecraft:deepslate_lapis_ore": 20,
        "minecraft:diamond_ore": 100,
        "minecraft:deepslate_diamond_ore": 100,
        "minecraft:ancient_debris": 200,
        
        // 木头类（少量经验）
        "minecraft:oak_log": 1,
        "minecraft:birch_log": 1,
        "minecraft:spruce_log": 1,
        "minecraft:jungle_log": 1,
        "minecraft:acacia_log": 1,
        "minecraft:dark_oak_log": 1
    };
    
    const exp = blockExp[block.type];
    if (exp) {
        GwLevel.addPlayerExp(player, exp);
        
        // 在方块位置显示经验
        player.tell(`§a+${exp} 经验`, 5);
        
        // 生成经验球特效
        mc.spawnParticle(block.pos, "minecraft:totem_particle");
    }
});

// 等级称号系统
const levelTitles = [
    { min: 1, max: 9, title: "§7新手", color: "§7" },
    { min: 10, max: 19, title: "§f学徒", color: "§f" },
    { min: 20, max: 29, title: "§a熟练", color: "§a" },
    { min: 30, max: 39, title: "§b专家", color: "§b" },
    { min: 40, max: 49, title: "§d大师", color: "§d" },
    { min: 50, max: 69, title: "§6宗师", color: "§6" },
    { min: 70, max: 89, title: "§c传奇", color: "§c" },
    { min: 90, max: 99, title: "§5史诗", color: "§5" },
    { min: 100, max: 100, title: "§4§l神话", color: "§4§l" }
];

// 获取玩家称号
function getPlayerTitle(level) {
    const title = levelTitles.find(t => level >= t.min && level <= t.max);
    return title || levelTitles[0];
}

// 更新玩家称号显示
function updatePlayerTitle(player) {
    const level = parseInt(GwLevel.getPlayerLevel(player));
    const title = getPlayerTitle(level);
    
    // 设置名称标签
    player.rename(`${title.color}[${title.title}] §r${player.realName}`);
}

// 玩家加入时更新称号
mc.listen("onJoin", (player) => {
    setTimeout(() => updatePlayerTitle(player), 1000);
});

// 升级时更新称号
GwLevel.on("onLevelUp", (data) => {
    const player = data.player;
    const newTitle = getPlayerTitle(data.newLevel);
    const oldTitle = getPlayerTitle(data.oldLevel);
    
    if (newTitle.title !== oldTitle.title) {
        player.tell(`§6恭喜！您获得了新称号: ${newTitle.color}${newTitle.title}`);
        mc.broadcast(`§e玩家 §b${player.name} §e获得了称号 ${newTitle.color}${newTitle.title}`);
    }
    
    updatePlayerTitle(player);
});

// 死亡惩罚配置
const deathPenalty = {
    expLossPercent: 10, // 损失 10% 经验
    protectionItems: [
        "minecraft:totem_of_undying", // 不死图腾
        "minecraft:golden_apple", // 金苹果保护
    ]
};

mc.listen("onPlayerDie", (player, source) => {
    // 检查保护物品
    const inventory = player.getInventory();
    let hasProtection = false;
    
    for (let i = 0; i < inventory.size; i++) {
        const item = inventory.getItem(i);
        if (item && deathPenalty.protectionItems.includes(item.type)) {
            hasProtection = true;
            // 消耗保护物品
            if (item.count > 1) {
                item.count--;
                inventory.setItem(i, item);
            } else {
                inventory.removeItem(i, 1);
            }
            break;
        }
    }
    
    if (hasProtection) {
        player.tell("§a死亡保护生效！免除经验损失");
        return;
    }
    
    // 计算经验损失
    const currentExp = parseInt(GwLevel.getPlayerExp(player));
    const expLoss = Math.floor(currentExp * deathPenalty.expLossPercent / 100);
    
    if (expLoss > 0) {
        GwLevel.reducePlayerExp(player, expLoss);
        player.tell(`§c死亡惩罚：损失 ${expLoss} 经验 (${deathPenalty.expLossPercent}%)`);
    }
});

// 等级权限系统
const levelPermissions = {
    commands: {
        "/home": 5,
        "/back": 10,
        "/tpa": 15,
        "/fly": 30,
        "/god": 50
    },
    areas: {
        "vip_mine": 20,
        "end_portal": 25,
        "boss_arena": 40
    },
    items: {
        "minecraft:elytra": 30,
        "minecraft:netherite_sword": 25,
        "minecraft:totem_of_undying": 20
    }
};

// 命令权限检查
mc.listen("onPlayerCmd", (player, cmd) => {
    const cmdName = cmd.split(" ")[0].toLowerCase();
    const requiredLevel = levelPermissions.commands[cmdName];
    
    if (requiredLevel) {
        const playerLevel = parseInt(GwLevel.getPlayerLevel(player));
        if (playerLevel < requiredLevel) {
            player.tell(`§c此命令需要等级 ${requiredLevel} 才能使用！`);
            player.tell(`§e您当前等级: ${playerLevel}`);
            return false; // 阻止命令执行
        }
    }
});

// 区域进入权限(实际没有onMove事件，此处仅举例)
mc.listen("onMove", (player) => {
    const pos = player.blockPos;
    
    // 检查特殊区域（示例）
    if (pos.x >= 1000 && pos.x <= 1100 && 
        pos.z >= 1000 && pos.z <= 1100) {
        const requiredLevel = levelPermissions.areas["vip_mine"];
        const playerLevel = parseInt(GwLevel.getPlayerLevel(player));
        
        if (playerLevel < requiredLevel) {
            player.tell(`§c此区域需要等级 ${requiredLevel} 才能进入！`);
            // 传送回出生点
            player.teleport(mc.getWorldSpawn());
        }
    }
});

// 物品使用权限
mc.listen("onUseItem", (player, item) => {
    const requiredLevel = levelPermissions.items[item.type];
    
    if (requiredLevel) {
        const playerLevel = parseInt(GwLevel.getPlayerLevel(player));
        if (playerLevel < requiredLevel) {
            player.tell(`§c使用 ${item.name} 需要等级 ${requiredLevel}！`);
            return false; // 阻止使用
        }
    }
});

// 转生系统
const rebirthSystem = {
    maxRebirth: 10, // 最大转生次数
    requiredLevel: 100, // 转生需要的等级
    
    // 获取玩家转生次数
    getRebirthCount(player) {
        return player.getExtraData("rebirth_count") || 0;
    },
    
    // 设置转生次数
    setRebirthCount(player, count) {
        player.setExtraData("rebirth_count", count);
    },
    
    // 检查是否可以转生
    canRebirth(player) {
        const level = parseInt(GwLevel.getPlayerLevel(player));
        const rebirthCount = this.getRebirthCount(player);
        
        return level >= this.requiredLevel && rebirthCount < this.maxRebirth;
    },
    
    // 执行转生
    doRebirth(player) {
        if (!this.canRebirth(player)) {
            return false;
        }
        
        const rebirthCount = this.getRebirthCount(player);
        const newRebirthCount = rebirthCount + 1;
        
        // 重置等级
        GwLevel.resetPlayerLevel(player);
        
        // 增加转生次数
        this.setRebirthCount(player, newRebirthCount);
        
        // 给予转生奖励
        this.giveRebirthRewards(player, newRebirthCount);
        
        // 更新称号
        player.rename(`§6[转生${newRebirthCount}] §r${player.realName}`);
        
        // 全服公告
        mc.broadcast(`§6恭喜玩家 §e${player.name} §6完成第 §c${newRebirthCount} §6次转生！`);
        
        // 特效
        mc.spawnParticle(player.pos, "minecraft:huge_explosion_emitter");
        player.playSound("random.levelup");
        
        return true;
    },
    
    // 转生奖励
    giveRebirthRewards(player, rebirthCount) {
        // 基础奖励
        player.giveItem(mc.newItem("minecraft:nether_star", rebirthCount));
        
        // 转生特殊奖励
        const rewards = {
            1: { item: "minecraft:diamond_block", count: 10 },
            2: { item: "minecraft:netherite_ingot", count: 5 },
            3: { item: "minecraft:enchanted_golden_apple", count: 3 },
            5: { item: "minecraft:beacon", count: 1 },
            10: { item: "minecraft:dragon_egg", count: 1 }
        };
        
        const reward = rewards[rebirthCount];
        if (reward) {
            player.giveItem(mc.newItem(reward.item, reward.count));
            player.tell(`§a转生特殊奖励: ${reward.count}x ${reward.item}`);
        }
        
        // 永久增益标签
        player.addTag(`rebirth_${rebirthCount}`);
    },
    
    // 显示转生界面
    showRebirthMenu(player) {
        const form = mc.newSimpleForm();
        form.setTitle("§6转生系统");
        
        const level = parseInt(GwLevel.getPlayerLevel(player));
        const rebirthCount = this.getRebirthCount(player);
        
        let content = `§e当前转生次数: §c${rebirthCount}§7/${this.maxRebirth}\n`;
        content += `§e当前等级: §a${level}\n\n`;
        
        if (this.canRebirth(player)) {
            content += "§a您已满足转生条件！\n";
            content += "§7转生后将重置等级，但获得永久加成和奖励\n";
            form.addButton("§6确认转生");
        } else {
            if (level < this.requiredLevel) {
                content += `§c需要达到 ${this.requiredLevel} 级才能转生\n`;
            }
            if (rebirthCount >= this.maxRebirth) {
                content += "§c您已达到最大转生次数\n";
            }
        }
        
        content += "\n§b转生加成:\n";
        content += `§7• 经验获取 +${rebirthCount * 10}%\n`;
        content += `§7• 攻击力 +${rebirthCount * 5}%\n`;
        content += `§7• 生命值 +${rebirthCount * 2}\n`;
        
        form.setContent(content);
        form.addButton("§c关闭");
        
        player.sendForm(form, (player, id) => {
            if (id === 0 && this.canRebirth(player)) {
                this.showConfirmRebirth(player);
            }
        });
    },
    
    // 确认转生
    showConfirmRebirth(player) {
        const form = mc.newSimpleForm();
        form.setTitle("§c确认转生");
        form.setContent("§c警告：转生将重置您的等级为1级！\n§e但您将获得永久加成和丰厚奖励\n\n§6确定要转生吗？");
        form.addButton("§a确认转生");
        form.addButton("§c取消");
        
        player.sendForm(form, (player, id) => {
            if (id === 0) {
                this.doRebirth(player);
            }
        });
    }
};

// 注册转生按钮
API.registerMainFormButton({
    text: "§6转生系统",
    image: "textures/items/nether_star.png",
    callback: (player) => {
        rebirthSystem.showRebirthMenu(player);
    }
});

// 转生加成
API.on("beforeExpAdd", (data) => {
    const rebirthCount = rebirthSystem.getRebirthCount(data.player);
    if (rebirthCount > 0) {
        // 每次转生增加 10% 经验获取
        data.amount = Math.floor(data.amount * (1 + rebirthCount * 0.1));
    }
});