Smart Restaurant Voice Order & Billing System

// app/api/v1/voice/process-and-order/route.js
import { NextResponse } from 'next/server';
import pool from '@/lib/db';

export async function POST(req) {
  const connection = await pool.getConnection();
  try {
    const { table_number, raw_transcript, customer_id, parsed_items } = await req.json();

    if (!parsed_items || !Array.isArray(parsed_items) || parsed_items.length === 0) {
      await connection.query('INSERT INTO voice_logs (raw_transcript, intent_status) VALUES (?, ?)', 
        [raw_transcript || '', 'UNRECOGNIZED_SPEECH']);
      return NextResponse.json({
        status: "FAILED",
        voice_response: "I couldn't understand your order. Please try again."
      }, { status: 400 });
    }

    await connection.beginTransaction();

    let subtotal = 0;
    const itemsToInsert = [];

    // Historical price freezing & verification
    for (const item of parsed_items) {
      const [dbItems] = await connection.query(
        'SELECT id, item_name, price FROM menu_items WHERE item_name LIKE ? AND is_available = TRUE LIMIT 1',
        [`%${item.item_name}%`]
      );

      if (dbItems.length > 0) {
        const menuItem = dbItems[0];
        const lineTotal = Number(menuItem.price) * (item.qty || 1);
        subtotal += lineTotal;
        itemsToInsert.push({ 
          id: menuItem.id, 
          name: menuItem.item_name, 
          qty: item.qty || 1, 
          unit_price: menuItem.price, 
          lineTotal 
        });
      }
    }

    // Safety Check: Avoid creating zero-amount empty orders
    if (itemsToInsert.length === 0) {
      await connection.rollback();
      await pool.query('INSERT INTO voice_logs (raw_transcript, intent_status) VALUES (?, ?)', 
        [raw_transcript, 'ITEM_NOT_FOUND']);
      return NextResponse.json({
        status: "FAILED",
        voice_response: "Sorry, the items you requested are currently not on our menu."
      }, { status: 404 });
    }

    const tax = Number((subtotal * 0.05).toFixed(2));
    const totalPrice = Number((subtotal + tax).toFixed(2));

    // Create Order Header
    const [orderResult] = await connection.query(
      'INSERT INTO orders (customer_id, table_number, order_status, subtotal, tax, total_price) VALUES (?, ?, ?, ?, ?, ?)',
      [customer_id || null, table_number, 'PENDING', subtotal, tax, totalPrice]
    );
    const orderId = orderResult.insertId;

    // Insert Order Line Items
    for (const line of itemsToInsert) {
      await connection.query(
        'INSERT INTO order_details (order_id, item_id, quantity, unit_price, total_item_price) VALUES (?, ?, ?, ?, ?)',
        [orderId, line.id, line.qty, line.unit_price, line.lineTotal]
      );
    }

    // Write Voice Log
    await connection.query(
      'INSERT INTO voice_logs (order_id, raw_transcript, intent_status) VALUES (?, ?, ?)',
      [orderId, raw_transcript, 'SUCCESS']
    );

    await connection.commit();

    const confirmSpeech = `Your order for ${itemsToInsert.map(i => `${i.qty} ${i.name}`).join(', ')} has been placed! Total amount is ${totalPrice} Taka. Sent to kitchen.`;

    return NextResponse.json({ order_id: orderId, status: "CONFIRMED", total_price: totalPrice, tts_confirmation_text: confirmSpeech });
  } catch (error) {
    await connection.rollback();
    return NextResponse.json({ error: "Transaction failed: " + error.message }, { status: 500 });
  } finally {
    connection.release();
  }
}

SELECT 
    o.id AS order_id,
    o.table_number,
    o.order_status,
    o.created_at AS order_time,
    m.item_name,
    od.quantity
FROM orders o
JOIN order_details od ON o.id = od.order_id
JOIN menu_items m ON od.item_id = m.id
WHERE o.order_status IN ('PENDING', 'COOKING')
ORDER BY o.created_at ASC; -- FIFO Order Processing

// app/api/v1/orders/[id]/status/route.js
import { NextResponse } from 'next/server';
import pool from '@/lib/db';

export async function PATCH(req, { params }) {
  try {
    const { id: orderId } = await params;
    const { status } = await req.json(); // 'COOKING' | 'READY' | 'COMPLETED'

    const [rows] = await pool.query('SELECT table_number FROM orders WHERE id = ?', [orderId]);
    if (rows.length === 0) {
      return NextResponse.json({ error: "Order not found" }, { status: 404 });
    }

    await pool.query('UPDATE orders SET order_status = ? WHERE id = ?', [status, orderId]);

    let alertText = "";
    if (status === "READY") {
      alertText = `Attention Table ${rows[0].table_number}! Order Number ${orderId} is ready to be served.`;
    }

    return NextResponse.json({ order_id: Number(orderId), updated_status: status, customer_voice_alert: alertText });
  } catch (error) {
    return NextResponse.json({ error: "Failed to update order status" }, { status: 500 });
  }
}

// app/api/v1/payments/process/route.js
import { NextResponse } from 'next/server';
import pool from '@/lib/db';

export async function POST(req) {
  const connection = await pool.getConnection();
  try {
    const { order_id, payment_method, transaction_id } = await req.json();

    const [orders] = await connection.query('SELECT total_price FROM orders WHERE id = ?', [order_id]);
    if (orders.length === 0) {
      return NextResponse.json({ error: "Order not found" }, { status: 404 });
    }

    const amountPaid = orders[0].total_price;

    await connection.beginTransaction();

    // 1. Record payment transaction
    await connection.query(
      'INSERT INTO payments (order_id, payment_method, payment_status, transaction_id, amount_paid) VALUES (?, ?, ?, ?, ?)',
      [order_id, payment_method, 'COMPLETED', transaction_id || null, amountPaid]
    );

    // 2. Finalize order lifecycle
    await connection.query('UPDATE orders SET order_status = ? WHERE id = ?', ['COMPLETED', order_id]);

    await connection.commit();

    return NextResponse.json({
      status: "SUCCESS",
      message: `Payment of ${amountPaid} Taka finalized successfully.`
    });
  } catch (error) {
    await connection.rollback();
    return NextResponse.json({ error: "Payment processing failed" }, { status: 500 });
  } finally {
    connection.release();
  }
}

// components/VoiceOrderKiosk.jsx
'use client';
import { useState } from 'react';

export default function VoiceOrderKiosk({ tableNumber }) {
  const [transcript, setTranscript] = useState('');
  const [isListening, setIsListening] = useState(false);
  const [responseMsg, setResponseMsg] = useState('');

  // 1. Text-to-Speech (TTS) Function
  const speak = (text) => {
    if ('speechSynthesis' in window) {
      window.speechSynthesis.cancel(); // Clear previous speech queue
      const utterance = new SpeechSynthesisUtterance(text);
      utterance.lang = 'en-US';
      utterance.rate = 0.95;
      window.speechSynthesis.speak(utterance);
    }
  };

  // 2. Speech-to-Text (STT) Recognition
  const startListening = () => {
    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
    if (!SpeechRecognition) {
      alert('Browser does not support Speech Recognition.');
      return;
    }

    const recognition = new SpeechRecognition();
    recognition.lang = 'en-US';
    recognition.continuous = false;
    recognition.interimResults = false;

    recognition.onstart = () => setIsListening(true);
    recognition.onend = () => setIsListening(false);

    recognition.onresult = async (event) => {
      const userVoiceInput = event.results[0][0].transcript;
      setTranscript(userVoiceInput);

      // 3. Send captured transcript to Backend API
      const res = await fetch('/api/v1/voice/process-and-order', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          table_number: tableNumber,
          raw_transcript: userVoiceInput,
          parsed_items: [{ item_name: userVoiceInput, qty: 1 }] // Simplified payload
        })
      });

      const data = await res.json();
      if (data.status === 'CONFIRMED') {
        setResponseMsg(data.tts_confirmation_text);
        speak(data.tts_confirmation_text); // Trigger AI Voice Response
      } else {
        const errorSpeech = "Please say again, I do not understand.";
        setResponseMsg(errorSpeech);
        speak(errorSpeech);
      }
    };

    recognition.start();
  };

  return (
    <div className="p-4 border rounded-xl bg-white space-y-4">
      <button 
        onClick={startListening}
        className={`px-4 py-2 rounded-lg font-bold ${isListening ? 'bg-red-500 text-white animate-pulse' : 'bg-blue-600 text-white'}`}
      >
        {isListening ? 'Listening...' : 'Push to Speak'}
      </button>
      <p className="text-sm"><strong>Your Voice:</strong> {transcript}</p>
      <p className="text-sm"><strong>AI Response:</strong> {responseMsg}</p>
    </div>
  );
}

// app/api/v1/kds/stream/route.js
import { NextResponse } from 'next/server';
import pool from '@/lib/db';

export async function GET(req) {
  const encoder = new TextEncoder();

  const customReadable = new ReadableStream({
    start(controller) {
      // 1. Send initial connection ACK
      controller.enqueue(encoder.encode(`data: ${JSON.stringify({ message: "KDS Stream Connected" })}\n\n`));

      // 2. Periodically push live pending orders to kitchen display every 3 seconds
      const interval = setInterval(async () => {
        try {
          const [liveOrders] = await pool.query(`
            SELECT 
                o.id AS order_id,
                o.table_number,
                o.order_status,
                o.created_at AS order_time,
                m.item_name,
                od.quantity
            FROM orders o
            JOIN order_details od ON o.id = od.order_id
            JOIN menu_items m ON od.item_id = m.id
            WHERE o.order_status IN ('PENDING', 'COOKING')
            ORDER BY o.created_at ASC
          `);

          controller.enqueue(encoder.encode(`data: ${JSON.stringify(liveOrders)}\n\n`));
        } catch (err) {
          console.error("KDS Stream DB Error:", err);
        }
      }, 3000);

      req.signal.addEventListener('abort', () => {
        clearInterval(interval);
        controller.close();
      });
    }
  });

  return new NextResponse(customReadable, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache, no-transform',
      'Connection': 'keep-alive',
    },
  });
}