const path = require("path");
const Embed = require(path.join(__dirname, "../functions/embed"));

/**
 * Validates role mentions in a message
 * @param {string} content - Message content to validate
 * @param {string} language - User's language setting
 * @param {Object} client - Discord client instance
 * @returns {Object} Validation result with roles and error message if any
 */
function validateRoleMentions(content, language, client) {
    const regex = /{role:(.*?)}/g;
    const matches = content.match(regex);
    
    if (!matches || matches.length === 0) {
        return {
            isValid: false,
            error: client.translate.get(language, "Events.messageCreate.noRoles")
        };
    }

    const roles = matches.map(match => match.match(/{role:(.*?)}/)[1]);
    
    if (roles.length > 20) {
        return {
            isValid: false,
            error: client.translate.get(language, "Events.messageCreate.maxRoles")
        };
    }

    return { isValid: true, roles };
}

/**
 * Finds server roles by name
 * @param {Array} roles - Array of role names
 * @param {Object} server - Server object
 * @returns {Object} Result containing found roles and unknown roles
 */
function findServerRoles(roles, server) {
    const roleIds = roles.map(roleName => 
        [...server.roles].find(([_, role]) => 
            roleName.toLowerCase() === role.name.toLowerCase()
        )
    );

    const unknown = roles.filter((_, index) => !roleIds[index]);
    
    return { roleIds, unknown };
}

/**
 * Checks for duplicate roles
 * @param {Array} roleIds - Array of role IDs
 * @returns {Array} Array of duplicate roles
 */
function findDuplicateRoles(roleIds) {
    return roleIds.filter((role, index) => 
        roleIds.findIndex(r => r[0] === role[0]) !== index
    );
}

/**
 * Checks role positions against bot's role
 * @param {Array} roleIds - Array of role IDs
 * @param {Object} botRole - Bot's highest role
 * @returns {Array} Array of roles with invalid positions
 */
function checkRolePositions(roleIds, botRole) {
    return roleIds.filter(role => role[1].rank <= botRole.rank);
}

/**
 * Main collector function for message editing
 * @param {Object} client - Discord client instance
 * @param {Object} message - Message object
 * @param {Object} db - Database object
 */
async function Collector(client, message, db) {
    const collector = client.messageEdit.get(message.authorId);
    
    // Validate role mentions
    const validation = validateRoleMentions(message.content, db.language, client);
    if (!validation.isValid) {
        await message.reply({
            embeds: [new Embed().setColor("#FF0000").setDescription(validation.error)]
        }, false).catch(() => {});
        return message.react(client.config.emojis.cross).catch(() => {});
    }

    // Find server roles
    const { roleIds, unknown } = findServerRoles(validation.roles, message.server);
    if (unknown.length > 0) {
        await message.reply({
            embeds: [new Embed().setColor("#FF0000").setDescription(
                `${client.translate.get(db.language, "Events.messageCreate.unknown")}\n${
                    unknown.map(e => `\`{role:${e}}\``).join(", ")
                }`
            )]
        }, false).catch(() => {});
        return message.react(client.config.emojis.cross).catch(() => {});
    }

    // Check for duplicates
    const duplicates = findDuplicateRoles(roleIds);
    if (duplicates.length > 0) {
        await message.reply({
            embeds: [new Embed().setColor("#FF0000").setDescription(
                `${client.translate.get(db.language, "Events.messageCreate.duplicate")}\n${
                    duplicates.map(e => `\`{role:${e[1].name}}\``)
                }`
            )]
        }, false).catch(() => {});
        return message.react(client.config.emojis.cross).catch(() => {});
    }

    // Check role positions
    const botRole = message.channel.server.member.orderedRoles.reverse()[0];
    if (!botRole) {
        await message.reply({
            embeds: [new Embed().setColor("#FF0000").setDescription(
                client.translate.get(db.language, "Events.messageCreate.noBotRole")
            )]
        }, false).catch(() => {});
        return message.react(client.config.emojis.cross).catch(() => {});
    }

    const invalidPositions = checkRolePositions(roleIds, botRole);
    if (invalidPositions.length > 0) {
        await message.reply({
            embeds: [new Embed().setColor("#FF0000").setDescription(
                `${client.translate.get(db.language, "Events.messageCreate.positions")}\n${
                    invalidPositions.map(e => `\`{role:${e[1].name}}\``)
                }`
            )]
        }, false).catch(() => {});
        return message.react(client.config.emojis.cross).catch(() => {});
    }

    // Process valid message
    await message.delete().catch(() => {});
    collector.roles = roleIds;
    collector.regex = validation.roles;

    const react = [client.config.emojis.check];
    const messageContent = collector.type === "content" 
        ? { content: message.content, interactions: [react] }
        : { 
            embeds: [new Embed().setDescription(message.content).setColor("#A52F05")], 
            interactions: [react] 
          };

    const msg = await message.channel.sendMessage(messageContent);
    collector.messageId = msg.id;
}

module.exports = Collector;