const { Client, LocalAuth, MessageMedia } = require('whatsapp-web.js');
const express = require('express');
const socketIO = require('socket.io');
const qrcode = require('qrcode');
const http = require('http');
const fileUpload = require('express-fileupload');
const port = 8000;
const app = express();
const server = http.createServer(app);
const io = socketIO(server);
const axios = require('axios');
const fs = require('fs');
const path = require('path');
const url = 'http://172.22.63.118:3002/api/v1/';
const typebot = 'zdg';
const dirBot = './typebot';

if (!fs.existsSync(dirBot)){
    fs.mkdirSync(dirBot)
}

app.use(express.json());
app.use(express.urlencoded({
  extended: true
}));
app.use(fileUpload({
  debug: true
}));
app.use("/", express.static(__dirname + "/"))
app.get('/', (req, res) => {
  res.sendFile('index.html', {
    root: __dirname
  });
});

const client = new Client({
  authStrategy: new LocalAuth({ clientId: 'typebot' }),
  puppeteer: { headless: true,
    executablePath: "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
    args: [
      '--no-sandbox',
      '--disable-setuid-sandbox',
      '--disable-dev-shm-usage',
      '--disable-accelerated-2d-canvas',
      '--no-first-run',
      '--no-zygote',
      '--single-process', // <- this one doesn't works in Windows
      '--disable-gpu'
    ] }
});

client.initialize();

io.on('connection', function(socket) {
  socket.emit('message', '© BOT-ZDG - Iniciado');
  socket.emit('qr', './icon.svg');

client.on('qr', (qr) => {
    console.log('QR RECEIVED', qr);
    qrcode.toDataURL(qr, (err, url) => {
      socket.emit('qr', url);
      socket.emit('message', '© BOT-ZDG QRCode recebido, aponte a câmera  seu celular!');
    });
});

client.on('ready', async () => {
    socket.emit('ready', '© BOT-ZDG Dispositivo pronto!');
    socket.emit('message', '© BOT-ZDG Dispositivo pronto!');
    socket.emit('qr', './check.svg')	
    console.log('© BOT-ZDG Dispositivo pronto');
});

client.on('authenticated', () => {
    socket.emit('authenticated', '© BOT-ZDG Autenticado!');
    socket.emit('message', '© BOT-ZDG Autenticado!');
    console.log('© BOT-ZDG Autenticado');
});

client.on('auth_failure', function() {
    socket.emit('message', '© BOT-ZDG Falha na autenticação, reiniciando...');
    console.error('© BOT-ZDG Falha na autenticação');
});

client.on('change_state', state => {
  console.log('© BOT-ZDG Status de conexão: ', state );
});

client.on('disconnected', (reason) => {
  socket.emit('message', '© BOT-ZDG Cliente desconectado!');
  console.log('© BOT-ZDG Cliente desconectado', reason);
  client.initialize();
});
});

function deleteDirectory(dirPath) {
  if (fs.existsSync(dirPath)) {
    const files = fs.readdirSync(dirPath);
    files.forEach((file) => {
      const filePath = path.join(dirPath, file);
      if (fs.statSync(filePath).isDirectory()) {
        deleteDirectory(filePath);
      } else {
        fs.unlinkSync(filePath);
      }
    });
    try {
      fs.rmdirSync(dirPath);
      console.log(`Diretório ${dirPath} deletado com sucesso.`);
    } catch (error) {
      console.error(`Erro ao deletar diretório ${dirPath}:`, error);
    }
  } else {
    console.log(`O diretório ${dirPath} não existe.`);
  }
}

async function readWriteFileJson(sessionId, from) {
  let dataFile = [];
  fs.writeFileSync("./typebot/" + from + "/typebot.json", JSON.stringify(dataFile));
  var data = fs.readFileSync("./typebot/" + from + "/typebot.json");
  var myObject = JSON.parse(data);
  let newData = {
    id: sessionId,
  };
  await myObject.push(newData);
  fs.writeFileSync("./typebot/" + from + "/typebot.json", JSON.stringify(myObject));
}

async function createSession(data){
  let config = {
    method: 'post',
    maxBodyLength: Infinity,
    url: `${url}typebots/${typebot}/startChat`,
    headers: { 
      'Content-Type': 'application/json', 
      'Accept': 'application/json'
    }
  };

  const response = await axios.request(config);
  console.log('createSession' + response.data)
    const dirFrom = './typebot/' + data.from.replace(/\D/g,'');
    if (!fs.existsSync(dirFrom)){
      fs.mkdirSync(dirFrom);
      await readWriteFileJson(response.data.sessionId, data.from.replace(/\D/g,''));
    }
  return response.data
}

async function continueSession(data, msg){
  let dataMessage = JSON.stringify({
    "message": msg
  });

  let config = {
    method: 'post',
    maxBodyLength: Infinity,
    url: `${url}sessions/${data}/continueChat`,
    headers: { 
      'Content-Type': 'application/json', 
      'Accept': 'application/json'
    },
    data : dataMessage
  };

  const response = await axios.request(config);
  console.log('continueSession', response.data)
  return response.data
}

const timer = ms => new Promise(res => setTimeout(res, ms))
function randomIntFromInterval(min, max) {
  return Math.floor(Math.random() * (max - min + 1) + min)
}
const rndInt = randomIntFromInterval(1, 3)

client.on('message', async msg => {
  const dirFrom = './typebot/' + msg.from.replace(/\D/g,'');
  if (msg.body === 'sair'){
    await deleteDirectory(dirFrom)
    await client.sendMessage(msg.from, 'Atendimento automático reiniciado.')
  }
  if (msg.body !== 'sair'){
    if (!fs.existsSync(dirFrom)){
      const session = await createSession(msg);
      const messages = session.messages
      for (const message of messages){
        if (message.type === 'text') {
          let formattedText = '';
          for (const richText of message.content.richText){
            for (const element of richText.children){
              let text = '';
              if (element.text) {
                  text = element.text;
              }
              if (element.bold) {
                  text = `*${text}*`;
              }
              if (element.italic) {
                  text = `_${text}_`;
              }
              if (element.underline) {
                  text = `~${text}~`;
              }
              formattedText += text;          
            }
            formattedText += '\n';
          }
          formattedText = formattedText.replace(/\n$/, '');
          await client.sendMessage(msg.from, formattedText);
          await timer(rndInt * 1000)
        }
        if (message.type === 'image' || message.type === 'video') {
          try{
            const media = await MessageMedia.fromUrl(message.content.url)
            await client.sendMessage(msg.from, media, {caption: 'Comunidade ZDG'})
            await timer(rndInt * 1000)
          }catch(e){}
        }
        if (message.type === 'audio') {
          try{
            const media = await MessageMedia.fromUrl(message.content.url)
            await client.sendMessage(msg.from, media, {sendAudioAsVoice: true})
            await timer(rndInt * 1000)
          }catch(e){}
        }
      }
      const input = session.input
      if (input) {
        if (input.type === 'choice input') {
          let formattedText = '';
          const items = input.items;
          for (const item of items) {
            formattedText += `▶️ ${item.content}\n`;
          }
          formattedText = formattedText.replace(/\n$/, '');
          await client.sendMessage(msg.from, formattedText);
          await timer(rndInt * 1000)
        }
      }
    }
    else {
      const from = msg.from.replace(/\D/g,'');
      const sessionId = fs.readFileSync("./typebot/" + from + "/typebot.json","utf8").split(':')[1].replace(/\W/g, '');
      const session = await continueSession(sessionId, msg.body);
      const messages = session.messages
      for (const message of messages){
        if (message.type === 'text') {
          let formattedText = '';
          for (const richText of message.content.richText){
            for (const element of richText.children){
              let text = '';
              if (element.text) {
                  text = element.text;
              }
              if (element.bold) {
                  text = `*${text}*`;
              }
              if (element.italic) {
                  text = `_${text}_`;
              }
              if (element.underline) {
                  text = `~${text}~`;
              }
              formattedText += text;          
            }
            formattedText += '\n';
          }
          formattedText = formattedText.replace(/\n$/, '');
          await client.sendMessage(msg.from, formattedText);
          await timer(rndInt * 1000)
        }
        if (message.type === 'image' || message.type === 'video') {
          try{
            const media = await MessageMedia.fromUrl(message.content.url)
            await client.sendMessage(msg.from, media, {caption: 'Comunidade ZDG'})
            await timer(rndInt * 1000)
          }catch(e){}
        }
        if (message.type === 'audio') {
          try{
            const media = await MessageMedia.fromUrl(message.content.url)
            await client.sendMessage(msg.from, media, {sendAudioAsVoice: true})
            await timer(rndInt * 1000)
          }catch(e){}
        }
      }
      const input = session.input
      if (input) {
        if (input.type === 'choice input') {
          let formattedText = '';
          const items = input.items;
          for (const item of items) {
            formattedText += `▶️ ${item.content}\n`;
          }
          formattedText = formattedText.replace(/\n$/, '');
          await client.sendMessage(msg.from, formattedText);
          await timer(rndInt * 1000)
        }
      }
    }
  }
});
   
server.listen(port, function() {
  console.log('App running on *: ' + port);
});