export const config = {
    sage: {
        defer: false,
    },
    command: {
        name: 'sync',
        description: 'Link your Minecraft account with your Discord account.',
        options: [
            {
                name: 'code',
                description: 'The 6-character code from the Minecraft server.',
                type: 'string',
                required: true
            }
        ]
    }
};

import { createCommandConfig, logger } from 'robo.js';
import mongoose from 'mongoose';
import dotenv from 'dotenv';

dotenv.config();

mongoose.connect(process.env.MONGO_URI, {
    user: process.env.MONGO_USER || undefined,
    pass: process.env.MONGO_PASS || undefined,
    useNewUrlParser: true,
    useUnifiedTopology: true
}).then(() => logger.info('Connected to MongoDB'))
  .catch(err => logger.error(`MongoDB connection error: ${err.message}`));

const CodeSchema = new mongoose.Schema({
    code: String,
    minecraftUUID: String,
    discordID: { type: String, default: null },
    role: String
});

const CodeModel = mongoose.model('Code', CodeSchema);

const roleMapping = {
    Pro: '1369448987299680436',
    Mythic: '1369448914314465472',
    MVP: '1369448863819370496',
    Ultimate: '1369448738044645477',
    Legend: '1369448649125527613',
};

export default async (interaction) => {
    try {
        await interaction.deferReply({ ephemeral: true });

        const code = interaction.options.getString('code');
        const discordID = interaction.user.id;

        const record = await CodeModel.findOne({ code });

        if (!record) {
            return interaction.editReply({
                content: 'Invalid code. Please make sure you entered the correct code.',
                ephemeral: true
            });
        }

        if (record.discordID) {
            return interaction.editReply({
                content: 'This code has already been used, and is linked to another Discord account. Please type /link to generate a new code and try again.',
                ephemeral: true
            });
        }

        record.discordID = discordID;
        await record.save();

        const guild = interaction.guild;
        const member = await guild.members.fetch(discordID);
        const roleID = roleMapping[record.role];

        if (roleID) {
            const role = guild.roles.cache.get(roleID);
            if (role) {
                await member.roles.add(role);
                logger.info(`Assigned role ${role.name} to user ${interaction.user.tag}`);
            } else {
                logger.warn(`Role ID ${roleID} not found in the guild.`);
            }
        } else {
            logger.warn(`No role mapping found for in-game role: ${record.role}`);
        }

        interaction.editReply({
            content: 'Your Minecraft account has been successfully linked to your Discord account, and your role has been assigned! \n*If you do not have a role in-game, no roles has been assigned to you. If you think that this was false, please create a ticket [here](https://ptb.discord.com/channels/703871348367425597/703871348790919192)*.',
            ephemeral: true
        });

        logger.info(`User ${interaction.user.tag} linked their account with code: ${code}`);
    } catch (error) {
        logger.error(`Error in /sync command: ${error.message}`);
        interaction.editReply({
            content: 'An error occurred while linking your account. Please try again later.',
            ephemeral: true
        });
    }
};