global.config = {
    name: "MiBot",              // Nombre del bot
    prefixes: ".¿?¡!#%&/,~@",   // Caracteres que activan comandos
    saveHistory: true,          // Guardar historial de mensajes
    autoRead: true              // Marcar mensajes como leídos
};

// Roles de usuario (usar número sin símbolos)
global.config.userRoles = {
    "521234567890": {
        root: true,   // Acceso total
        owner: true,  // Propietario
        mod: true,    // Moderador
        vip: true     // Usuario premium
    }
}

// INCORRECTO: m.chat.admins no existe en index=1
export default {
    before: true,
    index: 1,
    script: async (m) => {
        console.log(m.chat.admins); // undefined
    }
}

// CORRECTO: Verificar existencia o usar index apropiado
export default {
    before: true,
    index: 2,  // Aquí ya existe m.chat.admins
    script: async (m) => {
        if (m.chat.isGroup) {
            console.log(m.chat.admins); // Array<String>
        }
    }
}

/**
 * @param {Object} options
 * @param {string} options.connectType - 'qr-code' | 'pin-code'
 * @param {string} options.phoneNumber - Número para pin-code (sin símbolos)
 * @param {Object} store - Instancia de store (opcional)
 * 
 * @returns {Promise<Object>} sock - Instancia de Baileys extendida
 */

const plugins = new Plugins(folderPath, defaultContext)

import db from './library/db.js'

await db.start('./storage/store')  // Inicializar

const bot = new ForkManager(modulePath, {
    execArgv: ['--max-old-space-size=512'],
    env: { dataConfig: {}, connOptions: {} }
})

const cache = new TmpStore(60000)  // 60 segundos TTL

cache.set('key', value)   // Almacena con TTL
cache.get('key')          // Obtiene valor
cache.has('key')          // Verifica existencia
cache.delete('key')       // Elimina manualmente
cache.clear()             // Limpia todo
cache.keys()              // Array de claves
cache.values()            // Array de valores

const timer = new SimpleTimer(
    () => console.log('tick'), 
    5000, 
    'interval'  // 'timeout' | 'interval'
)

timer.start()   // Inicia
timer.stop()    // Detiene
timer.status    // true si está corriendo

import { color } from './library/utils.js';

console.log(color.rgb(255, 100, 0) + 'Texto naranja' + color.reset)
console.log(color.bg.rgb(0, 0, 255) + 'Fondo azul' + color.reset)

// plugins/ejemplo.plugin.js

export default {
    // === IDENTIFICACIÓN ===
    case: ['ping', 'p'],      // String o Array<String>
    
    // === CLASIFICACIÓN ===
    usePrefix: true,          // Requiere prefijo (default: true)
    command: true,            // Plugin de comando
    
    // === PARA PLUGINS BEFORE ===
    // before: true,
    // index: 1,              // Punto de ejecución (1, 2 o 3)
    // priority: 10,          // Menor = mayor prioridad
    
    // === PARA PLUGINS STUBTYPE ===
    // stubtype: true,
    // case: 'GROUP_PARTICIPANT_ADD',
    
    // === FUNCIÓN PRINCIPAL ===
    async script(m, context) {
        const { sock, plugin, store } = context
        // Para plugins before: context.control
        // Para plugins stubtype: context.parameters, context.even
        
        await m.reply('Pong!')
    }
}

// Buscar comandos con prefijo
const cmds = await plugins.query({ 
    case: 'ping', 
    usePrefix: true, 
    command: true 
});

// Buscar plugins before con index 2
const beforePlugins = await plugins.query({
    before: true,
    index: 2
});

// Buscar eventos stubtype
const events = await plugins.query({ 
    case: 'GROUP_PARTICIPANT_ADD', 
    stubtype: true 
});

// plugins/utils/helpers.plugin.js

const formatNumber = (n) => n.toLocaleString('es-ES');
const randomInt = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;

export default {
    before: true,
    index: 1,
    
    export: {
        '@helpers': {
            formatNumber,
            randomInt
        }
    },
    
    async script() {
        // Plugin mínimo, solo exporta
    }
}

// plugins/comandos/dado.plugin.js

export default {
    case: 'dado',
    command: true,
    
    async script(m, { plugin }) {
        const helpers = plugin.import('@helpers');
        const resultado = helpers.randomInt(1, 6);
        
        await m.reply(`🎲 Obtuviste: ${resultado}`);
    }
}

async script(m, { sock }) {
    const msg = await m.reply('¿Cuál es tu nombre?')
    
    await sock.setReplyHandler(msg, {
        security: {
            userId: m.sender.id,    // Solo este usuario puede responder
            chatId: m.chat.id,      // Solo en este chat
            scope: 'all'            // 'all' | 'private' | 'group'
        },
        lifecycle: {
            consumeOnce: true       // Eliminar después de una respuesta
        },
        state: {
            step: 'name',           // Estado personalizado
            intentos: 0
        },
        routes: [{
            priority: 1,
            code: {
                // guard retorna true para SALTAR esta ruta
                guard: (m, ctx) => m.body.length < 2,
                
                // executor se ejecuta si guard retorna false/undefined
                executor: async (m, ctx) => {
                    await m.reply(`¡Hola ${m.body}!`)
                }
            }
        }]
    }, 1000 * 60 * 5)  // Expira en 5 minutos
}

// plugins/admin/ban.plugin.js

export default {
    case: 'ban',
    usePrefix: true,
    command: true,
    
    async script(m, { sock }) {
        // Verificar que el ejecutor sea moderador o superior
        if (!m.sender.role('root', 'owner', 'mod')) {
            return m.sms('mod')
        }
        
        // Verificar que haya un usuario mencionado o citado
        const target = m.sender.mentioned[0] || m.quoted?.sender.id
        if (!target) {
            return m.reply('Menciona o cita al usuario a banear')
        }
        
        // Banear usuario
        await m.setBan(target, true)
        await m.reply(`Usuario @${target.split('@')[0]} baneado.`)
    }
}

// plugins/media/sticker.plugin.js

export default {
    case: ['sticker', 's'],
    usePrefix: true,
    command: true,
    
    async script(m, { sock }) {
        // Verificar si hay imagen en el mensaje o citada
        const media = m.content.media || m.quoted?.content.media
        
        if (!media || !media.mimeType.startsWith('image/')) {
            return m.reply('Envía o cita una imagen')
        }
        
        await m.react('wait')
        
        try {
            const buffer = await media.download()
            
            await sock.sendMessage(m.chat.id, {
                sticker: buffer
            }, { quoted: m.message })
            
            await m.react('done')
        } catch (e) {
            await m.react('error')
            await m.reply('Error al crear el sticker')
        }
    }
}

// plugins/middleware/antispam.plugin.js

const cooldowns = new Map();
const COOLDOWN_MS = 3000;

export default {
    before: true,
    index: 1,
    priority: 5,
    
    async script(m, { control }) {
        // Ignorar al bot
        if (m.sender.roles.bot) return
        
        // Ignorar admins/owners
        if (m.sender.role('root', 'owner', 'mod')) return
        
        const key = m.sender.id;
        const now = Date.now();
        
        if (cooldowns.has(key)) {
            const lastTime = cooldowns.get(key);
            if (now - lastTime < COOLDOWN_MS) {
                control.end = true;  // Detiene el pipeline
                return;
            }
        }
        
        cooldowns.set(key, now);
    }
}

// plugins/events/bienvenida.plugin.js

export default {
    case: 'GROUP_PARTICIPANT_ADD',
    stubtype: true,
    
    async script(m, { sock, parameters }) {
        const newMember = parameters[0];
        const groupName = m.chat.name || 'el grupo';
        
        await sock.sendMessage(m.chat.id, {
            text: `¡Bienvenido/a a *${groupName}*, @${newMember.split('@')[0]}! 🎉`,
            mentions: [newMember]
        });
    }
}

// plugins/economia/_init.plugin.js

const MONEDA = '💎';
const INICIAL = 1000;

const obtenerCuenta = async (userId) => {
    const db = await global.db.open('@economia');
    
    if (!db.data[userId]) {
        db.data[userId] = {
            balance: INICIAL,
            banco: 0,
            ultimoDaily: 0,
            streak: 0,
            inventario: [],
            creado: Date.now()
        };
        await db.update();
    }
    
    return {
        cuenta: db.data[userId],
        guardar: async () => await db.update()
    };
};

const formatearBalance = (cantidad) => {
    return `${cantidad.toLocaleString('es-ES')} ${MONEDA}`;
};

export default {
    before: true,
    index: 1,
    
    export: {
        '@economia': {
            obtenerCuenta,
            formatearBalance,
            MONEDA,
            INICIAL
        }
    },
    
    async script() {}
}

// plugins/economia/balance.plugin.js

export default {
    case: ['balance', 'bal', 'saldo'],
    command: true,
    usePrefix: true,
    
    async script(m, { plugin }) {
        const eco = plugin.import('@economia');
        const { cuenta } = await eco.obtenerCuenta(m.sender.id);
        
        const texto = [
            `*💰 Balance de ${m.sender.name}*`,
            '',
            `├ Efectivo: ${eco.formatearBalance(cuenta.balance)}`,
            `├ Banco: ${eco.formatearBalance(cuenta.banco)}`,
            `└ Total: ${eco.formatearBalance(cuenta.balance + cuenta.banco)}`
        ].join('\n');
        
        await m.reply(texto);
    }
}

// plugins/economia/daily.plugin.js

const COOLDOWN = 24 * 60 * 60 * 1000; // 24 horas
const RECOMPENSA_BASE = 500;
const BONUS_POR_STREAK = 50;
const MAX_BONUS = 500;

export default {
    case: ['daily', 'diario'],
    command: true,
    usePrefix: true,
    
    async script(m, { plugin }) {
        const eco = plugin.import('@economia');
        const { cuenta, guardar } = await eco.obtenerCuenta(m.sender.id);
        
        const ahora = Date.now();
        const diferencia = ahora - cuenta.ultimoDaily;
        
        // Verificar cooldown
        if (diferencia < COOLDOWN) {
            const restante = COOLDOWN - diferencia;
            const horas = Math.floor(restante / (60 * 60 * 1000));
            const minutos = Math.floor((restante % (60 * 60 * 1000)) / (60 * 1000));
            
            return m.reply(`⏰ Debes esperar *${horas}h ${minutos}m* para tu próxima recompensa.`);
        }
        
        // Calcular streak
        const dentroDeVentana = diferencia < COOLDOWN * 2;
        const nuevoStreak = dentroDeVentana ? cuenta.streak + 1 : 1;
        
        // Calcular recompensa
        const bonus = Math.min(nuevoStreak * BONUS_POR_STREAK, MAX_BONUS);
        const recompensa = RECOMPENSA_BASE + bonus;
        
        // Actualizar cuenta
        cuenta.balance += recompensa;
        cuenta.ultimoDaily = ahora;
        cuenta.streak = nuevoStreak;
        
        await guardar();
        
        await m.reply([
            `*🎁 Recompensa Diaria*`,
            '',
            `├ Base: ${eco.formatearBalance(RECOMPENSA_BASE)}`,
            `├ Bonus (x${nuevoStreak}): +${eco.formatearBalance(bonus)}`,
            `├ Total: ${eco.formatearBalance(recompensa)}`,
            `└ Nuevo balance: ${eco.formatearBalance(cuenta.balance)}`,
            '',
            `🔥 Racha: ${nuevoStreak} día${nuevoStreak > 1 ? 's' : ''}`
        ].join('\n'));
    }
}

// plugins/economia/transferir.plugin.js

const COMISION = 0.05; // 5%

export default {
    case: ['transferir', 'pay', 'enviar'],
    command: true,
    usePrefix: true,
    
    async script(m, { plugin }) {
        const eco = plugin.import('@economia');
        
        // Validar destinatario
        if (m.sender.mentioned.length === 0) {
            return m.reply([
                '*📤 Transferir*',
                '',
                'Uso: .transferir @usuario <cantidad>',
                'Ejemplo: .transferir @Juan 1000',
                '',
                `Comisión: ${COMISION * 100}%`
            ].join('\n'));
        }
        
        const destinatarioId = m.sender.mentioned[0];
        
        // No transferir a sí mismo
        if (destinatarioId === m.sender.id) {
            return m.reply('❌ No puedes transferirte a ti mismo.');
        }
        
        // Validar cantidad
        const cantidad = parseInt(m.args[1]);
        if (isNaN(cantidad) || cantidad <= 0) {
            return m.reply('❌ Especifica una cantidad válida.');
        }
        
        // Obtener cuentas
        const { cuenta: origen, guardar: guardarOrigen } = 
            await eco.obtenerCuenta(m.sender.id);
        const { cuenta: destino, guardar: guardarDestino } = 
            await eco.obtenerCuenta(destinatarioId);
        
        // Calcular comisión
        const comision = Math.floor(cantidad * COMISION);
        const total = cantidad + comision;
        
        // Validar balance
        if (origen.balance < total) {
            return m.reply([
                '❌ *Balance insuficiente*',
                '',
                `├ Cantidad: ${eco.formatearBalance(cantidad)}`,
                `├ Comisión: ${eco.formatearBalance(comision)}`,
                `├ Total requerido: ${eco.formatearBalance(total)}`,
                `└ Tu balance: ${eco.formatearBalance(origen.balance)}`
            ].join('\n'));
        }
        
        // Ejecutar transferencia
        origen.balance -= total;
        destino.balance += cantidad;
        
        await guardarOrigen();
        await guardarDestino();
        
        await m.reply([
            '✅ *Transferencia Exitosa*',
            '',
            `├ Enviado: ${eco.formatearBalance(cantidad)}`,
            `├ Comisión: ${eco.formatearBalance(comision)}`,
            `├ Destinatario: @${destinatarioId.split('@')[0]}`,
            `└ Tu nuevo balance: ${eco.formatearBalance(origen.balance)}`
        ].join('\n'));
    }
}

// plugins/economia/tienda.plugin.js

const CATALOGO = [
    { id: 'vip_1d', nombre: '⭐ VIP 1 Día', precio: 5000, tipo: 'rol' },
    { id: 'vip_7d', nombre: '🌟 VIP 7 Días', precio: 25000, tipo: 'rol' },
    { id: 'lootbox', nombre: '📦 Caja Misteriosa', precio: 1000, tipo: 'item' },
    { id: 'titulo_custom', nombre: '🏷️ Título Personalizado', precio: 10000, tipo: 'item' }
];

export default {
    case: ['tienda', 'shop'],
    command: true,
    usePrefix: true,
    
    async script(m, { sock, plugin }) {
        const eco = plugin.import('@economia');
        const { cuenta } = await eco.obtenerCuenta(m.sender.id);
        
        // Construir catálogo
        let texto = [
            `*🛒 Tienda*`,
            '',
            `Tu balance: ${eco.formatearBalance(cuenta.balance)}`,
            ''
        ].join('\n');
        
        CATALOGO.forEach((item, index) => {
            texto += `${index + 1}. ${item.nombre}\n`;
            texto += `   └ ${eco.formatearBalance(item.precio)}\n`;
        });
        
        texto += '\n_Responde con el número del artículo que deseas comprar._';
        
        const mensaje = await m.reply(texto);
        
        // Registrar ReplyHandler
        await sock.setReplyHandler(mensaje, {
            security: {
                userId: m.sender.id,
                chatId: m.chat.id,
                scope: 'all'
            },
            lifecycle: {
                consumeOnce: true
            },
            state: {
                catalogo: CATALOGO,
                compradorId: m.sender.id
            },
            routes: [
                {
                    priority: 1,
                    code: {
                        // Validar entrada
                        guard: (m, ctx) => {
                            const seleccion = parseInt(m.content.text);
                            return isNaN(seleccion) || 
                                   seleccion < 1 || 
                                   seleccion > ctx.state.catalogo.length;
                        },
                        
                        // Procesar compra
                        executor: async (m, ctx) => {
                            const seleccion = parseInt(m.content.text) - 1;
                            const item = ctx.state.catalogo[seleccion];
                            
                            // Obtener cuenta actualizada
                            const db = await global.db.open('@economia');
                            const cuenta = db.data[ctx.state.compradorId];
                            
                            // Verificar balance
                            if (cuenta.balance < item.precio) {
                                return m.reply([
                                    '❌ *Balance insuficiente*',
                                    '',
                                    `├ Precio: ${item.precio.toLocaleString()} 💎`,
                                    `└ Tu balance: ${cuenta.balance.toLocaleString()} 💎`
                                ].join('\n'));
                            }
                            
                            // Procesar compra
                            cuenta.balance -= item.precio;
                            cuenta.inventario.push({
                                id: item.id,
                                nombre: item.nombre,
                                tipo: item.tipo,
                                obtenido: Date.now()
                            });
                            
                            await db.update();
                            
                            await m.reply([
                                '✅ *Compra Exitosa*',
                                '',
                                `├ Artículo: ${item.nombre}`,
                                `├ Precio: ${item.precio.toLocaleString()} 💎`,
                                `└ Nuevo balance: ${cuenta.balance.toLocaleString()} 💎`
                            ].join('\n'));
                        }
                    }
                },
                {
                    priority: 2,
                    code: {
                        // Ruta por defecto si guard anterior fue true
                        executor: async (m) => {
                            await m.reply('❌ Opción no válida. Escribe un número del 1 al ' + CATALOGO.length);
                        }
                    }
                }
            ]
        }, 1000 * 60 * 2); // 2 minutos
    }
}

// Plugin before:index=2
export default {
    before: true,
    index: 2,
    script: async (m) => {
        m.customFlag = true;
        m.sender.roles.customRole = true;
    }
}

// Plugin de comando posterior
export default {
    case: 'test',
    command: true,
    script: async (m) => {
        console.log(m.customFlag);           // true
        console.log(m.sender.roles.customRole); // true
    }
}

export default {
    case: 'GROUP_PARTICIPANT_LEAVE',
    stubtype: true,
    
    async script(m, { parameters }) {
        const usuario = parameters[0];
        await m.reply(`👋 @${usuario.split('@')[0]} ha abandonado el grupo.`);
    }
}

export default {
    case: 'info',
    command: true,
    
    async script(m) {
        await m.reply([
            `*${global.config.name}*`,
            `Versión: ${global.$package.version}`,
            `Prefijos: ${global.config.prefixes}`,
            `Historial: ${global.config.saveHistory ? 'Sí' : 'No'}`
        ].join('\n'));
    }
}