var webhookData = <<update>>;

const participants = webhookData?.data?.participants || [];
const externals = participants.filter(p => p?.type === "external");

let externalNumbers = externals.map(e => e?.phone_number);

// Fallback: if no participants but we have raw_digits
if ((!externalNumbers || externalNumbers.length === 0) && webhookData?.data?.raw_digits) {
  externalNumbers = [webhookData.data.raw_digits];
}

// ✅ Final fallback: if still nothing, force default number
if (!externalNumbers || externalNumbers.length === 0) {
  externalNumbers = ["4135678707"];
}

return {
  event: webhookData?.event || null,

  // ✅ prefer call_id if present (transcription.created), otherwise use id
  callId: webhookData?.data?.call_id || webhookData?.data?.id || null,

  status: webhookData?.data?.status || null,
  direction: webhookData?.data?.direction || null,

  startedAt: webhookData?.data?.started_at || null,
  endedAt: webhookData?.data?.ended_at || null,

  recordingUrl: webhookData?.data?.recording || null,

  ownerEmail: webhookData?.data?.user?.email || null,
  ownerName: webhookData?.data?.user?.name || null,

  externalNumbers
};

const m = <<Step 1>>;
if (!m) return "No call";

// ---- Helpers ----
const normalizePhone = (p) =>
  (p || "")
    .replace(/\D/g, "")
    .replace(/^1/, "");

async function findEnduserByPhone(phone) {
  const target = normalizePhone(phone);
  let offset = 0;
  const limit = 2000;

  while (true) {
    const batch = await ph.models.endUsers.getAll({ limit, offset });
    if (!batch.length) break;

    const match = batch.find(eu => {
      const candidates = [
        eu.phone,
        eu.custom ? eu.custom["Phone 2"] : null
      ]
        .filter(Boolean)
        .map(normalizePhone);

      return candidates.includes(target);
    });

    if (match) return match;
    if (batch.length < limit) break;
    offset += limit;
  }
  return null;
}

// ---- Team Members ----
let users = [];
if (m?.ownerEmail) users.push({ email: m.ownerEmail });
users = users.filter((u, i, arr) => u?.email && i === arr.findIndex(v => v.email === u.email));

// ---- End Users ----
let endusers = [];
let companyId = null;
let contactId = null;

if (m?.externalNumbers?.length) {
  let match = await findEnduserByPhone(m.externalNumbers[0]);

  // ✅ fallback: if no match, force lookup on 4135678707
  if (!match) {
    match = await findEnduserByPhone("4135678707");
  }

  if (match) {
    endusers.push({ email: match.email });
    companyId = match.companyId;
    contactId = match.id;
  }
}

endusers = endusers.filter(
  (e, i, arr) => e?.email && i === arr.findIndex(v => v.email === e.email)
);

// ---- Handle events ----
if (m.event === "call.created" || m.event === "call.answered") {
  let subject;
  if (m.event === "call.created") {
    if (m.direction === "inbound") {
      subject = `Aircall – inbound call from ${endusers[0]?.email || m.externalNumbers?.[0] || "Unknown"}`;
    } else {
      subject = `Aircall – call made to ${endusers[0]?.email || m.externalNumbers?.[0] || "Unknown"}`;
    }
  } else {
    subject = `Aircall – call answered with ${endusers[0]?.email || m.externalNumbers?.[0] || "Unknown"}`;
  }

  const description =
    m.event === "call.created"
      ? "Call attempt logged."
      : "Call was answered.";

  return {
    subject,
    type: "Cold Call",
    externalId: `${m.callId}-cold call`,
    companyId,
    contactId,
    endusers,
    users,
    custom: { "Call Recording": m?.recordingUrl || null },
    description,
    date: m?.endedAt || m?.startedAt || new Date().toISOString(),
    callId: m.callId
  };
}

// ---- Case: transcription.created ----
if (m.event === "transcription.created") {
  return {
    type: "transcription.created",
    callId: m.callId || null,
    companyId,
    contactId,
    endusers,
    users,
    externalNumbers: m.externalNumbers || []
  };
}

// Inputs
const callData = <<Get Call Details>>.call;   // note: unwrap .call
const transcriptData = <<Get Transcript>>;

// ---- Helpers ----
const normalizePhone = (p) =>
  (p || "").replace(/\D/g, "").replace(/^1/, "");

async function findEnduserByPhone(phone) {
  const target = normalizePhone(phone);
  let offset = 0;
  const limit = 2000;

  while (true) {
    const batch = await ph.models.endUsers.getAll({ limit, offset });
    if (!batch.length) break;

    const match = batch.find(eu => {
      const candidates = [
        normalizePhone(eu.phone),
        normalizePhone(eu.custom?.["Phone 2"])
      ].filter(Boolean);
      return candidates.includes(target);
    });

    if (match) return match;
    if (batch.length < limit) break;
    offset += limit;
  }
  return null;
}

// ---- Team Members ----
let users = [];
if (callData?.user?.email) users.push({ email: callData.user.email });
users = users.filter((u, i, arr) => u?.email && i === arr.findIndex(v => v.email === u.email));

// ---- End Users ----
let endusers = [];
let companyId = null;
let contactId = null;

// ✅ use raw_digits as external number
const extNum = callData?.raw_digits || null;

if (extNum) {
  const match = await findEnduserByPhone(extNum);
  if (match) {
    endusers.push({ email: match.email });
    companyId = match.companyId;
    contactId = match.id;
  }
}
endusers = endusers.filter(
  (e, i, arr) => e?.email && i === arr.findIndex(v => v.email === e.email)
);

// ---- Guard: skip if still no company match ----
if (!companyId) {
  return {
    skip: true,
    reason: `No company found for number ${extNum}`
  };
}

// ---- Transcript handling ----
if (!transcriptData?.transcription?.content?.utterances?.length) {
  return {
    subject: callData?.subject || "Aircall – call",
    type: "Cold Call",
    externalId: `${callData?.id || callData?.callId}-notranscript`,
    description: "Transcript not available yet.",
    date: callData?.ended_at || callData?.started_at || new Date().toISOString(),
    companyId,
    contactId,
    endusers,
    users,
    url: callData?.recording || null
  };
}

const utterances = transcriptData.transcription.content.utterances
  .map(u => {
    const speaker =
      u.participant_type === "internal"
        ? "Agent"
        : (u.phone_number || "External");
    return `<p><strong>${speaker}:</strong> ${u.text}</p>`;
  })
  .join("");

// ---- Subject w/ direction ----
let subject;
if (callData?.direction === "inbound") {
  subject = `Aircall – inbound call transcript from ${endusers[0]?.email || extNum || "Unknown"}`;
} else {
  subject = `Aircall – outbound call transcript with ${endusers[0]?.email || extNum || "Unknown"}`;
}

// ---- Final payload ----
return {
  subject,
  type: "Cold Call",
  externalId: `${callData?.id || callData?.callId}-transcript`,
  description: `
    <p>Call was answered.</p>
    <p><strong>Transcript:</strong></p>
    ${utterances}
  `,
  date: callData?.ended_at || callData?.started_at || new Date().toISOString(),
  companyId,
  contactId,
  endusers,
  users,
  url: callData?.asset || callData?.recording || null

};

{
    "subject": "<<CleanOutput.subject>>",
    "type": "Cold Call",
    "externalId": "<<CleanOutput.externalId>>",
    "companyId": "<<CleanOutput.companyId>>",
    "contactId": "<<CleanOutput.contactId>>",
    "endusers": "<<CleanOutput.endusers>>",
    "users": "<<CleanOutput.users>>",
    "custom": {
        "Call Recording": "<<CleanOutput.url>>"
    },
    "description": "<<CleanOutput.description>>",
    "date": "<<CleanOutput.date>>"
}

{
    "subject": "<<Step 2.subject>>",
    "type": "Cold Call",
    "externalId": "<<Step 2.externalId>>",
    "companyId": "<<Step 2.companyId>>",
    "contactId": "<<Step 2.contactId>>",
    "endusers": "<<Step 2.endusers>>",
    "users": "<<Step 2.users>>",
    "custom": {
        "Call Recording": "<<Step 2.url>>"
    },
    "description": "<<Step 2.description>>",
    "date": "<<Step 2.date>>"
}