const axios = require(`axios`);
const path = require('path');
const botConfig = require(path.join(__dirname, '../../botconfig.json'));
const { generateUniqueId } = require(path.join(__dirname, '../../functions/randomStr'));
const https = require('https');
const Invites = require(path.join(__dirname, '../../models/registerInvite'));
const Embed = require(path.join(__dirname, '../../functions/embed'));
const DELAY = '5m';

// Helper function to parse time string to milliseconds
const parseTimeToMs = (timeStr) => {
    const unit = timeStr.slice(-1).toLowerCase();
    const value = parseInt(timeStr.slice(0, -1));
    
    switch(unit) {
        case 's': return value * 1000;           // seconds
        case 'm': return value * 60 * 1000;      // minutes
        case 'h': return value * 60 * 60 * 1000; // hours
        case 'd': return value * 24 * 60 * 60 * 1000; // days
        default: return 300000; // default 5 minutes if invalid format
    }
};

// Create axios instance outside of module.exports
const makeRequest = axios.create({
    baseURL: `https://rule7.zonies.xyz/api/v1`,
    headers: {
        "Authorization": `Bearer ${botConfig.rule7.apiKey}`
    },
    httpsAgent: new https.Agent({
        rejectUnauthorized: false
    })
});

// Helper function to delete messages after delay
const deleteAfterDelay = async (message, delay = parseTimeToMs(DELAY)) => {
    try {
        await new Promise(resolve => setTimeout(resolve, delay));
        await message.delete().catch(() => {});
    } catch (error) {
        console.error('Error deleting message:', error);
    }
};

module.exports = {
    config: {
        name: `register`,
        usage: true,
        cooldown: 10000,
        available: true,
        permissions: [''],
        roles: ['staff', 'uploader', 'jrmod', 'mod'],
        aliases: ["reg"],
        dm: true
    },
    run: async (client, message, args, db) => {
        console.log('[Register Command] Command started with args:', {
            args: args,
            channelType: message.channel.type,
            author: message.author.username,
            guild: message.server?.name || 'DM'
        });
        try {
            // If not in DM, check for permissions and roles
            if (message.channel.type !== 'DirectMessage') {
                console.log('[Register Command] Not in DM, checking permissions');
                // Get allowed role IDs from config
                const allowedRoleIds = module.exports.config.roles
                    .map(roleName => botConfig.roles[0][roleName])
                    .filter(Boolean);
                console.log('[Register Command] Allowed role IDs:', allowedRoleIds);
                console.log('[Register Command] User roles:', message.member.roles);
                console.log('[Register Command] Bot config roles:', botConfig.roles[0]);

                const hasRequiredRole = message.member.roles.some(roleId => allowedRoleIds.includes(roleId));
                console.log('[Register Command] Has required role:', hasRequiredRole);
                console.log('[Register Command] Is owner:', client.config.owners.includes(message.authorId));
                
                if (!hasRequiredRole && !client.config.owners.includes(message.authorId)) {
                    console.log('[Register Command] User lacks required permissions');
                    const reply = await message.reply({
                        embeds: [
                            new Embed()
                                .setColor("#FF0000")
                                .setDescription(`You don't have the required roles to use this command.`)
                        ]
                    });
                    // Delete both messages after 5 minutes
                    deleteAfterDelay(message);
                    deleteAfterDelay(reply);
                    return;
                }
            }

            // Check if the command is used in a DM
            if (message.channel.type !== 'DirectMessage') {
                const inviteCode = generateUniqueId();

                const staffRoles = {
                    is_staff: 0,
                    is_mod: 0,
                    is_jrmod: 0,
                    is_uploader: 0,
                    is_jruploader: 0
                }

                let memberRoles = message.member.roles;
                
                // Set staff role values based on member's roles
                if (memberRoles.includes(botConfig.roles[0].staff)) staffRoles.is_staff = 1;
                if (memberRoles.includes(botConfig.roles[0].mod)) staffRoles.is_mod = 1;
                if (memberRoles.includes(botConfig.roles[0].jrmod)) staffRoles.is_jrmod = 1;
                if (memberRoles.includes(botConfig.roles[0].uploader)) staffRoles.is_uploader = 1;
                if (memberRoles.includes(botConfig.roles[0].jruploader)) staffRoles.is_jruploader = 1;

                const registerInvite = new Invites({
                    userId: message.author.id,
                    invite: inviteCode,
                    staffRoles,
                    createdAt: Date.now()
                });

                await registerInvite.save();

                const reply = await message.reply({
                    content: `Run this command in a DM to the bot and use this invite code: \`${inviteCode}\`\n
                    **Usage:** \`!register ${inviteCode} <username> <email> <f95zone profile url>\`\n
                    **Note: This invite code will expire in 10 minutes.**`
                });
                return;
            }

            const [invite, username, email, profileUrl] = args;

            if (!invite || !username || !email || !profileUrl) {
                const reply = await message.reply({
                    content: `[REG3] Please provide a invite code, username, email, and f95zone profile url. \n\n**Usage:** \`${client.prefix}register <invite> <username> <email> <f95zone profile url>\``
                });
                return;
            }

            // DM flow - Use client.database instead of direct model
            const registerInvite = await Invites.findOne({ invite: invite });
            
            if (!registerInvite) {
                const reply = await message.reply({
                    content: `[REG1] You don't have an invite code. Please run the command outside of DMs.`
                });
                return;
            }

            if (registerInvite.createdAt + 10 * 60 * 1000 < Date.now()) {
                await registerInvite.deleteOne({ invite: invite });
                const reply = await message.reply({
                    content: `[REG2] Your invite code has expired. Please run the command outside of DMs.`
                });
                return;
            }

            if (invite !== registerInvite.invite) {
                const reply = await message.reply({
                    content: `[REG4] Invalid invite code. Please run the command outside of DMs.`
                });
                return;
            }

            let f95zoneId = profileUrl.split('/')[4];
            f95zoneId = f95zoneId.split('.')[1];

            try {
                const { data } = await makeRequest.post(`/bot/register`, {
                    username,
                    email,
                    f95_id: f95zoneId,
                    is_staff: registerInvite.staffRoles.is_staff,
                    is_mod: registerInvite.staffRoles.is_mod,
                    is_jrmod: registerInvite.staffRoles.is_jrmod,
                    is_uploader: registerInvite.staffRoles.is_uploader,
                    is_jruploader: registerInvite.staffRoles.is_jruploader
                });

                if (data.status === 'success') {
                    await registerInvite.deleteOne({ invite: invite });
                    const reply = await message.reply({
                        content: `[REG5] You have been registered. Please check your email for verification.\n
                        **If you do not receive email in 5 minutes. Please check your spam or trash for email.**`
                    });
                    return;
                } else if (data.status === 'invalid_email') {
                    const reply = await message.reply({
                        content: `[REG5.1] An error occurred during registration. ${data.msg}`
                    });
                    return;
                } else if (data.status === 'username_exists') {
                    const reply = await message.reply({
                        content: `[REG5.2] An error occurred during registration. ${data.msg}`
                    });
                    return;
                } else if (data.status === 'invalid_f95_id') {
                    const reply = await message.reply({
                        content: `[REG5.3] An error occurred during registration. ${data.msg}`
                    });
                    return;
                } else if (data.status === 'email_exists') {
                    const reply = await message.reply({
                        content: `[REG5.4] An error occurred during registration. ${data.msg}`
                    });
                    return;
                } else if (data.status === 'error') {
                    const reply = await message.reply({
                        content: `[REG5.5] An error occurred during registration. ${data.msg}`
                    });
                    return;
                }
            } catch (apiError) {
                const reply = await message.reply({
                    content: `[REG6] An error occurred during registration. Please try again later.\n\`${apiError}\``
                });
                return;
            }
        } catch (error) {
            console.error('Registration Error:', error);
            const reply = await message.reply({
                content: `[REG7] An unexpected error occurred. Please try again later.\n\`${error}\``
            });
            return;
        }
    },
};