module.exports = function(RED) {
    function WhatsappGroupOut(config) {
        RED.nodes.createNode(this,config);
        var node = this;
        node.number = config.gID;
        var whatsappLinkNode = RED.nodes.getNode(config.whatsappLink);
        node.waClient = whatsappLinkNode.client;

        const { MessageMedia, Buttons } = require('whatsapp-web.js')

        let SetStatus = function(WAStatus, color){
            node.status({fill:color,shape:"dot",text:WAStatus});
        };
        const delay = ms => new Promise(resolve => setTimeout(resolve, ms));


        async function webNubmerSeteing(numb){
            // Validate and clean the number
            if (!numb) {
                throw new Error('Number is required');
            }
            
            // Convert to string if number
            numb = typeof numb === 'number' ? numb.toString() : numb;
            
            // Check if it's already a formatted ID (contains @)
            if (numb.includes('@')) {
                return numb;
            }
            
            // For group IDs, preserve the hyphen (format: NUMBER-TIMESTAMP@g.us)
            // Only strip non-digits and non-hyphens for cleaning
            numb = numb.replace(/[^\d-]/g, '');
            
            // Check if number is valid after cleaning
            if (!numb || numb.length === 0) {
                throw new Error('Invalid number format');
            }
            
            // Check if it looks like a group ID (contains hyphen)
            if (numb.includes('-')) {
                // It's a group ID, format it directly without validation
                return `${numb}@g.us`;
            }
            
            // It's a regular phone number, validate with getNumberId
            try {
                var numbID = await node.waClient.getNumberId(numb);
                if(numbID) {
                    return `${numbID.user}@${numbID.server}`;
                } else {
                    return `${numb}@g.us`
                }
            } catch (e) {
                node.error(`Error getting number ID for ${numb}: ${e.message}`);
                throw e;
            }
        }

        async function socNubmerSeteing(numb){
            if (numb && numb.remoteJid){
                return numb.remoteJid;
            }
            
            // Validate and clean the number
            if (!numb) {
                throw new Error('Number is required');
            }
            
            // Convert to string if number
            numb = typeof numb === 'number' ? numb.toString() : numb;
            
            // Check if it's already a formatted ID (contains @)
            if (numb.includes('@')) {
                return numb;
            }
            
            // For group IDs, preserve the hyphen (format: NUMBER-TIMESTAMP@g.us)
            // Only strip non-digits and non-hyphens for cleaning
            numb = numb.replace(/[^\d-]/g, '');
            
            // Check if number is valid after cleaning
            if (!numb || numb.length === 0) {
                throw new Error('Invalid number format');
            }
            
            // Check if it looks like a group ID (contains hyphen)
            if (numb.includes('-')) {
                // It's a group ID, format it directly
                return `${numb}@g.us`;
            }
            
            // It's a regular phone number, validate with onWhatsApp
            try {
                const [result] = await (await node.waClient).onWhatsApp(numb)
                if (result?.exists){
                    return result.jid
                }
                return numb = `${numb}@g.us`;
            } catch (e) {
                node.error(`Error checking WhatsApp for ${numb}: ${e.message}`);
                throw e;
            }
        }

        async function whatsappMessage(numb , inputMessage){
            if (node.waClient.clientType === "waWebClient"){
                try {
                    numb = await webNubmerSeteing(numb);
                    if(typeof inputMessage === "object"){
                        inputMessage = new Buttons(inputMessage.text, inputMessage.buttons, "text" ,inputMessage.footer);
                        node.waClient.sendMessage(numb, inputMessage);
                    }
                    node.waClient.sendMessage(numb, inputMessage);
                }
                catch(e){
                    node.error(`Error Sending Msg: ${e}`);
                }
            } 
            else if (node.waClient.clientType === "waSocketClient"){
                try {
                    let client = await node.waClient;
                    numb = await socNubmerSeteing(numb)
                    if (typeof inputMessage ==="string"){
                        inputMessage = {text : inputMessage};
                    }
                    const msgStatus = await client.sendMessage(numb, inputMessage);
                }
                catch(e) {
                    node.error(`Error Sending Msg:: ${e}`);
                }
            } 
            else { 
                node.error(`Error Sending Msg: ${e}`)
            }
            SetStatus("Message Send.", "green");
            setTimeout(()=>{
                SetStatus('Connected','green');
            }, 2000)
        };

        async function whatsappMultiMediaMessage(numb, whatsappImage, whatsappCaption){
            try {
                if (node.waClient.clientType === "waWebClient"){
                    numb = await webNubmerSeteing(node.number)
                    var whatsappImageBase64 = whatsappImage.split(',')[1] || whatsappImage;
                    var myMessage = new MessageMedia('image/png', whatsappImageBase64, null, null);
                    node.waClient.sendMessage(numb, myMessage, {caption : whatsappCaption || "Image from Node-Red"});
                } 
                else {
                    numb = await socNubmerSeteing(node.number);
                    
                    let imageToSend = Buffer.from(whatsappImageBase64, "base64");
                    const imageMessage = { 
                        // image: {url : whatsappImage}, 
                        image: imageToSend, 
                        caption: whatsappCaption
                    }

                    let client = await node.waClient;
                    const msgStatus = await client.sendMessage(numb, imageMessage);
                }              
                SetStatus("Message Send.", "green");
                setTimeout(()=>{
                    SetStatus('Connected','green');
                }, 2000)
            } catch(e) {
                node.error(`Error sending MultiMedia Message : ${e}`)
            }
        };

        node.on('input', (message)=> {
            if (node.number){
                if (message.image){
                    whatsappMultiMediaMessage(node.number, message.image, message.payload);       
                }  
                else {
                    whatsappMessage(node.number, message.payload);
                }

            } else if (message.toNumber){
                var numbers = message.toNumber instanceof Array ? message.toNumber : Array.of(message.toNumber);
                for (number of numbers) {
                    if(message.image){
                        whatsappMultiMediaMessage(number, message.image, message.payload)
                        delay(2000);

                    } else {
                        whatsappMessage(number, message.payload)
                        delay(2000)
                    }
                }
            } else if(message.key.remoteJid){
                whatsappMessage(message.key, message.payload)
            } 
            else {
                SetStatus("No number","red");
                setTimeout(()=>{
                    SetStatus('Connected','green');
                }, 5000)
            }
        });

        //whatsapp Status Parameters----
        if (node.waClient.clientType === "waWebClient"){
            node.waClient.on('qr', (qr) => {
                SetStatus("QR Code Generated", "yellow");
            });
            
            node.waClient.on('auth_failure', () => {
                SetStatus('Not Connected','red');
            });
                    
            node.waClient.on('loading_screen', () => {
                SetStatus('Connecting...','yellow');
            });
            
            node.waClient.on('ready', () => {
                SetStatus('Connected','green');
            });

            node.waClient.on('disconnected', () => {
                SetStatus("Disconnected","red");
            });

        } else if (node.waClient.clientType === "waSocketClient"){
            async function checkStatusOfSockets(){
                let client = await node.waClient;
                client.ev.on('connection.update', (updates)=>{
                    var {connection} = updates
                    if(connection === 'open'){
                        SetStatus("Connected", "green");
                    }
                    else if(updates.isOnline){
                        SetStatus("Connected", "green");
                    }
                    else if(connection === 'close'){
                        SetStatus("Disconnected", "red");
                    }
                    else if(connection === 'connecting'){
                        SetStatus("Connecting...", "yellow");
                    }
                    else if(updates.qr){
                        SetStatus("Scan QR Code to Connect.", "yellow");
                    }
                })
            }
            checkStatusOfSockets();

        }

   
    }
    RED.nodes.registerType("group-out", WhatsappGroupOut);
}