const path = require("path");
const Embed = require(path.join(__dirname, "../functions/embed"));
const Collector = require(path.join(__dirname, "../functions/messageCollector"));
const EditCollector = require(path.join(__dirname, "../functions/messageEdit"));
const CommandDB = require(path.join(__dirname, "../models/commands"));
const { isJson } = require(path.join(__dirname, "../functions/randomStr"));
const botConfig = require(path.join(__dirname, "../botConfig.json"));

module.exports = async (client, message) => {
    // Early return checks
    if (!message || !message.content || message.author.bot) return;

    const isDM = message.channel.type === "DirectMessage";
    
    // Get guild settings (if not DM)
    const db = isDM ? { prefix: client.botConfig.prefix, language: 'en' } : await client.database.getGuild(message.server.id, true);
    
    // Check if message starts with prefix
    if (!message.content.startsWith(db.prefix)) {
        // Handle bot mention
        if (message.content && (new RegExp(`^(<@!?${client.user.id}>)`)).test(message.content)) {
            const mention = new Embed()
                .setColor("#A52F05")
                .setTitle(client.user.username)
                .setDescription(`${client.translate.get(db.language, "Events.messageCreate.prefix")} \`${db.prefix}\`\n${client.translate.get(db.language, "Events.messageCreate.prefix2")} \`${db.prefix}help\``)

            return message.reply({
                embeds: [mention]
            }, false).catch(() => { return });
        }
        return;
    }

    let args = message.content.slice(db.prefix.length).trim().split(/ +/g);
    let cmd = args.shift().toLowerCase();

    // Handle collectors
    if (client.messageCollector.has(message.authorId) && client.messageCollector.get(message.authorId).channelId === message.channelId && !client.messageCollector.get(message.authorId).messageId) return await Collector(client, message, db);
    if (client.messageEdit.has(message.authorId) && client.messageEdit.get(message.authorId).channelId === message.channelId && !client.messageEdit.get(message.authorId).messageId) return await EditCollector(client, message, db);

    // Handle custom commands
    let check = await CommandDB.findOne({ name: cmd }).select("name").lean();
    if (check) {
        CommandDB.findOne({ name: cmd }).then((data) => {
            if (isJson(data.content)) {
                let items = JSON.parse(data.content);
                let item = items[Math.floor(Math.random() * items.length)];
                return message.reply(item);
            }
            return message.reply(data.content);
        });
    }

    // Command handling
    let commandfile = client.commands.get(cmd) || client.commands.get(client.aliases.get(cmd));
    if (commandfile) {
        // DM Check - if command doesn't allow DMs and we're in a DM, return
        if (isDM && !commandfile.config.dm) {
            return message.reply({
                embeds: [new Embed()
                    .setColor("#FF0000")
                    .setDescription(client.translate.get(db.language, "Events.messageCreate.noDM"))]
            }, false).catch(() => { return });
        }

        // Permission checks for non-DM messages
        if (!isDM) {
            // Check bot permissions first
            const canSendMessage = message.channel.havePermission("SendMessage");
            const canReact = message.channel.havePermission("React");

            if (!canSendMessage) {
                return message.member.user.openDM().then((dm) => {
                    dm.sendMessage(`${client.translate.get(db.language, "Events.messageCreate.unable")} <#${message.channelId}>. ${client.translate.get(db.language, "Events.messageCreate.contact")}.`)
                }).catch(() => { return });
            }

            if (!canReact) {
                return message.reply(`${client.translate.get(db.language, "Events.messageCreate.noPerms")}. ${client.translate.get(db.language, "Events.messageCreate.contact")}.`, false).catch(() => { return });
            }

            // Check if user has required roles
            const hasRequiredRole = commandfile.config.roles && message.member.roles && botConfig.roles[0] ? 
                message.member.roles.some(role => {
                    const requiredRoleIds = commandfile.config.roles.map(roleName => botConfig.roles[0][roleName.toLowerCase()]);
                    return requiredRoleIds.includes(role);
                }) : false;

            // Command availability check (skip for DMs)
            if (!commandfile.config.available && !hasRequiredRole && !botConfig.owners.includes(message.authorId)) {
                return message.reply({
                    embeds: [new Embed()
                        .setColor("#FF0000")
                        .setDescription(client.translate.get(db.language, "Events.messageCreate.unavail"))]
                }, false).catch(() => { return });
            }

            // Permission and role checks (skip for DMs)
            const needsPermissionCheck = commandfile.config.permissions && commandfile.config.permissions.length > 0;
            const needsRoleCheck = commandfile.config.roles && commandfile.config.roles.length > 0;

            if (needsPermissionCheck || needsRoleCheck) {
                let hasPermission = true;
                
                if (needsPermissionCheck) {
                    try {
                        hasPermission = message.member.hasPermission(commandfile.config.permissions[0]);
                    } catch (err) {
                        hasPermission = false;
                    }
                }

                if (!hasPermission && !hasRequiredRole && !client.botConfig.owners.includes(message.authorId)) {
                    return message.reply({
                        embeds: [new Embed()
                            .setColor("#FF0000")
                            .setDescription(`${client.translate.get(db.language, "Events.messageCreate.perms")}.\n${needsPermissionCheck ? `${client.translate.get(db.language, "Events.messageCreate.perms2")}: [${commandfile.config.permissions[0]}]` : ''}`)]
                    }, false).catch(() => { return });
                }
            }
        }

        // Cooldown handling
        const used = client.used.get(`${message.authorId}-${cmd.toLowerCase()}`);
        if (used) {
            if (client.timeout.get(`${message.authorId}-${cmd.toLowerCase()}`)) return;

            client.timeout.set(`${message.authorId}-${cmd.toLowerCase()}`, used);
            setTimeout(() => client.timeout.delete(`${message.authorId}-${cmd.toLowerCase()}`), used);

            const uremaining = client.functions.get("fetchTime")(used, client, db.language)
            const embed = new Embed()
                .setColor("#A52F05")
                .setDescription(`<@${message.authorId}>, ${client.translate.get(db.language, "Events.messageCreate.wait")} \`${uremaining}\` ${client.translate.get(db.language, "Events.messageCreate.wait2")} \`${cmd.toLowerCase()}\` ${client.translate.get(db.language, "Events.messageCreate.wait3")}.`)

            return message.reply({ embeds: [embed] }, false).catch(() => { return })
        } else {
            let cooldown = commandfile.config.cooldown;
            client.used.set(`${message.authorId}-${cmd.toLowerCase()}`, cooldown);
            setTimeout(() => client.used.delete(`${message.authorId}-${cmd.toLowerCase()}`), cooldown);

            return commandfile.run(client, message, args, db);
        }
    }
}