AI Assistants

export enum MessageSender {
  USER = 'user',
  BOT = 'bot',
}

export interface ChatMessage {
  sender: MessageSender;
  text: string;
}

export interface ChatHistorySession {
  id: string;                          // Unique session ID
  startTime: string;                   // ISO timestamp
  messages: ChatMessage[];             // Full conversation
  outcome: 'order' | 'reservation' | null;  // Final result
  tokensUsed: number;                  // Gemini API token count
  lastActivity: string;                // Last message timestamp
}

export interface SliceBotMetrics {
  distinctCustomers: number;    // Unique users
  totalMessages: number;        // All messages sent/received
  totalTokensUsed: number;      // Gemini API usage
  ordersMade: number;           // Successful orders
  reservationsMade: number;     // Successful reservations
}

sendMessageToGemini(
  history: ChatMessage[],
  actionLock: 'order' | 'reservation' | null
): Promise<{ text: string }>

const response = await ai.models.generateContent({
  model: 'gemini-2.5-flash',
  contents: formattedHistory,
  config: {
    systemInstruction: systemInstruction,  // Contains menu, hours, rules
  },
});

return { text: response.text };

transcribeAudio(
  base64Audio: string,
  mimeType: string
): Promise<string>

import { transcribeAudio } from './services/geminiService';

// User records voice message
const audioBlob = /* ... microphone recording ... */;
const base64Audio = await blobToBase64(audioBlob);

const transcription = await transcribeAudio(base64Audio, 'audio/webm');
console.log(transcription);  // "Quiero pedir una pizza muzzarella"

// Then send as text message to AI
await sendMessageToGemini([...history, { sender: 'user', text: transcription }]);

const [actionLock, setActionLock] = useState<'order' | 'reservation' | null>(null);

// First user message determines intent
const userText = text.toLowerCase();
if (userText.includes('pedido') || userText.includes('ordenar') || userText.includes('pizza')) {
  currentActionLock = 'order';
} else if (userText.includes('reserva') || userText.includes('mesa')) {
  currentActionLock = 'reservation';
}

if (currentActionLock) {
  setActionLock(currentActionLock);
}

{
  "intent": "ORDER",
  "customer": {
    "name": "Juan Pérez",
    "phone": "1123456789",
    "address": "Calle 123"
  },
  "items": [
    { "name": "Pizza Muzzarella", "quantity": 2, "price": 9200 }
  ],
  "total": 18400,
  "type": "delivery",
  "paymentMethod": "Transferencia"
}

if (data.intent === 'ORDER') {
  await saveOrder({ ...data, createdBy: CreatedBy.WEB_ASSISTANT });
  
  // Log metrics
  if (sessionId) sliceBotMetricsService.logOutcome(sessionId, 'order');
  
  // Show confirmation
  handleActionSuccess(
    `¡Perfecto! Tu pedido ha sido registrado con éxito. ¡Gracias!`
  );
}

{
  "intent": "RESERVATION",
  "customerName": "María González",
  "customerPhone": "1198765432",
  "guests": 4,
  "date": "2026-03-15",
  "time": "20:00"
}

if (data.intent === 'RESERVATION') {
  const reservationTime = new Date(`${data.date}T${data.time}`);
  
  // Final availability check
  const availableTableIds = findAvailableTables(reservationTime, data.guests);
  
  if (availableTableIds) {
    await addReservation({
      ...data,
      reservationTime: reservationTime.toISOString(),
      tableIds: availableTableIds,
      createdBy: CreatedBy.WEB_ASSISTANT,
    });
    
    // Log and confirm
    sliceBotMetricsService.logOutcome(sessionId, 'reservation');
    handleActionSuccess(`¡Reserva confirmada para ${data.guests} personas!`);
  } else {
    // Offer alternatives
    const alternativeSlots = getAvailability(date, data.guests);
    // Show alternative times to customer
  }
}

if (isOpen) {
  return `Eres "Slice", un asistente de IA amigable para "Pizzería Los Genios".
  
  Tu objetivo es ayudar con:
  1) Realizar pedidos para recoger o a domicilio
  2) Hacer reservas de mesa
  
  **REGLAS DE PAGO OBLIGATORIAS**:
  - Delivery: Solo "Transferencia"
  - Pickup: "Efectivo" o "Credito" (preguntar)
  
  **PROCESO OBLIGATORIO**:
  1. Recopila información completa
  2. Presenta resumen y PREGUNTA si es correcto
  3. Espera confirmación explícita ("sí", "confirmo")
  4. SOLO DESPUÉS genera el JSON
  
  Menú:
  ${menu}
  
  Horario:
  ${schedule}
  `;
}

else {
  return `Eres "Slice", asistente de "Pizzería Los Genios".
  
  El local está CERRADO para pedidos.
  
  **INSTRUCCIONES**:
  1. Informa que el local está cerrado para tomar pedidos
  2. Muestra el horario: ${schedule}
  3. Aclara que SÍ pueden hacer una reserva
  
  Si el usuario no quiere reservar, finaliza amablemente.
  `;
}

if (actionLock === 'order') {
  return `Ya estás en medio de tomar un pedido.
  
  Tu ÚNICA tarea es completar este pedido:
  - NO ofrezcas hacer una reserva
  - Pide la información faltante
  - Presenta resumen y espera confirmación
  - Genera JSON de PEDIDO
  `;
}

if (actionLock === 'reservation') {
  return `Ya estás en medio de hacer una reserva.
  
  Tu ÚNICA tarea es completar esta reserva:
  - NO ofrezcas tomar un pedido
  - Pide datos faltantes (nombre, teléfono, personas, fecha, hora)
  - Presenta resumen y espera confirmación
  - Genera JSON de RESERVA
  `;
}

const generateMenuForPrompt = (): string => {
  const products = getProductsFromCache();
  return JSON.stringify(groupedMenu, null, 2);
};

const formatScheduleForPrompt = (): string => {
  const schedule = getScheduleFromCache();
  return days.map((day, index) => {
    const daySchedule = schedule[dayKeys[index]];
    if (daySchedule.isOpen) {
      return `${dayName}: de ${slot.open} a ${slot.close}`;
    }
    return `${dayName}: Cerrado`;
  }).join('\n');
};

const generateAvailabilityForPrompt = (): string => {
  const reservations = getReservationsFromCache().filter(
    r => r.status === ReservationStatus.CONFIRMED
  );
  const orders = getOrdersFromCache().filter(
    o => o.type === OrderType.DINE_IN && !isOrderFinished(o.status)
  );
  
  // Build list of busy time slots with table names
  return formattedSlots;  // "Hoy 20:00-21:30 en Mesa 1, Mesa 2"
};

export type BotApiStatus = 'READY_TO_SCAN' | 'ACTIVE' | 'DISCONNECTED';

export type WhatsAppBotStatus = 
  'disconnected' | 'initiating' | 'ready_to_scan' | 
  'scanning' | 'active' | 'error' | 'disconnecting';

// Start bot deployment
initiateWhatsAppDeploy(): Promise<boolean>

// Get QR code for scanning
getWhatsAppQR(): Promise<string>  // Returns base64 image

// Check connection status
getWhatsAppStatus(): Promise<BotApiStatus>

// Disconnect bot
disconnectWhatsAppBot(): Promise<boolean>

sendWhatsAppMessage(
  number: string,
  content: string,
  mediaUrl?: string
): Promise<{ success: boolean; error?: string }>

import { sendWhatsAppMessage } from './services/whatsappBotService';

const result = await sendWhatsAppMessage(
  '1145678901',
  '¡Hola! Tu pedido está listo para retirar.',
  'https://example.com/order-ready.jpg'
);

if (result.success) {
  console.log('Notification sent!');
} else {
  console.error(`Failed: ${result.error}`);
}

sendWhatsAppGroupMessage(
  groupId: string,
  content: string,
  mediaUrl?: string
): Promise<{ success: boolean; error?: string }>

export interface WhatsAppBotMetrics {
  distinctCustomers: number;    // Unique phone numbers
  totalMessages: number;        // All messages handled
  ordersMade: number;           // Orders created via WhatsApp
  reservationsMade: number;     // Reservations created via WhatsApp
}

// Start new conversation
startSession(): string  // Returns session ID

// Log each message
logMessage(sessionId: string, message: ChatMessage): void

// Record final outcome
logOutcome(sessionId: string, outcome: 'order' | 'reservation'): void

// Get session history
getSessionHistory(sessionId: string): ChatHistorySession | null

export const getMetrics = (): SliceBotMetrics => {
  const sessions = getAllSessions();
  
  return {
    distinctCustomers: sessions.length,  // Unique sessions
    totalMessages: sessions.reduce((sum, s) => sum + s.messages.length, 0),
    totalTokensUsed: sessions.reduce((sum, s) => sum + s.tokensUsed, 0),
    ordersMade: sessions.filter(s => s.outcome === 'order').length,
    reservationsMade: sessions.filter(s => s.outcome === 'reservation').length,
  };
};

const ai = new GoogleGenAI({ apiKey: process.env.API_KEY! });

const projectId = 'e40701d9-d93a-451f-9d5b-5cb02c237add';
const builderBotApiKey = 'bbc-ff129879-89ee-43a5-a28b-640480e3294a';
const builderBotV2ApiKey = 'bb-e25d1057-de9a-4cc0-b103-4bcbc2873820';