Checkmate/client/src/Components/NotificationIntegrationModal/Hooks/useNotification.js

import { useState } from 'react';
import { useTranslation } from "react-i18next";
import { networkService } from '../../../Utils/NetworkService'; 
import { createToast } from '../../../Utils/toastUtils';

// Define constants for notification types to avoid magic values
const NOTIFICATION_TYPES = {
  SLACK: 'slack',
  DISCORD: 'discord',
  TELEGRAM: 'telegram',
  WEBHOOK: 'webhook'
};

// Define constants for field IDs
const FIELD_IDS = {
  WEBHOOK: 'webhook',
  TOKEN: 'token',
  CHAT_ID: 'chatId',
  URL: 'url'
};

/**
 * Custom hook for notification-related operations
 */
const useNotifications = () => {
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(undefined);
  const { t } = useTranslation();

  /**
   * Send a test notification
   * @param {string} type - The notification type (slack, discord, telegram, webhook)
   * @param {object} config - Configuration object with necessary params
   */
  const sendTestNotification = async (type, config) => {
    setLoading(true);
    setError(undefined);
    
    // Validation based on notification type
    let payload = { platform: type };
    let isValid = true;
    let errorMessage = '';
    
    switch(type) {
      case NOTIFICATION_TYPES.SLACK:
        payload.webhookUrl = config.webhook;
        if (typeof payload.webhookUrl === 'undefined' || payload.webhookUrl === '') {
          isValid = false;
          errorMessage = t('notifications.slack.webhookRequired');
        }
        break;
        
      case NOTIFICATION_TYPES.DISCORD:
        payload.webhookUrl = config.webhook;
        if (typeof payload.webhookUrl === 'undefined' || payload.webhookUrl === '') {
          isValid = false;
          errorMessage = t('notifications.discord.webhookRequired');
        }
        break;
        
      case NOTIFICATION_TYPES.TELEGRAM:
        payload.botToken = config.token;
        payload.chatId = config.chatId;
        if (typeof payload.botToken === 'undefined' || payload.botToken === '' || 
            typeof payload.chatId === 'undefined' || payload.chatId === '') {
          isValid = false;
          errorMessage = t('notifications.telegram.fieldsRequired');
        }
        break;
        
      case NOTIFICATION_TYPES.WEBHOOK:
        payload.webhookUrl = config.url;
        payload.platform = NOTIFICATION_TYPES.SLACK; 
        if (typeof payload.webhookUrl === 'undefined' || payload.webhookUrl === '') {
          isValid = false;
          errorMessage = t('notifications.webhook.urlRequired');
        }
        break;
        
      default:
        isValid = false;
        errorMessage = t('notifications.unsupportedType');
    }

    // If validation fails, show error and return
    if (isValid === false) {
      createToast({
        body: errorMessage,
        variant: "error"
      });
      setLoading(false);
      return;
    }

    try {
      const response = await networkService.testNotification({ 
        platform: type, 
        payload: payload 
      });
      
      if (response.data.success === true) {
        createToast({
          body: t('notifications.testSuccess'),
          variant: "info"
        });
      } else {
        throw new Error(response.data.msg || t('notifications.testFailed'));
      }
    } catch (error) {
      const errorMsg = error.response?.data?.msg || error.message || t('notifications.networkError');
      createToast({
        body: `${t('notifications.testFailed')}: ${errorMsg}`,
        variant: "error"
      });
      setError(errorMsg);
    } finally {
      setLoading(false);
    }
  };

  return [
    loading,
    error,
    sendTestNotification
  ];
};

export default useNotifications;