// LLEGA OTRO CLIENTE A UNA MESA QUE TODAVIA TIENE LA CUENTA DE OTRO (2026-07-28)
// Antes, al escanear el QR de una mesa con pedidos, la tienda metia al cliente
// DIRECTO en esa cuenta: veia el consumo ajeno y podia pagarlo. Ahora la tienda
// solo entra sola si ESTE telefono es de la cuenta (la abrio o ya pidio ahi), y
// si no, ofrece avisarle al negocio con una llamada tipo 'ocupada'.
// Lo que se prueba aca es el lado del servidor: el dato que necesita la tienda
// para decidir, y que el aviso llegue al panel. Corre contra el DEMO y limpia.
import { createClient } from '@supabase/supabase-js';

const URL = process.env.SUPABASE_URL || process.env.VITE_SUPABASE_URL;
const ANON = process.env.SUPABASE_ANON_KEY || process.env.VITE_SUPABASE_ANON_KEY;
const SERVICE = process.env.SUPABASE_SERVICE_KEY || process.env.SUPABASE_SERVICE_ROLE_KEY;
if (!URL || !ANON || !SERVICE) {
  console.log('Faltan SUPABASE_URL / SUPABASE_ANON_KEY / SUPABASE_SERVICE_KEY');
  process.exit(1);
}

let fallos = 0;
const check = (cond, msg) => {
  console.log((cond ? '  OK  ' : '  XX  ') + msg);
  if (!cond) fallos++;
};
const anon = () => createClient(URL, ANON, { auth: { persistSession: false } });
const svc = createClient(URL, SERVICE, { auth: { persistSession: false } });
const MESA = 'TX91';

const { data: rest } = await svc.from('restaurantes').select('id').eq('slug', 'demo-gustito').maybeSingle();
const REST = rest?.id;
const { data: prods } = await svc
  .from('productos')
  .select('id,nombre,precio_usd')
  .eq('restaurante_id', REST)
  .eq('disponible', true)
  .limit(1);
const PROD = prods?.[0];

const limpiar = async () => {
  const { data: cuentas } = await svc.from('cuentas_mesa').select('id').eq('restaurante_id', REST).eq('mesa', MESA);
  for (const c of cuentas ?? []) {
    const { data: peds } = await svc.from('pedidos').select('id').eq('cuenta_id', c.id);
    for (const p of peds ?? []) {
      await svc.from('pedido_items').delete().eq('pedido_id', p.id);
      await svc.from('pagos').delete().eq('pedido_id', p.id);
    }
    await svc.from('pedidos').delete().eq('cuenta_id', c.id);
    await svc.from('llamadas_mesa').delete().eq('cuenta_id', c.id);
    await svc.from('comensales_mesa').delete().eq('cuenta_id', c.id);
    await svc.from('cuentas_mesa').delete().eq('id', c.id);
  }
};

try {
  await limpiar();

  console.log('\n== La mesa la usa un cliente ==');
  const cli = anon();
  const { data: d1, error: e1 } = await cli.rpc('crear_pedido', {
    p_restaurante_id: REST,
    p_cliente_nombre: 'Ramona la primera',
    p_cliente_telefono: '04120000011',
    p_tipo_entrega: 'mesa',
    p_metodo_pago: 'efectivo',
    p_items: [{ producto_id: PROD.id, nombre: PROD.nombre, precio_usd: PROD.precio_usd, cantidad: 2 }],
    p_mesa: MESA,
  });
  check(!e1, `el primero pide: ${e1?.message ?? 'ok'}`);
  const cuentaId = d1?.[0]?.cuenta_id;

  console.log('\n== Lo que ve el que escanea despues ==');
  const { data: act, error: e2 } = await anon().rpc('cuenta_mesa_activa', { p_restaurante_id: REST, p_mesa: MESA });
  const fila = act?.[0];
  check(!e2 && !!fila, `la tienda encuentra la cuenta: ${e2?.message ?? 'ok'}`);
  check(Number(fila?.total_usd) > 0, `sabe que la mesa YA tiene consumo (${fila?.total_usd})`);
  check(!!fila?.abierta_en, 'sabe desde cuando esta abierta');
  check(!!fila?.ultimo_pedido_en, 'sabe cuando fue el ultimo pedido (para decidir si el aviso es fuerte)');
  check(fila?.abierta_por === 'Ramona la primera', `sabe de quien es la cuenta ("${fila?.abierta_por}")`);

  console.log('\n== "Acabo de llegar": el aviso llega al panel ==');
  const { data: llam, error: e3 } = await anon().rpc('llamar_mesero', { p_cuenta_id: cuentaId, p_tipo: 'ocupada' });
  check(!e3, `un cliente sin sesion puede avisar: ${e3?.message ?? 'ok'}`);
  check(llam?.[0]?.ya_estaba === false, 'la primera vez crea el aviso');
  const { data: rep } = await anon().rpc('llamar_mesero', { p_cuenta_id: cuentaId, p_tipo: 'ocupada' });
  check(rep?.[0]?.ya_estaba === true, 'si toca dos veces NO llena el panel de avisos repetidos');

  const { data: enPanel } = await svc
    .from('llamadas_mesa')
    .select('tipo,mesa,atendida_en')
    .eq('cuenta_id', cuentaId)
    .eq('tipo', 'ocupada');
  check(enPanel?.length === 1, `queda 1 aviso en el panel (hay ${enPanel?.length ?? 0})`);
  check(enPanel?.[0]?.mesa === MESA, 'con el numero de mesa, para que sepan a donde ir');

  console.log('\n== Los otros avisos siguen funcionando ==');
  const { error: e4 } = await anon().rpc('llamar_mesero', { p_cuenta_id: cuentaId, p_tipo: 'mesero' });
  check(!e4, `llamar al mesero de siempre: ${e4?.message ?? 'ok'}`);
  const { error: e5 } = await anon().rpc('llamar_mesero', { p_cuenta_id: cuentaId, p_tipo: 'inventado' });
  check(!!e5, 'un tipo inventado sigue rebotando');

  console.log('\n== La mesa vacia no confunde a nadie ==');
  await svc.from('cuentas_mesa').update({ estado: 'cerrada', cerrada_en: new Date().toISOString() }).eq('id', cuentaId);
  const { data: act2 } = await anon().rpc('cuenta_mesa_activa', { p_restaurante_id: REST, p_mesa: MESA });
  check((act2?.length ?? 0) === 0, 'cerrada la cuenta, el siguiente que escanee entra limpio');
} catch (e) {
  console.log('  XX  ' + e.message);
  fallos++;
} finally {
  await limpiar();
}

console.log(fallos === 0 ? '\nTODO VERDE' : `\n${fallos} FALLO(S)`);
process.exit(fallos === 0 ? 0 : 1);
