/**
 * notificationService.js
 * Servicio de notificaciones multi-canal para AR Project Management.
 * Lee la configuración desde localStorage key `arpm_messaging`.
 */

const STORAGE_KEY = 'arpm_messaging';

function getConfig() {
  try {
    const raw = localStorage.getItem(STORAGE_KEY);
    return raw ? JSON.parse(raw) : {};
  } catch {
    return {};
  }
}

/**
 * Envía un email usando EmailJS (cargado vía CDN como window.emailjs).
 * @param {{ to: string, subject: string, body: string }} params
 */
async function sendEmail({ to, subject, body }) {
  const config = getConfig();

  if (!window.emailjs) {
    console.warn('[notificationService] EmailJS no está disponible. Asegúrate de que el SDK esté cargado via CDN.');
    throw new Error('EmailJS no está disponible. Verifica que el SDK esté cargado en index.html.');
  }

  const { emailjsServiceId, emailjsTemplateId, emailjsPublicKey, emailjsToEmail } = config;

  if (!emailjsServiceId || !emailjsTemplateId || !emailjsPublicKey) {
    throw new Error('Faltan credenciales de EmailJS. Configura ServiceID, TemplateID y Public Key en Ajustes > Mensajería.');
  }

  const toAddress = to || emailjsToEmail;
  if (!toAddress) {
    throw new Error('No se especificó dirección de email destinatario.');
  }

  try {
    window.emailjs.init(emailjsPublicKey);
    const result = await window.emailjs.send(emailjsServiceId, emailjsTemplateId, {
      to_email: toAddress,
      subject,
      message: body,
    });
    return result;
  } catch (err) {
    console.error('[notificationService] Error enviando email via EmailJS:', err);
    throw err;
  }
}

/**
 * Abre WhatsApp Web con un mensaje pre-escrito en una nueva pestaña.
 * @param {{ phone: string, message: string }} params
 */
function sendWhatsApp({ phone, message }) {
  const config = getConfig();
  const phoneNumber = phone || config.whatsappPhone;

  if (!phoneNumber) {
    throw new Error('No se configuró un número de WhatsApp. Ve a Ajustes > Mensajería para configurarlo.');
  }

  // Limpiar el número: solo dígitos y el signo +
  const cleanPhone = phoneNumber.replace(/[^\d+]/g, '');
  const encodedMsg = encodeURIComponent(message || '');
  const url = `https://wa.me/${cleanPhone}?text=${encodedMsg}`;
  window.open(url, '_blank', 'noopener,noreferrer');
}

/**
 * Envía un mensaje a través del bot de Telegram usando la API oficial.
 * @param {{ chatId: string, message: string }} params
 */
async function sendTelegram({ chatId, message }) {
  const config = getConfig();
  const token = config.telegramToken;
  const targetChatId = chatId || config.telegramChatId;

  if (!token) {
    throw new Error('No se configuró el Token del bot de Telegram. Ve a Ajustes > Mensajería.');
  }

  if (!targetChatId) {
    throw new Error('No se configuró el Chat ID de Telegram. Ve a Ajustes > Mensajería.');
  }

  const url = `https://api.telegram.org/bot${token}/sendMessage`;

  try {
    const response = await fetch(url, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        chat_id: targetChatId,
        text: message,
        parse_mode: 'HTML',
      }),
    });

    if (!response.ok) {
      const errData = await response.json().catch(() => ({}));
      throw new Error(`Error de Telegram API: ${errData.description || response.statusText}`);
    }

    return await response.json();
  } catch (err) {
    console.error('[notificationService] Error enviando mensaje via Telegram:', err);
    throw err;
  }
}

/**
 * Abre el chat de Messenger de una página de Facebook en una nueva pestaña.
 * @param {{ pageId: string, message: string }} params
 */
function sendMessenger({ pageId, message }) {
  const config = getConfig();
  const targetPageId = pageId || config.messengerPageId;

  if (!targetPageId) {
    throw new Error('No se configuró el Page ID de Facebook. Ve a Ajustes > Mensajería.');
  }

  // Messenger deep link — el usuario debe haber iniciado conversación previamente
  const url = `https://m.me/${targetPageId}`;
  window.open(url, '_blank', 'noopener,noreferrer');

  // Nota: m.me no admite pre-llenado de texto en el link estándar
  if (message) {
    console.info('[notificationService] Messenger no admite mensaje pre-llenado vía m.me. Se abrió el chat directamente.');
  }
}

/**
 * Envía notificación por todos los canales activos configurados.
 * @param {{ subject: string, body: string, phone: string, message: string, chatId: string, pageId: string }} params
 */
async function sendAll({ subject, body, phone, message, chatId, pageId }) {
  const config = getConfig();
  const errors = [];
  const results = [];

  const notificationMessage = message || body || subject || 'Notificación de AR Project Management';

  if (config.emailEnabled) {
    try {
      await sendEmail({ to: config.emailjsToEmail, subject, body });
      results.push({ channel: 'email', status: 'ok' });
    } catch (err) {
      errors.push({ channel: 'email', error: err.message });
      console.error('[notificationService] Falló canal email:', err.message);
    }
  }

  if (config.whatsappEnabled) {
    try {
      sendWhatsApp({ phone, message: notificationMessage });
      results.push({ channel: 'whatsapp', status: 'ok' });
    } catch (err) {
      errors.push({ channel: 'whatsapp', error: err.message });
      console.error('[notificationService] Falló canal whatsapp:', err.message);
    }
  }

  if (config.telegramEnabled) {
    try {
      await sendTelegram({ chatId, message: notificationMessage });
      results.push({ channel: 'telegram', status: 'ok' });
    } catch (err) {
      errors.push({ channel: 'telegram', error: err.message });
      console.error('[notificationService] Falló canal telegram:', err.message);
    }
  }

  if (config.messengerEnabled) {
    try {
      sendMessenger({ pageId, message: notificationMessage });
      results.push({ channel: 'messenger', status: 'ok' });
    } catch (err) {
      errors.push({ channel: 'messenger', error: err.message });
      console.error('[notificationService] Falló canal messenger:', err.message);
    }
  }

  if (errors.length > 0 && results.length === 0) {
    throw new Error(`Todos los canales fallaron: ${errors.map(e => `${e.channel}: ${e.error}`).join('; ')}`);
  }

  return { results, errors };
}

export const notificationService = {
  sendEmail,
  sendWhatsApp,
  sendTelegram,
  sendMessenger,
  sendAll,
  getConfig,
};
