const mongoose = require("mongoose");

const adventureSchema = new mongoose.Schema({
  userID: { type: String, required: true, unique: true },
  userName: { type: String, default: "Unknown" },
  balance: { type: Number, default: 1000 },
  xp: { type: Number, default: 0 },
  level: { type: Number, default: 1 },
  energy: { type: Number, default: 100 },
  maxEnergy: { type: Number, default: 100 },
  lastAdvTime: { type: Number, default: 0 },
  title: { type: String, default: "novice" },
  bag: {
    sword: { type: Number, default: 0 },
    shield: { type: Number, default: 0 },
    ring: { type: Number, default: 0 },
    potion: { type: Number, default: 0 },
    boots: { type: Number, default: 0 },
    helmet: { type: Number, default: 0 },
    armor: { type: Number, default: 0 },
    spear: { type: Number, default: 0 },
    cloak: { type: Number, default: 0 },
    amulet: { type: Number, default: 0 }
  },
  dailyTasks: {
    advCount: { type: Number, default: 0 },
    winCount: { type: Number, default: 0 },
    claimedReward: { type: Boolean, default: false },
    lastReset: { type: Number, default: 0 }
  }
});

const AdventureUser = mongoose.models.DiabloAdventureUser || mongoose.model("DiabloAdventureUser", adventureSchema);

const SHOP = {
  sword: { name: "sword", emoji: "⚔️", price: 500000, boost: 5 },
  shield: { name: "shield", emoji: "🛡️", price: 300000, boost: 3 },
  ring: { name: "magic ring", emoji: "💍", price: 1000000, boost: 10 },
  potion: { name: "power potion", emoji: "🧪", price: 200000, boost: 2 },
  boots: { name: "swift boots", emoji: "👢", price: 150000, boost: 4 },
  helmet: { name: "elite helmet", emoji: "⛑️", price: 10000000, boost: 15 },
  armor: { name: "dragon armor", emoji: "🛡️", price: 25000000, boost: 20 },
  spear: { name: "god spear", emoji: "🔱", price: 50000000, boost: 30 },
  cloak: { name: "invisibility cloak", emoji: "👻", price: 75000000, boost: 25 },
  amulet: { name: "amulet of immortality", emoji: "📿", price: 100000000, boost: 50 }
};

const MISSIONS = [
  { name: "slay the dragon", emoji: "🐉", reward: 600000, xp: 350 },
  { name: "find hidden treasure", emoji: "💰", reward: 400000, xp: 250 },
  { name: "explore dark forest", emoji: "🌲", reward: 200000, xp: 150 },
  { name: "fight the demon", emoji: "👹", reward: 500000, xp: 300 },
  { name: "raid the museum", emoji: "🏛️", reward: 300000, xp: 200 },
  { name: "sea monster hunt", emoji: "🐙", reward: 700000, xp: 400 },
  { name: "battle in heaven", emoji: "⚡", reward: 900000, xp: 600 },
  { name: "rescue the princess", emoji: "👸", reward: 550000, xp: 320 },
  { name: "defend the castle", emoji: "🏰", reward: 480000, xp: 280 },
  { name: "hunt the werewolf", emoji: "🐺", reward: 380000, xp: 220 }
];

const TITLES = {
  1: "novice",
  5: "warrior",
  10: "knight",
  20: "lord",
  30: "dragon slayer",
  40: "legend",
  50: "champion",
  70: "elite",
  90: "mythic",
  100: "immortal"
};

module.exports = {
  config: {
    name: "adventure",
    aliases: ["adv"],
    version: "7.0.0",
    author: "protik shah",
    countDown: 5,
    role: 0,
    shortDescription: "adventure kingdom - rpg game",
    category: "game",
    guide: {
      en: "⚔️ {p}adventure\n🛒 {p}adv shop\n🎒 {p}adv bag\n📋 {p}adv task\n🏆 {p}adv lb"
    }
  },

  formatMoney: (num) => {
    if (num >= 1e9) return (num / 1e9).toFixed(1) + "B";
    if (num >= 1e6) return (num / 1e6).toFixed(1) + "M";
    if (num >= 1e3) return (num / 1e3).toFixed(1) + "K";
    return num.toString();
  },

  progressBar: (current, max, size = 15) => {
    const filled = Math.round((current / max) * size);
    const empty = size - filled;
    return "[" + "█".repeat(filled) + "░".repeat(empty) + "] " + current + "/" + max;
  },

  getTitle: (level) => {
    let title = "novice";
    for (const [lv, t] of Object.entries(TITLES)) {
      if (level >= parseInt(lv)) title = t;
    }
    return title;
  },

  regenEnergy: (user) => {
    const now = Date.now();
    const REGEN = 2 * 60 * 1000;
    const elapsed = now - (user.lastAdvTime || 0);
    const added = Math.floor(elapsed / REGEN);
    if (added > 0) {
      user.energy = Math.min(user.maxEnergy || 100, user.energy + added);
      user.lastAdvTime = now;
    }
  },

  checkDailyReset: (user) => {
    const now = Date.now();
    const ONE_DAY = 24 * 60 * 60 * 1000;
    if (!user.dailyTasks || now - user.dailyTasks.lastReset > ONE_DAY) {
      user.dailyTasks = {
        advCount: 0,
        winCount: 0,
        claimedReward: false,
        lastReset: now
      };
    }
  },

  onStart: async function ({ api, event, args, message }) {
    const sendMsg = (txt) => message?.reply ? message.reply(txt) : api.sendMessage(txt, event.threadID, event.messageID);
    const { senderID } = event;
    const sub = (args[0] || "").toLowerCase();

    try {
      let user = await AdventureUser.findOne({ userID: senderID });
      if (!user) {
        user = new AdventureUser({ userID: senderID });
        await user.save();
      }

      try {
        const info = await api.getUserInfo(senderID);
        user.userName = info[senderID]?.name || senderID;
        await user.save();
      } catch (e) {}

      this.regenEnergy(user);
      this.checkDailyReset(user);

      if (sub === "shop" || sub === "advshop") {
        const item = args.slice(1).join(" ").trim();
        if (!item) {
          let txt = "🛒 ══[ADVENTURE SHOP]══ 🛒\n\n";
          txt += `👤 ${user.userName}  |  💳 $${this.formatMoney(user.balance)}\n`;
          txt += `🏷️ ${user.title}  |  Lv.${user.level}\n\n`;
          for (const [key, info] of Object.entries(SHOP)) {
            const owned = user.bag[key] > 0 ? " ✅x" + user.bag[key] : "";
            txt += `${info.emoji} ${info.name}  $${this.formatMoney(info.price)}  +${info.boost}%${owned}\n`;
          }
          txt += `\n💡 BUY: {p}adv shop <item>`;
          return sendMsg(txt);
        }

        const matched = Object.keys(SHOP).find(k => k === item.toLowerCase());
        if (!matched) return sendMsg("❌ Item not found.");
        const info = SHOP[matched];
        if (user.balance < info.price) return sendMsg(`❌ Insufficient funds. Need $${this.formatMoney(info.price)}`);
        user.balance -= info.price;
        user.bag[matched] = (user.bag[matched] || 0) + 1;
        await user.save();
        return sendMsg(`🎉 Bought **${info.name}** x${user.bag[matched]}!`);
      }

      if (sub === "bag" || sub === "advbag") {
        let txt = "🎒═[ ADVENTURE BAG ]═🎒\n\n";
        let total = 0;
        for (const [key, amount] of Object.entries(user.bag)) {
          if (amount > 0) {
            const item = SHOP[key];
            txt += `${item.emoji} ${item.name}  x${amount}  (+${item.boost}%)\n`;
            total += amount;
          }
        }
        if (total === 0) txt += "🟡 Bag empty. Buy from shop!\n";
        txt += `\n📦 TOTAL ITEMS: ${total}`;
        return sendMsg(txt);
      }

      if (sub === "task" || sub === "advtask") {
        const task = user.dailyTasks;
        if (args[1] && args[1].toLowerCase() === "claim") {
          if (task.claimedReward) return sendMsg("❌ Already claimed today.");
          if (task.advCount < 5 || task.winCount < 3) return sendMsg("❌ Complete all tasks first.");
          const bonus = 5000000 * user.level;
          const bonusXP = 1000 * user.level;
          user.balance += bonus;
          user.xp += bonusXP;
          task.claimedReward = true;
          await user.save();
          return sendMsg(`🎁DAILY REWARD CLAIMED🎁\n\n💵 +$${this.formatMoney(bonus)}\n⭐ +${bonusXP} XP`);
        }

        let txt = "📋 DAILY ADVENTURE TASKS 📋\n\n";
        txt += `👤 ${user.userName}  |  Lv.${user.level}\n\n`;
        txt += `1. ⚔️ Adventure 5x : ${task.advCount >= 5 ? "✅" : "❌"}  [${task.advCount}/5]\n`;
        txt += `2. 🏆 Win 3x       : ${task.winCount >= 3 ? "✅" : "❌"}  [${task.winCount}/3]\n\n`;
        if (task.advCount >= 5 && task.winCount >= 3) {
          txt += task.claimedReward ? "🎉 Already claimed today!" : "🎁 Type `{p}adv task claim` to collect!";
        } else {
          txt += "💡 Complete all tasks to unlock reward!";
        }
        return sendMsg(txt);
      }

      if (sub === "lb" || sub === "leaderboard" || sub === "advlb") {
        const all = await AdventureUser.find({});
        const sorted = all
          .map(u => ({ ...u, userName: u.userName || u.userID }))
          .sort((a, b) => b.level - a.level || b.balance - a.balance)
          .slice(0, 10);

        let txt = "🏆 ═══[ ADVENTURE LEADERBOARD ]═══ 🏆\n\n";
        let rank = 1;
        for (const u of sorted) {
          const name = u.userName || u.userID;
          const medal = rank === 1 ? "🥇" : rank === 2 ? "🥈" : rank === 3 ? "🥉" : `#${rank}`;
          txt += `${medal} ${name.slice(0, 18)}  |  Lv.${u.level}  |  $${this.formatMoney(u.balance)}\n`;
          rank++;
        }
        if (rank === 1) txt += "🟡 No data found.";
        return sendMsg(txt);
      }

      if (user.energy < 1) {
        return sendMsg(`🔋 Out of energy \n⚡ ${this.progressBar(0, user.maxEnergy, 15)}\n⏳ Recharges 1 every 2 min.`);
      }

      let boost = 0;
      for (const [key, amount] of Object.entries(user.bag)) {
        if (amount > 0) boost += SHOP[key].boost * amount;
      }
      const multi = 1 + (boost / 100);
      const mission = MISSIONS[Math.floor(Math.random() * MISSIONS.length)];
      const win = Math.random() < 0.55;
      const rewardBase = mission.reward * multi;
      const xpBase = mission.xp * multi;
      const reward = win ? Math.floor(rewardBase * 0.75) : Math.floor(rewardBase * 0.25);
      const xp = win ? Math.floor(xpBase * 0.75) : Math.floor(xpBase * 0.25);

      user.energy -= 1;
      user.lastAdvTime = Date.now();
      user.balance += reward;
      user.xp += xp;
      user.dailyTasks.advCount += 1;
      if (win) user.dailyTasks.winCount += 1;

      let leveled = false;
      const reqXP = user.level * 500;
      if (user.xp >= reqXP) {
        user.level += 1;
        user.xp -= reqXP;
        user.maxEnergy += 5;
        user.energy = user.maxEnergy;
        user.title = this.getTitle(user.level);
        leveled = true;
      }

      await user.save();

      let msg = "⚔️═ADVENTURE RESULT═⚔️\n\n";
      msg += `${mission.emoji} Mission: **${mission.name}**\n`;
      msg += `🏆 Result: ${win ? "✅ Win" : "❌ Lost"}\n`;
      msg += `💰 Reward: +$${this.formatMoney(reward)} (boost: ${boost}%)\n`;
      msg += `⭐ XP: +${xp}\n`;
      msg += `⚡ Energy: ${this.progressBar(user.energy, user.maxEnergy, 15)}\n`;
      msg += `🏷️ Title: ${user.title}`;
      if (leveled) msg += `\n\n🎉 LEVEL UP Reached **Lv.${user.level}**! (Energy fully restored!)`;
      return sendMsg(msg);

    } catch (err) {
      console.error("Adventure Error:", err);
      return sendMsg("❌ Adventure error.");
    }
  }
};