const { SlashCommandBuilder, EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, StringSelectMenuBuilder } = require('discord.js');
const User = require('../models/User');
const Asset = require('../models/Asset');
const LotterySettings = require('../models/LotterySettings');

const cooldowns = new Set();

const translations = {
  types: {
    mask: 'Masque',
    background: 'Fond',
    border: 'Bordure'
  },
  rarities: {
    common: 'Commun',
    rare: 'Rare',
    epic: 'Épique',
    legendary: 'Légendaire'
  }
};

module.exports = {
  data: new SlashCommandBuilder()
    .setName('fragment8')
    .setDescription('Ajoutez un fragment de votre inventaire à vos assets'),

  async execute(interaction) {
    try {
      if (cooldowns.has(interaction.user.id)) {
        return interaction.reply({ content: 'Veuillez patienter une minute avant de réutiliser cette commande.', ephemeral: true });
      }
      cooldowns.add(interaction.user.id);
      setTimeout(() => cooldowns.delete(interaction.user.id), 20000);

      const user = await User.findOne({ discordId: interaction.user.id }).populate('fragments.asset');
      if (!user) {
        return interaction.reply({ content: 'Vous n\'êtes pas inscrit.', ephemeral: true });
      }

      if (user.fragments.length === 0) {
        return interaction.reply({ content: 'Vous n\'avez aucun fragment dans votre inventaire.', ephemeral: true });
      }

      const menuOptions = user.fragments.map((fragment) => ({
        label: `${fragment.asset.name} (${fragment.quantity})`,
        description: `Type: ${translations.types[fragment.asset.type]}, Rareté: ${translations.rarities[fragment.asset.rarity]}`,
        value: `${fragment.asset._id}`
      }));

      const selectMenu = new StringSelectMenuBuilder()
        .setCustomId('select_fragment')
        .setPlaceholder('Sélectionnez un fragment')
        .addOptions(menuOptions);

      const row = new ActionRowBuilder().addComponents(selectMenu);

      const embed = new EmbedBuilder()
        .setColor('#FFD700')
        .setTitle('🧩 Sélectionnez un Fragment 🧩')
        .setDescription('Veuillez sélectionner un fragment dans le menu déroulant ci-dessous:');

      await interaction.reply({ embeds: [embed], components: [row], ephemeral: true });

      const filter = i => i.customId === 'select_fragment' && i.user.id === interaction.user.id;
      const collector = interaction.channel.createMessageComponentCollector({ filter, time: 60000 });

      collector.on('collect', async i => {
        const selectedAssetId = i.values[0];
        const selectedFragment = user.fragments.find(fragment => fragment.asset._id.toString() === selectedAssetId);

        if (!selectedFragment) {
          return i.reply({ content: 'Fragment sélectionné introuvable.', ephemeral: true });
        }

        const asset = selectedFragment.asset;
        const settings = await LotterySettings.findOne();
        if (!settings) {
          return i.reply({ content: 'Paramètres de loterie introuvables.', ephemeral: true });
        }

        const rarity = asset.rarity.toLowerCase();
        const coinCost = settings.coinCosts[rarity];
        const finalCost = coinCost; // Pas de remise basée sur les fragments possédés
        const alreadyOwned = user.inventory.masks.includes(asset._id) || user.inventory.backgrounds.includes(asset._id) || user.inventory.borders.includes(asset._id);

        const actionRow = new ActionRowBuilder()
          .addComponents(
            new ButtonBuilder()
              .setCustomId(`achat_${selectedFragment._id}`)
              .setLabel(`Acheter (${coinCost} Inquicoins)`)
              .setStyle(ButtonStyle.Primary)
              .setDisabled(alreadyOwned),
            new ButtonBuilder()
              .setCustomId(`craft_${selectedFragment._id}`)
              .setLabel('Craft')
              .setStyle(ButtonStyle.Primary)
              .setDisabled(alreadyOwned),
            new ButtonBuilder()
              .setCustomId(`desenchanter_${selectedFragment._id}`)
              .setLabel('Désenchanter')
              .setStyle(ButtonStyle.Primary)
          );

        const updatedEmbed = new EmbedBuilder()
          .setColor('#FFD700')
          .setTitle(asset.name)
          .setDescription(
            `**Type:** ${translations.types[asset.type]}\n**Rareté:** ${translations.rarities[asset.rarity]}\n**Quantité de fragments:** ${selectedFragment.quantity}\n${alreadyOwned ? "Vous possédez déjà cet élément, que diriez-vous de le désenchanter ?" : ""}`
          )
          .setImage(asset.url); // Assurez-vous que l'URL de l'image est correcte dans votre modèle d'Asset

        await i.update({ embeds: [updatedEmbed], components: [actionRow], ephemeral: true });
      });

      collector.on('end', async () => {
        row.components.forEach(component => component.setDisabled(true));
        await interaction.editReply({ components: [row] });
      });

      // Gestion des interactions pour les boutons
      const buttonFilter = i => i.customId.startsWith('achat_') || i.customId.startsWith('craft_') || i.customId.startsWith('desenchanter_');
      const buttonCollector = interaction.channel.createMessageComponentCollector({ buttonFilter, time: 60000 });

      buttonCollector.on('collect', async i => {
        const [action, fragmentId] = i.customId.split('_');
        const fragment = user.fragments.id(fragmentId);

        //if (!fragment) {
          //return i.reply({ content: 'Fragment introuvable.', ephemeral: true });
        //}

        if (action === 'achat') {
          await handleAchat(i, user, fragment);
        } else if (action === 'craft') {
          await handleCraft(i, user, fragment);
        } else if (action === 'desenchanter') {
          await handleDesenchanter(i, user, fragment);
        }
      });

    } catch (error) {
      console.error('Error in executing command:', error);
      return interaction.reply({ content: 'Une erreur est survenue lors de l\'exécution de la commande.', ephemeral: true });
    }
  }
};

async function handleAchat(interaction, user, fragment) {
  try {
    const asset = await Asset.findById(fragment.asset._id);
    if (!asset) {
      return interaction.reply({ content: 'Asset introuvable.', ephemeral: true });
    }

    const settings = await LotterySettings.findOne();
    if (!settings) {
      return interaction.reply({ content: 'Paramètres de loterie introuvables.', ephemeral: true });
    }

    const rarity = asset.rarity.toLowerCase();
    const coinCost = settings.coinCosts[rarity];
    const finalCost = coinCost;

    if (user.inventory.masks.includes(asset._id) || user.inventory.backgrounds.includes(asset._id) || user.inventory.borders.includes(asset._id)) {
      return interaction.reply({ content: `L'asset ${asset.name} est déjà dans votre inventaire.`, ephemeral: true });
    }

    if (user.inquicoins < finalCost) {
      return interaction.reply({ content: 'Vous n\'avez pas assez d\'Inquicoins pour acheter cet asset.', ephemeral: true });
    }

    user.inquicoins -= finalCost;
    fragment.quantity -= 1;
    if (fragment.quantity <= 0) {
      user.fragments.id(fragment._id).remove();
    }

    switch (asset.type) {
      case 'mask':
        user.inventory.masks.push(asset._id);
        break;
      case 'background':
        user.inventory.backgrounds.push(asset._id);
        break;
      case 'border':
        user.inventory.borders.push(asset._id);
        break;
      default:
        return interaction.reply({ content: 'Type d\'asset non supporté.', ephemeral: true });
    }

    await user.save();

    const embed = new EmbedBuilder()
      .setColor('#00FF00')
      .setTitle('✅ Achat Réussi ✅')
      .setDescription(`L'asset ${asset.name} a été ajouté à votre inventaire.`);

    await interaction.update({ embeds: [embed], components: [] });
  } catch (error) {
    console.error('Error in handleAchat:', error);
    return interaction.reply({ content: 'Une erreur est survenue lors de l\'achat de l\'asset.', ephemeral: true });
  }
}

async function handleCraft(interaction, user, fragment) {
  try {
    const asset = await Asset.findById(fragment.asset._id);
    if (!asset) {
      return interaction.reply({ content: 'Asset introuvable.', ephemeral: true });
    }

    if (fragment.quantity < 4) {
      return interaction.reply({ content: 'Vous n\'avez pas assez de fragments pour crafter cet asset.', ephemeral: true });
    }

    if (user.inventory.masks.includes(asset._id) || user.inventory.backgrounds.includes(asset._id) || user.inventory.borders.includes(asset._id)) {
      return interaction.reply({ content: `L'asset ${asset.name} est déjà dans votre inventaire.`, ephemeral: true });
    }

    fragment.quantity -= 4;

    switch (asset.type) {
      case 'mask':
        user.inventory.masks.push(asset._id);
        break;
      case 'background':
        user.inventory.backgrounds.push(asset._id);
        break;
      case 'border':
        user.inventory.borders.push(asset._id);
        break;
      default:
        return interaction.reply({ content: 'Type d\'asset non supporté.', ephemeral: true });
    }

    await user.save();

    const embed = new EmbedBuilder()
      .setColor('#00FF00')
      .setTitle('✅ Craft Réussi ✅')
      .setDescription(`L'asset ${asset.name} a été ajouté à votre inventaire.`);

    await interaction.update({ embeds: [embed], components: [] });
  } catch (error) {
    console.error('Error in handleCraft:', error);
    return interaction.reply({ content: 'Une erreur est survenue lors du craft de l\'asset.', ephemeral: true });
  }
}

async function handleDesenchanter(interaction, user, fragment) {
  try {
    const asset = await Asset.findById(fragment.asset._id);
    if (!asset) {
      return interaction.reply({ content: 'Asset introuvable.', ephemeral: true });
    }

    const settings = await LotterySettings.findOne();
    if (!settings) {
      return interaction.reply({ content: 'Paramètres de loterie introuvables.', ephemeral: true });
    }

    const rarity = asset.rarity.toLowerCase();
    const coinReward = settings.coinsForDuplicate[rarity];

    user.inquicoins += coinReward;
    fragment.quantity -= 1;
    if (fragment.quantity <= 0) {
      user.fragments.id(fragment._id).remove();
    }

    await user.save();

    const embed = new EmbedBuilder()
      .setColor('#00FF00')
      .setTitle('✅ Désenchantement Réussi ✅')
      .setDescription(`Vous avez désenchanté ${asset.name} et obtenu ${coinReward} Inquicoins.`);

    await interaction.update({ embeds: [embed], components: [] });
  } catch (error) {
    console.error('Error in handleDesenchanter:', error);
    return interaction.reply({ content: 'Une erreur est survenue lors du désenchantement de l\'asset.', ephemeral: true });
  }
}