import { createDbService } from '@/server/services/db.js';
/**
 * Support email helpers: build subject + React element for templateKey,
 * and resolve case recipient email by role.
 *
 * Shared by support.notif.email handler and any future support handlers.
 */

import React from 'react';
import { eq, sql } from 'drizzle-orm';
import { users, vendors, transactionCases } from '../../../db/schema.js';
import { captureCaught } from '@/server/observability/capture.server';
import type { DispatchEnv } from '../types.js';
import { TicketOpened } from '../../../email/templates/support/TicketOpened.js';
import { TicketResolved } from '../../../email/templates/support/TicketResolved.js';
import { TicketReopened } from '../../../email/templates/support/TicketReopened.js';
import { EscalatedToHuman } from '../../../email/templates/support/EscalatedToHuman.js';
import { CaseOpened } from '../../../email/templates/support/CaseOpened.js';
import { CaseResolved } from '../../../email/templates/support/CaseResolved.js';
import { VendorOffered } from '../../../email/templates/support/VendorOffered.js';
import { CustomerDecided } from '../../../email/templates/support/CustomerDecided.js';
import { Reopened } from '../../../email/templates/support/Reopened.js';
import { asCaseId } from '@/server/platform-seams/ids.js';

/** Build subject + React element for a support templateKey. */
export function buildSupportEmail(
  templateKey: string,
  params: Record<string, string>,
  locale: 'he' | 'en',
): { subject: string; react: React.ReactElement | null } {
  const subjectMap: Record<string, Record<'he' | 'en', string>> = {
    'support.ticket_opened': { he: 'הפנייה שלך נפתחה', en: 'Your ticket is open' },
    'support.ticket_resolved': { he: 'הפנייה שלך נסגרה', en: 'Your ticket was resolved' },
    'support.ticket_reopened': { he: 'הפנייה נפתחה מחדש', en: 'Ticket reopened' },
    'support.escalated_to_human': { he: 'הפנייה הועברה לנציג', en: 'Your ticket was escalated' },

    'support.case_opened': { he: 'פתחת תיק תמיכה', en: 'Your support case is open' },
    'support.case_resolved': { he: 'התיק נסגר', en: 'Your support case is resolved' },
    'support.vendor_offered': { he: 'הוצעה הצעה', en: 'An offer was made' },
    'support.customer_decided': { he: 'התקבלה החלטה', en: 'A decision was made' },
    'support.reopened': { he: 'התיק נפתח מחדש', en: 'Your case was reopened' },
  };

  const subject = subjectMap[templateKey]?.[locale] ?? 'Multideal Support';

  try {
    switch (templateKey) {
      case 'support.ticket_opened': {
        return {
          subject,
          react: React.createElement(TicketOpened, {
            ticketId: params['ticketId'] ?? '',
            subject: params['subject'] ?? '',
            category: params['category'] ?? '',
            ticketUrl: params['ticketUrl'] ?? '',
            locale,
          }),
        };
      }
      case 'support.ticket_resolved': {
        return {
          subject,
          react: React.createElement(TicketResolved, {
            ticketId: params['ticketId'] ?? '',
            resolution: params['resolution'] ?? '',
            ticketUrl: params['ticketUrl'] ?? '',
            reopenUrl: (params['reopenUrl'] ?? params['ticketUrl'] ?? '') + '/reopen',
            locale,
          }),
        };
      }
      case 'support.ticket_reopened': {
        return {
          subject,
          react: React.createElement(TicketReopened, {
            ticketId: params['ticketId'] ?? '',
            ticketUrl: params['ticketUrl'] ?? '',
            locale,
          }),
        };
      }
      case 'support.escalated_to_human': {
        return {
          subject,
          react: React.createElement(EscalatedToHuman, {
            ticketId: params['ticketId'] ?? '',
            reason: params['reason'] ?? '',
            ticketUrl: params['ticketUrl'] ?? '',
            locale,
          }),
        };
      }
      case 'support.case_opened': {
        return {
          subject,
          react: React.createElement(CaseOpened, {
            caseId: params['caseId'] ?? '',
            caseTitle: params['caseTitle'] ?? '',
            caseUrl: params['caseUrl'] ?? '#',
            locale,
          }),
        };
      }
      case 'support.case_resolved': {
        return {
          subject,
          react: React.createElement(CaseResolved, {
            caseId: params['caseId'] ?? '',
            resolution: params['resolution'] ?? '',
            caseUrl: params['caseUrl'] ?? '#',
            locale,
          }),
        };
      }
      case 'support.vendor_offered': {
        return {
          subject,
          react: React.createElement(VendorOffered, {
            caseId: params['caseId'] ?? '',
            offerSummary: params['offerSummary'] ?? '',
            caseUrl: params['caseUrl'] ?? '#',
            locale,
          }),
        };
      }
      case 'support.customer_decided': {
        return {
          subject,
          react: React.createElement(CustomerDecided, {
            caseId: params['caseId'] ?? '',
            decision: params['decision'] ?? '',
            caseUrl: params['caseUrl'] ?? '#',
            locale,
          }),
        };
      }
      case 'support.reopened': {
        return {
          subject,
          react: React.createElement(Reopened, {
            caseId: params['caseId'] ?? '',
            caseUrl: params['caseUrl'] ?? '#',
            locale,
          }),
        };
      }
      default:
        return { subject, react: null };
    }
  } catch (err) {
    captureCaught(err, { scope: 'server.workflows.outbox.support-email', severity: 'warning' });
    return { subject, react: null };
  }
}

/** Resolve an email for a case participant role. */
export async function resolveCaseRecipientEmail(
  env: DispatchEnv,
  caseId: string,
  role: 'customer' | 'vendor',
): Promise<string | null> {
  if (!env.PII_KEY) return null;
  const db = createDbService({ DATABASE_URL: env.DATABASE_URL });

  try {
    if (role === 'customer') {
      const rows = await db
        .select({
          email: sql<string>`pgp_sym_decrypt(CASE WHEN substring(${users.email}, 1, 2) = '\\x' THEN ${users.email}::bytea ELSE decode(${users.email}, 'base64') END, ${env.PII_KEY})::text`,
        })
        .from(transactionCases)
        .innerJoin(users, eq(users.id, transactionCases.customerId))
        .where(eq(transactionCases.id, asCaseId(caseId)))
        .limit(1);
      return rows[0]?.email ?? null;
    } else {
      const rows = await db
        .select({
          email: sql<string>`pgp_sym_decrypt(CASE WHEN substring(${users.email}, 1, 2) = '\\x' THEN ${users.email}::bytea ELSE decode(${users.email}, 'base64') END, ${env.PII_KEY})::text`,
        })
        .from(transactionCases)
        .innerJoin(vendors, eq(vendors.id, transactionCases.vendorId))
        .innerJoin(users, eq(users.id, vendors.ownerUserId))
        .where(eq(transactionCases.id, asCaseId(caseId)))
        .limit(1);
      return rows[0]?.email ?? null;
    }
  } catch (err) {
    captureCaught(err, { scope: 'server.workflows.outbox.support-email', severity: 'warning' });
    return null;
  }
}