B2BCall-dialer/apps/predictive-dialer/src/tick.ts

import type Redis from "ioredis";
import { getPrismaClient, withTenantContext, type Campaign, type Tenant } from "@b2bcall/database";
import type { FreeSwitchTelephonyProvider } from "@b2bcall/telephony";
import { createLogger } from "@b2bcall/shared";
import { tryAcquireCps } from "./redis-primitives";
import { reserveLeads } from "./lead-reservation";
import { computeCapacity, decidePacing } from "./pacing";
import { isWithinSchedule } from "./schedule";
import { simulateOutcome } from "./simulation";
import { originateSimulatedAnswerLeg, originateRealPstnLeg } from "./originate";
import { createCallAttempt, setAttemptStatus, completeAttempt } from "./call-attempt";
import { registerQueuedAttempt } from "./queued-attempts-registry";

const logger = createLogger("b2bcall-predictive-dialer");

export interface TickDeps {
  redis: Redis;
  provider: FreeSwitchTelephonyProvider;
  dialerSimulation: boolean;
  allowRealOutboundCalls: boolean;
}

function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

export async function tickCampaign(deps: TickDeps, tenant: Tenant, campaign: Campaign): Promise<void> {
  const prisma = getPrismaClient();

  if (!isWithinSchedule(campaign)) {
    if (campaign.status === "RUNNING") {
      await withTenantContext(prisma, tenant.id, (tx) =>
        tx.campaign.update({ where: { id: campaign.id }, data: { status: "WAITING_SCHEDULE" } }),
      );
      logger.info("campanha fora da janela de funcionamento", { campaignId: campaign.id });
    }
    return;
  }
  if (campaign.status === "WAITING_SCHEDULE") {
    await withTenantContext(prisma, tenant.id, (tx) =>
      tx.campaign.update({ where: { id: campaign.id }, data: { status: "RUNNING" } }),
    );
  }

  const stats = await withTenantContext(prisma, tenant.id, (tx) =>
    tx.campaignStats.upsert({
      where: { campaignId: campaign.id },
      update: {},
      create: { campaignId: campaign.id, tenantId: tenant.id, pacingFactor: campaign.pacingInitial },
    }),
  );

  const capacity = await withTenantContext(prisma, tenant.id, (tx) => computeCapacity(tx, tenant.id, campaign, stats));
  const { callsToOriginate, newPacingFactor } = decidePacing(campaign, stats, capacity);

  if (newPacingFactor !== stats.pacingFactor) {
    await withTenantContext(prisma, tenant.id, (tx) =>
      tx.campaignStats.update({ where: { campaignId: campaign.id }, data: { pacingFactor: newPacingFactor } }),
    );
  }

  if (callsToOriginate <= 0) return;

  const reserved = await withTenantContext(prisma, tenant.id, (tx) =>
    reserveLeads(tx, tenant.id, campaign.id, callsToOriginate),
  );
  if (reserved.length === 0) return;

  logger.info("originando tentativas", {
    campaignId: campaign.id,
    count: reserved.length,
    availableAgents: capacity.availableAgents,
    predictedBecomingAvailable: capacity.predictedBecomingAvailable,
    pacingFactor: newPacingFactor,
    answerProbability: stats.answerProbability,
  });

  for (const lead of reserved) {
    const cpsChecks = [
      { key: "cps:global", maxPerSecond: 0 }, // sem teto global configurado nesta fase
      { key: `cps:tenant:${tenant.id}`, maxPerSecond: (await getTenantMaxCps(tenant.id)) ?? 0 },
      { key: `cps:campaign:${campaign.id}`, maxPerSecond: campaign.maxCps ?? 0 },
      { key: `cps:trunk:${campaign.trunkId}`, maxPerSecond: 0 }, // Trunk.maxCps já e' opcional; aplicado no real-outbound path
    ];
    const allowed = await tryAcquireCps(deps.redis, cpsChecks);
    if (!allowed) {
      // De volta pra READY: essa reserva não gerou tentativa nenhuma, não
      // conta como attempt (agente.md secao 62: hierarquia de CPS respeitada
      // antes de originar, não depois).
      await withTenantContext(prisma, tenant.id, (tx) =>
        tx.lead.update({ where: { id: lead.id }, data: { status: "READY" } }),
      );
      continue;
    }

    await originateOneAttempt(deps, tenant, campaign, lead.id);
  }
}

async function getTenantMaxCps(tenantId: string): Promise<number | null> {
  const prisma = getPrismaClient();
  const tenant = await prisma.tenant.findUniqueOrThrow({ where: { id: tenantId }, include: { plan: true } });
  return tenant.plan.maxCps;
}

async function originateOneAttempt(
  deps: TickDeps,
  tenant: Tenant,
  campaign: Campaign,
  leadId: string,
): Promise<void> {
  const prisma = getPrismaClient();
  const simulated = deps.dialerSimulation || !deps.allowRealOutboundCalls;

  const attempt = await withTenantContext(prisma, tenant.id, (tx) =>
    createCallAttempt(tx, { tenantId: tenant.id, campaignId: campaign.id, leadId, simulated }),
  );

  if (simulated) {
    runSimulatedAttempt(deps, tenant, campaign, leadId, attempt.id).catch((err) => {
      logger.error("falha na simulacao da tentativa", { error: String(err), attemptId: attempt.id });
    });
    return;
  }

  await runRealAttempt(deps, tenant, campaign, leadId, attempt.id);
}

/**
 * Modo simulação (agente.md secao 185): sorteia o desfecho da "chamada
 * PSTN" inteiramente em software (RINGING -> ANSWER/BUSY/NO_ANSWER/FAILED
 * com delay), sem tocar o FreeSWITCH pra isso. Só quando o sorteio dá
 * ANSWERED é que uma chamada real (sintética, sem PSTN) entra na fila de
 * verdade — a partir daí quem decide o resto é o mod_callcenter real,
 * observado via event-listener.ts.
 */
async function runSimulatedAttempt(
  deps: TickDeps,
  tenant: Tenant,
  campaign: Campaign,
  leadId: string,
  attemptId: string,
): Promise<void> {
  const prisma = getPrismaClient();
  const stats = await withTenantContext(prisma, tenant.id, (tx) =>
    tx.campaignStats.findUniqueOrThrow({ where: { campaignId: campaign.id } }),
  );
  const outcome = simulateOutcome(campaign.ringTimeout, stats.averageTalkTime);

  await withTenantContext(prisma, tenant.id, (tx) => setAttemptStatus(tx, attemptId, "RINGING", { ringingAt: new Date() }));
  await sleep(outcome.ringDelayMs);

  if (outcome.type !== "ANSWERED") {
    await withTenantContext(prisma, tenant.id, (tx) =>
      completeAttempt(
        tx,
        {
          attemptId,
          tenantId: tenant.id,
          campaignId: campaign.id,
          leadId,
          outcome: outcome.type as "BUSY" | "NO_ANSWER" | "FAILED",
          reachedQueue: false,
        },
        campaign.maxAttempts,
      ),
    );
    return;
  }

  const answerDelaySeconds = outcome.ringDelayMs / 1000;
  await withTenantContext(prisma, tenant.id, (tx) => setAttemptStatus(tx, attemptId, "ANSWERED", { answeredAt: new Date() }));

  const { uuid } = await originateSimulatedAnswerLeg(
    deps.provider,
    { tenantId: tenant.id, attemptId, campaignId: campaign.id, leadId },
    campaign.queueId,
    tenant.telephonyDomain ?? "",
    campaign.recordingEnabled,
  );

  registerQueuedAttempt(uuid, {
    attemptId,
    tenantId: tenant.id,
    campaignId: campaign.id,
    leadId,
    maxAttempts: campaign.maxAttempts,
    queuedAtMs: Date.now(),
    answerDelaySeconds,
  });

  await withTenantContext(prisma, tenant.id, (tx) => setAttemptStatus(tx, attemptId, "QUEUEING", { originationUuid: uuid }));

  // A perna sintética (null/dummy) não tem mídia real do outro lado — nada
  // faz a chamada terminar sozinha depois de bridgear com um agente
  // (diferente de uma ligação PSTN de verdade, onde o cliente desliga).
  // Encerra explicitamente depois do talk_time simulado; se a chamada já
  // tiver terminado antes disso (abandonada na fila, por exemplo),
  // `killCall` num uuid que não existe mais só retorna erro, sem efeito.
  setTimeout(() => {
    deps.provider.killCall(uuid, "NORMAL_CLEARING").catch(() => undefined);
  }, outcome.talkTimeSeconds! * 1000);
}

/**
 * Perna PSTN real (agente.md secao 80-83, 186) — só chamada quando as DUAS
 * flags de segurança estão explicitamente ligadas. Nunca exercitada nesta
 * sessão (sem trunk/operadora real disponível) — ver
 * docs/PREDICTIVE_DIALER.md.
 */
async function runRealAttempt(
  deps: TickDeps,
  tenant: Tenant,
  campaign: Campaign,
  leadId: string,
  attemptId: string,
): Promise<void> {
  const prisma = getPrismaClient();
  const lead = await withTenantContext(prisma, tenant.id, (tx) => tx.lead.findUniqueOrThrow({ where: { id: leadId } }));

  const { uuid } = await originateRealPstnLeg(
    deps.provider,
    { tenantId: tenant.id, attemptId, campaignId: campaign.id, leadId },
    {
      trunkId: campaign.trunkId,
      phoneNumber: lead.phoneNormalized,
      queueId: campaign.queueId,
      domain: tenant.telephonyDomain ?? "",
      callerIdName: campaign.callerIdName ?? undefined,
      callerIdNumber: campaign.callerIdNumber ?? undefined,
      ringTimeoutSeconds: campaign.ringTimeout,
      recordingEnabled: campaign.recordingEnabled,
    },
  );

  registerQueuedAttempt(uuid, {
    attemptId,
    tenantId: tenant.id,
    campaignId: campaign.id,
    leadId,
    maxAttempts: campaign.maxAttempts,
    queuedAtMs: Date.now(),
  });

  await withTenantContext(prisma, tenant.id, (tx) => setAttemptStatus(tx, attemptId, "ORIGINATING", { originationUuid: uuid }));
}