Кофе 40 секундта немесе тегін: Firebase Realtime Database және Gemini Live Audio арқылы Астана БО-дағы кезектерді жою

import { useState, useRef, useCallback } from 'react';

const GATEWAY_WS_URL = 'wss://gemini-live-gateway.ozat.kz/v1/kiosk-session';

export type PaymentStatus = 'pending' | 'qr_emitted' | 'authorized' | 'captured' | 'failed' | 'refunded';

export interface ValidatedOrderItem {
  sku: string;
  name: string;
  size: 'regular' | 'large';
  milk: 'standard' | 'oat' | 'coconut' | 'lactose_free';
  syrup?: string;
  temperature: 'hot' | 'iced';
  unitPriceKzt: number;
}

export interface KioskOrder {
  orderId: string;
  items: ValidatedOrderItem[];
  totalKzt: number;
  paymentPayloadKaspi: string;
  paymentState: PaymentStatus;
  status: 'draft' | 'validated' | 'paid' | 'pushed_to_kds';
}

export function useGeminiLiveKiosk(onOrderReady: (order: KioskOrder) => Promise<void>) {
  const [sessionActive, setSessionActive] = useState(false);
  const [currentOrder, setCurrentOrder] = useState<KioskOrder | null>(null);

  const wsRef = useRef<WebSocket | null>(null);
  const audioCtxRef = useRef<AudioContext | null>(null);
  const workletNodeRef = useRef<AudioWorkletNode | null>(null);
  const mediaStreamRef = useRef<MediaStream | null>(null);

  const startSession = useCallback(async () => {
    try {
      const stream = await navigator.mediaDevices.getUserMedia({
        audio: {
          channelCount: 1,
          sampleRate: 16000,
          echoCancellation: true,
          noiseSuppression: true,
          autoGainControl: true
        }
      });
      mediaStreamRef.current = stream;

      const ws = new WebSocket(GATEWAY_WS_URL);
      wsRef.current = ws;

      ws.onopen = () => {
        setSessionActive(true);
        ws.send(JSON.stringify({
          type: 'session.setup',
          model: 'models/gemini-2.5-flash',
          generationConfig: {
            temperature: 0.1,
            responseModalities: ['AUDIO', 'TEXT']
          },
          systemInstruction: {
            parts: [{
              text: "Сен ОЗАТ Coffee Bar AI-көмекшісісің. Тез әрі нақты жұмыс істе. Қазақша, орысша немесе аралас сөйлегенді табиғи түсін. Клиент кофе түрі мен сүтін айтқан бойда request_order_validation құралын шақыр. Бағаны өзің ойлап таппа."
            }]
          },
          tools: [{
            functionDeclarations: [{
              name: 'request_order_validation',
              description: 'Қоймадағы қалдық бойынша тапсырыс құрамын тексереді және бағасын есептеуге жібереді',
              parameters: {
                type: 'OBJECT',
                properties: {
                  requestedItems: {
                    type: 'ARRAY',
                    items: {
                      type: 'OBJECT',
                      properties: {
                        sku: { type: 'STRING' },
                        name: { type: 'STRING' },
                        size: { type: 'STRING', enum: ['regular', 'large'] },
                        milk: { type: 'STRING', enum: ['standard', 'oat', 'coconut', 'lactose_free'] },
                        syrup: { type: 'STRING' },
                        temperature: { type: 'STRING', enum: ['hot', 'iced'] }
                      },
                      required: ['sku', 'name', 'size', 'milk']
                    }
                  }
                },
                required: ['requestedItems']
              }
            }]
          }]
        }));
      };

      ws.onmessage = async (evt) => {
        const msg = JSON.parse(evt.data);

        if (msg.toolCall?.functionCalls) {
          for (const call of msg.toolCall.functionCalls) {
            if (call.name === 'request_order_validation') {
              const res = await fetch('/api/v1/orders/validate-and-price', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ items: call.args.requestedItems })
              });
              const validatedPayload: KioskOrder = await res.json();

              setCurrentOrder(validatedPayload);
              await onOrderReady(validatedPayload);

              ws.send(JSON.stringify({
                type: 'tool_response',
                toolResponses: [{
                  response: {
                    output: {
                      success: true,
                      orderId: validatedPayload.orderId,
                      totalKzt: validatedPayload.totalKzt,
                      currency: 'KZT'
                    }
                  },
                  id: call.id
                }]
              }));
            }
          }
        }
      };

      const audioCtx = new AudioContext({ sampleRate: 16000 });
      audioCtxRef.current = audioCtx;
      const source = audioCtx.createMediaStreamSource(stream);

      await audioCtx.audioWorklet.addModule('/audio-stream-processor.js');
      const workletNode = new AudioWorkletNode(audioCtx, 'audio-stream-processor');
      workletNodeRef.current = workletNode;

      workletNode.port.onmessage = (e) => {
        if (ws.readyState === WebSocket.OPEN && e.data.pcm16Chunk) {
          ws.send(e.data.pcm16Chunk);
        }
      };

      source.connect(workletNode);
    } catch (err) {
      console.error('[Gemini Live Gateway] Init error:', err);
      setSessionActive(false);
    }
  }, [onOrderReady]);

  const stopSession = useCallback(() => {
    setSessionActive(false);
    mediaStreamRef.current?.getTracks().forEach(t => t.stop());
    workletNodeRef.current?.disconnect();
    audioCtxRef.current?.close();
    wsRef.current?.close();
  }, []);

  return { sessionActive, startSession, stopSession, currentOrder };
}

import { initializeApp, getApps } from 'firebase/app';
import { getDatabase, ref, set, get, onValue, push, runTransaction, update } from 'firebase/database';

const firebaseConfig = {
  apiKey: "AIzaSy_OZAT_COFFEE_PROD_KEY",
  authDomain: "ozat-astana-coffee.firebaseapp.com",
  databaseURL: "https://ozat-astana-coffee-default-rtdb.asia-southeast1.firebasedatabase.app",
  projectId: "ozat-astana-coffee"
};

const app = getApps().length === 0 ? initializeApp(firebaseConfig) : getApps()[0];
const rtdb = getDatabase(app);

export type PaymentState = 'pending' | 'qr_emitted' | 'authorized' | 'captured' | 'failed' | 'refunded';

export interface KDSTicket {
  id: string;
  orderNumber: number;
  items: Array<{
    name: string;
    size: string;
    milk: string;
    syrup?: string;
  }>;
  totalKzt: number;
  paymentState: PaymentState;
  paymentRefKaspi?: string;
  status: 'pending' | 'in_progress' | 'completed' | 'canceled';
  createdAt: number;
}

export class CoffeeKDSManager {
  private queueRef = ref(rtdb, 'kiosks/astana_bc_01/queue');

  async pushTicket(order: Omit<KDSTicket, 'id' | 'orderNumber' | 'createdAt' | 'status'>): Promise<string> {
    const counterRef = ref(rtdb, 'kiosks/astana_bc_01/daily_counter');
    let generatedOrderNum = 1;

    await runTransaction(counterRef, (currentVal) => {
      generatedOrderNum = (currentVal || 0) + 1;
      return generatedOrderNum;
    });

    const newTicketRef = push(this.queueRef);
    const ticketPayload: KDSTicket = {
      ...order,
      id: newTicketRef.key!,
      orderNumber: generatedOrderNum,
      status: 'pending',
      createdAt: Date.now()
    };

    await set(newTicketRef, ticketPayload);
    return newTicketRef.key!;
  }

  subscribeQueue(onUpdate: (tickets: KDSTicket[]) => void): () => void {
    return onValue(this.queueRef, (snapshot) => {
      const data = snapshot.val();
      if (!data) {
        onUpdate([]);
        return;
      }
      const list: KDSTicket[] = Object.values(data);
      list.sort((a, b) => a.createdAt - b.createdAt);
      onUpdate(list);
    });
  }

  async completeAndArchive(ticketId: string): Promise<void> {
    const itemRef = ref(rtdb, `kiosks/astana_bc_01/queue/${ticketId}`);
    const archiveRef = ref(rtdb, `kiosks/astana_bc_01/archive/${ticketId}`);

    const snapshot = await get(itemRef);
    if (snapshot.exists()) {
      const ticketData = snapshot.val();
      await set(archiveRef, {
        ...ticketData,
        status: 'completed',
        completedAt: Date.now()
      });
      await set(itemRef, null);
    }
  }

  async updatePaymentState(ticketId: string, paymentState: PaymentState, paymentRefKaspi?: string): Promise<void> {
    const itemRef = ref(rtdb, `kiosks/astana_bc_01/queue/${ticketId}`);
    await update(itemRef, {
      paymentState,
      ...(paymentRefKaspi ? { paymentRefKaspi } : {})
    });
  }
}