Code I'm proud of.

  // Price match (30%)
  // Use budget range if available, otherwise fall back to legacy budget field
  const budgetMin = buyer.budget_min ?? Math.round(buyer.budget * 0.8)
  const budgetMax = buyer.budget_max ?? buyer.budget

  // Full points if listing price is within buyer's budget range
  if (listing.asking_price >= budgetMin && listing.asking_price <= budgetMax) {
    scores.price_match = 30
  } else if (listing.asking_price < budgetMin) {
    // Below minimum - partial points (buyer might want something more expensive)
    const percentBelow = (budgetMin - listing.asking_price) / budgetMin
    if (percentBelow <= 0.2) {
      // Within 20% below minimum - scale from 30 down to 20
      scores.price_match = Math.round(30 - (percentBelow * 50))
    } else {
      scores.price_match = 15 // Too far below budget range
    }
  } else {
    // Over budget_max - partial if within 10% over
    const percentOver = (listing.asking_price - budgetMax) / budgetMax
    if (percentOver <= 0.1) {
      // Within 10% over budget - scale from 30 down to 20
      scores.price_match = Math.round(30 - (percentOver * 100))
    }
    // Over 10% = 0 points
  }

  // Bedrooms (10%)
  if (listing.bedrooms >= buyer.min_bedrooms) {
    scores.bedrooms = 10
  } else if (listing.bedrooms === buyer.min_bedrooms - 1) {
    // One less bedroom - partial credit
    scores.bedrooms = 5
  }

  // Bathrooms (10%)
  if (listing.bathrooms >= buyer.min_bathrooms) {
    scores.bathrooms = 10
  } else if (listing.bathrooms >= buyer.min_bathrooms - 0.5) {
    scores.bathrooms = 7
  } else if (listing.bathrooms >= buyer.min_bathrooms - 1) {
    scores.bathrooms = 4
  } else if (listing.bathrooms >= buyer.min_bathrooms - 2) {
    scores.bathrooms = 2
  }

  // Location - ZIP code (15%)
  if (buyer.zip_codes && buyer.zip_codes.length > 0) {
    if (buyer.zip_codes.includes(listing.zip_code)) {
      scores.location = 15
    }
  } else {
    scores.location = 15
  }

  // Property type / Home type (10%)
  if (buyer.home_types && buyer.home_types.length > 0) {
    if (
      buyer.home_types.includes('no_preference') ||
      buyer.home_types.includes(listing.property_type)
    ) {
      scores.property_type = 10
    }
  } else {
    // No home types specified = flexible
    scores.property_type = 10
  }

export function filterBuyersByRequirements(
  buyers: BuyerProfile[],
  listing: SellerListing
): BuyerProfile[] {
  return buyers.filter((buyer) => {
    // Budget range check - listing must fall within buyer's budget range (with 10% flexibility on max)
    const budgetMin = buyer.budget_min ?? Math.round(buyer.budget * 0.8)
    const budgetMax = buyer.budget_max ?? buyer.budget
    const maxAffordable = budgetMax * 1.1

    // Must be within range or at most 10% over max
    if (listing.asking_price > maxAffordable) return false

    // Allow some flexibility below minimum (20% below is still acceptable)
    const minAcceptable = budgetMin * 0.8
    if (listing.asking_price < minAcceptable) return false

    // Bedrooms check - allow one less than minimum (partial match)
    if (buyer.min_bedrooms > listing.bedrooms + 1) return false

    // Property type check
    const hasHomeTypes = Array.isArray(buyer.home_types) && buyer.home_types.length > 0
    if (hasHomeTypes) {
      const matchesType =
        buyer.home_types.includes('no_preference') ||
        buyer.home_types.includes(listing.property_type)
      if (!matchesType) return false
    }

    // ZIP code check - only filter if buyer specified locations
    if (buyer.zip_codes && buyer.zip_codes.length > 0) {
      if (!buyer.zip_codes.includes(listing.zip_code)) return false
    }

    return true
  })
}

/**
 * Score and sort buyers for a listing
 * Returns buyers sorted by match score (highest first)
 */
export function scoreAndSortBuyers(
  buyers: BuyerProfile[],
  listing: SellerListing
): Array<BuyerProfile & { matchScore: number; matchGrade: string }> {
  return buyers
    .map((buyer) => {
      const result = calculateMatchScore(buyer, listing)
      return {
        ...buyer,
        matchScore: result.total,
        matchGrade: result.grade,
      }
    })
    .sort((a, b) => b.matchScore - a.matchScore)
}

export function normalizeIdentityEmail(value: string | null | undefined): string | null {
  if (!value || typeof value !== "string") return null;
  const t = value.trim().toLowerCase();
  return t.length > 0 ? t : null;
}

function collectListingPartyEmails(listing: ListingSelfMatchInput): Set<string> {
  const s = new Set<string>();
  const a = normalizeIdentityEmail(listing.email);
  const b = normalizeIdentityEmail(listing.client_email);
  if (a) s.add(a);
  if (b) s.add(b);
  return s;
}

function collectBuyerPartyEmails(buyer: object): Set<string> {
  const b = buyer as Record<string, unknown>;
  const s = new Set<string>();
  const a = normalizeIdentityEmail(typeof b.email === "string" ? b.email : null);
  const c = normalizeIdentityEmail(typeof b.client_email === "string" ? b.client_email : null);
  if (a) s.add(a);
  if (c) s.add(c);
  return s;
}

export function buyerListingIsSelfMatch(
  listing: ListingSelfMatchInput,
  buyer: object,
  auth?: SelfMatchAuthContext | null
): boolean {
  const listingEmails = collectListingPartyEmails(listing);
  const buyerEmails = collectBuyerPartyEmails(buyer);

  for (const e of buyerEmails) {
    if (listingEmails.has(e)) return true;
  }

  if (auth?.userId && auth.email && listing.user_id === auth.userId) {
    const ae = normalizeIdentityEmail(auth.email);
    if (ae && buyerEmails.has(ae)) return true;
  }

  return false;
}

  const loanAmount = homePrice - downPayment;
  const monthlyRate = interestRate / 100 / 12;
  const numberOfPayments = loanTerm * 12;

  const monthlyPayment = loanAmount *
    (monthlyRate * Math.pow(1 + monthlyRate, numberOfPayments)) /
    (Math.pow(1 + monthlyRate, numberOfPayments) - 1);

  const totalPayment = monthlyPayment * numberOfPayments;
  const totalInterest = totalPayment - loanAmount;

  const formatCurrency = (value: number) =>
    new Intl.NumberFormat("en-US", { style: "currency", currency: "USD", maximumFractionDigits: 0 }).format(value);

// Silent beat at the start of every slide so visuals land before the voice.
const START_DELAY_MS = 1000;

export function useSlideAudio({
  enabled,
  src,
  slideKey,
  isPlaying,
  onEnd,
  onMissing,
  onAutoplayBlocked,
}: UseSlideAudioOptions) {
  const onEndRef = React.useRef(onEnd);
  const onMissingRef = React.useRef(onMissing);
  const onAutoplayBlockedRef = React.useRef(onAutoplayBlocked);
  React.useEffect(() => {
    onEndRef.current = onEnd;
  }, [onEnd]);
  React.useEffect(() => {
    onMissingRef.current = onMissing;
  }, [onMissing]);
  React.useEffect(() => {
    onAutoplayBlockedRef.current = onAutoplayBlocked;
  }, [onAutoplayBlocked]);

  React.useEffect(() => {
    if (!enabled || !isPlaying) return;
    if (typeof window === "undefined") return;

    let cancelled = false;
    const audio = new Audio(src);
    audio.preload = "auto";

    const handleEnded = () => {
      if (cancelled) return;
      window.setTimeout(() => {
        if (!cancelled) onEndRef.current();
      }, 350);
    };
    const handleError = () => {
      if (cancelled) return;
      onMissingRef.current?.();
    };

    audio.addEventListener("ended", handleEnded);
    audio.addEventListener("error", handleError);

    const startTimer = window.setTimeout(() => {
      if (cancelled) return;
      audio.play().catch((err: unknown) => {
        if (cancelled) return;
        // NotAllowedError = browser autoplay policy — user needs to click once.
        // Everything else = actual load/decode/network failure.
        const name = (err as { name?: string } | null)?.name;
        if (name === "NotAllowedError") {
          onAutoplayBlockedRef.current?.();
        } else {
          onMissingRef.current?.();
        }
      });
    }, START_DELAY_MS);

    return () => {
      cancelled = true;
      window.clearTimeout(startTimer);
      audio.removeEventListener("ended", handleEnded);
      audio.removeEventListener("error", handleError);
      audio.pause();
      audio.src = "";
    };
  }, [enabled, isPlaying, slideKey, src]);
}

const PREFERRED_VOICE_NAMES = [
  // macOS Enhanced / Premium voices (sound noticeably better when installed)
  "Ava (Enhanced)",
  "Ava (Premium)",
  "Allison (Enhanced)",
  "Tom (Enhanced)",
  "Samantha (Enhanced)",
  // Fallbacks — always available on macOS
  "Samantha",
  "Ava",
  "Allison",
  "Tom",
  "Alex",
];

function pickBestVoice(voices: SpeechSynthesisVoice[]): SpeechSynthesisVoice | null {
  for (const name of PREFERRED_VOICE_NAMES) {
    const match = voices.find((v) => v.name === name);
    if (match) return match;
  }
  const enUs = voices.find((v) => v.lang === "en-US" && v.localService);
  return enUs ?? voices.find((v) => v.lang.startsWith("en")) ?? null;
}

export function useNarration({
  enabled,
  text,
  slideKey,
  isPlaying,
  onEnd,
}: UseNarrationOptions) {
  const onEndRef = React.useRef(onEnd);
  React.useEffect(() => {
    onEndRef.current = onEnd;
  }, [onEnd]);

  React.useEffect(() => {
    if (!enabled || !isPlaying) return;
    if (typeof window === "undefined" || !("speechSynthesis" in window)) return;

    const synth = window.speechSynthesis;
    synth.cancel();

    let cancelled = false;

    function speak() {
      if (cancelled) return;
      const voices = synth.getVoices();
      const utter = new SpeechSynthesisUtterance(text);
      const voice = pickBestVoice(voices);
      if (voice) utter.voice = voice;
      utter.rate = 0.96;
      utter.pitch = 1.0;
      utter.volume = 1.0;
      utter.onend = () => {
        if (cancelled) return;
        window.setTimeout(() => {
          if (!cancelled) onEndRef.current();
        }, 350);
      };
      synth.speak(utter);
    }

    const startTimer = window.setTimeout(() => {
      if (cancelled) return;
      // Voices can load asynchronously on first call
      if (synth.getVoices().length === 0) {
        const handler = () => {
          synth.removeEventListener("voiceschanged", handler);
          speak();
        };
        synth.addEventListener("voiceschanged", handler);
      } else {
        speak();
      }
    }, START_DELAY_MS);

    return () => {
      cancelled = true;
      window.clearTimeout(startTimer);
      synth.cancel();
    };
  }, [enabled, isPlaying, slideKey, text]);
}

function invertMembership(kind: "dashboards" | "selfService"): Record<string, string[]> {
  const map: Record<string, string[]> = {};
  for (const [valueId, entry] of Object.entries(MEMBERSHIP)) {
    for (const key of entry[kind]) {
      (map[key] ??= []).push(valueId);
    }
  }
  return map;
}

const DASHBOARD_TAXONOMY = invertMembership("dashboards");
const SELF_SERVICE_TAXONOMY = invertMembership("selfService");

export function getDashboardTaxonomyValues(slug: string): string[] {
  return DASHBOARD_TAXONOMY[slug] ?? [];
}

export function getSelfServiceTaxonomyValues(title: string): string[] {
  return SELF_SERVICE_TAXONOMY[title] ?? [];
}

export type TaxonomySelection = Record<string, string[]>;

/**
 * Faceted match: OR within a group, AND across groups. An item passes when, for
 * every group that has at least one selected value, the item carries one of
 * those values.
 */
export function matchesTaxonomySelection(
  itemValueIds: string[],
  selection: TaxonomySelection,
): boolean {
  const itemValues = new Set(itemValueIds);
  for (const group of TAXONOMY_GROUPS) {
    const selected = selection[group.id];
    if (!selected || selected.length === 0) continue;
    if (!selected.some((valueId) => itemValues.has(valueId))) return false;
  }
  return true;
}

    // Parse the response according to the format
    let responseContent = response.data?.nl_response ?? response.data?.agent_response ?? response.data?.data ?? response.data;
    let suggestedFollowUps = response.data?.suggested_follow_ups ?? null;
    let queryInfo = null;
    let sources = null;

    // Parse the response
    if (typeof responseContent === 'string') {
      try {
        const parsed = JSON.parse(responseContent);
        queryInfo = parsed.query_info || null;
        sources = parsed.source || null;
        suggestedFollowUps = parsed.suggested_follow_ups || suggestedFollowUps;
        responseContent = parsed.nl_response || parsed.aggregated_response || parsed.insights || parsed.response || responseContent;
      } catch (e) {
        // If parsing fails, use the string as is
      }
    } else if (responseContent) {
      queryInfo = responseContent.query_info || null;
      sources = responseContent.source || null;
      suggestedFollowUps = responseContent.suggested_follow_ups || suggestedFollowUps;
      responseContent =
        responseContent.nl_response ||
        responseContent.aggregated_response ||
        responseContent.insights ||
        responseContent.response ||
        JSON.stringify(responseContent);
    }