'use strict'

const { initIO } = require("./helpers/socket")

const { ObjectId } = require('mongodb')


const backup_session = require('./helpers/backup_session')
const restore = require('./helpers/restore')

const dbcloud = require('./funcs/dbcloud.js')

const { Client, Location, List, Buttons, LocalAuth } = require('whatsapp-web.js/index')


const qrencode = require('qr-encode')
const axios = require('axios').default
const bodyparser = require('body-parser')
const path = require('path')
const fs = require('fs')
const express = require('express')
const FormData = require('form-data')

// const { MessageMedia } = require('./node_modules/whatsapp-web.js/src/structures'); 
let whatsappWebGlobalPath = path.join(process.env.NODE_PATH, 'whatsapp-web.js', '/src/structures')
whatsappWebGlobalPath = whatsappWebGlobalPath.replace(':', '')

console.log('whatsappWebGlobalPath: ', whatsappWebGlobalPath)
console.log('process.env.NODE_PATH: ', process.env.NODE_PATH)

const { MessageMedia } = require(whatsappWebGlobalPath)

const logger = require('logger')

const dotenv = require('dotenv')
dotenv.config({ path: '.env' })

const mime = require('mime')
const qrcode = require('qrcode-terminal')
const omnihit = require('./funcs/omnihit.js')
const { allowedNodeEnvironmentFlags } = require('process')

const checkInternetConnection = require('./helpers/checkIntenet')

const mongo = require('./funcs/mongoConn')

const db = mongo.db(process.env.DB_MONGO_NAME)

let auxCampaignMessage = ''



require("./funcs/tools.js")()
let scheduler_messages_outbound
let scheduler_monitor
let scheduler_monitor_cell
let scheduler_campaign_monitor
let scheduler_internet_conn

let client
// const PORT = 80;
let sendSeen = false
let unreadMessaesProcess

const { imageUpload } = require('./helpers/image-uploader')

var QRCODE = "0"
var mobileuid
var destroy
var changeInternetConn = true

let asking_qrcode = false

const dbcc = require('./helpers/mysql_conn.js')

const removeDir = require('./helpers/remove_dir')


// (async()=>{
//     backup_session(destroy)   
//     clearTimeout(destroy)
// })  
// console.log('PASSOU............')
// return


// Sleep
const sleep = (ms) => {
    return new Promise((resolve) => setTimeout(resolve, ms))
}

function getRandomNumber(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min
}

const app = express()

app.use(express.static(path.join(__dirname, 'public')))
//app.use(bodyparser.urlencoded({ extended: true }));
app.use(bodyparser.json())

const sessionName = process.env.MOBILEUID



// console.log('DIRNAME: ', path.join(__dirname, '.wwebjs_auth', 'session-omnihit_sesssion'))

//TEST DEL

console.log('process.env.CLIENT_URL: ', process.env.CLIENT_URL)

console.log('1')
// Connect to server
var io = require('socket.io-client')




// const socket = initIO('http://localhost:8024') 


const socketIo = io(process.env.CLIENT_URL, { reconnect: true, maxHttpBufferSize: 1e8 })

socketIo.on('connect', async function () {
    console.log('Made socket connection', socketIo.id)

    console.log('process.env.WHATSAPP_ID: ', process.env.WHATSAPP_ID)

    socketIo.emit('joinWhatsSession', process.env.WHATSAPP_ID)

    sendSeen = true

    if (mobileuid) {

        console.log('Socket conectado com o cliente: ', mobileuid)

        setTimeout(async () => {

            console.log('Entro no syncUnreadMessages ON CONNECTED SOCKET')
            await syncUnreadMessages(client)

            client.sendPresenceAvailable()

        }, 5000)
    }

})

socketIo.on('message_from_server', function () {
    console.log('message_from_server data: ')
})

// socketIo.on('disconnect', function () {
//     console.log('disconnect');
// });

// var count = 0

// // Send a message to the server 3 seconds after initial connection.
// setInterval(function () {
//     // socketIo.emit('message_from_client', 'Sent an event from the client!');

//     const data = {
//         id: "64d7fa0ce984e1cb781baee0",
//         sent: count
//     }

//     socketIo.emit("campaign_message_sent", data)

//     count++

// }, 3000)

socketIo.on('connect_error', async function (err) {

    console.log('connection errror', err)

    sendSeen = false

    if (mobileuid) {
        client.sendPresenceUnavailable()
    }
})
//

const wwebVersion = '2.2402.5';


//NOVA OPÇÃO MD
client = new Client({
    authStrategy: new LocalAuth({ clientId: 'omnihit_sesssion' }),
    puppeteer: { args: ['--no-sandbox', '--disable-setuid-sandbox'], executablePath: process.env.CHROME_BIN || '/usr/bin/google-chrome-stable' },
    webVersionCache: {
        type: 'remote',
        remotePath: `https://raw.githubusercontent.com/wppconnect-team/wa-version/main/html/${wwebVersion}.html`,
    },
})

client.initialize()

client.on("qr", async qr => {

    console.log("Session:", sessionName)

    //    Generate and scan this code with your phone
    QRCODE = qr
    qrcode.generate(qr, { small: true })
    console.log('QR RECEIVED', qr)

    //  omnihit.qrcode(process.env.MOBILEUID, process.env.MOBILENAME, qr);
    // omnihit.monitor(process.env.MOBILEUID, process.env.MOBILENAME, "STARTUP"); 

    asking_qrcode = true

    await new Promise((resolve, reject) => {

        dbcc.query("UPDATE Whatsapps SET qrcode = ?, status = ?, retries = ? where id = ?", [qr, 'qrcode', 0, process.env.WHATSAPP_ID],

            function (err, result) {

                if (err) {
                    console.log("ERROR: " + err)
                    reject(err)
                }
                else {
                    resolve(result)
                }
            })

    })

    let url = process.env.CLIENT_URL + '/whatsapp/connection/qrcode'

    try {

        let response = await axios.post(url, { whatsappId: process.env.WHATSAPP_ID })

    } catch (error) {
        console.log('There was an error on POST THE DATA TO URL: ', url, '\n' + error)
    }

})

client.on("authenticated", async session => {
    console.log(`Session: ${sessionName} AUTHENTICATED`)
})

client.on("auth_failure", async msg => {
    console.log(
        `Session: ${sessionName} AUTHENTICATION FAILURE! Reason: ${msg}`
    )

    // omnihit.monitor(process.env.MOBILEUID, process.env.MOBILENAME, "AUTHFAILURE");

    //reject(new Error("Error starting whatsapp session."));
})

client.on("ready", async () => {
    console.log(`Session: ${sessionName} READY`)

    // console.log('>>>>>>>>>>>>>> ready client.ts MOBILE NUMBER: ', client.info["wid"]["user"]) 

    mobileuid = client.info["wid"]["user"]
    console.log(new Date().toISOString() + " >>> Mobile UID  ::: " + mobileuid)


    // logger.info(`Session: ${sessionName} READY`);



    const whatsapp = await new Promise((resolve, reject) => {

        dbcc.query("SELECT * from Whatsapps where id = ?", [process.env.WHATSAPP_ID], (err, result) => {

            if (err) {
                reject(err)
            }
            else {
                resolve(result)
            }
        })

    })


    if (whatsapp[0]['name'].includes(client.info["wid"]["user"])) {
        console.log('-----------------> THIS IS THE RIGHT NUMBER')

    }
    else {
        console.log('-----------------> THIS IS THE WRONG NUMBER')
        let read_number = client.info["wid"]["user"]


        let url = process.env.CLIENT_URL + '/whatsapp/connection/number'

        try {

            await client.logout()

            let response = await axios.post(url, { number: read_number })

        } catch (error) {
            console.log('There was an error on POST THE DATA TO URL: ', url, '\n' + error)
        }

        return
    }


    if (process.env.OLD_MOBILEUID) {
        const ticketSettingsId = await new Promise((resolve, reject) => {

            dbcc.query("select id from SettingTickets where number = ?", [process.env.OLD_MOBILEUID,], (err, result) => {

                if (err) {
                    reject(err)
                }
                else {
                    // resolve(result)
                    const idArray = result.map(row => row.id)
                    resolve(idArray)
                }
            })

        })


        if (ticketSettingsId?.length > 0) {
            await new Promise((resolve, reject) => {
                const idsToUpdate = ticketSettingsId // Assuming ticketSettingsId is an array of IDs

                // Create placeholders for the IN clause based on the number of elements in idsToUpdate
                const placeholders = Array(idsToUpdate.length).fill('?').join(',')

                dbcc.query(
                    `UPDATE SettingTickets SET number = ? WHERE id IN (${placeholders})`,
                    [client.info["wid"]["user"], ...idsToUpdate], // Spread the array to pass individual values
                    function (err, result) {
                        if (err) {
                            console.log("ERROR: " + err)
                            reject(err)
                        } else {
                            resolve(result)
                        }
                    }
                )
            })
        }
    }



    await new Promise((resolve, reject) => {

        dbcc.query("UPDATE Whatsapps SET qrcode = ?, status = ?, retries = ?, number = ? where id = ?", ["", 'CONNECTED', 0, client.info["wid"]["user"], process.env.WHATSAPP_ID],

            function (err, result) {

                if (err) {
                    console.log("ERROR: " + err)
                    reject(err)
                }
                else {
                    resolve(result)
                }

            })

    })


    let url = process.env.CLIENT_URL + '/whatsapp/connection/qrcode'

    try {

        let response = await axios.post(url, { whatsappId: process.env.WHATSAPP_ID })

    } catch (error) {
        console.log('There was an error on POST THE DATA TO URL: ', url, '\n' + error)
    }

    console.log('SEND SEEN: ', sendSeen)


    await syncUnreadMessages(client)

    if (sendSeen) {
        client.sendPresenceAvailable()
    }

    // if(asking_qrcode){ 
    //     // backup_session(destroy, 120000, true) 
    // }

    backup_session(destroy, 120000, false)

    asking_qrcode = false

    console.log('PASSOU............')
})


async function read() {
    let chats = await client.getState()
    console.log(chats)
}



client.on("message_create", async msg => {

    // if (msg.hasMedia && msg.fromMe)
    //     return

    if (msg.fromMe && msg.type === "chat" && auxCampaignMessage.trim() == msg?.body?.trim()) {
        console.log('IGNORED MESSAGE SENT CAMPAIGN')
        return
    }

    await handleMessage(msg)


})

client.on("media_uploaded", async msg => {

    console.log('Entrou no midia upload')

    let msgContact = null
    let media = null

    if (msg.fromMe) {

        msgContact = await client.getContactById(msg.to)

    }
    else {

        msgContact = await msg.getContact()

    }

    const chat = await msg.getChat()

    msgContact.getProfilePicUrl = await msgContact.getProfilePicUrl()

    let quotedMsg = await msg.getQuotedMessage()

    if (msg.hasMedia) {
        media = await msg.downloadMedia()
    }

    let data = {
        id: process.env.WHATSAPP_ID,
        msg: msg,
        msgContact: msgContact,
        chat: chat,
        quotedMsg: quotedMsg ? quotedMsg.id.id : null,
        media: media
    }

    socketIo.emit("media_uploaded", data)

})

client.on("message_ack", async (msg, ack) => {

    const campaigSend = await db.collection('campaignsends').findOne({ whatsapp_msg_id: msg.id.id })

    if (campaigSend && ack == 3) {

        const updateResult = await db.collection('campaignsends').updateOne({ _id: ObjectId(campaigSend._id) },
            {
                $set: {
                    read: new Date(new Date() + "UTC"),
                    ack: ack
                }
            })

        // console.log('RESULT ACK UPDATE: ', updateResult)

        const read = await db.collection('campaignsends').countDocuments({ campaignId: ObjectId(campaigSend.campaignId), ack: 3 })

        const data = {
            id: ObjectId(campaigSend.campaignId),
            read: read
        }

        console.log('DATA ACK READ MESSAGE CAMPAIGN: ', data)

        socketIo.emit("campaign_message_sent", data)

        return
    }
    else if (campaigSend && (ack == 2 || ack == 1)) {
        return
    }


    let data = {
        whatsappId: process.env.WHATSAPP_ID,
        id: msg.id.id,
        ack: ack
    }

    socketIo.emit("message_ack", data)

})

socketIo.on('send_message', async data => {

    console.log('#')
    console.log('--------------> send_message from number: ', mobileuid)
    console.log('--------------> send_message to number: ', data.msg.number)
    console.log('--------------> send_message body: ', data.msg.body)
    console.log('--------------> send_message quotedMessageId: ', data.msg.quotedMessageId)
    console.log('--------------> send_message linkPreview: ', data.msg.linkPreview)
    console.log('#')
    const sentMessage = await client.sendMessage(data.msg.number, data.msg.body, { quotedMessageId: data.msg.quotedMessageId, linkPreview: data.msg.linkPreview })

    // console.log('=====================> sentMessage: ', sentMessage)

})


socketIo.on('send_media', async data => {

    console.log('#')
    console.log('--------------> send_message from number: ', mobileuid)
    console.log('--------------> send_message to number: ', data.msg.number)
    // console.log('--------------> send_message media: ', data.msg.media);
    console.log('--------------> send_message sendAudioAsVoice: ', data.msg.sendAudioAsVoice)
    console.log('--------------> data.msg.media.mimetype: ', data.msg.media.mimetype)
    console.log('--------------> data.msg.media.filename: ', data.msg.media.filename)
    console.log('#')

    let media = new MessageMedia(data.msg.media.mimetype, data.msg.media.data, data.msg.media.file)

    if (media && !media.filename)
        media.filename = data.msg.media.filename

    const sentMessage = await client.sendMessage(data.msg.number, media, { sendAudioAsVoice: data.msg.sendAudioAsVoice })

    // const fullFilename = process.cwd() + process.env.MEDIA_DOWNLOAD_IN + data.msg.media.filename;
    // console.log('fullFIlename: ', fullFilename)
    // fs.writeFileSync(fullFilename, data.msg.media.data, { encoding: 'base64' });

})



client.on("change_state", async newState => {

    let omnihit_url = process.env.CLIENT_URL + '/whatsapp/connection/monitor'

    // logger.info(`Monitor session: ${sessionName}, ${newState}`);

    console.log('>>>>>>>>>>>>>> change_state wbotMonitor.ts MOBILE NUMBER: ', client.info["wid"]["user"])

    let data = {
        action: 'change_state',
        whatsappId: process.env.WHATSAPP_ID
    }

    await whatsappMonitor(newState, omnihit_url, data)

})

client.on("disconnected", async reason => {

    let omnihit_url = process.env.CLIENT_URL + '/whatsapp/connection/monitor'

    console.log('>>>>>>>>>>>>>> change_state wbotMonitor.ts MOBILE NUMBER: ', client.info["wid"]["user"])

    let data = {
        action: 'disconnected',
        whatsappId: process.env.WHATSAPP_ID,
        reason: reason
    }


    await removeDir(path.join(__dirname, '.wwebjs_auth', 'session-omnihit_sesssion'))

    setTimeout(() => {
        process.exit()
    }, 3000)

    await whatsappMonitor('OPENING', omnihit_url, data)


})

app.get('/', function (req, res) { return res.send('Express + TypeScript Server') })

app.post('/start', function (req, res) {
    client.initialize()
    res.send("OK")
})

app.post('/qr', function (req, res) {
    res.send(QRCODE)
})


app.post('/api/getWbotMessage', async (req, res) => {

    const { number, messageId, limit } = req.body

    console.log('number: ', number, '  |  limit: ', limit)

    const wbotChat = await client.getChatById(number)

    const fetchWbotMessagesGradually = async () => {

        const chatMessages = await wbotChat.fetchMessages({ limit })

        const msgFound = chatMessages.find(msg => msg.id.id === messageId)

        if (!msgFound && limit < 100) {
            limit += 20
            return fetchWbotMessagesGradually()
        }

        return msgFound
    }

    try {
        const msgFound = await fetchWbotMessagesGradually()

        if (!msgFound) {
            res.status(404).json({ message: "Cannot found message within 100 last messages" })
            return
        }

        res.status(200).json({ message: "ok", data: msgFound })

    } catch (err) {

        console.log('ERR_FETCH_WAPP_MSG: ', err)

        res.status(404).json({ message: "ERR_FETCH_WAPP_MSG" })
    }

})


app.post('/api/disconnect', async (req, res) => {

    try {

        console.log('Restaring the session.........')

        await removeDir(path.join(__dirname, '.wwebjs_auth', 'session-omnihit_sesssion'))

        await client.logout()

        setTimeout(() => {
            process.exit()
        }, 3000)


    } catch (error) {
        console.log('There was an error on try disconnect the whatsapp: ', error)
    }

    res.status(200).json({ message: "ok" })

})


app.post('/api/DeleteWhatsAppMessage', async (req, res) => {

    const { number, messageId, limit } = req.body

    console.log('number: ', number, ' | messageId: ', messageId, ' | limit: ', limit)

    try {

        const messageToDelete = await getWbotMessage(messageId, number, limit)

        await messageToDelete.delete(true)

        res.status(200).json({ message: "ok", data: messageToDelete })
        return

    } catch (error) {

        console.log('There was an error on try delete the massage: ', error)

        res.status(500).json({ message: "There was an error on trying delete the message" })
        return
    }


})


app.post('/api/GetProfilePicUrl', async (req, res) => {

    const { number } = req.body

    console.log('THE NUMBER: ', number)

    const profilePicUrl = await client.getProfilePicUrl(`${number}@c.us`)

    res.status(200).json({ message: "ok", data: profilePicUrl })
})


app.post('/api/restore', async (req, res) => {

    await restore(client)

    res.status(200).json({ message: "ok" })
})

app.post('/api/sendSeen', async (req, res) => {

    let stat

    const { number } = req.body

    try {

        stat = await client.getState()

        // await syncUnreadMessages(client)

        const wbotChat = await client.getChatById(number)

        wbotChat.sendSeen()

        // const chatMessages = await wbotChat.fetchMessages({ limit: 100 });

        // console.log('=============> wbotChat: ', chatMessages)

    } catch (err) {

        let terr = err.message

        stat = (terr.search('Session closed') > -1 ? 'SESSIONCLOSED' : 'UNKNOWN')

    }

    res.status(200).json({ message: "ok" })
})

app.get('/api/connection/status', async (req, res) => {

    let stat

    try {

        stat = await client.getState()

    } catch (err) {

        let terr = err.message

        stat = (terr.search('Session closed') > -1 ? 'SESSIONCLOSED' : 'UNKNOWN')

    }

    res.status(200).json({ message: "ok", data: stat })

})


const syncUnreadMessages = async (wbot) => {

    console.log('ENTROU NO UNREAD MESSAGES +++++++++++++=')

    const chats = await wbot.getChats()

    /* eslint-disable no-restricted-syntax */
    /* eslint-disable no-await-in-loop */
    for (const chat of chats) {

        // console.log('chat: ', chat) 

        if (chat.unreadCount > 0) {

            const unreadMessages = await chat.fetchMessages({
                limit: chat.unreadCount
            })

            for (const msg of unreadMessages) {

                // console.log('--BACKEND MSG: ', msg)

                if (!sendSeen) {
                    return
                }

                await handleMessage(msg, wbot)
            }

            console.log(':::::::::::::::::::::::::::::PASSOU')

            await chat.sendSeen()
        }

    }
}


const getWbotMessage = async (messageId, number, limit,) => {

    const wbotChat = await client.getChatById(number)

    const fetchWbotMessagesGradually = async () => {

        const chatMessages = await wbotChat.fetchMessages({ limit })

        const msgFound = chatMessages.find(msg => msg.id.id === messageId)

        if (!msgFound && limit < 100) {
            limit += 20
            return fetchWbotMessagesGradually()
        }

        return msgFound
    }

    try {
        const msgFound = await fetchWbotMessagesGradually()

        if (!msgFound) {
            return null
        }

        return msgFound

    } catch (err) {

        console.log('ERR_FETCH_WAPP_MSG: ', err)
    }

    return null
}


async function whatsappMonitor(newState, omnihit_url, data) {

    const whatsapp = await whatsappUpdateStatus(newState)

    if (whatsapp && whatsapp.affectedRows) {
        console.log('whatsapp status update affectedRows: ', whatsapp.affectedRows)
    }

    // console.log('  whatsappwhatsappwhatsappwhatsapp: ', whatsapp)


    try {
        let response = await axios.post(omnihit_url, data)
    } catch (error) {
        console.log('There was an error on POST THE DATA TO URL: ', omnihit_url, '\n' + error)
    }
}

async function whatsappUpdateStatus(newState) {
    return await new Promise((resolve, reject) => {

        dbcc.query("UPDATE Whatsapps SET status = ? where id = ?", [newState, process.env.WHATSAPP_ID],
            function (err, result) {
                if (err) {
                    console.log("ERROR: " + err)
                    reject(err)
                }
                else {
                    resolve(result)
                }
            })

    })
}

async function handleMessage(msg) {

    console.log('Entrou no message_create')

    let msgContact = null
    let media = null

    if (msg.fromMe) {

        msgContact = await client.getContactById(msg.to)

    }
    else {

        console.log('#################  RECEIVING MESSAGE FROM: ', msg.from, ' to ', msg.to)

        msgContact = await msg.getContact()

    }

    const chat = await msg.getChat()

    msgContact.getProfilePicUrl = await msgContact.getProfilePicUrl()

    let quotedMsg = await msg.getQuotedMessage()

    if (msg.hasMedia) {
        media = await msg.downloadMedia()
    }

    let data = {
        id: process.env.WHATSAPP_ID,
        msg: msg,
        msgContact: msgContact,
        chat: chat,
        quotedMsg: quotedMsg ? quotedMsg.id.id : null,
        media: media
    }


    socketIo.emit("message_create", data)

}

async function getlabels() {
    var ret = await client.getContactById('551721379544-1625752306@g.us')
    //createGroup('The books', ['551100000000@c.us']); 
    console.log("-- Chats --------------------------------")
    console.log(ret)
    return ret
}

function base64_encode(file) {
    // read binary data
    var bitmap = fs.readFileSync(file)
    // convert binary data to base64 encoded string
    return new Buffer(bitmap).toString('base64')
}

function getBase64(url) {
    return axios
        .get(url, {
            responseType: 'arraybuffer'
        })
        .then(response => Buffer.from(response.data, 'binary').toString('base64'))
}

function downloadMedia(url) {
    let base64 = axios.get(url, { response: "arraybuffer" }).toString("base64")
    console.log("-- BASE64 -------------------------------")
    console.log(base64)
    return base64
}

async function validate(mobile, cb) {

    // let ret = await client.isRegisteredUser(mobile);  

    let ret = await client.isRegisteredUser(`${mobile}@c.us`)

    // ///////////////////////////////////////////////////// 5571992888229 casaes

    let _validNumber = null

    console.log('******** mobile: ', mobile)

    try {

        _validNumber = (await client.getNumberId(`${mobile}@c.us`)).user

    } catch (err) {
        console.log(`Error number: ${err}`)
    }


    console.log('_validNumber: ', _validNumber)

    ////////////////////////////////////////////////////////////////////

    cb({ isValid: ret, number: _validNumber })

    // cb(ret)
}

app.post('/api/validate', (req, res) => {

    console.log('ENTROU')

    let mobile = req.body['mobile']

    console.log(new Date() + " >>> Validating Registration Number ::: " + mobile + " on WhatsApp ...")

    validate(mobile, function (e) {

        res.send(e)

    })
})

app.post('/api/chat', (req, res) => {
    let mobile = req.body['mobile']
    let message = req.body['message']
    console.log(new Date() + " >>> Send Message ::: " + mobile + " ...")
    client.sendMessage(mobile, message)
    res.send('OK')
})


app.post('/group', function (req, res) {
    //var ret = client.createGroup("Prueba", ["55@c.us"]);
    var ret = getlabels()
    res.send(ret)
})

app.post('/stop', function (req, res) {
    client.destroy()
    res.send("OK")
})


app.post('/api/status', function (req, res) {
    res.send("OK")
})

async function monitor() {
    let _nextime = 0
    try {
        clearInterval(scheduler_monitor)
        let stat

        if (mobileuid != undefined) {
            try {
                stat = await client.getState()
            } catch (err) {
                let terr = err.message
                stat = (terr.search('Session closed') > -1 ? 'SESSIONCLOSED' : 'UNKNOWN')
            }
            // omnihit.monitor(process.env.MOBILEUID, process.env.MOBILENAME, stat); 

            _nextime = 30000
        } else {
            _nextime = 10000
        }

        console.log(`WHATSAPP_ID: ${process.env.WHATSAPP_ID} | CLIENT MOBILEUID: ${mobileuid} | NAME: ${process.env.MOBILENAME} | ENV MOBILEUID: ${process.env.MOBILEUID} | STATUS: ${stat} | INTERNET: ${changeInternetConn}`)

        if (stat && stat === 'CONNECTED') {



            const result = await whatsappUpdateStatus('CONNECTED')

            if (result)
                console.log(`Update status to CONNECTED WHATSAPP_ID: ${process.env.WHATSAPP_ID} => result.affectedRows: ${result.affectedRows}`)

        }

    } catch (error) {
        //new Date(new Date() + 'UTC')
        // console.log(new Date().toISOString() + " >>> ", error);
        console.log(new Date(new Date() + 'UTC') + " >>> ", error)
    } finally {
        scheduler_monitor = setInterval(monitor, _nextime)
    }
}


const sendCampaignMessage = async () => {

    try {
        clearInterval(scheduler_campaign_monitor)


        let internetConnection = await checkInternetConnection()

        if (!internetConnection) {
            changeInternetConn = false
        } else {
            changeInternetConn = true
        }

        // let stat
        // try {
        //     stat = await client.getState()
        // } catch (err) {
        //     stat = (err?.message?.search('Session closed') > -1 ? 'SESSIONCLOSED' : 'UNKNOWN')
        // } 
        // console.log('===========> stat: ', stat) 

        if (mobileuid != undefined && internetConnection) {

            auxCampaignMessage = ''

            const campaign = await db.collection('campaigns').findOne({ 'campaign.whatsapp_sender': process.env.MOBILEUID, 'app.status': 'running' })

            if (!campaign)
                return

            const campaigSend = await db.collection('campaignsends').findOne({ campaignId: ObjectId(campaign._id), ack: 1 })

            if (!campaigSend) {

                const countCampaignSend = await db.collection('campaignsends').countDocuments()

                if (countCampaignSend && countCampaignSend > 0) {

                    await db.collection('campaigns').updateOne({ _id: ObjectId(campaign._id) },
                        {
                            $set: {
                                'app.status': 'success'
                            }
                        })

                    const data = {
                        id: ObjectId(campaign._id),
                        status: 'success'
                    }

                    socketIo.emit("campaign_message_sent", data)

                }

                return
            }


            if (campaign.campaign?.textToSeconds &&
                campaign.campaign?.message &&
                campaign.campaign.message.trim().length > 0) {

                let msgMs = Math.round((campaign.campaign.message.trim().length * 0.1) * 1000)

                console.log('AWAITING MESSAGE TEXT LENGTH TO MILISECONDS: ', msgMs)

                await sleep(msgMs)

            }

            if (campaign.campaign?.secondStart && campaign.campaign?.secondEnd) {

                let randomTime = getRandomNumber(campaign.campaign.secondStart, campaign.campaign.secondEnd) * 1000

                console.log('AWAITING RANDOM TIME TO SEND CAMPAIGN MESSAGE: ', randomTime)

                await sleep(randomTime)
            }


            auxCampaignMessage = campaign.campaign.message

            const sentMessage = await client.sendMessage(`${campaigSend.number}@c.us`, campaign.campaign.message)

            if (sentMessage) {

                const updateResult = await db.collection('campaignsends').updateOne({ _id: ObjectId(campaigSend._id) },
                    {
                        $set: {
                            whatsapp_msg_id: sentMessage.id.id,
                            sender: process.env.MOBILEUID,
                            delivered: new Date(new Date() + "UTC"),
                            ack: 2
                        }
                    })

                // console.log('RESULT: ', updateResult)

                const sent = await db.collection('campaignsends').countDocuments({ campaignId: ObjectId(campaign._id), $or: [{ ack: 2 }, { ack: 3 }] })

                const data = {
                    id: ObjectId(campaign._id),
                    sent
                }

                socketIo.emit("campaign_message_sent", data)

            }


        }

    } catch (error) {
        console.log('error on sendCampaignMessage: ', error)
    }
    finally {
        scheduler_campaign_monitor = setInterval(sendCampaignMessage, 3000)
    }
}

async function monitorCell() {

    try {
        clearInterval(scheduler_monitor_cell)
        // let _contact_mobile = "5511954803572@c.us";
        let _message = new Date(new Date() + 'UTC')

        if (client.info && client.info["wid"]["user"]) {
            client.sendMessage(`${process.env.MONITOR_NUMBER}@c.us`, _message)
        }

    } catch (error) {
        console.log(`Error on send monitor message to number ${process.env.MONITOR_NUMBER} from monitorCell function: ${error}`)
    } finally {
        scheduler_monitor_cell = setInterval(monitorCell, 1800000)
    }
}


async function internetMonitor() {
    try {
        clearInterval(scheduler_internet_conn)

        if (!changeInternetConn) {

            console.log('INTERNET IS OFFLINE. THE PM2 WILL RESTORE THE PROCESS')

            process.exit()
        }

    } catch (error) {
        console.log(`Error on try kill the process from internetMonitor function`)
    } finally {
        scheduler_internet_conn = setInterval(internetMonitor, 60000)
    }
}


function comercialBuss(until_hour) {
    const _hour = new Date().getHours()

    console.log('                         _hour: ', _hour)
    // const _minute = new Date().getMinutes()
    // const _second = new Date().getSeconds()

    if (_hour >= until_hour) {
        console.log('Trying send message into comercial buss!')
        return
    }
}


scheduler_monitor = setInterval(monitor, 10000)

// scheduler_campaign_monitor = setInterval(sendCampaignMessage, 3000)

// scheduler_internet_conn = setInterval(internetMonitor, 60000)

app.listen(process.env.PORT || 8003, function () {
    console.log("\u26A1[server]: Server is running at Port ::: " + process.env.PORT || 8003)
})


process.on('uncaughtException', function (err) {
    console.error(' ')
    console.error('----- ' + (new Date).toUTCString() + ' ----------------------------------')
    console.error('Erro uncaughtException: ', err.message)
    console.error(err.stack)
    console.error(' ')
    return
});