const path = require('path');
const ejs = require('ejs');
const nodemailer = require('nodemailer');
const LibWinston = require('./LibWinston');

const logName = 'libMail';
const Logger = LibWinston.initialize(logName);

class LibMail {

  static createTransport() {
    return new Promise((resolve, reject) => {
      try {
        const transporter = nodemailer.createTransport({
          host: process.env.SMTP_HOST,
          port: process.env.SMTP_PORT,
          auth: {
            user: process.env.SMTP_USER,
            pass: process.env.SMTP_PASW,
          },
          pool: true,
          // connectionTimeout: 10000,
          // greetingTimeout: 5000,
          // socketTimeout: 5000,
          // maxConnections: 10,
          // maxMessages: 500,
          // secure: false,
          // tls: {
          //     rejectUnauthorized: false
          // }
        });

        transporter.verify(function (err, success) {
          if (err) {
            transporter.close();
            // reject(err);
            resolve({
              type: 'error',
              e: err,
            });
            return false;
          }
          return resolve({
            type: 'success',
            transporter,
          });
        });
      } catch (e) {
        // reject(e);
        resolve({
          type: 'error',
          e,
        });
      }
    });
  }

  static async initializeTransport() {
    return new Promise(async (resolve, reject) => {
      try {
        let conn = await LibMail.createTransport();
        if (conn.type != 'success') {
          conn = await LibMail.createTransport();
        } else {
          if (!conn.transporter.isIdle()) {
            conn = await LibMail.createTransport();
          }
        }
        if (conn.type != 'success') {
          conn = await LibMail.createTransport();
        } else {
          if (!conn.transporter.isIdle()) {
            conn = await LibMail.createTransport();
          }
        }
        if (conn.type != 'success') {
          resolve({
            type: conn.type,
            e: conn.e,
          });
          return false;
        } else {
          if (!conn.transporter.isIdle()) {
            resolve({
              type: 'fail',
              msg: 'transporter not idle',
            });
            return false;
          }
        }

        resolve({
          type: 'success',
          transporter: conn.transporter,
        });
      } catch (e) {
        // reject(e);
        resolve({
          type: 'error',
          e,
        });
      }
    })
  }

  static async sendVhcSpawnZoneMail(subject, to, mailData) {
    return new Promise(async (resolve, reject) => {
      try {
        const { pic_name, pic_mail, z_name, z_type_name, z_workflow_name, shiptocode, z_fulladdress, v_nopol, da_name, da_phone, } = mailData;

        const initTransport = await LibMail.initializeTransport();
        if (initTransport.type != 'success') {
          Logger.log('error', `${logName} transporter_error vhcSpawnZoneMail: ${JSON.stringify(initTransport)}`);
          resolve({
            type: initTransport.type,
            msg: initTransport.msg,
            e: initTransport.e,
          });
          return false;
        }
        const transporter = initTransport.transporter;

        const renderData = {
          pic_name,
          pic_mail,
          z_name,
          z_type_name,
          z_workflow_name,
          shiptocode,
          z_fulladdress,
          v_nopol,
          da_name,
          da_phone,
          cs_phone: process.env.CS_PHONE,
          cs_mail: process.env.CS_MAIL,
          cs_addr: process.env.CS_ADDR,
          asset: process.env.MAIL_ASSET,
        }
        ejs.renderFile(path.join(__dirname, '../files/mails/zoningMail.ejs'), renderData, function (err, html) {
          if (err) {
            Logger.log('error', `${logName} rendering_fail vhcSpawnZoneMail: ${JSON.stringify(err)}`);
            // reject(err);
            console.error(err);
            resolve({
              type: 'error',
              e: err,
            });
            return false;
          }
          const options = {
            from: process.env.SMTP_FROM,
            to,
            subject,
            html,
          };
          transporter.sendMail(options, function (err, info) {
            if (err) {
              Logger.log('error', `${logName} sending_fail vhcSpawnZoneMail: ${JSON.stringify(err)}`);
              // reject(err);
              console.error(err);
              resolve({
                type: 'error',
                e: err,
              });
              return false;
            }
            resolve({
              type: 'success',
              info,
            });
          });
        });
      } catch (e) {
        Logger.log('error', `${logName} sending_error vhcSpawnZoneMail: ${JSON.stringify(e)}`);
        // reject(e);
        console.error(e);
        resolve({
          type: 'error',
          e,
        });
      }
    });
  }

  static async sendBidOrderMail(subject, to, mailData) {
    return new Promise(async (resolve, reject) => {
      try {
        const {
          trx_code,
          // client_id,
          client_name,
          client_phone,
          client_mail,
          // client_addr,
          client_prefer_type_truck,
          // weight,
          // cbm,
          // koli,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
          // vendor_id,
          vendor_name,
          vendor_phone,
          vendor_mail,
          // vendor_addr,
          vendor_acc_link,
          // vendor_reject_link,
        } = mailData;

        const initTransport = await LibMail.initializeTransport();
        if (initTransport.type != 'success') {
          Logger.log('error', `${logName} transporter_error bidOrderMaill: ${JSON.stringify(initTransport)}`);
          resolve({
            type: initTransport.type,
            msg: initTransport.msg,
            e: initTransport.e,
          });
          return false;
        }
        const transporter = initTransport.transporter;

        const renderData = {
          trx_code,
          // client_id,
          client_name,
          client_phone,
          client_mail,
          // client_addr,
          client_prefer_type_truck,
          // weight,
          // cbm,
          // koli,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
          // vendor_id,
          vendor_name,
          vendor_phone,
          vendor_mail,
          // vendor_addr,
          vendor_acc_link,
          // vendor_reject_link,
          cs_phone: process.env.CS_PHONE,
          cs_mail: process.env.CS_MAIL,
          cs_addr: process.env.CS_ADDR,
          asset: process.env.MAIL_ASSET,
        }
        ejs.renderFile(path.join(__dirname, '../files/mails/bidOrderMail.ejs'), renderData, function (err, html) {
          if (err) {
            Logger.log('error', `${logName} rendering_fail bidOrderMaill: ${JSON.stringify(err)}`);
            // reject(err);
            console.error(err);
            resolve({
              type: 'error',
              e: err,
            });
            return false;
          }
          const options = {
            from: process.env.SMTP_FROM,
            to,
            subject,
            html,
          };
          transporter.sendMail(options, function (err, info) {
            if (err) {
              Logger.log('error', `${logName} sending_fail bidOrderMaill: ${JSON.stringify(err)}`);
              // reject(err);
              console.error(err);
              resolve({
                type: 'error',
                e: err,
              });
              return false;
            }
            resolve({
              type: 'success',
              info,
            });
          });
        });
      } catch (e) {
        Logger.log('error', `${logName} sending_error bidOrderMaill: ${JSON.stringify(e)}`);
        // reject(e);
        console.error(e);
        resolve({
          type: 'error',
          e,
        });
      }
    });
  }

  static async sendClientCreateOrdMail(subject, to, mailData) {
    return new Promise(async (resolve, reject) => {
      try {
        const {
          trx_code,
          trx_at,
          client_id,
          client_name,
          client_phone,
          client_mail,
          client_addr,
          client_prefer_type_truck,
          // weight,
          // cbm,
          // koli,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
        } = mailData;

        const initTransport = await LibMail.initializeTransport();
        if (initTransport.type != 'success') {
          Logger.log('error', `${logName} transporter_error clientCreateOrdMail: ${JSON.stringify(initTransport)}`);
          resolve({
            type: initTransport.type,
            msg: initTransport.msg,
            e: initTransport.e,
          });
          return false;
        }
        const transporter = initTransport.transporter;

        const renderData = {
          trx_code,
          trx_at,
          // client_id,
          client_name,
          client_phone,
          client_mail,
          // client_addr,
          client_prefer_type_truck,
          // weight,
          // cbm,
          // koli,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
          cs_phone: process.env.CS_PHONE,
          cs_mail: process.env.CS_MAIL,
          cs_addr: process.env.CS_ADDR,
          asset: process.env.MAIL_ASSET,
        }
        ejs.renderFile(path.join(__dirname, '../files/mails/clientCreateOrd.ejs'), renderData, function (err, html) {
          if (err) {
            Logger.log('error', `${logName} rendering_fail clientCreateOrdMail: ${JSON.stringify(err)}`);
            // reject(err);
            console.error(err);
            resolve({
              type: 'error',
              e: err,
            });
            return false;
          }
          const options = {
            from: process.env.SMTP_FROM,
            to,
            subject,
            html,
          };
          transporter.sendMail(options, function (err, info) {
            if (err) {
              Logger.log('error', `${logName} sending_fail clientCreateOrdMail: ${JSON.stringify(err)}`);
              // reject(err);
              console.error(err);
              resolve({
                type: 'error',
                e: err,
              });
              return false;
            }
            resolve({
              type: 'success',
              info,
            });
          });
        });
      } catch (e) {
        Logger.log('error', `${logName} sending_error clientCreateOrdMail: ${JSON.stringify(e)}`);
        // reject(e);
        console.error(e);
        resolve({
          type: 'error',
          e,
        });
      }
    });
  }

  static async sendAdminInfoOrdMail(subject, to, mailData) {
    return new Promise(async (resolve, reject) => {
      try {
        const {
          trx_code,
          trx_at,
          admin_id,
          admin_name,
          admin_phone,
          admin_mail,
          client_id,
          client_name,
          client_phone,
          client_mail,
          client_addr,
          client_prefer_type_truck,
          // weight,
          // cbm,
          // koli,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
        } = mailData;

        const initTransport = await LibMail.initializeTransport();
        if (initTransport.type != 'success') {
          Logger.log('error', `${logName} transporter_error admInfoOrdMail: ${JSON.stringify(initTransport)}`);
          resolve({
            type: initTransport.type,
            msg: initTransport.msg,
            e: initTransport.e,
          });
          return false;
        }
        const transporter = initTransport.transporter;

        const renderData = {
          trx_code,
          trx_at,
          // admin_id,
          admin_name,
          admin_phone,
          admin_mail,
          // client_id,
          client_name,
          client_phone,
          client_mail,
          // client_addr,
          // client_prefer_type_truck,
          // weight,
          // cbm,
          // koli,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
          cs_phone: process.env.CS_PHONE,
          cs_mail: process.env.CS_MAIL,
          cs_addr: process.env.CS_ADDR,
          asset: process.env.MAIL_ASSET,
        }
        ejs.renderFile(path.join(__dirname, '../files/mails/admInfoOrder.ejs'), renderData, function (err, html) {
          if (err) {
            Logger.log('error', `${logName} rendering_fail admInfoOrdMail: ${JSON.stringify(err)}`);
            // reject(err);
            console.error(err);
            resolve({
              type: 'error',
              e: err,
            });
            return false;
          }
          const options = {
            from: process.env.SMTP_FROM,
            to,
            subject,
            html,
          };
          transporter.sendMail(options, function (err, info) {
            if (err) {
              Logger.log('error', `${logName} sending_fail admInfoOrdMail: ${JSON.stringify(err)}`);
              // reject(err);
              console.error(err);
              resolve({
                type: 'error',
                e: err,
              });
              return false;
            }
            resolve({
              type: 'success',
              info,
            });
          });
        });
      } catch (e) {
        Logger.log('error', `${logName} sending_error admInfoOrdMail: ${JSON.stringify(e)}`);
        // reject(e);
        console.error(e);
        resolve({
          type: 'error',
          e,
        });
      }
    });
  }

  static async sendAdminInfoNoVdrAccOrd(subject, to, mailData) {
    return new Promise(async (resolve, reject) => {
      try {
        const {
          trx_code,
          trx_at,
          admin_id,
          admin_name,
          admin_phone,
          admin_mail,
          client_id,
          client_name,
          client_phone,
          client_mail,
          client_addr,
          client_prefer_type_truck,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
        } = mailData;

        const initTransport = await LibMail.initializeTransport();
        if (initTransport.type != 'success') {
          Logger.log('error', `${logName} transporter_error adminInfoNoVdrAccOrd: ${JSON.stringify(initTransport)}`);
          resolve({
            type: initTransport.type,
            msg: initTransport.msg,
            e: initTransport.e,
          });
          return false;
        }
        const transporter = initTransport.transporter;

        const renderData = {
          trx_code,
          trx_at,
          // admin_id,
          admin_name,
          admin_phone,
          admin_mail,
          // client_id,
          client_name,
          client_phone,
          client_mail,
          // client_addr,
          // client_prefer_type_truck,
          // weight,
          // cbm,
          // koli,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
          cs_phone: process.env.CS_PHONE,
          cs_mail: process.env.CS_MAIL,
          cs_addr: process.env.CS_ADDR,
          asset: process.env.MAIL_ASSET,
        }

        ejs.renderFile(path.join(__dirname, '../files/mails/adminInfoNoVdrAccOrd.ejs'), renderData, function (err, html) {
          if (err) {
            Logger.log('error', `${logName} rendering_fail adminInfoNoVdrAccOrd: ${JSON.stringify(err)}`);
            // reject(err);
            console.error(err);
            resolve({
              type: 'error',
              e: err,
            });
            return false;
          }
          const options = {
            from: process.env.SMTP_FROM,
            to,
            subject,
            html,
          };
          transporter.sendMail(options, function (err, info) {
            if (err) {
              Logger.log('error', `${logName} sending_fail adminInfoNoVdrAccOrd: ${JSON.stringify(err)}`);
              // reject(err);
              console.error(err);
              resolve({
                type: 'error',
                e: err,
              });
              return false;
            }
            resolve({
              type: 'success',
              info,
            });
          });
        });
      } catch (e) {
        Logger.log('error', `${logName} sending_error adminInfoNoVdrAccOrd: ${JSON.stringify(e)}`);
        // reject(e);
        console.error(e);
        resolve({
          type: 'error',
          e,
        });
      }
    });
  }

  static async sendDrvGetOrderMail(subject, to, mailData) {
    return new Promise(async (resolve, reject) => {
      try {
        const {
          trx_code,
          // client_id,
          client_name,
          client_phone,
          client_mail,
          // client_addr,
          client_prefer_type_truck,
          // weight,
          // cbm,
          // koli,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
          // driver_id,
          driver_name,
          driver_phone,
          driver_mail,
          // driver_addr,
          acc_at,
        } = mailData;

        const initTransport = await LibMail.initializeTransport();
        if (initTransport.type != 'success') {
          Logger.log('error', `${logName} transporter_error drvGetOrderMail: ${JSON.stringify(initTransport)}`);
          resolve({
            type: initTransport.type,
            msg: initTransport.msg,
            e: initTransport.e,
          });
          return false;
        }
        const transporter = initTransport.transporter;

        const renderData = {
          trx_code,
          // client_id,
          client_name,
          client_phone,
          client_mail,
          // client_addr,
          client_prefer_type_truck,
          // weight,
          // cbm,
          // koli,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
          // driver_id,
          driver_name,
          driver_phone,
          driver_mail,
          // driver_addr,
          acc_at,
          cs_phone: process.env.CS_PHONE,
          cs_mail: process.env.CS_MAIL,
          cs_addr: process.env.CS_ADDR,
          asset: process.env.MAIL_ASSET,
        }
        ejs.renderFile(path.join(__dirname, '../files/mails/driverGetOrderMail.ejs'), renderData, function (err, html) {
          if (err) {
            Logger.log('error', `${logName} rendering_fail drvGetOrderMail: ${JSON.stringify(err)}`);
            // reject(err);
            console.error(err);
            resolve({
              type: 'error',
              e: err,
            });
            return false;
          }
          const options = {
            from: process.env.SMTP_FROM,
            to,
            subject,
            html,
          };
          transporter.sendMail(options, function (err, info) {
            if (err) {
              Logger.log('error', `${logName} sending_fail drvGetOrderMail: ${JSON.stringify(err)}`);
              // reject(err);
              console.error(err);
              resolve({
                type: 'error',
                e: err,
              });
              return false;
            }
            resolve({
              type: 'success',
              info,
            });
          });
        });
      } catch (e) {
        Logger.log('error', `${logName} sending_error drvGetOrderMail: ${JSON.stringify(e)}`);
        // reject(e);
        console.error(e);
        resolve({
          type: 'error',
          e,
        });
      }
    });
  }

  static async sendVdrAccOrderMail(subject, to, mailData) {
    return new Promise(async (resolve, reject) => {
      try {
        const {
          trx_code,
          // client_id,
          client_name,
          client_phone,
          client_mail,
          // client_addr,
          client_prefer_type_truck,
          // weight,
          // cbm,
          // koli,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
          // vendor_id,
          vendor_name,
          vendor_phone,
          vendor_mail,
          // vendor_addr,
          acc_at,
        } = mailData;

        const initTransport = await LibMail.initializeTransport();
        if (initTransport.type != 'success') {
          Logger.log('error', `${logName} transporter_error vdrAccOrderMail: ${JSON.stringify(initTransport)}`);
          resolve({
            type: initTransport.type,
            msg: initTransport.msg,
            e: initTransport.e,
          });
          return false;
        }
        const transporter = initTransport.transporter;

        const renderData = {
          trx_code,
          // client_id,
          client_name,
          client_phone,
          client_mail,
          // client_addr,
          client_prefer_type_truck,
          // weight,
          // cbm,
          // koli,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
          // vendor_id,
          vendor_name,
          vendor_phone,
          vendor_mail,
          // vendor_addr,
          acc_at,
          cs_phone: process.env.CS_PHONE,
          cs_mail: process.env.CS_MAIL,
          cs_addr: process.env.CS_ADDR,
          asset: process.env.MAIL_ASSET,
        }
        ejs.renderFile(path.join(__dirname, '../files/mails/vdrAccOrderMail.ejs'), renderData, function (err, html) {
          if (err) {
            Logger.log('error', `${logName} rendering_fail vdrAccOrderMail: ${JSON.stringify(err)}`);
            // reject(err);
            console.error(err);
            resolve({
              type: 'error',
              e: err,
            });
            return false;
          }
          const options = {
            from: process.env.SMTP_FROM,
            to,
            subject,
            html,
          };
          transporter.sendMail(options, function (err, info) {
            if (err) {
              Logger.log('error', `${logName} sending_fail vdrAccOrderMail: ${JSON.stringify(err)}`);
              // reject(err);
              console.error(err);
              resolve({
                type: 'error',
                e: err,
              });
              return false;
            }
            resolve({
              type: 'success',
              info,
            });
          });
        });
      } catch (e) {
        Logger.log('error', `${logName} sending_error vdrAccOrderMail: ${JSON.stringify(e)}`);
        // reject(e);
        console.error(e);
        resolve({
          type: 'error',
          e,
        });
      }
    });
  }

  static async sendClientOrderHaveBeenAccMail(subject, to, mailData) {
    return new Promise(async (resolve, reject) => {
      try {
        const {
          trx_code,
          // client_id,
          client_name,
          client_phone,
          client_mail,
          // client_addr,
          client_prefer_type_truck,
          // weight,
          // cbm,
          // koli,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
          // vendor_id,
          vendor_name,
          vendor_phone,
          vendor_mail,
          // vendor_addr,
          // driver_id,
          driver_name,
          driver_phone,
          driver_mail,
          // driver_addr,
          acc_at,
        } = mailData;

        const initTransport = await LibMail.initializeTransport();
        if (initTransport.type != 'success') {
          Logger.log('error', `${logName} transporter_error clientOrdHaveBeenAccMail: ${JSON.stringify(initTransport)}`);
          resolve({
            type: initTransport.type,
            msg: initTransport.msg,
            e: initTransport.e,
          });
          return false;
        }
        const transporter = initTransport.transporter;

        const renderData = {
          trx_code,
          // client_id,
          client_name,
          client_phone,
          client_mail,
          // client_addr,
          client_prefer_type_truck,
          // weight,
          // cbm,
          // koli,
          pickup_zone_title,
          pickup_zone_addr,
          pickup_at,
          drop_zone_title,
          drop_zone_addr,
          // vendor_id,
          vendor_name,
          vendor_phone,
          vendor_mail,
          // vendor_addr,
          // driver_id,
          driver_name,
          driver_phone,
          driver_mail,
          // driver_addr,
          acc_at,
          cs_phone: process.env.CS_PHONE,
          cs_mail: process.env.CS_MAIL,
          cs_addr: process.env.CS_ADDR,
          asset: process.env.MAIL_ASSET,
        }
        ejs.renderFile(path.join(__dirname, '../files/mails/clientOrdHaveBeenAccMail.ejs'), renderData, function (err, html) {
          if (err) {
            Logger.log('error', `${logName} rendering_fail clientOrdHaveBeenAccMail: ${JSON.stringify(err)}`);
            // reject(err);
            console.error(err);
            resolve({
              type: 'error',
              e: err,
            });
            return false;
          }
          const options = {
            from: process.env.SMTP_FROM,
            to,
            subject,
            html,
          };
          transporter.sendMail(options, function (err, info) {
            if (err) {
              Logger.log('error', `${logName} sending_fail clientOrdHaveBeenAccMail: ${JSON.stringify(err)}`);
              // reject(err);
              console.error(err);
              resolve({
                type: 'error',
                e: err,
              });
              return false;
            }
            resolve({
              type: 'success',
              info,
            });
          });
        });
      } catch (e) {
        Logger.log('error', `${logName} sending_error clientOrdHaveBeenAccMail: ${JSON.stringify(e)}`);
        // reject(e);
        console.error(e);
        resolve({
          type: 'error',
          e,
        });
      }
    });
  }

  static async sendFinanceInfoTfPocket(subject, to, mailData) {
    return new Promise(async (resolve, reject) => {
      try {
        const {
          trx_code,
          admin_name,
          drv_name,
          pickup_zone_title,
          pickup_zone_addr,
          drop_zone_title,
          drop_zone_addr,
          pocket_total,
          bank_name,
          bank_code,
          bank_branch_name,
          bank_acc_name,
          bank_acc_no,
        } = mailData;

        const initTransport = await LibMail.initializeTransport();
        if (initTransport.type != 'success') {
          Logger.log('error', `${logName} transporter_error financeInfoTfPocketMail: ${JSON.stringify(initTransport)}`);
          resolve({
            type: initTransport.type,
            msg: initTransport.msg,
            e: initTransport.e,
          });
          return false;
        }
        const transporter = initTransport.transporter;

        const renderData = {
          trx_code,
          admin_name,
          drv_name,
          pickup_zone_title,
          pickup_zone_addr,
          drop_zone_title,
          drop_zone_addr,
          pocket_total,
          bank_name,
          bank_code,
          bank_branch_name,
          bank_acc_name,
          bank_acc_no,
          cs_phone: process.env.CS_PHONE,
          cs_mail: process.env.CS_MAIL,
          cs_addr: process.env.CS_ADDR,
          asset: process.env.MAIL_ASSET,
        }
        ejs.renderFile(path.join(__dirname, '../files/mails/financeInfoTfPocket.ejs'), renderData, function (err, html) {
          if (err) {
            Logger.log('error', `${logName} rendering_fail financeInfoTfPocketMail: ${JSON.stringify(err)}`);
            // reject(err);
            console.error(err);
            resolve({
              type: 'error',
              e: err,
            });
            return false;
          }
          const options = {
            from: process.env.SMTP_FROM,
            to,
            subject,
            html,
          };
          transporter.sendMail(options, function (err, info) {
            if (err) {
              Logger.log('error', `${logName} sending_fail financeInfoTfPocketMail: ${JSON.stringify(err)}`);
              // reject(err);
              console.error(err);
              resolve({
                type: 'error',
                e: err,
              });
              return false;
            }
            resolve({
              type: 'success',
              info,
            });
          });
        });
      } catch (e) {
        Logger.log('error', `${logName} sending_error financeInfoTfPocketMail: ${JSON.stringify(e)}`);
        // reject(e);
        console.error(e);
        resolve({
          type: 'error',
          e,
        });
      }
    });
  }

  static async sendFinanceInfoDanaAmount(subject, to, mailData) {
    return new Promise(async (resolve, reject) => {
      try {
        const {
          trx_code,
          admin_name,
          drv_name,
          pickup_zone_title,
          pickup_zone_addr,
          drop_zone_title,
          drop_zone_addr,
          pocket_total,
          bank_name,
          bank_code,
          bank_branch_name,
          bank_acc_name,
          bank_acc_no,
          dana_current,
          dana_minimum,
        } = mailData;

        const initTransport = await LibMail.initializeTransport();
        if (initTransport.type != 'success') {
          Logger.log('error', `${logName} transporter_error sendFinanceInfoDanaAmount: ${JSON.stringify(initTransport)}`);
          resolve({
            type: initTransport.type,
            msg: initTransport.msg,
            e: initTransport.e,
          });
          return false;
        }
        const transporter = initTransport.transporter;

        const renderData = {
          trx_code,
          admin_name,
          drv_name,
          pickup_zone_title,
          pickup_zone_addr,
          drop_zone_title,
          drop_zone_addr,
          pocket_total,
          bank_name,
          bank_code,
          bank_branch_name,
          bank_acc_name,
          bank_acc_no,
          dana_current,
          dana_minimum,
          cs_phone: process.env.CS_PHONE,
          cs_mail: process.env.CS_MAIL,
          cs_addr: process.env.CS_ADDR,
          asset: process.env.MAIL_ASSET,
        }
        ejs.renderFile(path.join(__dirname, '../files/mails/financeInfoDanaAmount.ejs'), renderData, function (err, html) {
          if (err) {
            Logger.log('error', `${logName} rendering_fail sendFinanceInfoDanaAmount: ${JSON.stringify(err)}`);
            // reject(err);
            console.error(err);
            resolve({
              type: 'error',
              e: err,
            });
            return false;
          }
          const options = {
            from: process.env.SMTP_FROM,
            to,
            subject,
            html,
          };
          transporter.sendMail(options, function (err, info) {
            if (err) {
              Logger.log('error', `${logName} sending_fail sendFinanceInfoDanaAmount: ${JSON.stringify(err)}`);
              // reject(err);
              console.error(err);
              resolve({
                type: 'error',
                e: err,
              });
              return false;
            }
            resolve({
              type: 'success',
              info,
            });
          });
        });
      } catch (e) {
        Logger.log('error', `${logName} sending_error sendFinanceInfoDanaAmount: ${JSON.stringify(e)}`);
        // reject(e);
        console.error(e);
        resolve({
          type: 'error',
          e,
        });
      }
    });
  }

}

module.exports = LibMail;