Reconcile Failed Syncs

async function findStuckTransactions(customerId) {
  const token = await loadCustomerApiToken(customerId);
  const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000); // 24 hours ago

  // Find queue records still in 'submitted' state past the cutoff
  const stuck = await db.virtuous_donation_queue.find({
    where: {
      customer_id: customerId,
      status: 'submitted',
      submitted_at: { lt: cutoff },
    },
  });

  for (const record of stuck) {
    const response = await fetch(
      `https://api.virtuoussoftware.com/api/Gift/YourPlatform/${encodeURIComponent(record.platform_donation_id)}`,
      { headers: { Authorization: `Bearer ${token}` } }
    );

    if (response.ok) {
      // The Gift exists in Virtuous — the webhook was lost.
      const gift = await response.json();
      console.log(`Recovered stuck submission ${record.platform_donation_id} → Gift ${gift.id}`);
      await db.virtuous_donation_queue.update(
        { platform_donation_id: record.platform_donation_id },
        {
          status: 'confirmed',
          confirmed_at: new Date(),
          virtuous_gift_id: gift.id,
          recovery_path: 'reconciliation_lookup',
        }
      );
    }
    // If response is 404, the Transaction may be in needs-update — see Category 2.
  }
}

async function findNeedsUpdateTransactions(customerId) {
  const cutoff = new Date(Date.now() - 72 * 60 * 60 * 1000); // 72 hours

  const stale = await db.virtuous_donation_queue.find({
    where: {
      customer_id: customerId,
      status: 'submitted',
      submitted_at: { lt: cutoff },
    },
  });

  const token = await loadCustomerApiToken(customerId);

  for (const record of stale) {
    const response = await fetch(
      `https://api.virtuoussoftware.com/api/Gift/YourPlatform/${encodeURIComponent(record.platform_donation_id)}`,
      { headers: { Authorization: `Bearer ${token}` } }
    );

    if (response.status === 404) {
      // Transaction not resolved to a real Gift after 72 hours.
      // Highly likely it landed in needs-update for manual resolution.
      await db.virtuous_donation_queue.update(
        { platform_donation_id: record.platform_donation_id },
        {
          status: 'needs_review',
          last_error: 'Likely in needs-update bucket — manual resolution required in Virtuous',
        }
      );
    }
  }
}

async function reconcileMissedGiftEvents(customerId, sinceTimestamp) {
  const token = await loadCustomerApiToken(customerId);

  // Query Virtuous for all Gifts modified since the last reconciliation
  const virtuousGifts = await fetchAllPages(async (skip, take) => {
    const response = await fetch(
      'https://api.virtuoussoftware.com/api/Gift/Query',
      {
        method: 'POST',
        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
        body: JSON.stringify({
          groups: [
            {
              conditions: [
                {
                  parameter: 'Last Modified Date',
                  operator: 'Is After',
                  value: sinceTimestamp,
                },
              ],
            },
          ],
          sortBy: 'GiftDate',
          descending: false,
          skip,
          take,
        }),
      }
    );
    return await response.json();
  });

  // For each Virtuous Gift, ensure our records reflect it
  for (const virtuousGift of virtuousGifts) {
    const localGift = await db.partner_gifts.findOne({
      virtuous_gift_id: virtuousGift.id,
    });

    if (!localGift) {
      // We don't have this Gift on our side — webhook was missed.
      // Apply it through the normal inbound path.
      await applyGiftToPartner(virtuousGift);
    }
  }
}

async function findDriftedContacts(customerId) {
  const token = await loadCustomerApiToken(customerId);
  const drifts = [];

  // Walk each paired record on your side
  const pairs = await db.partner_contacts.find({
    where: { customer_id: customerId, sync_state: 'in_sync' },
  });

  for (const partnerRecord of pairs) {
    const virtuousResponse = await fetch(
      `https://api.virtuoussoftware.com/api/Contact/${partnerRecord.virtuous_contact_id}`,
      { headers: { Authorization: `Bearer ${token}` } }
    );

    if (!virtuousResponse.ok) continue;
    const virtuousContact = await virtuousResponse.json();

    const differences = compareCanonicalFields(partnerRecord, virtuousContact);
    if (differences.length > 0) {
      drifts.push({
        partnerId: partnerRecord.id,
        virtuousContactId: virtuousContact.id,
        differences,
      });
    }
  }

  return drifts;
}

function compareCanonicalFields(partnerRecord, virtuousContact) {
  const differences = [];

  if (partnerRecord.email !== extractPrimaryEmail(virtuousContact)) {
    differences.push({ field: 'email', partner: partnerRecord.email, virtuous: extractPrimaryEmail(virtuousContact) });
  }
  if (partnerRecord.name !== virtuousContact.name) {
    differences.push({ field: 'name', partner: partnerRecord.name, virtuous: virtuousContact.name });
  }
  // ... compare any other canonical fields

  return differences;
}