const {
  getAllNotificationErrorUserDb,
  getNotificationErrorUserByIdDb,
  createNotificationErrorUserDb,
  updateNotificationErrorUserDb,
  deleteNotificationErrorUserDb,
} = require("../db/notification_error_user.db");

const {
  generateTokenRedirect,
  shortUrltiny,
  sendNotifikasi,
} = require("../db/notification_wa.db");

const { ErrorHandler } = require("../helpers/error");

class NotificationErrorUserService {
  // Get all Contact
  static async getAllNotificationErrorUser(param) {
    try {
      const results = await getAllNotificationErrorUserDb(param);

      results.data.map((element) => {});

      return results;
    } catch (error) {
      throw new ErrorHandler(error.statusCode, error.message);
    }
  }

  // Get NotificationErrorUser by ID
  static async getNotificationErrorUserById(id) {
    try {
      const result = await getNotificationErrorUserByIdDb(id);

      if (result.length < 1)
        throw new ErrorHandler(404, "Notification Error User not found");

      return result;
    } catch (error) {
      throw new ErrorHandler(error.statusCode, error.message);
    }
  }

  // Create NotificationErrorUser
  static async createNotificationErrorUser(data) {
    try {
      if (!data || typeof data !== "object") data = {};

      const result = await createNotificationErrorUserDb(data);

      return result;
    } catch (error) {
      throw new ErrorHandler(error.statusCode, error.message);
    }
  }

  // Update NotificationErrorUser
  static async updateNotificationErrorUser(id, data) {
    try {
      if (!data || typeof data !== "object") data = {};

      const dataExist = await getNotificationErrorUserByIdDb(id);

      if (dataExist.length < 1) {
        throw new ErrorHandler(404, "Notification Error User not found");
      }

      const result = await updateNotificationErrorUserDb(id, data);

      return result;
    } catch (error) {
      throw new ErrorHandler(error.statusCode, error.message);
    }
  }

  // Soft delete NotificationErrorUser
  static async deleteNotificationErrorUser(id, userId) {
    try {
      const dataExist = await getNotificationErrorUserByIdDb(id);

      if (dataExist.length < 1) {
        throw new ErrorHandler(404, "Notification Error User not found");
      }

      const result = await deleteNotificationErrorUserDb(id, userId);

      return result;
    } catch (error) {
      throw new ErrorHandler(error.statusCode, error.message);
    }
  }

  static async resendNotificationByUser(id, contact_phone) {
    const results = [];

    const idUser = Array.isArray(id) ? id : [id];

    for (const id of idUser) {
      try {
        const dataExist = await getNotificationErrorUserByIdDb(id);

        if (!dataExist || dataExist.length < 1) {
          results.push({
            id,
            status: "failed",
            message: "Data Notification Error User not found",
          });
          continue;
        }

        const data = dataExist[0];

        if (data.contact_phone !== contact_phone) {
          results.push({
            id,
            status: "failed",
            message: `Phone ${contact_phone} not found.`,
          });
          continue;
        }

        if (data.contact_is_active === false) {
          results.push({
            id,
            status: "failed",
            message: `Contact ${data.contact_phone} not active.`,
          });
          continue;
        }

        const tokenRedirect = await generateTokenRedirect(
          data.contact_phone,
          data.contact_name,
          data.notification_error_id
        );

        const encodedToken = encodeURIComponent(tokenRedirect);
        const shortUrl = await shortUrltiny(encodedToken);

        const bodyWithUrl =
          `Hai ${data.contact_name || "-"}\n` +
          `Terjadi peringatan dengan kode error ${data.error_code || "-"} - ${
            data.error_code_name || "-"
          } ` +
          `pada device ${
            data.device_name || "-"
          }, silahkan cek detail pada link berikut:\n` +
          `${shortUrl}`;

        const resultSend = await sendNotifikasi(
          data.contact_phone,
          bodyWithUrl
        );
        const isSuccess = resultSend?.error ? false : true;

        const updateData = {
          is_send: isSuccess,
          message_error_issue: bodyWithUrl,
        };

        await updateNotificationErrorUserDb(id, updateData);

        if (!isSuccess) {
          results.push({
            id,
            status: "failed",
            message: `WhatsApp API Gagal: ${
              resultSend?.message || "Unknown Error"
            }`,
          });
        } else {
          results.push({
            status: 200,
            notification_error_user_id: id,
            notification_error_id: data.notification_error_id,
            device_name: data.device_name,
            error_code: data?.error_code,
            error_code_name: data?.error_code_name,
            users: {
              contact_name: data.contact_name,
              contact_phone: data.contact_phone,
              is_send: isSuccess,
            },
          });
        }
      } catch (err) {
        results.push({ id, status: "error", message: err.message });
      }
    }
    return results;
  }
}

module.exports = NotificationErrorUserService;