// Shared email-sender module for the generated Next.js project.
//
// Why this exists: order-notification and low-stock-alert API routes
// both render `{{token}}` templates and dispatch to one of several
// providers (Postmark / SendGrid / Resend / SMTP fallback). Without a
// shared helper each endpoint duplicates the provider switch + retry
// + logging, which led to drift the last time we touched it (postmark
// wasn't supported in order-notification, sendgrid wasn't supported
// in low-stock, etc.). One helper means one place to fix.
//
// Emits `utils/ecommerce/email-sender.js` as plain CommonJS so the
// API routes (which are `pages/api/**` and use mixed import styles)
// can `require()` it without a TypeScript transpile step. The
// generated file is otherwise self-contained — no React, no Next
// runtime — and safe to import from any server-side context
// (workflow server segments, webhooks, the data-api itself).

import { UIDLEcommerceSettings } from '@teleporthq/teleport-types'
import { EmailSender } from '@teleporthq/teleport-shared'

const POSTMARK_PROVIDER = 'postmark'
const SENDGRID_PROVIDER = 'sendgrid'
const RESEND_PROVIDER = 'resend'

// Render `{{token}}` placeholders against a flat payload of values.
// The regex matches `{{ word }}` (whitespace-tolerant, word chars only)
// so surrounding HTML markup that contains lone `{` / `}` is left
// untouched. Missing tokens render as empty string — never as the
// literal `{{token}}`, which would leak the template into the email.
const RENDER_TEMPLATE_FN = `function renderTemplate(template, payload) {
  if (!template) return ''
  return String(template).replace(/\\{\\{\\s*([a-zA-Z0-9_]+)\\s*\\}\\}/g, function(_match, key) {
    var v = payload && payload[key]
    if (v == null) return ''
    return String(v)
  })
}`

// Expand the repeating-row blocks a BUILDER email template serializes an
// array-mapper into: `<!--tq:each KEY-->…{{field}}…<!--/tq:each-->`. The inner
// body is repeated once per row of `lists[KEY]`, with the row's `{{field}}`
// tokens replaced by the (HTML-escaped) item value. Tokens the row doesn't
// carry are left verbatim so the page-level `renderTemplate` below can still
// resolve them (e.g. `{{companyName}}` inside a row).
//
// MUST run BEFORE `renderTemplate`: that one blanks every unknown token, so a
// row template reaching it un-expanded renders exactly once with every
// per-item value empty — which is precisely the "Items ordered section is
// blank" defect this exists to prevent.
//
// PAIRED EDIT: identical logic lives in the workflow runtime
// (`executor-generator.ts` `expandListBlocks`), in teleport-gui
// (`order-side-effects-helper.ts` `EXPAND_LIST_BLOCKS_JS`) and in
// teleport-services-worker (`adapters/email/_bridge.ts`). Keep in sync.
const EXPAND_LIST_BLOCKS_FN = `function expandListBlocks(template, lists) {
  if (typeof template !== 'string' || template.indexOf('<!--tq:each') === -1) return template
  function escRow(v) {
    return String(v == null ? '' : v)
      .replace(/&/g, '&amp;')
      .replace(/</g, '&lt;')
      .replace(/>/g, '&gt;')
      .replace(/"/g, '&quot;')
  }
  return template.replace(/<!--tq:each\\s+([\\w.-]+)\\s*-->([\\s\\S]*?)<!--\\/tq:each-->/g, function(_m, key, body) {
    var rows = lists && lists[key]
    if (!Array.isArray(rows)) return ''
    var out = ''
    for (var r = 0; r < rows.length; r++) {
      var row = rows[r] || {}
      out += body.replace(/\\{\\{\\s*([\\w.-]+)\\s*\\}\\}/g, function(mm, field) {
        return (Object.prototype.hasOwnProperty.call(row, field) && row[field] != null)
          ? escRow(row[field])
          : mm
      })
    }
    return out
  })
}`

// True when a merchant template renders its own item list — either as a
// builder array-mapper block or via the legacy `{{itemsList}}` blob. The
// endpoints use this to skip appending a second, auto-generated list.
const HAS_OWN_ITEM_LIST_FN = `function hasOwnItemList(template) {
  if (!template) return false
  var t = String(template)
  return t.indexOf('<!--tq:each') !== -1 || t.indexOf('{{itemsList}}') !== -1
}`

// Strip every HTML tag for the plain-text fallback. Mail clients that
// can't render HTML (and most spam-score heuristics) need a parallel
// text body — this is the cheapest way to derive one from the HTML
// template the merchant authored in the GUI.
const HTML_TO_TEXT_FN = `function htmlToText(html) {
  if (!html) return ''
  return String(html).replace(/<[^>]+>/g, '').replace(/\\s+/g, ' ').trim()
}`

// Trim, drop blanks / non-strings and de-duplicate (case-insensitively) the
// configured recipient list. The list is merchant-edited — an address typed
// twice, or once with a trailing space, would otherwise be sent to twice.
const NORMALIZE_RECIPIENTS_FN = `function normalizeRecipients(recipients) {
  var list = Array.isArray(recipients) ? recipients : [recipients]
  var seen = {}
  var out = []
  for (var i = 0; i < list.length; i++) {
    if (typeof list[i] !== 'string') continue
    var email = list[i].trim()
    if (!email) continue
    var key = email.toLowerCase()
    if (seen[key]) continue
    seen[key] = true
    out.push(email)
  }
  return out
}`

// Build the provider-specific `dispatch(payload)` function for the
// generated email-sender module. Each provider returns a Promise
// that resolves on success and rejects on dispatch failure.
//
// We deliberately use the providers' HTTPS REST APIs (rather than
// their npm SDKs) for everything except SendGrid + Resend — both of
// those SDKs are tiny, already in our dependency tree elsewhere, and
// give better error messages than raw HTTP would. Postmark + the
// SMTP fallback go via fetch / nodemailer to avoid an extra
// dependency just to send one email.
const buildProviderDispatch = (provider: string | null | undefined): string => {
  switch (provider) {
    case SENDGRID_PROVIDER:
      // SendGrid reads a "Name <email>" string's name verbatim, quotes included,
      // so a named sender goes as its two parts.
      return `var sgMail = require('@sendgrid/mail')
sgMail.setApiKey(process.env.SENDGRID_API_KEY || '')
function dispatchProviderEmail(envelope) {
  var msg = {
    to: envelope.to,
    from: envelope.fromName ? { email: envelope.fromEmail, name: envelope.fromName } : envelope.fromDisplay,
    subject: envelope.subject,
    html: envelope.html,
    text: envelope.text,
  }
  if (envelope.replyTo) msg.replyTo = envelope.replyTo
  return sgMail.send(msg)
}`

    case RESEND_PROVIDER:
      return `var Resend = require('resend').Resend
var resend = new Resend(process.env.RESEND_API_KEY || '')
function dispatchProviderEmail(envelope) {
  var payload = {
    from: envelope.fromDisplay,
    to: envelope.to,
    subject: envelope.subject,
    html: envelope.html,
    text: envelope.text,
  }
  if (envelope.replyTo) payload.reply_to = envelope.replyTo
  return resend.emails.send(payload)
}`

    case POSTMARK_PROVIDER:
      // Postmark exposes a simple HTTPS endpoint that we hit
      // directly via fetch. The Sender Signature for `From` must
      // already be verified in the Postmark dashboard — Postmark
      // returns a 422 with ErrorCode 405 otherwise and our caller
      // surfaces that as a 500.
      return `if (typeof globalThis.fetch === 'undefined') {
  globalThis.fetch = require('node-fetch')
}
function dispatchProviderEmail(envelope) {
  // Accept the modern, documented env var first; then a couple of
  // legacy aliases the GUI used to write into .env before this
  // generator existed. Keeps existing projects working without a
  // manual rename on the next regeneration.
  var token =
    process.env.POSTMARK_SERVER_TOKEN ||
    process.env.POSTMARK_API_TOKEN ||
    process.env.EMAIL_POSTMARK_SERVERTOKEN ||
    process.env.EMAIL_POSTMARK_SERVER_TOKEN ||
    ''
  if (!token) {
    return Promise.reject(new Error('POSTMARK_SERVER_TOKEN env var is not set'))
  }
  var payload = {
    From: envelope.fromDisplay,
    To: Array.isArray(envelope.to) ? envelope.to.join(',') : envelope.to,
    Subject: envelope.subject,
    HtmlBody: envelope.html,
    TextBody: envelope.text,
    MessageStream: process.env.POSTMARK_MESSAGE_STREAM || 'outbound',
  }
  if (envelope.replyTo) payload.ReplyTo = envelope.replyTo
  return fetch('https://api.postmarkapp.com/email', {
    method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Content-Type': 'application/json',
      'X-Postmark-Server-Token': token,
    },
    body: JSON.stringify(payload),
  }).then(function(res) {
    if (res.ok) return res.json().catch(function() { return {} })
    return res.text().catch(function() { return '' }).then(function(t) {
      throw new Error('Postmark API error ' + res.status + ': ' + t)
    })
  })
}`

    default:
      // SMTP fallback. Covers the merchant who picked an unknown
      // provider name in the GUI (e.g. mailgun, mailersend) — they
      // still get a working pipeline as long as the SMTP_* env vars
      // are populated.
      return `var nodemailer = require('nodemailer')
function dispatchProviderEmail(envelope) {
  var transporter = nodemailer.createTransport({
    host: process.env.SMTP_HOST,
    port: parseInt(process.env.SMTP_PORT || '587'),
    secure: String(process.env.SMTP_SECURE || '') === 'true',
    auth: process.env.SMTP_USER ? { user: process.env.SMTP_USER, pass: process.env.SMTP_PASS } : undefined,
  })
  var msg = {
    from: envelope.fromDisplay,
    to: envelope.to,
    subject: envelope.subject,
    html: envelope.html,
    text: envelope.text,
  }
  if (envelope.replyTo) msg.replyTo = envelope.replyTo
  return transporter.sendMail(msg)
}`
  }
}

interface EmailSenderOptions {
  provider: string | null
  fromEmail: string
  fromName: string
  replyTo: string
  // Tag included in every diagnostic log line so the dev console
  // shows which generator emitted this module (helps when both
  // order + low-stock end up in the same dev terminal).
  logTag?: string
}

// The two consumer modules (order-notification, low-stock-alert)
// call `sendNotificationEmail` with a fully-built envelope. The
// envelope carries the per-call recipient list + subject + html
// body; provider, from-display, reply-to are baked in at codegen
// time from the matching `UIDLEcommerce*Config`.
//
// One provider call PER recipient, never one call carrying the whole
// list: a provider refuses the WHOLE call when any address in it is
// refused — Postmark's pending-approval rule ("every recipient must
// share the From domain"), a suppressed or malformed address — so a
// single bad recipient used to take every other one down with it.
// Each address now succeeds or fails on its own and gets its own
// ledger row; the promise rejects only when NO recipient was reached,
// which keeps the routes' existing "total failure" handling intact.
const buildSenderFunction = (opts: EmailSenderOptions): string => {
  const fromEmail = opts.fromEmail || ''
  const fromName = opts.fromName || ''
  const replyTo = opts.replyTo || ''
  const tag = opts.logTag || 'email'
  const providerName = opts.provider || 'smtp'
  return `// \`meta\` describes the send for the sent-email ledger:
// { emailType, source, sourceRef, payload, orderId }. Every attempt — accepted
// or refused by the provider — is recorded there in the background, one row per
// recipient; the route settles the ledger (\`settleSentEmailLog\`) before it
// replies.
//
// Resolves to { sent: true, recipients, delivered, failed } as soon as ONE
// recipient accepted the email (\`failed\` lists the others with the provider's
// reason); rejects only when every recipient was refused.
function sendNotificationEmail(recipients, subject, html, meta) {
  var to = normalizeRecipients(recipients)
  if (to.length === 0) {
    console.log('[${tag}] skipped: no recipients configured')
    return Promise.resolve({ sent: false, reason: 'no_recipients' })
  }
  var ledgerMeta = meta || {}
  var fromAddress = ${JSON.stringify(
    fromEmail
  )} || process.env.ORDER_NOTIFICATION_FROM_EMAIL || 'noreply@example.com'
  var sender = __emailSender({ from: fromAddress, name: ${JSON.stringify(fromName)} })
  var fromDisplay = sender.header
  var replyTo = ${JSON.stringify(replyTo)}
  var envelope = {
    fromDisplay: fromDisplay,
    fromEmail: sender.email,
    fromName: sender.name,
    subject: subject || '',
    html: html || '',
    text: htmlToText(html),
  }
  if (replyTo) envelope.replyTo = replyTo
  function recordAttempt(recipient, providerResponse, failure) {
    var messageId = null
    if (providerResponse && typeof providerResponse === 'object') {
      messageId = providerResponse.messageId || providerResponse.MessageID || providerResponse.id ||
        (providerResponse.data && providerResponse.data.id) || null
    }
    sentEmailLog.recordSentEmail({
      emailType: ledgerMeta.emailType || 'custom',
      audience: 'store-owner',
      to: [recipient],
      from: fromDisplay,
      fromName: sender.name,
      replyTo: replyTo,
      subject: envelope.subject,
      html: envelope.html,
      payload: ledgerMeta.payload,
      provider: ${JSON.stringify(providerName)},
      providerMessageId: messageId,
      status: failure ? 'failed' : 'sent',
      error: failure ? (failure.message || String(failure)) : null,
      source: ledgerMeta.source || 'ecommerce',
      sourceRef: ledgerMeta.sourceRef,
      orderId: ledgerMeta.orderId,
    })
  }
  // Never rejects: the outcome carries the provider's reason instead, so one
  // refused address cannot short-circuit the addresses after it. The dispatch
  // is entered from a resolved promise so that a synchronous throw (a
  // transport that fails to build) is a failure of THIS recipient too.
  function sendToRecipient(recipient) {
    return Promise.resolve()
      .then(function() { return dispatchProviderEmail(Object.assign({ to: [recipient] }, envelope)) })
      .then(function(result) {
        console.log('[${tag}] sent to ' + recipient)
        recordAttempt(recipient, result, null)
        return { recipient: recipient, error: null }
      }, function(err) {
        var failure = err || new Error('dispatch failed')
        var message = failure.message || String(failure)
        console.error('[${tag}] dispatch failed for ' + recipient + ': ' + message)
        recordAttempt(recipient, null, failure)
        return { recipient: recipient, error: message }
      })
  }
  console.log('[${tag}] dispatching to ' + to.join(', ') + ' (subject="' + envelope.subject + '")')
  // Sequential rather than parallel: a burst of one call per address is
  // exactly what a provider's per-second rate limit refuses.
  var outcomes = []
  var chain = Promise.resolve()
  to.forEach(function(recipient) {
    chain = chain.then(function() {
      return sendToRecipient(recipient).then(function(outcome) { outcomes.push(outcome) })
    })
  })
  return chain.then(function() {
    var delivered = []
    var failed = []
    outcomes.forEach(function(outcome) {
      if (outcome.error === null) delivered.push(outcome.recipient)
      else failed.push({ recipient: outcome.recipient, error: outcome.error })
    })
    if (delivered.length === 0) {
      throw new Error('no recipient accepted the email — ' + failed.map(function(f) {
        return f.recipient + ': ' + f.error
      }).join('; '))
    }
    if (failed.length > 0) {
      console.warn('[${tag}] delivered to ' + delivered.length + ' of ' + to.length + ' recipient(s)')
    }
    return { sent: true, recipients: to, delivered: delivered, failed: failed }
  })
}`
}

export const generateEmailSenderModule = (
  settings: UIDLEcommerceSettings,
  options: { logTag?: string } = {}
): string => {
  // The order-notification config drives the provider choice for
  // the module: both flows share one sender, so they share one
  // provider. If a merchant wants a different provider for
  // low-stock alerts they can configure it via the GUI today —
  // but the generated module today honours the order-notification
  // provider for both. This matches the typical real-world setup
  // (one transactional email provider per project) and keeps the
  // generated code small.
  const provider =
    settings.orderNotificationConfig?.provider ||
    settings.stockManagementConfig?.lowStockAlertConfig?.provider ||
    null
  const fromEmail =
    settings.orderNotificationConfig?.fromEmail ||
    settings.stockManagementConfig?.lowStockAlertConfig?.fromEmail ||
    ''
  const fromName =
    settings.orderNotificationConfig?.fromName ||
    settings.stockManagementConfig?.lowStockAlertConfig?.fromName ||
    ''
  const replyTo =
    settings.orderNotificationConfig?.replyTo ||
    settings.stockManagementConfig?.lowStockAlertConfig?.replyTo ||
    ''

  const providerDispatch = buildProviderDispatch(provider)
  const senderFn = buildSenderFunction({
    provider,
    fromEmail,
    fromName,
    replyTo,
    logTag: options.logTag,
  })

  return `// Auto-generated shared email sender.
// Consumed by /api/ecommerce/order-notification and
// /api/ecommerce/low-stock-alert. Edit the generator at
// teleport-project-generator-next/src/ecommerce/email-sender-generator.ts
// instead of this file — it will be overwritten on the next build.

var sentEmailLog = require('../email/sent-email-log')

${providerDispatch}

${RENDER_TEMPLATE_FN}

${EXPAND_LIST_BLOCKS_FN}

${HAS_OWN_ITEM_LIST_FN}

${HTML_TO_TEXT_FN}

${NORMALIZE_RECIPIENTS_FN}
${EmailSender.generateEmailSenderHelperCode()}
${senderFn}

module.exports = {
  sendNotificationEmail: sendNotificationEmail,
  settleSentEmailLog: sentEmailLog.settleSentEmailLog,
  renderTemplate: renderTemplate,
  expandListBlocks: expandListBlocks,
  hasOwnItemList: hasOwnItemList,
}
`
}