import twilio from "twilio";

// ==========================================
// CONFIGURATION
// ==========================================
const TARGET_MONTH = 11;
const TARGET_YEAR = 2026;
const TARGET_CALLER = "+18778894546";

const CONFERENCE_PARTICIPANT_RATE = 0.0018;

const accountSid = process.env.TWILIO_ACCOUNT_SID;
const authToken = process.env.TWILIO_AUTH_TOKEN;
const client = twilio(accountSid, authToken);

function getMonthBoundaries(year, month) {
  const start = new Date(Date.UTC(year, month - 1, 1, 0, 0, 0));
  const end = new Date(Date.UTC(year, month, 1, 0, 0, 0));
  return { start, end };
}

function normalizeNumber(num) {
  return (num || "").replace(/\D/g, "");
}

function numbersMatch(num1, num2) {
  const n1 = normalizeNumber(num1);
  const n2 = normalizeNumber(num2);
  if (!n1 || !n2) return false;
  return n1 === n2 || n1.endsWith(n2) || n2.endsWith(n1);
}

/**
 * Filters out SIP client setup legs and intermediate dial legs.
 * In a 3-leg SIP-to-Twilio-to-Twilio flow:
 *   Leg 1 (SIP -> Twilio) has children. (Discard: parent routing leg)
 *   Leg 2 (Twilio -> Twilio) has parentCallSid = Leg 1. (Discard: outbound dial leg)
 *   Leg 3 (Twilio receives -> Conference) is inbound, has no child legs. (KEEP)
 */
function isolateConferenceParticipantLegs(candidateCalls, allMonthCalls) {
  // Build a set of all calls that acted as parents (e.g. Leg 1)
  const parentCallSids = new Set(
    allMonthCalls
      .map((c) => c.parentCallSid)
      .filter((sid) => sid !== null && sid !== undefined)
  );

  return candidateCalls.filter((call) => {
    // 1. Exclude outbound dial/API legs (Leg 2)
    // When Twilio dials out to another Twilio number via <Dial>, it sets parentCallSid
    // and direction is outbound-dial/outbound-api.
    if (call.parentCallSid) {
      return false;
    }

    // 2. Exclude parent calls that spawned a child leg (Leg 1)
    // The SIP leg that dialed the conference host spawns the outbound leg
    if (parentCallSids.has(call.sid)) {
      return false;
    }

    // 3. Exclude raw SIP / Client endpoints acting as the carrier bridge
    if ((call.from || "").startsWith("sip:") || (call.from || "").startsWith("client:")) {
      return false;
    }

    return true;
  });
}

(async () => {
  try {
    const { start, end } = getMonthBoundaries(TARGET_YEAR, TARGET_MONTH);

    console.log(`\nAnalyzing Historical Month: ${TARGET_YEAR}-${String(TARGET_MONTH).padStart(2, "0")}`);
    console.log(`Range: ${start.toISOString()} -> ${end.toISOString()}`);
    console.log(`Target Participant: ${TARGET_CALLER}`);
    console.log("Fetching historical conference sessions & calls...");

    // 1. Fetch completed conferences
    const conferences = await client.conferences.list({
      status: "completed",
      dateCreatedAfter: start,
      dateCreatedBefore: end,
    });

    console.log(`Found ${conferences.length} completed conferences in this month.`);

    // 2. Fetch all completed calls across the account for that month
    const allCalls = await client.calls.list({
      startTimeAfter: start,
      startTimeBefore: end,
      status: "completed",
    });

    console.log(`Found ${allCalls.length} total call records.`);

    let grandTotalBilledMinutes = 0;
    let grandTotalCost = 0.0;
    const matchedConferences = [];

    // 3. Correlate calls to conferences
    for (const conf of conferences) {
      const confStart = new Date(conf.dateCreated).getTime();
      const confEnd = new Date(conf.dateUpdated).getTime();

      // Find all calls overlapping this conference session
      const overlappingCalls = allCalls.filter((call) => {
        const callStart = new Date(call.startTime).getTime();
        const durationMs = parseInt(call.duration || "0", 10) * 1000;
        const callEnd = callStart + durationMs;
        return callStart <= confEnd + 5000 && callEnd >= confStart - 5000;
      });

      // Filter down to ONLY the terminal leg that actually ran the conference
      const trueParticipants = isolateConferenceParticipantLegs(overlappingCalls, allCalls);

      // Verify the target participant was present in this room
      const targetPresent = trueParticipants.some(
        (call) => numbersMatch(call.from, TARGET_CALLER) || numbersMatch(call.to, TARGET_CALLER)
      );

      if (!targetPresent) continue;

      let confBilledMinutes = 0;
      const participantBreakdown = [];

      for (const call of trueParticipants) {
        const durationSec = parseInt(call.duration || "0", 10);
        const billedMins = durationSec > 0 ? Math.ceil(durationSec / 60) : 0;
        const legCost = billedMins * CONFERENCE_PARTICIPANT_RATE;

        confBilledMinutes += billedMins;

        const isTarget = numbersMatch(call.from, TARGET_CALLER) || numbersMatch(call.to, TARGET_CALLER);
        const callerNumber = call.from || call.to || "Unknown";

        participantBreakdown.push({
          callSid: call.sid,
          callerNumber,
          direction: call.direction,
          durationSeconds: durationSec,
          billedMinutes: billedMins,
          cost: legCost,
          isTarget,
        });
      }

      const confCost = confBilledMinutes * CONFERENCE_PARTICIPANT_RATE;
      grandTotalBilledMinutes += confBilledMinutes;
      grandTotalCost += confCost;

      matchedConferences.push({
        conferenceSid: conf.sid,
        friendlyName: conf.friendlyName,
        dateCreated: conf.dateCreated,
        participantCount: trueParticipants.length,
        billedMinutes: confBilledMinutes,
        cost: confCost,
        participants: participantBreakdown,
      });
    }

    // 4. Output Summary Report
    console.log("\n" + "=".repeat(65));
    console.log(`HISTORICAL CONFERENCE REPORT (ISOLATED CONFERENCE LEGS)`);
    console.log(`Month:                          ${TARGET_YEAR}-${String(TARGET_MONTH).padStart(2, "0")}`);
    console.log(`Target Number:                  ${TARGET_CALLER}`);
    console.log(`Conferences Attended:           ${matchedConferences.length}`);
    console.log(`Total Participant Leg Minutes:  ${grandTotalBilledMinutes} mins`);
    console.log(`Total Participant Mixing Cost:  $${grandTotalCost.toFixed(4)}`);
    console.log(`(Rate: $${CONFERENCE_PARTICIPANT_RATE}/min per participant)`);
    console.log("=".repeat(65));

    for (const conf of matchedConferences) {
      console.log(`\nConference: ${conf.friendlyName} (${conf.conferenceSid})`);
      console.log(`  Date: ${conf.dateCreated}`);
      console.log(`  Participants: ${conf.participantCount}`);
      console.log(`  Participant Billed Mins: ${conf.billedMinutes} mins | Cost: $${conf.cost.toFixed(4)}`);
      for (const p of conf.participants) {
        const marker = p.isTarget ? " [TARGET]" : "";
        console.log(`    - Number: ${p.callerNumber} | CallSid: ${p.callSid} (${p.direction}) | ${p.durationSeconds}s (${p.billedMinutes}m billed) | $${p.cost.toFixed(4)}${marker}`);
      }
    }
  } catch (err) {
    console.error("Execution failed:", err);
  }
})();