import { describe, it, expect, vi } from 'vitest';
import { parseAssistantConfig } from '../whatsapp-assistant-config';

describe('parseAssistantConfig', () => {
  it('returns disabled defaults when no row', () => {
    expect(parseAssistantConfig(null)).toEqual({ enabled: false, knowledge: '', disclosure: true });
  });
  it('reads isEnabled + config json', () => {
    const row = { isEnabled: true, config: JSON.stringify({ knowledge: 'We have parking.', disclosure: false }) };
    expect(parseAssistantConfig(row as any)).toEqual({ enabled: true, knowledge: 'We have parking.', disclosure: false });
  });
  it('tolerates malformed config json', () => {
    const row = { isEnabled: true, config: '{bad' };
    expect(parseAssistantConfig(row as any)).toEqual({ enabled: true, knowledge: '', disclosure: true });
  });
});

// server/src/lib/whatsapp-assistant-config.ts
import { getReadDb, getWriteDb } from './db';
import { clinicModules } from '../schema';
import { and, eq } from 'drizzle-orm';

export const ASSISTANT_MODULE_KEY = 'whatsapp_assistant';

export interface AssistantConfig {
  enabled: boolean;
  knowledge: string;
  disclosure: boolean;
}

export function parseAssistantConfig(row: { isEnabled?: boolean; config?: string | null } | null): AssistantConfig {
  if (!row) return { enabled: false, knowledge: '', disclosure: true };
  let cfg: any = {};
  try { cfg = row.config ? JSON.parse(row.config) : {}; } catch { cfg = {}; }
  return {
    enabled: !!row.isEnabled,
    knowledge: typeof cfg.knowledge === 'string' ? cfg.knowledge : '',
    disclosure: cfg.disclosure !== false,
  };
}

export async function getAssistantConfig(clinicId: string): Promise<AssistantConfig> {
  const db = getReadDb();
  const [row] = await db.select().from(clinicModules)
    .where(and(eq(clinicModules.clinicId, clinicId), eq(clinicModules.moduleKey, ASSISTANT_MODULE_KEY)))
    .limit(1);
  return parseAssistantConfig(row ?? null);
}

export async function saveAssistantConfig(clinicId: string, patch: Partial<AssistantConfig>): Promise<AssistantConfig> {
  const db = getWriteDb();
  const current = await getAssistantConfig(clinicId);
  const next: AssistantConfig = { ...current, ...patch };
  // Idempotent upsert; matches the no-migration CREATE-on-write style used elsewhere.
  await db.execute(/* sql */`
    INSERT INTO app.clinic_modules (id, clinic_id, module_key, is_enabled, config, created_at, updated_at)
    VALUES (gen_random_uuid()::text, '${clinicId}', '${ASSISTANT_MODULE_KEY}', ${next.enabled}, $cfg$${JSON.stringify({ knowledge: next.knowledge, disclosure: next.disclosure })}$cfg$, now(), now())
    ON CONFLICT (clinic_id, module_key) DO UPDATE SET is_enabled = EXCLUDED.is_enabled, config = EXCLUDED.config, updated_at = now()
  ` as any);
  return next;
}

import { describe, it, expect } from 'vitest';
import { formatKnowledgeBlock } from '../whatsapp-knowledge';

describe('formatKnowledgeBlock', () => {
  it('includes clinic facts, blob, and patient appt', () => {
    const out = formatKnowledgeBlock({
      clinicName: 'ssh & Associates', address: '12 Main St',
      hours: [{ day: 'Monday', open: '13:00', close: '21:00', closed: false }],
      services: ['Cleaning', 'Braces'], doctors: ['Dr Ayesha Khan'],
      knowledge: 'Free parking at the rear.',
      patient: { firstName: 'Sara', nextAppointment: { date: '2026-06-10', time: '14:30', type: 'Cleaning', doctor: 'Dr Ayesha Khan' } },
    });
    expect(out).toContain('ssh & Associates');
    expect(out).toContain('Free parking');
    expect(out).toContain('Braces');
    expect(out).toContain('2026-06-10');
    expect(out).toContain('Sara');
  });
  it('omits patient block when none', () => {
    const out = formatKnowledgeBlock({ clinicName: 'X', address: '', hours: [], services: [], doctors: [], knowledge: '', patient: null });
    expect(out).not.toContain('PATIENT CONTEXT');
  });
});

// server/src/lib/ai/whatsapp-knowledge.ts
import { getReadDb } from '../db';
import { clinics, clinicOperatingHours, procedures, users, doctorSchedules } from '../../schema';
import { and, eq } from 'drizzle-orm';
import { decryptPatientPHI } from '../encryption'; // match the helper used in the webhook
import { getAssistantConfig } from '../whatsapp-assistant-config';

export interface KnowledgeInput {
  clinicName: string;
  address: string;
  hours: Array<{ day: string; open?: string; close?: string; closed: boolean }>;
  services: string[];
  doctors: string[];
  knowledge: string;
  patient: { firstName: string; nextAppointment: { date: string; time: string; type: string; doctor: string } | null } | null;
}

export function formatKnowledgeBlock(k: KnowledgeInput): string {
  const lines: string[] = [];
  lines.push(`CLINIC: ${k.clinicName}`);
  if (k.address) lines.push(`ADDRESS: ${k.address}`);
  if (k.hours.length) {
    lines.push('HOURS:');
    for (const h of k.hours) lines.push(`  ${h.day}: ${h.closed ? 'Closed' : `${h.open}–${h.close}`}`);
  }
  if (k.services.length) lines.push(`SERVICES: ${k.services.join(', ')}`);
  if (k.doctors.length) lines.push(`DOCTORS: ${k.doctors.join(', ')}`);
  if (k.knowledge.trim()) lines.push(`CLINIC NOTES:\n${k.knowledge.trim()}`);
  if (k.patient) {
    lines.push(`PATIENT CONTEXT: messaging patient is ${k.patient.firstName}.`);
    lines.push(k.patient.nextAppointment
      ? `  Next appointment: ${k.patient.nextAppointment.date} ${k.patient.nextAppointment.time}, ${k.patient.nextAppointment.type} with ${k.patient.nextAppointment.doctor}.`
      : `  No upcoming appointment on file.`);
  }
  return lines.join('\n');
}

// Assemble live data. `patient` is the single phone-matched patient (or null).
export async function buildKnowledge(clinicId: string, patient: { id: string; firstName: string } | null): Promise<KnowledgeInput> {
  const db = getReadDb();
  const [clinic] = await db.select().from(clinics).where(eq(clinics.id, clinicId)).limit(1);
  const cfg = await getAssistantConfig(clinicId);
  const hoursRows = await db.select().from(clinicOperatingHours).where(eq(clinicOperatingHours.clinicId, clinicId));
  const procRows = await db.select({ name: procedures.procedureName }).from(procedures).where(eq(procedures.clinicId, clinicId));
  const docRows = await db.select({ first: users.firstName, last: users.lastName }).from(users)
    .where(and(eq(users.clinicId, clinicId), eq(users.role, 'doctor')));

  let patientCtx: KnowledgeInput['patient'] = null;
  if (patient) {
    // next upcoming, non-cancelled appointment for this patient
    const appt = await fetchNextAppointment(db, clinicId, patient.id); // implement inline; see NOTE
    patientCtx = { firstName: patient.firstName, nextAppointment: appt };
  }

  return {
    clinicName: clinic?.name ?? 'the clinic',
    address: (clinic as any)?.address ?? '',
    hours: hoursRows.map((h: any) => ({ day: capitalize(h.dayOfWeek), open: h.openTime, close: h.closeTime, closed: !!h.isClosed })),
    services: procRows.map((p: any) => p.name).filter(Boolean),
    doctors: docRows.map((d: any) => `Dr ${d.first ?? ''} ${d.last ?? ''}`.trim()),
    knowledge: cfg.knowledge,
    patient: patientCtx,
  };
}

function capitalize(s: string) { return s ? s.charAt(0).toUpperCase() + s.slice(1) : s; }

import { describe, it, expect, vi } from 'vitest';
vi.mock('../../client', () => ({ callAIJson: vi.fn() }));
import { callAIJson } from '../../client';
import { askRubyWhatsApp } from '../whatsapp-assistant';

describe('askRubyWhatsApp', () => {
  it('passes knowledge + transcript and returns the structured result', async () => {
    (callAIJson as any).mockResolvedValue({ intent: 'general', action: 'reply', reply: 'We are open till 9pm.', category: 'hours' });
    const res = await askRubyWhatsApp({
      clinicId: 'c1', knowledgeBlock: 'CLINIC: X\nHOURS:\n  Monday: 13:00–21:00',
      transcript: [{ role: 'user', text: 'what time do you close?' }],
    });
    expect(res.action).toBe('reply');
    expect(res.reply).toContain('9pm');
    const arg = (callAIJson as any).mock.calls[0][0];
    expect(arg.promptName).toBeDefined();
    expect(JSON.stringify(arg)).toContain('what time do you close');
  });
});

// server/src/lib/ai/agents/whatsapp-assistant.ts
import { callAIJson } from '../client';
import { PROMPTS, PROMPT_NAMES } from '../prompts';

export type RubyIntent = 'general' | 'appointment_lookup' | 'booking_request' | 'clinical' | 'escalate' | 'smalltalk' | 'unknown';
export type RubyAction = 'reply' | 'collect' | 'create_request' | 'handoff';

export interface RubyBooking {
  complete: boolean;
  preferredDate?: string; preferredTime?: string; reason?: string;
  name?: string; email?: string; missing?: string[];
}
export interface RubyResult {
  intent: RubyIntent;
  action: RubyAction;
  reply: string;
  category: string;
  booking?: RubyBooking;
  escalate?: { reason: string };
}

export interface AskRubyInput {
  clinicId: string;
  knowledgeBlock: string;
  transcript: Array<{ role: 'user' | 'assistant'; text: string }>; // last ~8 turns, oldest first
  patientMatched?: boolean;
}

export async function askRubyWhatsApp(input: AskRubyInput): Promise<RubyResult> {
  const userContent = [
    `KNOWLEDGE:\n${input.knowledgeBlock}`,
    `PATIENT_MATCHED: ${input.patientMatched ? 'yes' : 'no'}`,
    `CONVERSATION (oldest first):`,
    ...input.transcript.map(t => `${t.role === 'user' ? 'PATIENT' : 'CLINIC'}: ${t.text}`),
    `Respond with the JSON object now.`,
  ].join('\n');

  return callAIJson<RubyResult>({
    promptName: PROMPT_NAMES.whatsappAssistant,
    fallbackSystemPrompt: PROMPTS.whatsappAssistant,
    user: userContent,
    temperature: 0.3,
  });
}

import { describe, it, expect } from 'vitest';
import { shouldRubyEngage } from '../whatsapp-assistant-dispatch';

const base = { enabled: true, labels: [] as string[], staffActiveWithinMin: 999, repliesLastHour: 0 };
describe('shouldRubyEngage', () => {
  it('engages when enabled, no pause, no recent staff, under cap', () => {
    expect(shouldRubyEngage(base).engage).toBe(true);
  });
  it('skips when disabled', () => { expect(shouldRubyEngage({ ...base, enabled: false }).engage).toBe(false); });
  it('skips when ruby-paused label present', () => { expect(shouldRubyEngage({ ...base, labels: ['ruby-paused'] }).engage).toBe(false); });
  it('skips when staff active in last 15 min', () => { expect(shouldRubyEngage({ ...base, staffActiveWithinMin: 5 }).engage).toBe(false); });
  it('skips when over hourly cap', () => { expect(shouldRubyEngage({ ...base, repliesLastHour: 5 }).engage).toBe(false); });
});

// server/src/lib/whatsapp-assistant-dispatch.ts
export const RUBY_PAUSED_LABEL = 'ruby-paused';
const STAFF_BACKOFF_MIN = 15;
const HOURLY_CAP = 5;

export function shouldRubyEngage(s: { enabled: boolean; labels: string[]; staffActiveWithinMin: number; repliesLastHour: number }): { engage: boolean; reason?: string } {
  if (!s.enabled) return { engage: false, reason: 'disabled' };
  if (s.labels.includes(RUBY_PAUSED_LABEL)) return { engage: false, reason: 'handed-off' };
  if (s.staffActiveWithinMin < STAFF_BACKOFF_MIN) return { engage: false, reason: 'staff-active' };
  if (s.repliesLastHour >= HOURLY_CAP) return { engage: false, reason: 'rate-cap' };
  return { engage: true };
}

import { getReadDb } from './db';
import { sql } from 'drizzle-orm';
import { sendTextMessage } from './whatsapp';
import { getAssistantConfig } from './whatsapp-assistant-config';
import { buildKnowledge, formatKnowledgeBlock } from './ai/whatsapp-knowledge';
import { askRubyWhatsApp } from './ai/agents/whatsapp-assistant';
import { addRubyPausedLabel } from './whatsapp-assistant-state';
import { createNotificationForClinicUsers } from './notifications';

export async function runRubyForInbound(args: {
  clinicId: string;
  conversationId: string | null;
  patient: { id: string; clinicId: string; firstName: string; phone: string | null } | null; // single match or null
  matchCount: number;
  senderPhone: string;
  env?: any;
}): Promise<void> {
  try {
    const cfg = await getAssistantConfig(args.clinicId);
    const ctx = await gatherDispatchContext(args.clinicId, args.conversationId); // labels, staffActiveWithinMin, repliesLastHour, transcript, isFirstReply
    const decision = shouldRubyEngage({ enabled: cfg.enabled, ...ctx.guard });
    if (!decision.engage) return;

    const knowledge = await buildKnowledge(args.clinicId, args.matchCount === 1 ? args.patient : null);
    const res = await askRubyWhatsApp({
      clinicId: args.clinicId,
      knowledgeBlock: formatKnowledgeBlock(knowledge),
      transcript: ctx.transcript,
      patientMatched: args.matchCount === 1,
    });

    let replyText = res.reply;
    if (cfg.disclosure && ctx.isFirstReply) {
      replyText += `\n\n_(You're chatting with our automated assistant — a team member can jump in anytime.)_`;
    }

    if (res.action === 'create_request' && res.booking?.complete) {
      await createBookingArtifact(args, res.booking); // requested appt (matched) OR lead_submission (unmatched)
    }

    if (res.action === 'handoff') {
      await escalate(args, res.escalate?.reason ?? 'handoff');
    }

    await sendTextMessage({
      to: args.senderPhone,
      clinicId: args.clinicId,
      text: replyText,
      patientId: args.matchCount === 1 ? args.patient?.id : undefined,
      env: args.env,
    });
    // sendTextMessage writes the message row + outbound_message event; tag AI via metadata in a follow-up event write:
    await writeRubyEvent(args.clinicId, args.matchCount === 1 ? args.patient?.id ?? null : null, res.intent, res.category);
  } catch (err) {
    console.error('[Ruby] dispatch failed (non-fatal):', err);
  }
}

import { describe, it, expect } from 'vitest';
import { withLabel, withoutLabel } from '../whatsapp-assistant-state';
describe('label math', () => {
  it('adds without dupes', () => { expect(withLabel(['a'], 'ruby-paused')).toEqual(['a', 'ruby-paused']); expect(withLabel(['ruby-paused'], 'ruby-paused')).toEqual(['ruby-paused']); });
  it('removes', () => { expect(withoutLabel(['a', 'ruby-paused'], 'ruby-paused')).toEqual(['a']); });
});

// Best-effort Ruby autopilot. Runs after logging; never blocks the webhook.
await runRubyForInbound({
  clinicId,
  conversationId,                 // from the inbound insert above
  patient: matchingPatients.length === 1 ? matchingPatients[0] : null,
  matchCount: matchingPatients.length,
  senderPhone,
  env,
}).catch((e) => console.error('[Ruby] inbound hook failed:', e));