import SetTicketMessagesAsRead from "../helpers/SetTicketMessagesAsRead";
import ShowTicketService from "../services/TicketServices/ShowTicketService";
import SendWhatsAppMessage from "../services/WbotServices/SendWhatsAppMessage";

import ListSchedulingNotifyService from "../services/SchedulingNotifyServices/ListSchedulingNotifyService";
import DeleteSchedulingNotifyService from "../services/SchedulingNotifyServices/DeleteSchedulingNotifyService";
import { getIO } from "../libs/socket";
import ListWhatsAppsService from "../services/WhatsappService/ListWhatsAppsService";
import path from "path";
import { convertBytes } from "./ConvertBytes";
import { deleteScheduleByTicketIdCache } from "./SchedulingNotifyCache";
import SchedulingNotify from "../models/SchedulingNotify";
import Ticket from "../models/Ticket";
import User from "../models/User";
import { Sequelize, Op } from "sequelize";
import omnihitDashboardSession from "./OmnhitDashboardSession";

const fastFolderSize = require("fast-folder-size");
const { promisify } = require("util");
const fs = require("fs");

const { exec } = require("child_process");

let _fifo: any;

let scheduler_monitor: any;
let timeInterval = 5;

const monitor = async () => {
  let date = new Date();

  let day = date.getDate().toString().padStart(2, "0");
  let month = (date.getMonth() + 1).toString().padStart(2, "0");
  let year = date.getFullYear();

  let hour = date.getHours();
  let minute = date.getMinutes();

  let fullDate = `${year}-${month}-${day}`;
  let dateParm = `${fullDate} ${hour.toString().padStart(2, "0")}:${minute
    .toString()
    .padStart(2, "0")}:00`;

  //console.log(dateParm);

  try {
    const { schedulingNotifies, count, hasMore } =
      await ListSchedulingNotifyService({
        searchParam: dateParm,
        pageNumber: "1"
      });

    if (schedulingNotifies && schedulingNotifies.length > 0) {
      for (let i = 0; i < schedulingNotifies.length; i++) {
        const ticket: any = await ShowTicketService(
          +schedulingNotifies[i].ticketId
        );

        let _ticket = await Ticket.findOne({
          where: {
            contactId: ticket.contactId,
            status: { [Op.in]: ["open", "pending"] }
          }
        });

        await deleteScheduleByTicketIdCache(schedulingNotifies[i].ticketId);

        await DeleteSchedulingNotifyService(schedulingNotifies[i].id);

        if (_ticket) continue;

        if (ticket.dataValues.status == "closed") {
          await ticket.update({ status: "open" });
        }
        const userId: number = ticket.getDataValue("userId");
        let userN = "";
        if (userId) {
          const useer = await User.findByPk(userId);
          if (useer) {
            const userName: string = useer.getDataValue("name");
            userN = `*${userName}:* \n`;
          }
        }

        await new Promise(f => setTimeout(f, 3000));
        await SendWhatsAppMessage({
          body: userN + schedulingNotifies[i].message,
          ticket
        });
      }
    }

    exec("df -h /", (error: any, stdout: any, stderr: any) => {
      if (error) {
        console.log(`exec error: ${error.message}`);
        return;
      }
      if (stderr) {
        console.log(`exec stderr: ${stderr}`);
        return;
      }

      stdout = stdout.split(/\r?\n/);
      stdout = stdout[1].trim().split(/\s+/);

      // DISK SPACE MONITORING
      // const io = getIO();
      // io.emit("diskSpaceMonit", {
      //   action: "update",
      //   diskSpace: {
      //     size: stdout[1],
      //     used: stdout[2],
      //     available: stdout[3],
      //     use: stdout[4]
      //   }
      // });

      let data: any = {};

      data.diskSpace = {
        DB: process.env.DB_NAME,
        size: stdout[1],
        used: stdout[2],
        available: stdout[3],
        use: stdout[4]
      };
      data.action = "update";
      omnihitDashboardSession(data);
    });
 
  } catch (error) {
    console.log(">>> SchedulingNotifiySendMessage.ts error: ", error);
  }
};

const SchedulingNotifySendMessage = async () => {
  try {
    clearInterval(_fifo);

    await monitor();
  } catch (error) {
    console.log("error on SchedulingNotifySendMessage: ", error);
  } finally {
    _fifo = setInterval(SchedulingNotifySendMessage, 5000);
  }
};

_fifo = setInterval(SchedulingNotifySendMessage, 5000);

module.exports = SchedulingNotifySendMessage;
