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

// Hard-coded environment variables
const MONGO_URI = '';
const MONGO_USER = '';
const MONGO_PASS = '';

logger.info('Initializing MongoDB connection...');
mongoose.connect(MONGO_URI, {
    user: MONGO_USER || undefined,
    pass: 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',
};

logger.info('Role mapping initialized.');

export const config = createCommandConfig({ 
    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
        },
    ],
});

logger.info('Command configuration created.');

export default async (interaction) => {
    try {
        logger.info(`Received /sync command from user: ${interaction.user.tag} (${interaction.user.id})`);
        await interaction.deferReply({ ephemeral: true });
        logger.info('Reply deferred.');

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

        logger.info(`Code entered: ${code}, Discord ID: ${discordID}`);

        const record = await CodeModel.findOne({ code });
        logger.info(`Database query executed. Record found: ${record ? 'Yes' : 'No'}`);

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

        if (record.discordID) {
            logger.warn(`Code already used. Code: ${code}, Linked Discord ID: ${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();
        logger.info(`Record updated with Discord ID: ${discordID}`);

        const guild = interaction.guild;
        logger.info(`Fetched guild: ${guild.name} (${guild.id})`);

        const member = await guild.members.fetch(discordID);
        logger.info(`Fetched member: ${member.user.tag} (${member.id})`);

        const roleID = roleMapping[record.role];
        logger.info(`Role mapping for in-game role '${record.role}': ${roleID || 'No mapping found'}`);

        if (roleID) {
            const role = guild.roles.cache.get(roleID);
            if (role) {
                await member.roles.add(role);
                logger.info(`Assigned role '${role.name}' (${role.id}) to user ${member.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} successfully linked their account with code: ${code}`);
    } catch (error) {
        logger.error(`Error in /sync command: ${error.message}`);
        console.error(error); // Log the full error stack for debugging
        interaction.editReply({
            content: 'An error occurred while linking your account. Please try again later.',
            ephemeral: true
        });
    }
};