// 5-minute key-value cache. Per worker isolate — Cloudflare routes
// requests to the same isolate when possible so we get reasonable
// hit rates even without KV. No need for cross-isolate consistency
// because the data being cached (plans / modules / permission templates)
// is only mutated by superadmin actions which are infrequent.
const TTL_MS = 5 * 60 * 1000;
const store = new Map<string, { v: any; exp: number }>();

export async function cached<T>(key: string, loader: () => Promise<T>): Promise<T> {
  const hit = store.get(key);
  if (hit && hit.exp > Date.now()) return hit.v as T;
  const v = await loader();
  store.set(key, { v, exp: Date.now() + TTL_MS });
  return v;
}

export function invalidateCache(prefix?: string) {
  if (!prefix) { store.clear(); return; }
  for (const k of store.keys()) if (k.startsWith(prefix)) store.delete(k);
}

export type WhatsappTabKey =
  | 'inbox' | 'templates' | 'automations'
  | 'quickReplies' | 'analytics' | 'events';

export const WHATSAPP_TAB_KEYS: WhatsappTabKey[] = [
  'inbox', 'templates', 'automations', 'quickReplies', 'analytics', 'events',
];

export class WhatsappTabDisabledError extends Error {
  constructor(public readonly tab: WhatsappTabKey, public readonly clinicId: string) {
    super(`WhatsApp ${tab} tab is disabled for clinic ${clinicId}`);
    this.name = 'WhatsappTabDisabledError';
  }
}

/**
 * Resolves to `true` when:
 *   - the WhatsApp module is enabled for the clinic, AND
 *   - the requested tab is on in config.tabs (defaults to ON when the key
 *     is absent — preserves behavior for clinics configured before this
 *     feature shipped).
 */
export async function isWhatsappTabEnabled(
  clinicId: string,
  tab: WhatsappTabKey,
): Promise<boolean> {
  try {
    const db = getReadDb(getDatabaseUrl());
    const [row] = await db
      .select({ config: clinicModules.config })
      .from(clinicModules)
      .where(and(
        eq(clinicModules.clinicId, clinicId),
        eq(clinicModules.moduleKey, 'whatsapp'),
        eq(clinicModules.isEnabled, true),
      )).limit(1);
    if (!row?.config) return false;
    const parsed = JSON.parse(row.config) as { tabs?: Record<string, boolean> };
    if (!parsed.tabs) return true; // legacy config — default on
    return parsed.tabs[tab] !== false;
  } catch {
    return false;
  }
}

export async function requireWhatsappTab(
  clinicId: string,
  tab: WhatsappTabKey,
): Promise<void> {
  const ok = await isWhatsappTabEnabled(clinicId, tab);
  if (!ok) throw new WhatsappTabDisabledError(tab, clinicId);
}

export async function getEnabledWhatsappTabs(
  clinicId: string,
): Promise<Record<WhatsappTabKey, boolean>> {
  const result = {} as Record<WhatsappTabKey, boolean>;
  for (const tab of WHATSAPP_TAB_KEYS) {
    result[tab] = await isWhatsappTabEnabled(clinicId, tab);
  }
  return result;
}

// server/src/middleware/require-whatsapp-tab.ts
import { Hono } from 'hono';
import type { MiddlewareHandler } from 'hono';
import { requireWhatsappTab, type WhatsappTabKey } from '../lib/whatsapp';

export function requireTab(tab: WhatsappTabKey): MiddlewareHandler {
  return async (c, next) => {
    const user = c.get('user') as any;
    const clinicId = user?.clinicId ?? c.get('clinicContext')?.currentClinicId;
    if (!clinicId) return c.json({ error: 'no_clinic_context' }, 400);
    await requireWhatsappTab(clinicId, tab); // throws on disabled — caught by handleError
    return next();
  };
}

if (error instanceof WhatsappTabDisabledError) {
  const payload = createErrorResponse(
    'WhatsappTabDisabledError',
    403,
    `The ${error.tab} tab is disabled for this clinic. Contact your account manager to enable it.`,
    { feature: `whatsapp.${error.tab}` },
    'FEATURE_DISABLED',
    getRequestId(c),
  );
  return c.json(payload, 403);
}

adminRoute.patch('/tenants/:clinicId/whatsapp-tabs', async (c) => {
  try {
    const user = c.get('user') as any;
    if (user.role !== 'superadmin') throw new AppError('Superadmin only', 403);
    const clinicId = c.req.param('clinicId');
    const body = await c.req.json() as { tab: WhatsappTabKey; enabled: boolean };
    if (!WHATSAPP_TAB_KEYS.includes(body.tab)) throw new AppError('invalid tab', 400);

    const db = getReadDb();
    const [row] = await db.select({ config: clinicModules.config })
      .from(clinicModules)
      .where(and(eq(clinicModules.clinicId, clinicId), eq(clinicModules.moduleKey, 'whatsapp')))
      .limit(1);
    if (!row) throw new AppError('WhatsApp module not configured for this clinic', 404);

    const parsed = JSON.parse(row.config) as Record<string, any>;
    parsed.tabs = parsed.tabs ?? Object.fromEntries(WHATSAPP_TAB_KEYS.map(k => [k, true]));
    parsed.tabs[body.tab] = body.enabled;

    await db.update(clinicModules)
      .set({ config: JSON.stringify(parsed) })
      .where(and(eq(clinicModules.clinicId, clinicId), eq(clinicModules.moduleKey, 'whatsapp')));

    invalidateCache(`wa-tab:${clinicId}:`);

    await recordAuditLog({
      clinicId,
      actorUserId: c.get('actorUserId') ?? user.id,
      onBehalfOfUserId: user.id,
      action: 'whatsapp_tab.toggle',
      entityType: 'clinic_modules',
      entityId: clinicId,
      changes: { tab: body.tab, enabled: body.enabled },
    });

    return c.json({ ok: true, tabs: parsed.tabs });
  } catch (err) { return handleError(err, c); }
});

// ui/src/hooks/useWhatsappTabs.ts
import { useQuery } from '@tanstack/react-query';
import { fetchWithAuth } from '@/lib/serverComm';

export type WhatsappTabKey = 'inbox' | 'templates' | 'automations' | 'quickReplies' | 'analytics' | 'events';

export function useWhatsappTabs() {
  return useQuery({
    queryKey: ['wa-tabs'],
    queryFn: async (): Promise<Record<WhatsappTabKey, boolean>> => {
      const res = await fetchWithAuth('/api/v1/protected/whatsapp-module/tabs');
      if (!res.ok) {
        // Module disabled or feature off — surface as "all off"
        return { inbox: false, templates: false, automations: false, quickReplies: false, analytics: false, events: false };
      }
      return res.json();
    },
    staleTime: 5 * 60_000,
  });
}

-- 0044_automation_lifecycle_triggers.sql
-- Postgres requires ALTER TYPE … ADD VALUE outside a multi-statement transaction.
-- Apply with: psql ... -v ON_ERROR_STOP=1 -f 0044_automation_lifecycle_triggers.sql
-- AND ensure no \begin in this file.

ALTER TYPE app.automation_trigger_kind ADD VALUE IF NOT EXISTS 'appointment_requested';
ALTER TYPE app.automation_trigger_kind ADD VALUE IF NOT EXISTS 'appointment_scheduled';
ALTER TYPE app.automation_trigger_kind ADD VALUE IF NOT EXISTS 'appointment_confirmed';
ALTER TYPE app.automation_trigger_kind ADD VALUE IF NOT EXISTS 'appointment_cancelled';
ALTER TYPE app.automation_trigger_kind ADD VALUE IF NOT EXISTS 'appointment_rescheduled';
ALTER TYPE app.automation_trigger_kind ADD VALUE IF NOT EXISTS 'appointment_no_show';
ALTER TYPE app.automation_trigger_kind ADD VALUE IF NOT EXISTS 'last_visit_completed';

ALTER TABLE app.whatsapp_automations
  ADD COLUMN IF NOT EXISTS reconcile_notes TEXT,
  ADD COLUMN IF NOT EXISTS reconciled_at TIMESTAMP;

CREATE INDEX IF NOT EXISTS whatsapp_automations_clinic_trigger_enabled_idx
  ON app.whatsapp_automations (clinic_id, trigger_kind, is_enabled);

export const automationTriggerKindEnum = pgEnum('automation_trigger_kind', [
  'appointment_upcoming',
  'appointment_missed',
  'last_visit_recall',
  'invoice_overdue',
  'appointment_requested',
  'appointment_scheduled',
  'appointment_confirmed',
  'appointment_cancelled',
  'appointment_rescheduled',
  'appointment_no_show',
  'last_visit_completed',
]);

reconcileNotes: text('reconcile_notes'),
reconciledAt: timestamp('reconciled_at'),

export type InlineEvent =
  | 'appointment_requested'
  | 'appointment_scheduled'
  | 'appointment_confirmed'
  | 'appointment_cancelled'
  | 'appointment_rescheduled'
  | 'appointment_no_show';

export interface InlineDispatchResult { sent: number; skipped: number; failed: number }

export async function dispatchInlineAutomations(opts: {
  clinicId: string;
  event: InlineEvent;
  appointmentId: string;
  patientId: string;
}): Promise<InlineDispatchResult> {
  const db = getReadDb();
  const autos = await db
    .select()
    .from(whatsappAutomations)
    .where(and(
      eq(whatsappAutomations.clinicId, opts.clinicId),
      eq(whatsappAutomations.triggerKind, opts.event as any),
      eq(whatsappAutomations.isEnabled, true),
    ));

  const result: InlineDispatchResult = { sent: 0, skipped: 0, failed: 0 };
  for (const auto of autos) {
    const cand: Candidate = {
      subjectKind: 'appointment',
      subjectId: opts.appointmentId,
      patientId: opts.patientId,
      appointmentId: opts.appointmentId,
    };
    const outcome = await runOne(auto, cand);
    if (outcome === 'sent') result.sent += 1;
    else if (outcome === 'skipped') result.skipped += 1;
    else result.failed += 1;
  }
  return result;
}

case 'last_visit_completed': {
  const rows = await db.execute(sql`
    WITH last_completed AS (
      SELECT a.id AS appointment_id, a.patient_id,
             a.appointment_date::timestamp + a.appointment_time::time AS completed_at
      FROM app.appointments a
      WHERE a.clinic_id = ${auto.clinicId}
        AND a.status = 'completed'
    )
    SELECT appointment_id, patient_id
    FROM last_completed
    WHERE completed_at BETWEEN now() - (${offsetMin + TRIGGER_WING_MIN} || ' minutes')::interval
                           AND now() - (${offsetMin - TRIGGER_WING_MIN} || ' minutes')::interval
  `);
  const list = ((rows as any).rows ?? rows) as Array<{ appointment_id: string; patient_id: string }>;
  return list.map((r) => ({
    subjectKind: 'appointment' as const,
    subjectId: r.appointment_id,
    patientId: r.patient_id,
    appointmentId: r.appointment_id,
  }));
}

recentCompletedAppointment: {
  appointmentDate?: string | null;
  appointmentTime?: string | null;
  appointmentType?: string | null;
  doctorName?: string | null;
} | null;
googleReviewUrlSuffix: string | null;

case 'recentAppointmentDate':
  return fmtDate(ctx.recentCompletedAppointment?.appointmentDate);
case 'recentAppointmentTime':
  return fmtTime(ctx.recentCompletedAppointment?.appointmentTime);
case 'googleReviewUrl':
  return ctx.googleReviewUrlSuffix;  // suffix only — Meta button URL placeholder takes the trailing path

const HIDDEN_TEMPLATES = new Set<string>(['hello_world']);

const visible = (templates ?? []).filter((t: any) => !HIDDEN_TEMPLATES.has(t.name));
cache.set(clinicId, { ts: Date.now(), data: visible });
return c.json({ templates: visible });

import type { InlineEvent } from './automation-dispatcher';

export function inlineEventFor(
  prevStatus: string | null,
  newStatus: string,
): InlineEvent | null {
  if (prevStatus == null) {
    if (newStatus === 'requested') return 'appointment_requested';
    if (newStatus === 'scheduled') return 'appointment_scheduled';
    if (newStatus === 'confirmed') return 'appointment_confirmed';
    return null;
  }
  if (newStatus === prevStatus) return null;
  if (newStatus === 'confirmed') return 'appointment_confirmed';
  if (newStatus === 'cancelled') return 'appointment_cancelled';
  if (newStatus === 'no_show') return 'appointment_no_show';
  return null;
}

const tabOn = await isWhatsappTabEnabled(opts.clinicId, 'automations');
if (!tabOn) return { sent: 0, skipped: 0, failed: 0, reason: 'automations_tab_disabled' } as any;

import { inlineEventFor } from '../lib/lifecycle-events';
import { dispatchInlineAutomations } from '../lib/automation-dispatcher';

// ... inside handler, after `if (!updated) throw ...`
const event = inlineEventFor(currentStatus, newStatus);
let whatsappOutcome: { queued: boolean; templateName?: string; reason?: string } | null = null;
if (event) {
  // Run in waitUntil so the response isn't blocked, but capture the count
  // synchronously by doing the find-automations query inline; the actual
  // Meta send happens in the background.
  const db2 = getReadDb();
  const [auto] = await db2
    .select({ name: whatsappAutomations.name, templateName: whatsappAutomations.templateName })
    .from(whatsappAutomations)
    .where(and(
      eq(whatsappAutomations.clinicId, currentClinicId),
      eq(whatsappAutomations.triggerKind, event as any),
      eq(whatsappAutomations.isEnabled, true),
    ))
    .limit(1);
  if (auto) {
    whatsappOutcome = { queued: true, templateName: auto.templateName };
    c.executionCtx?.waitUntil(
      dispatchInlineAutomations({
        clinicId: currentClinicId,
        event,
        appointmentId: updated.id,
        patientId: updated.patientId!,
      }).catch(err => console.error('[lifecycle] inline dispatch failed:', err)),
    );
  } else {
    whatsappOutcome = { queued: false, reason: 'no_automation_bound' };
  }
}

if (utcHour === 2) {
  await handleAutomationReconcile(env, ctx);
}

adminRoute.post('/automations/suggest-mapping', async (c) => {
  const { templateName, templateLanguage } = await c.req.json();
  const known = TEMPLATE_DEFAULTS[templateName];
  if (known) return c.json({ paramMapping: known.paramMapping, confidence: 'known' });
  // Heuristic — fetch template body, regex placeholders, score by surrounding text.
  // ... (heuristic implementation)
});