import { createHash } from "node:crypto";
import type { Locator, Page } from "playwright";
import {
  ADDRESS_CANDIDATE_SUGGESTION_TIMEOUT_MS,
  ADDRESS_SUGGESTION_TIMEOUT_MS,
  RPA_STREET_INPUT_CLICK_MS,
} from "@/lib/constants/rpa";
import { COLLECT_ADDRESS_LABELS_FROM_DOM, COLLECT_PAC_ITEM_LABELS, COLLECT_WIDGET_SUGGESTION_LABELS } from "@/workers/rpa/kernel/browser-scripts";
import { ensureArray } from "@/workers/rpa/kernel/context-validator";
import { pageLocator } from "@/lib/rpa/locator";
import { awaitHumanPacing } from "@/lib/rpa/human-pacing";
import { getSelector } from "@/lib/rpa/selectors";
import { getSelectorSpecs } from "@/lib/rpa/selector-specs";
import type {
  AddressLookupInput,
  MothershipAddressCandidate,
} from "@/modules/address/types";
import { RpaError } from "@/modules/rpa/errors";
import type { QuoteRequest } from "@/modules/providers/quote-provider";
import { isPickupReadyForDeliveryInput } from "@/workers/rpa/address-commit";
import {
  formatPlaceCommitFailure,
  type AxelSelectionBridge,
  type AxelSelectionPayload,
} from "@/workers/rpa/axel-selection-bridge";
import { commitViaAxelPlacePrefetch } from "@/workers/rpa/axel-place-prefetch";
import {
  clickMothershipStyledSuggestion,
  waitForStyledSuggestionRows,
} from "@/workers/rpa/mothership-styled-suggestion-click";
import {
  captureSelectionTrace,
  logSelectionTrace,
} from "@/workers/rpa/selection-trace";
import type { RPAContext } from "@/workers/rpa/kernel/context";

const POLL_INTERVAL_MS = 250;
const MAX_SUGGESTION_ROW_LEN = 180;
const DEFAULT_MOTHERSHIP_COUNTRY = "USA";
const SUGGESTION_STABLE_POLL_MS = 150;

/** 输入框已有与查询等效文案时，避免 fill("") 造成界面「闪清」 */
export function normalizeAddressInputValue(value: string): string {
  return value.replace(/\s+/g, " ").trim();
}

export function addressInputMatchesQuery(current: string, query: string): boolean {
  const c = normalizeAddressInputValue(current);
  const q = normalizeAddressInputValue(query);
  if (!c || !q) {
    return false;
  }
  if (c === q) {
    return true;
  }
  const cLower = c.toLowerCase();
  const qLower = q.toLowerCase();
  if (cLower.includes(qLower) || qLower.includes(cLower)) {
    return true;
  }
  const streetNum = q.match(/^\d+/)?.[0];
  if (streetNum && cLower.startsWith(streetNum.toLowerCase()) && c.length >= 12) {
    return true;
  }
  return false;
}
const SUGGESTION_STABLE_PASSES = 2;

/** 候选枚举与 autocomplete 共用 query 序列，避免粘连-only 漏采真实地址 */
export function buildAddressEnumerationQueries(
  address: AddressLookupInput,
): string[] {
  return buildAddressAutocompleteQueries(address);
}

export function stripCountrySuffix(label: string): string {
  return label.replace(/,\s*USA\s*$/i, "").trim();
}
function toGluedStreetCity(street: string, city: string): string {
  const s = street.trim();
  const c = city.trim().replace(/\s+/g, " ");
  if (!s || !c) {
    return s;
  }
  if (s.toLowerCase().includes(c.toLowerCase())) {
    return s;
  }
  return `${s}${c}`;
}

function normalizeParsedStreet(
  street: string,
  query?: AddressLookupInput,
): string {
  const parsed = street.trim();
  const qStreet = query?.street?.trim();
  if (
    qStreet &&
    parsed.toLowerCase().startsWith(qStreet.toLowerCase()) &&
    parsed.length > qStreet.length
  ) {
    return qStreet;
  }
  return parsed;
}

function normalizeDomSuggestionLabel(label: string): string {
  return stripCountrySuffix(label).replace(/\s+/g, " ").trim();
}

function gluedVariants(label: string): string[] {
  const base = normalizeDomSuggestionLabel(label);
  const variants = new Set<string>([base]);
  const glued = base.replace(
    /\b(Street|St|Ave|Avenue|Blvd|Boulevard|Dr|Drive|Road|Rd|Lane|Ln)\s+([A-Z])/gi,
    "$1$2",
  );
  if (glued !== base) {
    variants.add(glued);
  }
  const spaced = base.replace(
    /\b(Street|St|Ave|Avenue|Blvd|Boulevard|Dr|Drive|Way|Road|Rd|Lane|Ln)\s*([A-Z])/gi,
    "$1 $2",
  );
  if (spaced !== base) {
    variants.add(spaced);
  }
  return [...variants];
}

async function locateSuggestionByLabelText(
  page: Page,
  text: string,
): Promise<Locator | null> {
  const normalized = text.replace(/\s+/g, " ").trim();
  const candidates = [
    normalized,
    stripCountrySuffix(normalized),
    normalized.split(",")[0]?.trim() ?? "",
    ...gluedVariants(normalized),
  ].filter((value, index, arr) => value.length >= 8 && arr.indexOf(value) === index);

  const roots = [
    page.locator(".pac-container .pac-item"),
    page.locator('[role="listbox"] [role="option"]'),
    getQuoteWidgetLocator(page).locator('[role="listbox"] [role="option"]'),
    page.locator("div[class*='sc-']"),
  ];

  for (const probe of candidates) {
    for (const root of roots) {
      const loc = root.filter({ hasText: probe }).first();
      if (await loc.isVisible().catch(() => false)) {
        return loc;
      }
    }

    const pageLoc = page.getByText(probe, { exact: false }).first();
    if (await pageLoc.isVisible().catch(() => false)) {
      return pageLoc;
    }

    const widgetLoc = getQuoteWidgetLocator(page)
      .getByText(probe, { exact: false })
      .first();
    if (await widgetLoc.isVisible().catch(() => false)) {
      return widgetLoc;
    }
  }

  return null;
}

function resolveCountry(address: AddressLookupInput): string {
  return address.country?.trim() || DEFAULT_MOTHERSHIP_COUNTRY;
}

/** MotherShip 输入框键入：仅街道+城市+州+国家（不含邮编，对齐 PRD GD-15） */
export function formatAddressQuery(address: AddressLookupInput): string {
  const street = address.street.trim();
  const city = address.city.trim();
  const state = address.state.trim();
  return `${street}, ${city}, ${state}, ${resolveCountry(address)}`;
}

const STREET_SUFFIX_PATTERN =
  "Street|St|Road|Rd|Avenue|Ave|Boulevard|Blvd|Drive|Dr|Lane|Ln|Way|Court|Ct|Circle|Cir|Place|Pl|Terrace|Ter|Highway|Hwy|Parkway|Pkwy|Freeway|Fwy";

/**
 * 从 mothership label / 粘连文案提取纯街道名。
 * 取最后一个街道后缀（Street/Ave/Blvd…），再回溯门牌号与街名，避免 POI 前缀污染查询。
 */
export function extractStreetFromLabel(label: string): string | null {
  const normalized = label.replace(/\s+/g, " ").trim();
  if (!normalized) {
    return null;
  }

  const suffixRe = new RegExp(
    `\\b(${STREET_SUFFIX_PATTERN})(?=\\s*,|\\s|$|[A-Z][a-z])`,
    "gi",
  );
  let lastSuffix: RegExpExecArray | null = null;
  let match: RegExpExecArray | null = suffixRe.exec(normalized);
  while (match) {
    const token = match[1];
    const idx = match.index;
    if (token.toLowerCase() === "st") {
      const prevChar = idx > 0 ? normalized[idx - 1] : "";
      if (prevChar && /[a-z]/i.test(prevChar)) {
        match = suffixRe.exec(normalized);
        continue;
      }
      const head = normalized.slice(0, idx).trimEnd();
      if (!/\s\S+$/.test(head)) {
        match = suffixRe.exec(normalized);
        continue;
      }
    }
    lastSuffix = match;
    match = suffixRe.exec(normalized);
  }
  if (!lastSuffix) {
    return null;
  }

  const suffix = lastSuffix[1];
  const before = normalized.slice(0, lastSuffix.index).replace(/,\s*$/, "").trimEnd();
  const commaIdx = before.lastIndexOf(",");
  const segment = (commaIdx >= 0 ? before.slice(commaIdx + 1) : before).trim();
  if (!segment) {
    return null;
  }

  const numbered = segment.match(/^(\d+)\s+(.+)$/);
  const number = numbered?.[1];
  const namePart = (numbered?.[2] ?? segment).trim();
  const words = namePart.split(/\s+/).filter(Boolean);
  if (!number && words.length === 0) {
    return null;
  }

  const streetName = number ? `${number} ${words.join(" ")}`.trim() : words[words.length - 1];
  const street = `${streetName} ${suffix}`.replace(/\s+/g, " ").trim();
  if (street.length < 8 || street.length > 80) {
    return null;
  }
  return street;
}

/** 将 POI 粘连 street 归一为纯街道，供联想键入与 DOM 采集使用 */
export function resolveAddressAutocompleteInput(
  address: AddressLookupInput,
  options?: { mothershipLabel?: string },
): AddressLookupInput {
  const label = options?.mothershipLabel?.trim();
  const sources = [label, address.street.trim()].filter(Boolean) as string[];

  for (const source of sources) {
    const pureStreet = extractStreetFromLabel(source);
    if (!pureStreet) {
      continue;
    }
    const current = address.street.trim();
    if (pureStreet.toLowerCase() === current.toLowerCase()) {
      return address;
    }
    return { ...address, street: pureStreet };
  }

  return address;
}

/** 联想未出现时依次尝试的键入文案（纯街道优先，完整 POI 置后） */
export function buildAddressAutocompleteQueries(
  address: AddressLookupInput,
  options?: { mothershipLabel?: string; preferConfirmedLabel?: boolean },
): string[] {
  const resolved = resolveAddressAutocompleteInput(address, options);
  const label = options?.mothershipLabel?.trim();
  const street = resolved.street.trim();
  const city = resolved.city.trim();
  const state = resolved.state.trim();
  const origStreet = address.street.trim();

  const queries: string[] = [];
  if (options?.preferConfirmedLabel && label) {
    queries.push(stripCountrySuffix(label));
  }
  queries.push(formatAddressQuery(resolved));
  queries.push(`${street}, ${city}, ${state}`);
  queries.push(`${toGluedStreetCity(street, city)}, ${state}`);

  const streetToken = street.match(/^\d+\s+\S+(?:\s+\S+)?/)?.[0]?.trim();
  if (streetToken && streetToken.length >= 6) {
    queries.push(streetToken);
  }

  if (origStreet && origStreet.toLowerCase() !== street.toLowerCase()) {
    queries.push(formatAddressQuery(address));
    queries.push(`${origStreet}, ${city}, ${state}`);
    queries.push(`${toGluedStreetCity(origStreet, city)}, ${state}`);
    if (label) {
      queries.push(stripCountrySuffix(label));
    }
  } else if (label) {
    const stripped = stripCountrySuffix(label);
    if (stripped !== queries[0]) {
      queries.push(stripped);
    }
  }

  return [...new Set(queries.map((q) => q.trim()).filter(Boolean))];
}

export function formatMothershipFormattedAddress(
  street: string,
  city: string,
  state: string,
  country = DEFAULT_MOTHERSHIP_COUNTRY,
): string {
  return `${street}, ${city}, ${state}, ${country}`;
}

function queryStreetNumber(address: AddressLookupInput): string | null {
  return address.street.match(/^\d+/)?.[0] ?? null;
}

function labelsContainStreetNumber(labels: readonly string[], streetNum: string): boolean {
  return labels.some((label) => label.includes(streetNum));
}

/** place 绑定优先尝试的 label 序列（完整街道优先于粘连 display_label） */
export function buildAddressBindingLabels(
  address: AddressLookupInput,
  mothershipLabel?: string,
): string[] {
  const street = address.street.trim();
  const city = address.city.trim();
  const state = address.state.trim();
  const labels: string[] = [];
  if (street && city && state) {
    labels.push(`${street}, ${city}, ${state}`);
    labels.push(formatAddressQuery(address));
  }
  const glued = mothershipLabel?.trim();
  if (glued) {
    labels.push(stripCountrySuffix(glued));
  }
  return [...new Set(labels.map((l) => l.trim()).filter(Boolean))];
}

function enrichCandidateFromQuery(
  item: MothershipAddressCandidate,
  query?: AddressLookupInput,
): MothershipAddressCandidate {
  if (!query) {
    return item;
  }
  const country = resolveCountry(query);
  const zip = item.zip || query.zip;

  let street = item.street.trim();
  const queryStreetNum = queryStreetNumber(query);
  const itemStreetNum = street.match(/^\d+/)?.[0];
  if (queryStreetNum && !itemStreetNum) {
    const nameFromItem = street.replace(/\s+/g, " ").trim();
    const nameFromQuery = query.street.replace(/^\d+\s*/, "").trim();
    const streetName = nameFromItem.length >= 3 ? nameFromItem : nameFromQuery;
    street = `${queryStreetNum} ${streetName}`.trim();
  }

  const city = item.city.trim() || query.city.trim();
  const state = item.state.trim() || query.state.trim();
  const hasStructured = Boolean(city) && Boolean(state) && Boolean(street);
  const formatted_address = hasStructured
    ? formatMothershipFormattedAddress(street, city, state, country)
    : item.formatted_address;
  const display_label =
    queryStreetNum && !itemStreetNum && hasStructured
      ? `${toGluedStreetCity(street, city)}, ${state}`
      : item.display_label;

  return {
    ...item,
    street,
    city,
    state,
    zip,
    formatted_address,
    display_label,
  };
}

function toOptionId(label: string): string {
  return `ms_${createHash("sha256").update(label).digest("hex").slice(0, 16)}`;
}

const US_STATE_NAME_TO_CODE: Record<string, string> = {
  alabama: "AL",
  alaska: "AK",
  arizona: "AZ",
  arkansas: "AR",
  california: "CA",
  colorado: "CO",
  connecticut: "CT",
  delaware: "DE",
  florida: "FL",
  georgia: "GA",
  texas: "TX",
  // 其余州按需扩展；MotherShip 常见 CA/TX
};

function resolveStateCode(raw: string, query?: AddressLookupInput): string {
  const trimmed = raw.trim();
  if (/^[A-Z]{2}$/.test(trimmed)) {
    return trimmed;
  }
  const mapped = US_STATE_NAME_TO_CODE[trimmed.toLowerCase()];
  if (mapped) {
    return mapped;
  }
  return query?.state?.trim() || trimmed.slice(0, 2).toUpperCase();
}

/** 解析 pac-item 结构化标签 main|secondary 或粘连 innerText */
function parsePacStructuredLabel(
  label: string,
  query?: AddressLookupInput,
): MothershipAddressCandidate | null {
  const pipeIdx = label.indexOf("|");
  if (pipeIdx > 0) {
    const street = label.slice(0, pipeIdx).trim();
    const secondary = stripCountrySuffix(label.slice(pipeIdx + 1).trim());
    const parts = secondary.split(",").map((p) => p.trim()).filter(Boolean);
    if (street.length >= 5 && parts.length >= 2) {
      const city = parts[0];
      const stateToken =
        [...parts].reverse().find((part) => /^[A-Z]{2}$/.test(part)) ??
        parts.find((part) => US_STATE_NAME_TO_CODE[part.toLowerCase()]);
      const state = resolveStateCode(stateToken ?? parts[parts.length - 1], query);
      const item: MothershipAddressCandidate = {
        option_id: toOptionId(label),
        display_label: `${toGluedStreetCity(street, city)}, ${state}`,
        formatted_address: formatMothershipFormattedAddress(street, city, state),
        street,
        city,
        state,
        zip: query?.zip ?? "",
      };
      return enrichCandidateFromQuery(item, query);
    }
  }

  const normalized = stripCountrySuffix(label.replace(/\s+/g, " ").trim());
  
  // 含 suburb 格式：street city, suburb, state
  const suburbMatch = normalized.match(
    /^(\d+\s+(?:[\w.]+\s+)*?(?:Street|St|Blvd|Boulevard|Dr|Drive|Way|Road|Rd|Lane|Ln|Ave|Avenue)\.?)\s+([A-Z][A-Za-z\s.]+?),\s*([^,]+),\s*([A-Za-z]{2,})$/,
  );
  if (suburbMatch) {
    const [, street, city, , stateRaw] = suburbMatch;
    const state = resolveStateCode(stateRaw, query);
    const item: MothershipAddressCandidate = {
      option_id: toOptionId(label),
      display_label: `${toGluedStreetCity(street.trim(), city.trim())}, ${state}`,
      formatted_address: formatMothershipFormattedAddress(
        street.trim(),
        city.trim(),
        state,
      ),
      street: street.trim(),
      city: city.trim(),
      state,
      zip: query?.zip ?? "",
    };
    return enrichCandidateFromQuery(item, query);
  }

  // 无门牌号街道（Fifth Avenue / Hollywood Boulevard 等）
  const namedStreetMatch = normalized.match(
    /^([A-Z][A-Za-z0-9\s.'-]*(?:Avenue|Ave|Boulevard|Blvd|Street|St|Road|Rd|Drive|Dr|Way|Lane|Ln|Place|Pl|Court|Ct|Highway|Hwy)(?:\s+(?:North|South|East|West|N|S|E|W|NE|NW|SE|SW))?)\s+([A-Z][A-Za-z\s.]+?),\s*([A-Z]{2})$/,
  );
  if (namedStreetMatch) {
    const [, street, city, state] = namedStreetMatch;
    const item: MothershipAddressCandidate = {
      option_id: toOptionId(label),
      display_label: `${toGluedStreetCity(street.trim(), city.trim())}, ${state}`,
      formatted_address: formatMothershipFormattedAddress(
        street.trim(),
        city.trim(),
        state,
      ),
      street: street.trim(),
      city: city.trim(),
      state,
      zip: query?.zip ?? "",
    };
    return enrichCandidateFromQuery(item, query);
  }

  // 无 suburb 格式 (styled-components)：street city, state
  // 例如："1234 Warehouse Street Los Angeles, CA"
  const directCityMatch = normalized.match(
    /^(\d+\s+(?:[\w.]+\s+)*?(?:Street|St|Blvd|Boulevard|Dr|Drive|Way|Road|Rd|Lane|Ln|Ave|Avenue)\.?)\s+([A-Z][A-Za-z\s.]+?),\s*([A-Z]{2})$/,
  );
  if (directCityMatch) {
    const [, street, city, state] = directCityMatch;
    const item: MothershipAddressCandidate = {
      option_id: toOptionId(label),
      display_label: `${toGluedStreetCity(street.trim(), city.trim())}, ${state}`,
      formatted_address: formatMothershipFormattedAddress(
        street.trim(),
        city.trim(),
        state,
      ),
      street: street.trim(),
      city: city.trim(),
      state,
      zip: query?.zip ?? "",
    };
    return enrichCandidateFromQuery(item, query);
  }

  return null;
}

/** 解析 MotherShip 联想文案（含 StreetLos Angeles 粘连格式） */
export function labelToCandidate(
  label: string,
  query?: AddressLookupInput,
): MothershipAddressCandidate | null {
  const trimmed = label.replace(/\s+/g, " ").trim();
  if (trimmed.length < 5) {
    return null;
  }

  const pacParsed = parsePacStructuredLabel(trimmed, query);
  if (pacParsed) {
    return pacParsed;
  }

  const standard = trimmed.match(
    /^(.+?),\s*([^,]+),\s*([A-Z]{2})\s*(\d{5}(?:-\d{4})?)/,
  );
  if (standard) {
    const [, street, city, state, zip] = standard;
    const item: MothershipAddressCandidate = {
      option_id: toOptionId(trimmed),
      display_label: trimmed.replace(/\s+\d{5}(-\d{4})?$/, "").trim(),
      formatted_address: formatMothershipFormattedAddress(
        street.trim(),
        city.trim(),
        state,
      ),
      street: street.trim(),
      city: city.trim(),
      state,
      zip,
    };
    return enrichCandidateFromQuery(item, query);
  }

  const tail = trimmed.match(/,\s*([A-Z]{2})\s+(\d{5}(?:-\d{4})?)$/);
  if (tail) {
    const state = tail[1];
    const zip = tail[2];
    const beforeState = trimmed
      .slice(0, trimmed.lastIndexOf(tail[0]))
      .trim()
      .replace(/,\s*$/, "");
    const glued = beforeState.match(/^(.+?[a-z])([A-Z][\sA-Za-z.']+)$/);
    if (glued) {
      const street = glued[1].trim();
      const city = glued[2].trim();
      const item: MothershipAddressCandidate = {
        option_id: toOptionId(trimmed),
        display_label: `${street}${city}, ${state}`.replace(
          /\s+\d{5}(-\d{4})?$/,
          "",
        ),
        formatted_address: formatMothershipFormattedAddress(street, city, state),
        street,
        city,
        state,
        zip,
      };
      return enrichCandidateFromQuery(item, query);
    }
    if (query && query.zip === zip) {
      const item: MothershipAddressCandidate = {
        option_id: toOptionId(trimmed),
        display_label: trimmed.replace(/\s+\d{5}(-\d{4})?$/, "").trim(),
        formatted_address: formatMothershipFormattedAddress(
          query.street,
          query.city,
          query.state,
          resolveCountry(query),
        ),
        street: query.street,
        city: query.city,
        state: query.state,
        zip,
      };
      return enrichCandidateFromQuery(item, query);
    }
  }

  // 去掉 ", USA" / ", US" 等国家后缀后再匹配
  const trimmedNoCountry = stripCountrySuffix(trimmed);
  const stateOnly = trimmedNoCountry.match(/,\s*([A-Z]{2})\s*$/);
  if (stateOnly && query && query.state === stateOnly[1]) {
    const state = stateOnly[1];
    const beforeState = trimmedNoCountry
      .slice(0, trimmedNoCountry.lastIndexOf(stateOnly[0]))
      .trim();
    const glued = beforeState.match(/^(.+?[a-z])([A-Z][\sA-Za-z.']+)$/);
    if (glued) {
      const street = glued[1].trim();
      const city = glued[2].trim();
      const item: MothershipAddressCandidate = {
        option_id: toOptionId(trimmed),
        display_label: trimmed,
        formatted_address: formatMothershipFormattedAddress(street, city, state),
        street,
        city,
        state,
        zip: "",
      };
      return enrichCandidateFromQuery(item, query);
    }
    // 标准逗号分隔格式（无 ZIP）：street, city, state
    const commaSpaced = beforeState.match(/^(.+?),\s*([^,]+)$/);
    if (commaSpaced) {
      const street = commaSpaced[1].trim();
      const city = commaSpaced[2].trim();
      const item: MothershipAddressCandidate = {
        option_id: toOptionId(trimmed),
        display_label: `${toGluedStreetCity(street, city)}, ${state}`,
        formatted_address: formatMothershipFormattedAddress(street, city, state),
        street,
        city,
        state,
        zip: query?.zip ?? "",
      };
      return enrichCandidateFromQuery(item, query);
    }
  }

  if (query && isLikelySuggestionRow(trimmed, query)) {
    const normalized = normalizeDomSuggestionLabel(trimmed);
    const spaced = normalized.match(/^(.+?),\s*([^,]+),\s*([A-Z]{2})$/);
    if (spaced) {
      const street = normalizeParsedStreet(spaced[1], query);
      const city = spaced[2].trim();
      const state = spaced[3];
      const item: MothershipAddressCandidate = {
        option_id: toOptionId(trimmed),
        display_label: `${toGluedStreetCity(street, city)}, ${state}`,
        formatted_address: formatMothershipFormattedAddress(
          street,
          city,
          state,
          resolveCountry(query),
        ),
        street,
        city,
        state,
        zip: query.zip,
      };
      return enrichCandidateFromQuery(item, query);
    }
  }

  const streetOnly = parseStreetOnlySuggestion(trimmed, query);
  if (streetOnly) {
    return streetOnly;
  }

  return null;
}

/** MotherShip listbox 仅返回街道行（无城市/州）时的候选补全 */
function parseStreetOnlySuggestion(
  label: string,
  query?: AddressLookupInput,
): MothershipAddressCandidate | null {
  if (!query) {
    return null;
  }
  const trimmed = label.replace(/\s+/g, " ").trim();
  if (trimmed.includes(",") || trimmed.includes("|")) {
    return null;
  }
  const streetNum = query.street.match(/^\d+/)?.[0];
  if (!streetNum || !trimmed.startsWith(streetNum)) {
    return null;
  }
  if (trimmed.length < 8 || trimmed.length > MAX_SUGGESTION_ROW_LEN) {
    return null;
  }
  if (
    !/\b(street|st|avenue|ave|blvd|boulevard|dr|drive|road|rd|lane|ln|way)\b/i.test(
      trimmed,
    )
  ) {
    return null;
  }
  if (isInputEcho(trimmed, query)) {
    return null;
  }
  const street = trimmed;
  const city = query.city.trim();
  const state = query.state.trim();
  const item: MothershipAddressCandidate = {
    option_id: toOptionId(`${trimmed}|${city}|${state}`),
    display_label: `${toGluedStreetCity(street, city)}, ${state}`,
    formatted_address: formatMothershipFormattedAddress(
      street,
      city,
      state,
      resolveCountry(query),
    ),
    street,
    city,
    state,
    zip: query.zip,
  };
  return enrichCandidateFromQuery(item, query);
}

/** 候选是否为「用户输入回显」而非 MotherShip 独立坐标 */
export function isMotherShipEchoCandidate(
  item: MothershipAddressCandidate,
  query: AddressLookupInput,
): boolean {
  const norm = (s: string) => s.replace(/\s+/g, " ").trim().toLowerCase();
  if (norm(item.street) !== norm(query.street)) {
    return false;
  }
  if (norm(item.city) !== norm(query.city)) {
    return false;
  }
  const glued = `${toGluedStreetCity(query.street, query.city)}, ${query.state}`;
  const compact = (s: string) => s.replace(/\s+/g, "").toLowerCase();
  return (
    compact(item.display_label) === compact(glued) ||
    compact(item.display_label) ===
      compact(`${query.street}, ${query.city}, ${query.state}`)
  );
}

function getQuoteWidgetLocator(page: Page): Locator {
  return pageLocator(page, getSelector("RPA_SELECTOR_QUOTE_WIDGET")).first();
}

function isInputEcho(text: string, query: AddressLookupInput): boolean {
  const normalized = text.replace(/\s+/g, " ").trim();
  for (const candidate of buildAddressAutocompleteQueries(query)) {
    if (normalized === candidate || normalized === stripCountrySuffix(candidate)) {
      return true;
    }
  }
  return (
    normalized === `${query.street}, ${query.city}, ${query.state}` ||
    normalized ===
      `${query.street}, ${query.city}, ${query.state}, ${resolveCountry(query)}`
  );
}

function isMotherShipEnumerationRow(
  text: string,
  query: AddressLookupInput,
): boolean {
  if (/use my location|使用我的位置/i.test(text)) {
    return false;
  }
  if (text.includes("|")) {
    const main = text.split("|")[0]?.trim() ?? "";
    const secondary = text.slice(text.indexOf("|") + 1).trim();
    if (main.length < 5 || secondary.length < 2) {
      return false;
    }
    const compact = (s: string) =>
      s.replace(/\s+/g, "").toLowerCase().replace(/,usa$/i, "");
    const echoSecondary = compact(`${query.city}, ${query.state}`);
    if (compact(secondary).startsWith(echoSecondary)) {
      return false;
    }
    return true;
  }
  const probe = text;
  if (isInputEcho(probe, query) || isInputEcho(text, query)) {
    return false;
  }
  const normalized = text.replace(/\s+/g, " ").trim();
  if (normalized.length < 8) {
    return false;
  }
  const streetNum = query.street.match(/^\d+/)?.[0];
  if (streetNum && normalized.includes(streetNum)) {
    return true;
  }
  const cityToken = query.city.trim().split(/\s+/)[0]?.toLowerCase();
  return Boolean(
    cityToken &&
      cityToken.length >= 3 &&
      normalized.toLowerCase().includes(cityToken),
  );
}

/** @internal 单测：listbox pipe 行过滤 */
export function isMotherShipEnumerationRowForTest(
  text: string,
  query: AddressLookupInput,
): boolean {
  return isMotherShipEnumerationRow(text, query);
}

function isLikelySuggestionRow(
  text: string,
  query: AddressLookupInput,
): boolean {
  const normalized = text.replace(/\s+/g, " ").trim();
  if (normalized.length < 8 || normalized.length > MAX_SUGGESTION_ROW_LEN) {
    return false;
  }
  if (isInputEcho(normalized, query)) {
    return false;
  }
  const streetNum = query.street.match(/^\d+/)?.[0];
  if (streetNum) {
    if (!normalized.includes(streetNum)) {
      return false;
    }
  } else {
    const streetTokens = query.street
      .trim()
      .toLowerCase()
      .split(/\s+/)
      .filter((token) => token.length >= 4);
    if (
      streetTokens.length > 0 &&
      !streetTokens.some((token) => normalized.toLowerCase().includes(token))
    ) {
      return false;
    }
  }
  if (query.state && normalized.includes(query.state)) {
    return true;
  }
  const cityToken = query.city.trim().split(/\s+/)[0];
  if (
    cityToken.length >= 3 &&
    normalized.toLowerCase().includes(cityToken.toLowerCase())
  ) {
    return true;
  }
  const streetWord = query.street.split(/\s+/)[1];
  return Boolean(
    streetWord &&
      streetWord.length >= 3 &&
      normalized.toLowerCase().includes(streetWord.toLowerCase()),
  );
}

function streetSearchTokens(query: AddressLookupInput): string[] {
  const streetNum = query.street.match(/^\d+/)?.[0] ?? "";
  const streetWords = query.street.split(/\s+/).slice(1, 3).join(" ").trim();
  const tokens = [
    streetNum && streetWords ? `${streetNum} ${streetWords}` : "",
    streetNum,
  ].filter((token) => token.length >= 4);
  return [...new Set(tokens)];
}

function normalizeListboxLabel(text: string): string {
  const lines = text
    .split(/\r?\n/)
    .map((line) => line.trim())
    .filter(Boolean);
  if (lines.length >= 2 && !/use my location|使用我的位置/i.test(lines.join(" "))) {
    return `${lines[0]}|${lines.slice(1).join(", ")}`;
  }
  return text.replace(/\s+/g, " ").trim();
}

async function collectSuggestionLabelsFromWidget(
  page: Page,
  query: AddressLookupInput,
): Promise<string[]> {
  const rawLabels: string[] = ensureArray(
    await page
      .evaluate(COLLECT_WIDGET_SUGGESTION_LABELS)
      .catch(() => []) as string[] | null | undefined,
  ) as string[];
  // 不过滤：COLLECT_WIDGET_SUGGESTION_LABELS 已内置 skipRe 过滤
  // 对于 styled-components 检测，过严的 isMotherShipEnumerationRow 会漏掉合法联想
  if (rawLabels.length > 0) {
    return rawLabels;
  }
  // 回退：使用严格过滤
  return rawLabels.filter((label) => isMotherShipEnumerationRow(label, query));
}

async function collectEnumerationLabels(
  page: Page,
  query: AddressLookupInput,
): Promise<string[]> {
  const widgetLabels = await collectSuggestionLabelsFromWidget(page, query);
  if (widgetLabels.length > 0) {
    return widgetLabels;
  }
  const merged = await collectAddressSuggestionLabels(page, query);
  const filtered = merged.filter((label) =>
    isMotherShipEnumerationRow(label, query),
  );
  // 为何：waitFor 已确认 DOM 有联想，过严 filter 会把 pac-item 真实候选全部滤掉
  return filtered.length > 0 ? filtered : merged;
}

async function collectSuggestionLabelsFromPacStructured(
  page: Page,
  query: AddressLookupInput,
): Promise<string[]> {
  const rawLabels: string[] = ensureArray(
    await page
      .evaluate(COLLECT_PAC_ITEM_LABELS)
      .catch(() => []) as string[] | null | undefined,
  ) as string[];
  return rawLabels.filter((label: string) => {
    const main = label.includes("|") ? label.split("|")[0] : label;
    return isLikelySuggestionRow(main, query) || isLikelySuggestionRow(label, query);
  });
}

async function collectSuggestionLabelsFromPacContainer(
  page: Page,
  query: AddressLookupInput,
): Promise<string[]> {
  const labels: string[] = [];
  const roots = [
    page.locator(".pac-container"),
    page.locator('[role="listbox"]'),
    page.locator('[class*="suggestion" i], [class*="Suggestion"]'),
  ];

  for (const root of roots) {
    const rootCount = await root.count().catch(() => 0);
    for (let r = 0; r < rootCount; r += 1) {
      const container = root.nth(r);
      if (!(await container.isVisible().catch(() => false))) {
        continue;
      }
      let itemLocator = container.locator(".pac-item, [role='option']");
      let count = await itemLocator.count().catch(() => 0);
      if (count === 0) {
        itemLocator = container.locator("li, button");
        count = await itemLocator.count().catch(() => 0);
      }
      for (let i = 0; i < count; i += 1) {
        const text = await itemLocator.nth(i).innerText().catch(() => "");
        const normalized = text.replace(/\s+/g, " ").trim();
        if (isLikelySuggestionRow(normalized, query)) {
          labels.push(normalized);
        }
      }
    }
  }

  return labels;
}

/** 对齐录制：page.getByText(门牌号+街道) 点选，下拉项常不含 zip */
async function collectSuggestionLabelsByTextMatch(
  page: Page,
  query: AddressLookupInput,
): Promise<string[]> {
  const labels: string[] = [];

  for (const token of streetSearchTokens(query)) {
    const loc = page.getByText(token, { exact: false });
    const count = await loc.count().catch(() => 0);
    for (let i = 0; i < Math.min(count, 12); i += 1) {
      const el = loc.nth(i);
      if (!(await el.isVisible().catch(() => false))) {
        continue;
      }
      const text = await el.innerText().catch(() => "");
      const normalized = text.replace(/\s+/g, " ").trim();
      if (isLikelySuggestionRow(normalized, query)) {
        labels.push(normalized);
      }
    }
  }

  return labels;
}

async function collectSuggestionLabelsFromSpecs(page: Page): Promise<string[]> {
  const specs = getSelectorSpecs("RPA_SELECTOR_ADDRESS_SUGGESTION");
  const labels: string[] = [];
  const seen = new Set<string>();

  for (const spec of specs) {
    const root = pageLocator(page, spec);
    const count = await root.count().catch(() => 0);
    for (let i = 0; i < count; i++) {
      const text = await root
        .nth(i)
        .innerText()
        .catch(() => "");
      const normalized = text.replace(/\s+/g, " ").trim();
      if (normalized && !seen.has(normalized)) {
        seen.add(normalized);
        labels.push(normalizeListboxLabel(text));
      }
    }
  }

  return labels;
}

/** MotherShip 联想：全页扫描（含 body 级 .pac-container portal） */
async function collectSuggestionLabelsByHeuristic(
  page: Page,
  query: AddressLookupInput,
): Promise<string[]> {
  const streetNum = query.street.match(/^\d+/)?.[0] ?? "";
  const cityToken = query.city.trim().split(/\s+/)[0] ?? "";

  const rawLabels: string[] = ensureArray(
    await page
      .evaluate(COLLECT_ADDRESS_LABELS_FROM_DOM, {
        streetNumber: streetNum,
        cityHint: cityToken,
      })
      .catch(() => []) as string[] | null | undefined,
  ) as string[];

  return rawLabels.filter((label: string) => isLikelySuggestionRow(label, query));
}

export async function collectAddressSuggestionLabels(
  page: Page,
  query: AddressLookupInput,
): Promise<string[]> {
  const seen = new Set<string>();
  const merged: string[] = [];

  for (const label of [
    // 优先：COLLECT_WIDGET_SUGGESTION_LABELS（含 styled-components 检测）
    ...(await collectSuggestionLabelsFromWidget(page, query)),
    ...(await collectSuggestionLabelsFromPacStructured(page, query)),
    ...(await collectSuggestionLabelsFromPacContainer(page, query)),
    ...(await collectSuggestionLabelsFromSpecs(page)),
    ...(await collectSuggestionLabelsByTextMatch(page, query)),
    ...(await collectSuggestionLabelsByHeuristic(page, query)),
  ]) {
    const normalized = label.replace(/\s+/g, " ").trim();
    if (normalized && !seen.has(normalized)) {
      seen.add(normalized);
      merged.push(normalized);
    }
  }

  return merged;
}

/** 等待下拉项数量稳定后再采集（避免首条即返回漏掉其余选项） */
export async function collectAddressSuggestionLabelsWhenStable(
  page: Page,
  query: AddressLookupInput,
  options?: { timeoutMs?: number },
): Promise<string[]> {
  const timeoutMs =
    options?.timeoutMs ?? ADDRESS_CANDIDATE_SUGGESTION_TIMEOUT_MS;
  const deadline = Date.now() + timeoutMs;
  let best: string[] = [];
  let stablePasses = 0;

  while (Date.now() < deadline) {
    const labels = await collectAddressSuggestionLabels(page, query);
    if (labels.length >= 2) {
      return labels;
    }
    if (labels.length > best.length) {
      best = labels;
      stablePasses = 0;
    } else if (labels.length === best.length && best.length > 0) {
      stablePasses += 1;
      if (stablePasses >= SUGGESTION_STABLE_PASSES) {
        return best;
      }
    }
    await page.waitForTimeout(SUGGESTION_STABLE_POLL_MS);
  }

  return best;
}

/** 候选 API：多 query 尝试 + WhenStable 采集（不依赖 waitFor 误报） */
export async function enumerateAddressCandidates(
  page: Page,
  input: Locator,
  address: AddressLookupInput,
): Promise<string[]> {
  const queries = buildAddressEnumerationQueries(address);
  const seen = new Set<string>();
  const merged: string[] = [];
  let lastQuery = queries[0] ?? formatAddressQuery(address);
  const waitMs = ADDRESS_CANDIDATE_SUGGESTION_TIMEOUT_MS;

  const absorb = (labels: string[]) => {
    for (const label of labels) {
      const normalized = label.replace(/\s+/g, " ").trim();
      if (normalized && !seen.has(normalized)) {
        seen.add(normalized);
        merged.push(normalized);
      }
    }
  };

  for (let i = 0; i < queries.length; i += 1) {
    const queryText = queries[i];
    lastQuery = queryText;

    await triggerAddressAutocomplete(input, queryText, page, {
      suggestionTimeoutMs: waitMs,
      forEnumeration: true,
    });

    absorb(
      await collectAddressSuggestionLabelsWhenStable(page, address, {
        timeoutMs: waitMs,
      }),
    );

    const streetNum = queryStreetNumber(address);
    if (
      merged.length > 0 &&
      (streetNum == null || labelsContainStreetNumber(merged, streetNum))
    ) {
      break;
    }
  }

  if (merged.length === 0) {
    throw new RpaError(
      "ADDRESS_SUGGESTION_NOT_FOUND",
      `MotherShip 地址联想未出现：${lastQuery}`,
      { retryable: false },
    );
  }

  return merged;
}

export async function triggerAddressAutocomplete(
  input: Locator,
  query: string,
  page?: Page,
  options?: { suggestionTimeoutMs?: number; forEnumeration?: boolean },
): Promise<void> {
  const suggestionTimeoutMs =
    options?.suggestionTimeoutMs ?? ADDRESS_SUGGESTION_TIMEOUT_MS;
  const forEnumeration = options?.forEnumeration ?? false;

  await input.scrollIntoViewIfNeeded().catch(() => undefined);

  const focused = await input
    .focus({ timeout: RPA_STREET_INPUT_CLICK_MS })
    .then(() => true)
    .catch(() => false);

  if (!focused) {
    await input.click({ timeout: 3_000, force: true }).catch(() => undefined);
  }

  const currentValue = normalizeAddressInputValue(
    (await input.inputValue().catch(() => "")) || "",
  );
  if (addressInputMatchesQuery(currentValue, query)) {
    await input.dispatchEvent("input").catch(() => undefined);
    await input.dispatchEvent("change").catch(() => undefined);
    if (page) {
      await awaitHumanPacing(page);
      const appeared = await waitForGooglePlacesPredictions(
        page,
        suggestionTimeoutMs,
      );
      if (!appeared && !forEnumeration) {
        await input.click({ timeout: 3_000, force: true }).catch(() => undefined);
        await waitForGooglePlacesPredictions(page, suggestionTimeoutMs);
      }
      if (!forEnumeration) {
        const hasPac = await page
          .locator(".pac-container .pac-item")
          .first()
          .isVisible()
          .catch(() => false);
        if (hasPac) {
          await input.press("ArrowDown").catch(() => undefined);
          await page.waitForTimeout(150);
        }
      }
    }
    return;
  }

  try {
    await input.fill("", { timeout: suggestionTimeoutMs });
    await input.fill(query, { timeout: suggestionTimeoutMs });
  } catch {
    await input.press("Control+A").catch(() => undefined);
    await input.press("Backspace").catch(() => undefined);
    await input.pressSequentially(query, { delay: 25 });
  }

  await input.dispatchEvent("input").catch(() => undefined);
  await input.dispatchEvent("change").catch(() => undefined);
  if (page) {
    await awaitHumanPacing(page);
    const appeared = await waitForGooglePlacesPredictions(
      page,
      suggestionTimeoutMs,
    );
    // 某些地址（如 7000 NW 52nd St, Miami, FL）fill 写值不触发 Google 联想：
    // 逐字符重输产生真实 keydown/input 序列，重新等待联想请求完成
    if (!appeared) {
      await input.click({ timeout: 3_000, force: true }).catch(() => undefined);
      await input.press("Control+A").catch(() => undefined);
      await input.press("Backspace").catch(() => undefined);
      await input.pressSequentially(query, { delay: 60 }).catch(() => undefined);
      await waitForGooglePlacesPredictions(page, suggestionTimeoutMs);
    }
    if (!forEnumeration) {
      const hasPac = await page
        .locator(".pac-container .pac-item")
        .first()
        .isVisible()
        .catch(() => false);
      // MotherShip 主路径为 styled-components 联想；ArrowDown 会把焦点移到 Use my location
      if (hasPac) {
        await input.press("ArrowDown").catch(() => undefined);
        await page.waitForTimeout(150);
      }
    }
  }
}

/** 返回联想是否出现（Google Places 响应、.pac-item、或 styled-components 联想可见） */
async function waitForGooglePlacesPredictions(
  page: Page,
  timeoutMs: number,
): Promise<boolean> {
  return Promise.race([
    // Google Places API 响应
    page
      .waitForResponse(
        (response) =>
          response.url().includes("maps.googleapis.com") &&
          /Autocomplete|Autocompletion|place/i.test(response.url()) &&
          response.status() === 200,
        { timeout: timeoutMs },
      )
      .then(() => true),
    // 标准 pac-container
    page
      .waitForSelector(".pac-container .pac-item", {
        state: "visible",
        timeout: timeoutMs,
      })
      .then(() => true),
    // MotherShip styled-components 联想（轮询检测）
    (async () => {
      const pollInterval = 200;
      const deadline = Date.now() + timeoutMs;
      while (Date.now() < deadline) {
        // 检测 styled-components 联想（特征：包含州缩写的 sc- div）
        const found = await page.evaluate(() => {
          const stateRe = /(USA|US|CA|NY|TX|FL|IL|PA|OH|GA|NC|MI|NJ|VA|WA|AZ|MA|TN|IN|MO|MD|WI|CO|MN|SC|AL|LA|KY|OR|OK|CT|UT|IA|NV|AR|MS|KS|NM|NE|WV|ID|HI|NH|ME|MT|RI|DE|SD|ND|AK|DC|VT|WY|PR)/;
          const skipRe = /use my location|使用我的位置|get a freight|freight details|pick up from|deliver to|where to/i;
          let count = 0;
          document.querySelectorAll("div[class*='sc-']").forEach((el) => {
            const text = (el.textContent || "").replace(/\\s+/g, " ").trim();
            if (text.length >= 15 && text.length <= 150 && text.includes(",") && stateRe.test(text) && !skipRe.test(text)) {
              const rect = (el as HTMLElement).getBoundingClientRect();
              if (rect.width > 300 && rect.height >= 30 && rect.height <= 70) {
                count++;
              }
            }
          });
          return count >= 1;
        }).catch(() => false);
        if (found) return true;
        await page.waitForTimeout(pollInterval);
      }
      return false;
    })(),
  ]).catch(() => false);
}

/** 多策略键入直至 MotherShip 联想出现 */
export async function ensureAddressSuggestions(
  page: Page,
  input: Locator,
  address: AddressLookupInput,
  options?: {
    mothershipLabel?: string;
    suggestionTimeoutMs?: number;
    maxQueries?: number;
    preferConfirmedLabel?: boolean;
  },
): Promise<string> {
  const resolved = resolveAddressAutocompleteInput(address, options);
  const allQueries = buildAddressAutocompleteQueries(address, options);
  const queries = allQueries.slice(
    0,
    options?.maxQueries ?? allQueries.length,
  );
  let lastQuery = queries[0] ?? formatAddressQuery(resolved);
  const suggestionTimeoutMs =
    options?.suggestionTimeoutMs ?? ADDRESS_SUGGESTION_TIMEOUT_MS;
  const streetNum = queryStreetNumber(resolved);
  let fallbackQuery = "";

  for (const query of queries) {
    lastQuery = query;
    await triggerAddressAutocomplete(input, query, page, {
      suggestionTimeoutMs,
    });
    if (
      await waitForAddressSuggestions(page, resolved, suggestionTimeoutMs)
    ) {
      if (streetNum) {
        const labels = await collectAddressSuggestionLabelsWhenStable(
          page,
          resolved,
          { timeoutMs: Math.min(suggestionTimeoutMs, 5_000) },
        );
        if (labelsContainStreetNumber(labels, streetNum)) {
          return query;
        }
        if (!fallbackQuery) {
          fallbackQuery = query;
        }
        continue;
      }
      return query;
    }
  }

  if (fallbackQuery) {
    return fallbackQuery;
  }

  throw new RpaError(
    "ADDRESS_SUGGESTION_NOT_FOUND",
    `MotherShip 地址联想未出现：${lastQuery}`,
    { retryable: false },
  );
}

async function hasVisibleSuggestionItems(page: Page): Promise<boolean> {
  const roots = [
    page.locator(".pac-container .pac-item"),
    page.locator('[role="listbox"] [role="option"]'),
  ];
  for (const root of roots) {
    const count = await root.count().catch(() => 0);
    if (count > 0) {
      return true;
    }
  }
  return false;
}

export async function waitForAddressSuggestions(
  page: Page,
  query: AddressLookupInput,
  timeoutMs = ADDRESS_SUGGESTION_TIMEOUT_MS,
): Promise<boolean> {
  const deadline = Date.now() + timeoutMs;
  let pass = 0;
  while (Date.now() < deadline) {
    pass += 1;
    const quickHit =
      pass <= 2 || (await hasVisibleSuggestionItems(page));
    if (quickHit) {
      const labels = await collectAddressSuggestionLabels(page, query);
      if (labels.length > 0) {
        return true;
      }
    }
    await page.waitForTimeout(POLL_INTERVAL_MS);
  }
  return false;
}

function suggestionMatchKeys(
  label: string,
  query?: AddressLookupInput,
): string[] {
  const keys: string[] = [];
  const trimmed = label.replace(/\s+/g, " ").trim();

  for (const variant of gluedVariants(trimmed)) {
    if (variant.length >= 8) {
      keys.push(variant.slice(0, Math.min(32, variant.length)));
    }
  }

  if (trimmed.length >= 12) {
    keys.push(trimmed.slice(0, Math.min(40, trimmed.length)));
  }

  const city = query?.city.trim();
  const streetNum = query?.street.match(/^\d+/)?.[0];
  if (streetNum && city && city.includes(" ")) {
    keys.push(`${streetNum} ${city}`);
  }

  return [...new Set(keys)].filter((key) => key.length >= 10);
}

/** 在当前页面下拉中解析与用户确认项最匹配的 DOM 文案 */
export function scoreSuggestionLabelMatch(
  userLabel: string,
  domLabel: string,
  query?: AddressLookupInput,
): number {
  const userVariants = gluedVariants(userLabel).map((v) => v.toLowerCase());
  const dom = normalizeDomSuggestionLabel(domLabel).toLowerCase();
  if (!dom) {
    return 0;
  }

  for (const variant of userVariants) {
    if (variant === dom) {
      return 100;
    }
    if (variant.length >= 12 && dom.includes(variant)) {
      return 100;
    }
    if (dom.length >= 12 && variant.includes(dom)) {
      return 100;
    }
  }

  const streetNum = query?.street.match(/^\d+/)?.[0];
  if (streetNum) {
    if (!dom.includes(streetNum)) {
      return 0;
    }
  } else {
    const streetTokens = (query?.street ?? "")
      .trim()
      .toLowerCase()
      .split(/\s+/)
      .filter((token) => token.length >= 4);
    if (
      streetTokens.length > 0 &&
      !streetTokens.some((token) => dom.includes(token))
    ) {
      return 0;
    }
  }

  let score = 40;
  if (query?.state && dom.includes(query.state.toLowerCase())) {
    score += 20;
  }
  const city = query?.city.trim().toLowerCase();
  if (city && city.length >= 3) {
    if (dom.includes(city)) {
      score += 40;
    } else {
      const cityParts = city.split(/\s+/).filter((part) => part.length >= 3);
      if (
        cityParts.length > 1 &&
        cityParts.every((part) => new RegExp(`\\b${part}\\b`).test(dom))
      ) {
        score += 25;
      } else if (cityParts.length === 1) {
        const token = cityParts[0];
        if (new RegExp(`\\b${token}\\b`).test(dom)) {
          score += 20;
        }
      }
    }
  }
  const streetWord = query?.street.split(/\s+/)[1]?.toLowerCase();
  if (streetWord && streetWord.length >= 3 && dom.includes(streetWord)) {
    score += 15;
  }
  return score;
}

export async function resolveDomSuggestionLabel(
  page: Page,
  userLabel: string,
  query: AddressLookupInput,
): Promise<string | null> {
  const labels = await collectAddressSuggestionLabels(page, query);
  let best: { label: string; score: number } | null = null;

  for (const label of labels) {
    const score = scoreSuggestionLabelMatch(userLabel, label, query);
    if (!best || score > best.score) {
      best = { label, score };
    }
  }

  return best && best.score >= 50 ? best.label : null;
}

/** 用键盘在联想列表中选中评分最高的项 */
export async function selectSuggestionByKeyboard(
  page: Page,
  input: Locator,
  userLabel: string,
  query: AddressLookupInput,
): Promise<boolean> {
  const labels = await collectAddressSuggestionLabels(page, query);
  let bestIndex = -1;
  let bestScore = 0;
  labels.forEach((domLabel, index) => {
    const score = scoreSuggestionLabelMatch(userLabel, domLabel, query);
    if (score > bestScore) {
      bestScore = score;
      bestIndex = index;
    }
  });
  if (bestIndex < 0 || bestScore < 50) {
    return false;
  }

  await input.click({ force: true }).catch(() => undefined);
  await page.waitForTimeout(150);
  for (let i = 0; i <= bestIndex; i += 1) {
    await page.keyboard.press("ArrowDown");
    await page.waitForTimeout(120);
  }
  await page.keyboard.press("Enter");
  await page.waitForTimeout(200);
  return true;
}

/** 定位用户确认的联想项（评分 + 联想容器内查找，避免短键误点） */
export async function findAddressSuggestionLocator(
  page: Page,
  label: string,
  query?: AddressLookupInput,
): Promise<Locator | null> {
  if (query) {
    const labels = await collectAddressSuggestionLabels(page, query);
    let best: { label: string; score: number } | null = null;
    for (const domLabel of labels) {
      const score = scoreSuggestionLabelMatch(label, domLabel, query);
      if (!best || score > best.score) {
        best = { label: domLabel, score };
      }
    }
    if (best && best.score >= 50) {
      const scored = await locateSuggestionByLabelText(page, best.label);
      if (scored) {
        return scored;
      }
    }
  }

  const specs = getSelectorSpecs("RPA_SELECTOR_ADDRESS_SUGGESTION");
  for (const spec of specs) {
    const loc = pageLocator(page, spec).filter({ hasText: label }).first();
    if (await loc.isVisible().catch(() => false)) {
      return loc;
    }
  }

  for (const variant of gluedVariants(label)) {
    const located = await locateSuggestionByLabelText(page, variant);
    if (located) {
      return located;
    }
  }

  const widget = getQuoteWidgetLocator(page);
  for (const key of suggestionMatchKeys(label, query)) {
    const partial = widget.getByText(key, { exact: false }).first();
    if (await partial.isVisible().catch(() => false)) {
      return partial;
    }
  }

  return null;
}

/** Google Places 打开联想时默认高亮第 0 项；index 即所需 ArrowDown 次数 */
export function arrowDownCountForPacIndex(index: number): number {
  return Math.max(0, index);
}

async function selectSuggestionByBoundIndex(
  page: Page,
  input: Locator,
  index: number,
  options?: { alreadyHighlightedFirst?: boolean },
): Promise<void> {
  await input.focus().catch(() => input.click({ force: true }).catch(() => undefined));
  await page.waitForTimeout(100);

  const highlighted = options?.alreadyHighlightedFirst ?? true;
  const arrowDownCount = highlighted
    ? arrowDownCountForPacIndex(index)
    : index + 1;
  for (let i = 0; i < arrowDownCount; i += 1) {
    await page.keyboard.press("ArrowDown");
    await page.waitForTimeout(80);
  }
  await page.keyboard.press("Enter");
  await page.waitForTimeout(200);
}

async function clickPacItemAtIndex(page: Page, index: number): Promise<boolean> {
  const items = page.locator(".pac-container .pac-item");
  const count = await items.count().catch(() => 0);
  if (index < 0 || index >= count) {
    return false;
  }
  const item = items.nth(index);
  if (!(await item.isVisible().catch(() => false))) {
    return false;
  }
  const queryLine = item.locator(".pac-item-query").first();
  const target =
    (await queryLine.isVisible().catch(() => false)) ? queryLine : item;
  await clickLocatedSuggestionWithPointer(page, target);
  return true;
}

/** 在页面上下文派发 pac-item 完整鼠标事件（绕过 Playwright click 未触发 handler 的情况） */
async function dispatchPacItemSelectionEvents(
  page: Page,
  index: number,
): Promise<boolean> {
  return page.evaluate((idx) => {
    const items = document.querySelectorAll(".pac-container .pac-item");
    const item = items[idx] as HTMLElement | undefined;
    if (!item) {
      return false;
    }
    item.scrollIntoView({ block: "center" });
    const target = (item.querySelector(".pac-item-query") ??
      item) as HTMLElement;
    for (const type of ["mousedown", "mouseup", "click"] as const) {
      target.dispatchEvent(
        new MouseEvent(type, {
          bubbles: true,
          cancelable: true,
          view: window,
        }),
      );
    }
    return true;
  }, index);
}

async function commitSelectionViaKeyboardTab(
  page: Page,
  input: Locator,
  index: number,
): Promise<void> {
  await selectSuggestionByBoundIndex(page, input, index, {
    alreadyHighlightedFirst: true,
  });
  await page.keyboard.press("Tab");
  await page.waitForTimeout(250);
}

async function clickListboxOptionAtIndex(page: Page, index: number): Promise<boolean> {
  const roots = [
    page.locator('[role="listbox"] [role="option"]'),
    getQuoteWidgetLocator(page).locator('[role="listbox"] [role="option"]'),
  ];
  for (const root of roots) {
    const count = await root.count().catch(() => 0);
    if (index < 0 || index >= count) {
      continue;
    }
    const item = root.nth(index);
    if (!(await item.isVisible().catch(() => false))) {
      continue;
    }
    await item.scrollIntoViewIfNeeded().catch(() => undefined);
    await item.click({ timeout: 3_000 });
    return true;
  }
  return false;
}

async function selectSuggestionBySearchIndex(
  page: Page,
  input: Locator,
  index: number,
): Promise<void> {
  await input.click({ force: true }).catch(() => undefined);
  await page.waitForTimeout(150);
  for (let i = 0; i < arrowDownCountForPacIndex(index); i += 1) {
    await page.keyboard.press("ArrowDown");
    await page.waitForTimeout(120);
  }
  await page.keyboard.press("Enter");
  await page.waitForTimeout(200);
}

/** 按 axel search 返回的 description 点选（绑定 placeId，非纯 DOM label） */
async function clickSuggestionBySearchDescription(
  page: Page,
  description: string,
  query?: AddressLookupInput,
): Promise<boolean> {
  const probes = [
    description,
    stripCountrySuffix(description),
    description.split(",")[0]?.trim() ?? "",
    ...gluedVariants(description),
  ].filter((value, index, arr) => value.length >= 8 && arr.indexOf(value) === index);

  for (const probe of probes) {
    const located = await locateSuggestionByLabelText(page, probe);
    if (!located) {
      continue;
    }
    const score = scoreSuggestionLabelMatch(description, probe, query);
    if (score < 50) {
      continue;
    }
    await located.scrollIntoViewIfNeeded().catch(() => undefined);
    await located.hover({ force: true }).catch(() => undefined);
    await located.click({ force: true, timeout: 3_000 }).catch(() => undefined);
    return true;
  }
  return false;
}

async function clickLocatedSuggestionWithPointer(
  page: Page,
  located: Locator,
): Promise<void> {
  await located.scrollIntoViewIfNeeded().catch(() => undefined);
  const box = await located.boundingBox().catch(() => null);
  if (box) {
    const x = box.x + box.width / 2;
    const y = box.y + box.height / 2;
    await page.mouse.move(x, y);
    await page.mouse.down();
    await page.waitForTimeout(60);
    await page.mouse.up();
    await page.waitForTimeout(120);
    return;
  }
  await located.click({ force: true, timeout: 3_000 }).catch(() => undefined);
}

/** 按 description 文本 pointer 点选（优先于 index 键盘，避免 pac 顺序与 axel search 不一致） */
async function clickSuggestionByDescriptionPointer(
  page: Page,
  description: string,
  query?: AddressLookupInput,
): Promise<boolean> {
  const probes = [
    description,
    stripCountrySuffix(description),
    description.split(",")[0]?.trim() ?? "",
    ...gluedVariants(description),
  ].filter((value, index, arr) => value.length >= 8 && arr.indexOf(value) === index);

  for (const probe of probes) {
    const located = await locateSuggestionByLabelText(page, probe);
    if (!located) {
      continue;
    }
    const score = scoreSuggestionLabelMatch(description, probe, query);
    if (score < 50) {
      continue;
    }
    await clickLocatedSuggestionWithPointer(page, located);
    return true;
  }
  return false;
}

export async function ensureSuggestionDropdownOpen(
  page: Page,
  input: Locator,
  query: AddressLookupInput,
  fallbackText: string,
): Promise<void> {
  const resolved = resolveAddressAutocompleteInput(query, {
    mothershipLabel: fallbackText,
  });
  const probes = [
    fallbackText,
    stripCountrySuffix(fallbackText),
    `${resolved.street}, ${resolved.city}, ${resolved.state}`,
    `${resolved.street}, ${resolved.city}, ${resolved.state}, USA`,
  ].filter((value, index, arr) => value.length >= 8 && arr.indexOf(value) === index);

  await input.click({ force: true }).catch(() => undefined);
  await page.waitForTimeout(150);
  if (await waitForStyledSuggestionRows(page, probes, resolved, 1_500)) {
    return;
  }
  if (await waitForAddressSuggestions(page, resolved, 2_000)) {
    return;
  }
  const hint = `${resolved.street}, ${resolved.city}, ${resolved.state}`.trim();
  const currentValue = normalizeAddressInputValue(
    (await input.inputValue().catch(() => "")) || "",
  );
  if (
    addressInputMatchesQuery(currentValue, hint) ||
    addressInputMatchesQuery(currentValue, fallbackText)
  ) {
    await waitForStyledSuggestionRows(page, probes, resolved, 4_000);
    if (await waitForAddressSuggestions(page, resolved, 2_000)) {
      return;
    }
  }
  if (addressInputMatchesQuery(currentValue, hint)) {
    return;
  }
  await input.fill("").catch(() => undefined);
  await input.pressSequentially(hint, { delay: 45 }).catch(() => undefined);
  await waitForGooglePlacesPredictions(page, 8_000);
  await waitForStyledSuggestionRows(page, probes, resolved, 4_000);
}

const AXEL_PLACE_COMMIT_TIMEOUT_MS = 12_000;
const AXEL_PLACE_COMMIT_QUICK_MS = 5_000;

// #region agent log
function debugSelectLog(
  hypothesisId: string,
  location: string,
  message: string,
  data: Record<string, unknown>,
): void {
  fetch("http://127.0.0.1:7489/ingest/ff976922-7b71-4f91-ad84-5521d8ba1420", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Debug-Session-Id": "efb842",
    },
    body: JSON.stringify({
      sessionId: "efb842",
      hypothesisId,
      location,
      message,
      data,
      timestamp: Date.now(),
    }),
  }).catch(() => undefined);
}
// #endregion

/**
 * search → placeId 绑定 → 点选 → 等待 GET place/{id} 200
 * 禁止无 placeId 的 selection(label)。
 */
function widgetShowsQueryAddress(
  widgetText: string,
  query: AddressLookupInput,
): boolean {
  const w = widgetText.replace(/\s+/g, " ").toLowerCase();
  const num = query.street.match(/^\d+/)?.[0];
  if (num && !w.includes(num.toLowerCase())) {
    return false;
  }
  const state = query.state?.trim().toLowerCase();
  if (state && !w.includes(state)) {
    return false;
  }
  const city = query.city?.trim().toLowerCase();
  if (city && city.length >= 3 && !w.includes(city)) {
    return false;
  }
  return true;
}

async function readStreetInputValuesInWidget(
  page: Page,
  widgetSelector: string,
): Promise<string[]> {
  return page.evaluate(
    `(function(sel) {
      var widget = document.querySelector(sel);
      if (!widget) return [];
      var out = [];
      var inputs = widget.querySelectorAll("input");
      for (var i = 0; i < inputs.length; i++) {
        var ph = (inputs[i].placeholder || "").toLowerCase();
        if (!/search|搜索/.test(ph)) continue;
        var val = (inputs[i].value || "").replace(/\\s+/g, " ").trim();
        if (val) out.push(val);
      }
      return out;
    })(${JSON.stringify(widgetSelector)})`,
  ) as Promise<string[]>;
}

/** 提货 commit 后须释放独立派送框（单框仍含提货全文则未锁定） */
async function isDeliveryInputUnlocked(
  page: Page,
  widgetSelector: string,
  query: AddressLookupInput,
): Promise<boolean> {
  const values = await readStreetInputValuesInWidget(page, widgetSelector);
  if (values.length >= 2) {
    return true;
  }
  if (values.length === 1) {
    const only = values[0]!.replace(/\s+/g, " ").trim().toLowerCase();
    const streetNum = query.street.match(/^\d+/)?.[0]?.toLowerCase();
    if (streetNum && only.includes(streetNum) && only.length >= 8) {
      return false;
    }
    return only.length < 8;
  }
  return true;
}

export async function selectAddressWithPlaceBinding(
  page: Page,
  bridge: AxelSelectionBridge,
  selection: AxelSelectionPayload,
  query: AddressLookupInput,
  input: Locator,
  options?: {
    side?: "pickup" | "delivery";
    widgetSelector?: string;
    pickupAnchor?: AddressLookupInput;
    confirmedAddress?: QuoteRequest["pickup"];
    ctx?: RPAContext;
  },
): Promise<void> {
  if (!selection.placeId?.trim()) {
    throw new RpaError(
      "ADDRESS_NOT_CONFIRMED",
      "地址选择缺少 placeId，无法触发 MotherShip commit",
      { retryable: false },
    );
  }

  const index = bridge.getCandidateIndex(selection.placeId);
  if (index < 0) {
    throw new RpaError(
      "ADDRESS_SUGGESTION_NOT_FOUND",
      `search 绑定 placeId 不在候选列表：${selection.placeId}`,
      { retryable: false },
    );
  }

  const attemptPaths: string[] = [];

  await ensureSuggestionDropdownOpen(page, input, query, selection.description);

  const traceSide = options?.side ?? "rpa";
  const preCommit = await captureSelectionTrace(page, "pre-commit-attempts");
  logSelectionTrace(traceSide, preCommit);

  const normalizedPlaceId = selection.placeId;

  const validateWidgetCommit = async (path: string): Promise<boolean> => {
    if (!options?.widgetSelector) {
      return true;
    }
    if (options.side === "pickup" && options.confirmedAddress) {
      const locked = await isPickupReadyForDeliveryInput(
        page,
        options.widgetSelector,
        options.confirmedAddress,
      );
      if (!locked) {
        console.log(
          `[rpa] address-select: pickup widget 未锁定 path=${path}`,
        );
        return false;
      }
      return true;
    }
    const widgetText = await page
      .locator(options.widgetSelector)
      .innerText()
      .catch(() => "");
    if (!widgetShowsQueryAddress(widgetText, query)) {
      console.log(
        `[rpa] address-select: widget 未体现 ${options.side ?? "side"} 地址 path=${path}`,
      );
      return false;
    }
    if (options.side === "delivery" && options.pickupAnchor) {
      if (!widgetShowsQueryAddress(widgetText, options.pickupAnchor)) {
        console.log(
          `[rpa] address-select: 派送 commit 后提货从 widget 消失 path=${path}`,
        );
        return false;
      }
    }
    return true;
  };

  const tryCommit = async (path: string, quickMs = AXEL_PLACE_COMMIT_QUICK_MS) => {
    attemptPaths.push(path);
    if (!(await bridge.waitForPlaceCommit(normalizedPlaceId, quickMs))) {
      return false;
    }
    if (!(await validateWidgetCommit(path))) {
      return false;
    }
    await page.keyboard.press("Escape").catch(() => undefined);
    await page.keyboard.press("Tab").catch(() => undefined);
    await page.waitForTimeout(200);
    debugSelectLog(
      "H2",
      "address-suggestions.ts:selectAddressWithPlaceBinding",
      "commit-ok",
      { clickPath: attemptPaths.join(" → "), placeId: normalizedPlaceId },
    );
    return true;
  };

  const styledClick = await clickMothershipStyledSuggestion(
    page,
    selection.description,
    query,
    { input, candidateIndex: index },
  );
  if (styledClick.clicked && (await tryCommit("mothership-styled-click"))) {
    return;
  }
  if (styledClick.clicked) {
    console.log(
      `[rpa] mothership-styled-click: 已点选但未观测 place 请求 matched=${styledClick.matchedText?.slice(0, 48) ?? "—"}`,
    );
    await ensureSuggestionDropdownOpen(page, input, query, selection.description);
  }

  if (
    (await commitViaAxelPlacePrefetch(
      page,
      bridge,
      normalizedPlaceId,
      selection.description,
      input,
      { query, candidateIndex: index },
    ).then((r) => r.ok)) &&
    (await tryCommit("axel-place-prefetch"))
  ) {
    return;
  }

  const preKeyboard = await captureSelectionTrace(
    page,
    `pre-keyboard-bound-${index}`,
  );
  logSelectionTrace(traceSide, preKeyboard);
  const pacVisible = await page
    .locator(".pac-container .pac-item")
    .first()
    .isVisible()
    .catch(() => false);
  if (pacVisible) {
    await selectSuggestionByBoundIndex(page, input, index, {
      alreadyHighlightedFirst: true,
    });
    if (await tryCommit(`keyboard-bound-${index}`)) {
      return;
    }
  }
  const postKeyboard = await captureSelectionTrace(
    page,
    `post-keyboard-bound-${index}`,
  );
  logSelectionTrace(traceSide, postKeyboard);

  debugSelectLog("H2", "address-suggestions.ts:selectAddressWithPlaceBinding", "after-keyboard", {
    clickPath: attemptPaths.join(" → "),
    placeId: normalizedPlaceId,
    description: selection.description.slice(0, 80),
    candidateIndex: index,
  });

  if (
    (await clickListboxOptionAtIndex(page, index)) &&
    (await tryCommit(`listbox-${index}`))
  ) {
    return;
  }

  await ensureSuggestionDropdownOpen(page, input, query, selection.description);
  await commitSelectionViaKeyboardTab(page, input, index);
  if (await tryCommit(`keyboard-tab-${index}`)) {
    return;
  }

  await ensureSuggestionDropdownOpen(page, input, query, selection.description);
  await selectSuggestionBySearchIndex(page, input, index);
  if (await tryCommit(`keyboard-full-${index}`)) {
    return;
  }

  if (
    (await clickSuggestionByDescriptionPointer(
      page,
      selection.description,
      query,
    )) &&
    (await tryCommit("description-pointer"))
  ) {
    return;
  }

  if (
    (await clickSuggestionBySearchDescription(
      page,
      selection.description,
      query,
    )) &&
    (await tryCommit("description-click"))
  ) {
    return;
  }

  if (
    (await dispatchPacItemSelectionEvents(page, index)) &&
    (await tryCommit(`pac-dispatch-${index}`))
  ) {
    return;
  }

  if (
    (await clickPacItemAtIndex(page, index)) &&
    (await tryCommit(`pac-item-${index}`))
  ) {
    return;
  }

  await ensureSuggestionDropdownOpen(page, input, query, selection.description);
  if (
    (await clickSuggestionByDescriptionPointer(
      page,
      selection.description,
      query,
    )) &&
    (await tryCommit("description-pointer-retry"))
  ) {
    return;
  }

  const diag = bridge.getPlaceCommitDiagnostics(normalizedPlaceId);
  const reason = formatPlaceCommitFailure(
    normalizedPlaceId,
    attemptPaths,
    diag,
  );
  console.log(`[rpa] axel-place-gate: ${reason}`);
  debugSelectLog(
    "H2",
    "address-suggestions.ts:selectAddressWithPlaceBinding",
    "commit-failed",
    { clickPath: attemptPaths.join(" → "), diag, reason },
  );
  throw new RpaError("ADDRESS_NOT_CONFIRMED", reason, { retryable: true });
}

/** MotherShip styled-components 联想项：按评分点击单行 */
export async function clickSuggestionByLabel(
  page: Page,
  label: string,
  query?: AddressLookupInput,
): Promise<boolean> {
  const labels = query
    ? await collectAddressSuggestionLabels(page, query)
    : [label];
  let bestLabel = label;
  let bestScore = 0;
  for (const domLabel of labels) {
    const score = scoreSuggestionLabelMatch(label, domLabel, query);
    if (score > bestScore) {
      bestScore = score;
      bestLabel = domLabel;
    }
  }
  if (bestScore < 50) {
    return false;
  }

  const roots = [
    page.locator(".pac-container .pac-item"),
    page.locator('[role="listbox"] [role="option"]'),
    page.locator("div[class*='sc-']"),
  ];

  let target: Locator | null = null;
  let targetScore = 0;
  for (const root of roots) {
    const count = await root.count().catch(() => 0);
    for (let i = 0; i < count; i += 1) {
      const item = root.nth(i);
      const text = ((await item.innerText().catch(() => "")) || "")
        .replace(/\s+/g, " ")
        .trim();
      if (!text) {
        continue;
      }
      const box = await item.boundingBox().catch(() => null);
      if (!box || box.width < 200 || box.height < 24 || box.height > 80) {
        continue;
      }
      const score = scoreSuggestionLabelMatch(label, text, query);
      if (score > targetScore) {
        targetScore = score;
        target = item;
      }
    }
  }

  if (!target || targetScore < bestScore - 5) {
    return false;
  }

  await target.scrollIntoViewIfNeeded().catch(() => undefined);
  await target.hover({ force: true }).catch(() => undefined);
  await target.click({ force: true, timeout: 3_000 }).catch(() => undefined);
  return true;
}

/** 读取已填入/锁定的地址字段文本（排除联想下拉 innerText 污染） */
export async function getAddressConfirmationSurfaceText(
  page: Page,
  widgetSelector: string,
): Promise<string> {
  return page.evaluate(
    `(function(sel) {
      var widget = document.querySelector(sel);
      if (!widget) return "";
      var chunks = [];
      var inputs = widget.querySelectorAll("input");
      for (var i = 0; i < inputs.length; i++) {
        var val = (inputs[i].value || "").replace(/\\s+/g, " ").trim();
        if (val.length >= 4) chunks.push(val);
      }
      return chunks.join(" ");
    })(${JSON.stringify(widgetSelector)})`,
  ) as Promise<string>;
}

/** 地址联想下拉是否仍打开（勿用 getByText 判断，输入框回显会误判） */
export async function isAddressSuggestionDropdownOpen(
  page: Page,
): Promise<boolean> {
  const roots = [
    page.locator(".pac-container"),
    page.locator('[role="listbox"]'),
    getQuoteWidgetLocator(page).locator('[role="listbox"]'),
  ];

  for (const root of roots) {
    const count = await root.count().catch(() => 0);
    for (let i = 0; i < count; i += 1) {
      if (await root.nth(i).isVisible().catch(() => false)) {
        return true;
      }
    }
  }

  const styledOpen = (await page.evaluate(`
    (function() {
      var stateRe = /,\\s*(USA|US|CA|NY|TX|FL|WA|[A-Z]{2})\\b/;
      var nodes = document.querySelectorAll("div[class*='sc-']");
      for (var i = 0; i < nodes.length; i++) {
        var el = nodes[i];
        var text = (el.innerText || "").replace(/\\s+/g, " ").trim();
        if (text.length < 15 || !stateRe.test(text)) continue;
        var rect = el.getBoundingClientRect();
        if (
          rect.width > 300 &&
          rect.height >= 30 &&
          rect.height <= 70 &&
          el.offsetParent !== null
        ) {
          return true;
        }
      }
      return false;
    })()
  `)) as boolean;

  return styledOpen;
}

/** 地址输入框是否已写入确认地址（styled-components 下拉检测不可靠时的兜底） */
export async function isAddressInputCommitted(
  input: Locator,
  address: AddressLookupInput,
): Promise<boolean> {
  const value = ((await input.inputValue().catch(() => "")) || "")
    .replace(/\s+/g, " ")
    .trim()
    .toLowerCase();
  if (value.length < 8) {
    return false;
  }
  const streetNum = address.street.match(/^\d+/)?.[0];
  if (streetNum && !value.includes(streetNum)) {
    return false;
  }
  const city = address.city.trim().toLowerCase();
  if (city && !value.includes(city)) {
    const last = city.split(/\s+/).pop();
    if (!last || !value.includes(last)) {
      return false;
    }
  }
  const state = address.state.trim().toLowerCase();
  return !state || value.includes(state);
}

/** 点选后等待联想下拉收起 */
export async function waitForAddressSuggestionLocked(
  page: Page,
  timeoutMs = 3_000,
): Promise<boolean> {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    if (!(await isAddressSuggestionDropdownOpen(page))) {
      return true;
    }
    await page.waitForTimeout(100);
  }
  return false;
}