import type { Locator, Page } from "playwright";
import type { QuoteRequest } from "@/modules/providers/quote-provider";
import { pageLocator } from "@/lib/rpa/locator";
import { clickFirstVisibleFromSpecs } from "@/lib/rpa/selector-specs";
import { RpaError } from "@/modules/rpa/errors";
import type { RPAContext } from "@/workers/rpa/kernel/context";
import type { AxelSelectionBridge } from "@/workers/rpa/axel-selection-bridge";
import {
  getAddressConfirmationSurfaceText,
  isAddressInputCommitted,
  isAddressSuggestionDropdownOpen,
  waitForAddressSuggestionLocked,
} from "@/workers/rpa/address-suggestions";
import { visibleStreetInput } from "@/workers/rpa/address-side";

type AddressFields = QuoteRequest["pickup"];

const POLL_MS = 200;
const ADDRESS_SIDE_COMMIT_TIMEOUT_MS = 12_000;
const ADDRESS_INPUT_STABLE_MS = 2_000;

export type AddressCommitSnapshot = {
  side: "pickup" | "delivery";
  inputValues: string[];
  surfaceText: string;
  widgetTextPreview: string;
  dropdownOpen: boolean;
  axelLocationHit: boolean;
};

function toQueryHint(address: AddressFields) {
  return {
    street: address.street,
    city: address.city ?? "",
    state: address.state ?? "",
    zip: address.zip ?? "",
  };
}

function normalizeWidgetText(text: string): string {
  return text
    .replace(/\bavenue\b/gi, "ave")
    .replace(/\bboulevard\b/gi, "blvd")
    .replace(/\bstreet\b/gi, "st")
    .replace(/\s+/g, " ")
    .trim()
    .toLowerCase();
}

function hasWordToken(text: string, token: string): boolean {
  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  return new RegExp(`\\b${escaped}\\b`, "i").test(text);
}

/** widget 内是否体现用户确认的 MotherShip 地址（防 widget 回退） */
export function widgetContainsConfirmedAddress(
  widgetText: string,
  address: AddressFields,
): boolean {
  const label = address.mothershipDisplayLabel?.trim();
  if (!label) {
    return false;
  }
  const w = normalizeWidgetText(widgetText);
  const streetNum = address.street.match(/^(\d+)/)?.[1];
  const labelNorm = normalizeWidgetText(label);
  if (
    streetNum &&
    labelNorm.includes(streetNum.toLowerCase()) &&
    !w.includes(streetNum.toLowerCase())
  ) {
    return false;
  }
  const state = address.state?.trim();
  if (state && !w.includes(state.toLowerCase())) {
    return false;
  }
  const city = address.city?.trim().toLowerCase();
  if (city && city.length >= 3 && !w.includes(city)) {
    const cityParts = city.split(/\s+/).filter((part) => part.length >= 2);
    if (cityParts.length > 1) {
      const allPartsPresent = cityParts.every((part) =>
        hasWordToken(widgetText, part),
      );
      if (!allPartsPresent) {
        return false;
      }
    } else {
      const streetCore = normalizeWidgetText(address.street);
      if (!streetCore || !w.includes(streetCore)) {
        return false;
      }
    }
  }
  const labelTokens = label
    .replace(/([a-z])([A-Z])/g, "$1 $2")
    .split(/[,\s]+/)
    .map((t) => t.toLowerCase())
    .filter((t) => t.length > 3);
  const streetCore = normalizeWidgetText(address.street);
  if (
    streetCore &&
    !/\bbridge\b/.test(streetCore) &&
    /\bbridge\b/.test(w) &&
    w.includes(streetCore.split(/\s+/)[0] ?? "")
  ) {
    return false;
  }
  return labelTokens.some((t) => w.includes(t));
}


async function readCommittedInputSurface(
  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 >= 8) chunks.push(val);
      }
      return chunks.join(" ");
    })(${JSON.stringify(widgetSelector)})`,
  ) as Promise<string>;
}

async function readStreetInputValues(
  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[]>;
}

export async function readWidgetCombinedText(
  page: Page,
  widgetSelector: string,
): Promise<string> {
  const surfaceText = await getAddressConfirmationSurfaceText(
    page,
    widgetSelector,
  );
  const fullText = await pageLocator(page, widgetSelector)
    .innerText()
    .catch(() => "");
  return [surfaceText, fullText]
    .map((part) => part.replace(/\s+/g, " ").trim())
    .filter(Boolean)
    .join(" ");
}

export async function captureAddressCommitSnapshot(
  ctx: RPAContext,
  side: "pickup" | "delivery",
  widgetSelector: string,
  axelLocationHit = false,
): Promise<AddressCommitSnapshot> {
  const widgetText = await readWidgetCombinedText(ctx.page, widgetSelector);
  return {
    side,
    inputValues: await readStreetInputValues(ctx.page, widgetSelector),
    surfaceText: await getAddressConfirmationSurfaceText(
      ctx.page,
      widgetSelector,
    ),
    widgetTextPreview: widgetText.slice(0, 220),
    dropdownOpen: await isAddressSuggestionDropdownOpen(ctx.page),
    axelLocationHit,
  };
}

export function logAddressCommitSnapshot(
  phase: string,
  snapshot: AddressCommitSnapshot,
): void {
  console.log(
    `[rpa] address-commit:${phase} side=${snapshot.side} inputs=${JSON.stringify(snapshot.inputValues)} dropdown=${snapshot.dropdownOpen} axelLocation=${snapshot.axelLocationHit} widget=${snapshot.widgetTextPreview}`,
  );
}

export async function dismissAddressSuggestionDropdown(
  page: Page,
  streetInput?: Locator | null,
): Promise<boolean> {
  const deadline = Date.now() + 4_000;
  while (Date.now() < deadline) {
    if (!(await isAddressSuggestionDropdownOpen(page))) {
      return true;
    }
    if (streetInput) {
      await streetInput.press("Enter").catch(() => undefined);
    }
    await page.keyboard.press("Escape").catch(() => undefined);
    await page.keyboard.press("Tab").catch(() => undefined);
    await page.waitForTimeout(POLL_MS);
  }
  return !(await isAddressSuggestionDropdownOpen(page));
}

/** 强制收起联想（仅键盘，避免误点 Use my location / 重置 widget） */
export async function forceDismissAddressSuggestionDropdown(
  page: Page,
  _widgetSelector: string,
): Promise<void> {
  for (let i = 0; i < 8; i += 1) {
    if (!(await isAddressSuggestionDropdownOpen(page))) {
      return;
    }
    await page.keyboard.press("Escape").catch(() => undefined);
    await page.waitForTimeout(POLL_MS);
  }
  for (let i = 0; i < 3; i += 1) {
    await page.keyboard.press("Tab").catch(() => undefined);
    await page.waitForTimeout(POLL_MS);
    if (!(await isAddressSuggestionDropdownOpen(page))) {
      return;
    }
  }
}

async function readAddressSurfaceForCommit(
  page: Page,
  widgetSelector: string,
  dropdownOpen: boolean,
): Promise<string> {
  const surfaceText = await getAddressConfirmationSurfaceText(
    page,
    widgetSelector,
  );
  if (dropdownOpen) {
    return surfaceText;
  }
  return readWidgetCombinedText(page, widgetSelector);
}

async function waitForInputSurfaceStable(
  page: Page,
  widgetSelector: string,
  address: AddressFields,
  stableMs: number,
  timeoutMs: number,
): Promise<boolean> {
  const deadline = Date.now() + timeoutMs;
  let lastSurface = "";
  let stableSince = 0;

  while (Date.now() < deadline) {
    const surface = await getAddressConfirmationSurfaceText(page, widgetSelector);
    const now = Date.now();
    if (widgetContainsConfirmedAddress(surface, address)) {
      if (surface === lastSurface) {
        if (stableSince === 0) {
          stableSince = now;
        }
        if (now - stableSince >= stableMs) {
          return true;
        }
      } else {
        lastSurface = surface;
        stableSince = now;
      }
    } else {
      lastSurface = "";
      stableSince = 0;
    }
    await page.waitForTimeout(POLL_MS);
  }

  return false;
}

async function waitForInputValueStable(
  input: Locator,
  address: AddressFields,
  stableMs: number,
  timeoutMs: number,
): Promise<boolean> {
  const queryHint = toQueryHint(address);
  const deadline = Date.now() + timeoutMs;
  let lastValue = "";
  let stableSince = 0;

  while (Date.now() < deadline) {
    const value = ((await input.inputValue().catch(() => "")) || "")
      .replace(/\s+/g, " ")
      .trim();
    const committed = await isAddressInputCommitted(input, queryHint);
    const now = Date.now();

    if (value.length >= 8 && committed && value === lastValue) {
      if (stableSince === 0) {
        stableSince = now;
      }
      if (now - stableSince >= stableMs) {
        return true;
      }
    } else {
      lastValue = value;
      stableSince = committed && value.length >= 8 ? now : 0;
    }

    await input.page().waitForTimeout(POLL_MS);
  }

  return false;
}

/** 收起当前地址编辑焦点，避免双地址 focus 竞争 */
export async function blurAddressEditing(
  ctx: RPAContext,
  widgetSelector: string,
): Promise<void> {
  const page = ctx.page;
  await page.keyboard.press("Escape").catch(() => undefined);
  await page.keyboard.press("Tab").catch(() => undefined);

  const deadline = Date.now() + 3_000;
  while (Date.now() < deadline) {
    if (!(await isAddressSuggestionDropdownOpen(page))) {
      return;
    }
    await page.keyboard.press("Escape").catch(() => undefined);
    await page.waitForTimeout(POLL_MS);
  }
}

/** pickup 提交后、打开 delivery 前：锁定提货侧，防止 React 未 commit 即切换 */
export async function settlePickupBeforeDelivery(
  ctx: RPAContext,
  widgetSelector: string,
  pickup: AddressFields,
): Promise<void> {
  await blurAddressEditing(ctx, widgetSelector);
  await dismissAddressSuggestionDropdown(ctx.page);
  await forceDismissAddressSuggestionDropdown(ctx.page, widgetSelector);
  await ctx.page.keyboard.press("Tab").catch(() => undefined);
  await ctx.page.waitForTimeout(POLL_MS);

  const deadline = Date.now() + ADDRESS_SIDE_COMMIT_TIMEOUT_MS;
  while (Date.now() < deadline) {
    if (await isAddressPresentInWidget(ctx.page, widgetSelector, pickup)) {
      break;
    }
    await ctx.page.waitForTimeout(POLL_MS);
  }
  if (!(await isAddressPresentInWidget(ctx.page, widgetSelector, pickup))) {
    throw new RpaError(
      "ADDRESS_NOT_CONFIRMED",
      `提货地址未写入 widget：${pickup.mothershipDisplayLabel}`,
      { retryable: true },
    );
  }

  while (Date.now() < deadline) {
    if (await isPickupReadyForDeliveryInput(ctx.page, widgetSelector, pickup)) {
      break;
    }
    await releasePickupFieldForDelivery(ctx, widgetSelector, pickup);
    await ctx.page.waitForTimeout(POLL_MS);
  }

  const snapshot = await captureAddressCommitSnapshot(
    ctx,
    "pickup",
    widgetSelector,
  );
  logAddressCommitSnapshot("pickup-settled", snapshot);

  if (!(await isPickupReadyForDeliveryInput(ctx.page, widgetSelector, pickup))) {
    const diag = await captureAddressCommitSnapshot(ctx, "pickup", widgetSelector);
    console.log("[rpa] pickup-commit-diagnostic", {
      phase: "settlePickupBeforeDelivery",
      placeId: pickup.placeId,
      mothershipDisplayLabel: pickup.mothershipDisplayLabel,
      commitState: "widget_not_locked",
      placeRequestObserved: diag.axelLocationHit,
      inputValues: diag.inputValues,
      dropdownOpen: diag.dropdownOpen,
    });
    throw new RpaError(
      "ADDRESS_NOT_CONFIRMED",
      `提货地址未锁定，无法打开派送侧（${pickup.mothershipDisplayLabel}）`,
      { retryable: true },
    );
  }
}

/** 等待单侧地址被 MotherShip widget 接受（须 place/{id} 200，禁止仅以 input.value 判定） */
export async function waitForAddressSideCommit(
  ctx: RPAContext,
  side: "pickup" | "delivery",
  address: AddressFields,
  widgetSelector: string,
  streetInput?: Locator | null,
  placeCommit?: { bridge: AxelSelectionBridge; placeId: string },
): Promise<void> {
  const page = ctx.page;
  const placeId = placeCommit?.placeId?.trim();
  const bridge = placeCommit?.bridge;

  if (placeId && bridge) {
    if (bridge.hasPlaceCommit(placeId)) {
      const snapshot = await captureAddressCommitSnapshot(
        ctx,
        side,
        widgetSelector,
        true,
      );
      logAddressCommitSnapshot(`${side}-committed`, snapshot);
      return;
    }

    const committed = await bridge.waitForPlaceCommit(
      placeId,
      ADDRESS_SIDE_COMMIT_TIMEOUT_MS,
    );
    if (committed) {
      const snapshot = await captureAddressCommitSnapshot(
        ctx,
        side,
        widgetSelector,
        true,
      );
      logAddressCommitSnapshot(`${side}-committed`, snapshot);
      return;
    }

    const snapshot = await captureAddressCommitSnapshot(
      ctx,
      side,
      widgetSelector,
      false,
    );
    logAddressCommitSnapshot(`${side}-commit-failed`, snapshot);
    throw new RpaError(
      "ADDRESS_NOT_CONFIRMED",
      `${side === "pickup" ? "提货" : "派送"}地址 place/${placeId} 未 commit（网络证据缺失）`,
      { retryable: true },
    );
  }

  const queryHint = toQueryHint(address);
  const deadline = Date.now() + ADDRESS_SIDE_COMMIT_TIMEOUT_MS;
  let consecutiveSurfaceMatches = 0;

  while (Date.now() < deadline) {
    const dropdownOpen = await isAddressSuggestionDropdownOpen(page);
    if (dropdownOpen) {
      await dismissAddressSuggestionDropdown(page, streetInput ?? undefined);
    }

    const surface = await readCommittedInputSurface(page, widgetSelector);
    const surfaceOk = widgetContainsConfirmedAddress(surface, address);

    if (surfaceOk) {
      consecutiveSurfaceMatches += 1;
      if (consecutiveSurfaceMatches * POLL_MS >= ADDRESS_INPUT_STABLE_MS) {
        const snapshot = await captureAddressCommitSnapshot(
          ctx,
          side,
          widgetSelector,
          false,
        );
        logAddressCommitSnapshot(`${side}-committed`, snapshot);
        return;
      }
    } else {
      consecutiveSurfaceMatches = 0;
    }

    if (!surfaceOk && !dropdownOpen) {
      const widgetText = await readWidgetCombinedText(page, widgetSelector);
      if (widgetContainsConfirmedAddress(widgetText, address)) {
        const snapshot = await captureAddressCommitSnapshot(
          ctx,
          side,
          widgetSelector,
          false,
        );
        logAddressCommitSnapshot(`${side}-committed`, snapshot);
        return;
      }
    }

    if (streetInput) {
      const inputVisible = await streetInput.isVisible().catch(() => false);
      const inputEditable = await streetInput.isEditable().catch(() => false);
      if (inputVisible && inputEditable && (await isAddressInputCommitted(streetInput, queryHint))) {
        const snapshot = await captureAddressCommitSnapshot(
          ctx,
          side,
          widgetSelector,
          false,
        );
        logAddressCommitSnapshot(`${side}-committed`, snapshot);
        return;
      }
    }

    await page.waitForTimeout(POLL_MS);
  }

  const snapshot = await captureAddressCommitSnapshot(
    ctx,
    side,
    widgetSelector,
    false,
  );
  logAddressCommitSnapshot(`${side}-commit-failed`, snapshot);
  throw new RpaError(
    "ADDRESS_NOT_CONFIRMED",
    `${side === "pickup" ? "提货" : "派送"}地址未提交到 widget（${snapshot.widgetTextPreview.slice(0, 100)}）`,
    { retryable: true },
  );
}

/** 双地址快照校验；delivery 为 null 时仅校验 pickup 已锁定（非仅 input 文本回显） */
export async function assertDualAddressStable(
  ctx: RPAContext,
  widgetSelector: string,
  pickup: AddressFields,
  delivery: AddressFields | null,
): Promise<void> {
  const page = ctx.page;
  const deadline = Date.now() + ADDRESS_SIDE_COMMIT_TIMEOUT_MS;
  let lastPickupOk = false;
  let lastDeliveryOk = delivery === null;

  while (Date.now() < deadline) {
    if (delivery === null) {
      lastPickupOk = await isPickupReadyForDeliveryInput(
        page,
        widgetSelector,
        pickup,
      );
    } else {
      const surface = await readCommittedInputSurface(page, widgetSelector);
      const full = await readWidgetCombinedText(page, widgetSelector);
      const combined = `${surface} ${full}`;
      lastPickupOk =
        widgetContainsConfirmedAddress(surface, pickup) ||
        widgetContainsConfirmedAddress(full, pickup) ||
        widgetContainsConfirmedAddress(combined, pickup);
      lastDeliveryOk =
        widgetContainsConfirmedAddress(surface, delivery) ||
        widgetContainsConfirmedAddress(full, delivery) ||
        widgetContainsConfirmedAddress(combined, delivery);
    }

    if (lastPickupOk && lastDeliveryOk) {
      const snapshot = await captureAddressCommitSnapshot(
        ctx,
        "pickup",
        widgetSelector,
      );
      logAddressCommitSnapshot("dual-stable", {
        ...snapshot,
        side: "pickup",
        widgetTextPreview: snapshot.widgetTextPreview.slice(0, 220),
      });
      return;
    }

    if (delivery && lastPickupOk === false) {
      await blurAddressEditing(ctx, widgetSelector);
      const pickupSections = ctx.selectors.specs("RPA_SELECTOR_PICKUP_SECTION");
      if (pickupSections.length > 0) {
        await clickFirstVisibleFromSpecs(page, pickupSections).catch(
          () => undefined,
        );
      }
    }

    await page.waitForTimeout(POLL_MS);
  }

  const widgetText = await readWidgetCombinedText(page, widgetSelector);
  if (!lastPickupOk) {
    throw new RpaError(
      "ADDRESS_NOT_CONFIRMED",
      `双地址校验失败：提货地址已从 widget 消失（${pickup.mothershipDisplayLabel}）preview=${widgetText.slice(0, 120)}`,
      { retryable: true },
    );
  }
  if (delivery && !lastDeliveryOk) {
    throw new RpaError(
      "ADDRESS_NOT_CONFIRMED",
      `双地址校验失败：派送地址未锁定（${delivery.mothershipDisplayLabel}）preview=${widgetText.slice(0, 120)}`,
      { retryable: true },
    );
  }
}

export async function isAddressPresentInWidget(
  page: Page,
  widgetSelector: string,
  address: AddressFields,
): Promise<boolean> {
  const surface = await readCommittedInputSurface(page, widgetSelector);
  const full = await readWidgetCombinedText(page, widgetSelector);
  return widgetContainsConfirmedAddress(`${surface} ${full}`, address);
}

/** 纯函数：widget 文案是否已体现双地址（截图态：两州码 / 两门牌 / Freight details 旁双址） */
export function evaluateAddressesVisuallyComplete(widgetText: string): boolean {
  const normalized = widgetText.replace(/\s+/g, " ").trim();
  if (!normalized) {
    return false;
  }
  const stateCount = (normalized.match(/,\s*[A-Z]{2}\b/g) ?? []).length;
  const streetMarkers = normalized.match(/\d{3,5}\s+\S+/g) ?? [];
  const hasFreightChip = /freight details|货运详情/i.test(normalized);
  if (stateCount >= 2) {
    return true;
  }
  if (streetMarkers.length >= 2) {
    return true;
  }
  if (hasFreightChip && (stateCount >= 1 || streetMarkers.length >= 1)) {
    const hasDeliverTo = /deliver to|送货至/i.test(normalized);
    if (hasDeliverTo || stateCount >= 1) {
      return true;
    }
  }
  return false;
}

/**
 * 视觉优先：双地址已在 widget/地图体现即可进入货物步（不等 place 网络 / 下拉收起）。
 */
export async function isAddressesVisuallyCompleteForCargo(
  page: Page,
  widgetSelector: string,
  pickup?: AddressFields,
  delivery?: AddressFields,
): Promise<boolean> {
  const widgetText = await readWidgetCombinedText(page, widgetSelector).catch(
    () => "",
  );
  const surface = await readCommittedInputSurface(page, widgetSelector).catch(
    () => "",
  );
  const combined = `${surface} ${widgetText}`.replace(/\s+/g, " ").trim();

  if (pickup && delivery) {
    const pickupOk = widgetContainsConfirmedAddress(combined, pickup);
    const deliveryOk = widgetContainsConfirmedAddress(combined, delivery);
    if (pickupOk && deliveryOk) {
      return true;
    }
  }

  if (evaluateAddressesVisuallyComplete(combined)) {
    return true;
  }

  return page.evaluate(() => {
    const body = (document.body.innerText || "").replace(/\s+/g, " ");
    const stateHits = body.match(/,\s*[A-Z]{2}\b/g) ?? [];
    if (stateHits.length < 2) {
      return false;
    }
    const hasMap =
      document.querySelector("canvas") !== null ||
      document.querySelector("svg") !== null ||
      document.querySelector('[class*="map" i]') !== null;
    return hasMap;
  });
}

async function hasEmptyEditableStreetInput(
  page: Page,
  widgetSelector: string,
): Promise<boolean> {
  return page.evaluate(
    `(function(sel) {
      var widget = document.querySelector(sel);
      if (!widget) return false;
      var inputs = widget.querySelectorAll("input");
      for (var i = 0; i < inputs.length; i++) {
        var ph = (inputs[i].placeholder || "").toLowerCase();
        if (!/search|搜索/.test(ph)) continue;
        if (inputs[i].offsetParent === null) continue;
        var val = (inputs[i].value || "").replace(/\\s+/g, " ").trim();
        var editable =
          !inputs[i].disabled &&
          inputs[i].readOnly === false &&
          inputs[i].getAttribute("aria-readonly") !== "true";
        if (editable && val.length < 8) return true;
      }
      return false;
    })(${JSON.stringify(widgetSelector)})`,
  ) as Promise<boolean>;
}

/** 提货已写入 widget 且派送侧可独立输入（非同一搜索框覆盖） */
export async function isPickupReadyForDeliveryInput(
  page: Page,
  widgetSelector: string,
  pickup: AddressFields,
): Promise<boolean> {
  await forceDismissAddressSuggestionDropdown(page, widgetSelector);

  const values = await readStreetInputValues(page, widgetSelector);
  const surface = await readCommittedInputSurface(page, widgetSelector);
  const full = await readWidgetCombinedText(page, widgetSelector);
  const combined = `${surface} ${full}`;

  if (!widgetContainsConfirmedAddress(combined, pickup)) {
    return false;
  }

  if (values.length >= 2) {
    return true;
  }
  if (await hasEmptyEditableStreetInput(page, widgetSelector)) {
    return true;
  }
  if (values.length === 1) {
    const only = values[0]!.replace(/\s+/g, " ").trim().toLowerCase();
    const streetNum = pickup.street.match(/^\d+/)?.[0]?.toLowerCase();
    if (streetNum && only.includes(streetNum) && only.length >= 8) {
      return false;
    }
    if (only.length >= 8) {
      const deliverVisible = await pageLocator(page, widgetSelector)
        .getByText(/^Deliver to$/i)
        .first()
        .isVisible()
        .catch(() => false);
      if (deliverVisible && widgetContainsConfirmedAddress(combined, pickup)) {
        return true;
      }
      return false;
    }
    return only.length < 8;
  }

  // chip 态：inputs 为空但 widget 已含提货且派送框可编辑
  return values.length === 0 && (await hasEmptyEditableStreetInput(page, widgetSelector));
}

/** 提货点选后：Enter/Tab 收起联想，再点「Deliver to」释放派送框 */
export async function lockPickupIntoChip(
  ctx: RPAContext,
  widgetSelector: string,
  streetInput?: Locator | null,
): Promise<void> {
  const page = ctx.page;
  const widget = pageLocator(page, widgetSelector);

  await dismissAddressSuggestionDropdown(page);
  if (streetInput) {
    await streetInput.press("Enter").catch(() => undefined);
    await page.waitForTimeout(250);
  }
  await page.keyboard.press("Tab").catch(() => undefined);
  await page.waitForTimeout(200);
  await forceDismissAddressSuggestionDropdown(page, widgetSelector);

  const deliverTo = widget.getByText(/^Deliver to$/i).first();
  if (await deliverTo.isVisible().catch(() => false)) {
    await deliverTo.click({ force: true, timeout: 3_000 }).catch(() => undefined);
  } else {
    await clickFirstVisibleFromSpecs(
      page,
      ctx.selectors.specs("RPA_SELECTOR_DELIVERY_SECTION"),
    ).catch(() => undefined);
  }
  await page.waitForTimeout(400);
  await dismissAddressSuggestionDropdown(page);
}

/** 点选提货后：收起下拉并打开派送侧，释放独立搜索框 */
export async function releasePickupFieldForDelivery(
  ctx: RPAContext,
  widgetSelector: string,
  pickup: AddressFields,
  streetInput?: Locator | null,
): Promise<boolean> {
  const page = ctx.page;

  if (await isPickupReadyForDeliveryInput(page, widgetSelector, pickup)) {
    return true;
  }

  const pickupInput =
    streetInput ?? (await visibleStreetInput(ctx, "pickup"));
  await lockPickupIntoChip(ctx, widgetSelector, pickupInput ?? undefined);
  return isPickupReadyForDeliveryInput(page, widgetSelector, pickup);
}

/** delivery 提交后若 pickup 被覆盖：交替 refill 直到双地址均出现在 widget */
export async function ensureDualAddressCommitted(
  ctx: RPAContext,
  widgetSelector: string,
  pickup: AddressFields,
  delivery: AddressFields,
  refillSide: (
    side: "pickup" | "delivery",
    address: AddressFields,
  ) => Promise<void>,
): Promise<void> {
  const page = ctx.page;
  const MAX_REFILL_ROUNDS = 6;

  for (let round = 0; round < MAX_REFILL_ROUNDS; round += 1) {
    await dismissAddressSuggestionDropdown(page);
    await blurAddressEditing(ctx, widgetSelector);

    const pickupOk = await isAddressPresentInWidget(
      page,
      widgetSelector,
      pickup,
    );
    const deliveryOk = await isAddressPresentInWidget(
      page,
      widgetSelector,
      delivery,
    );

    if (pickupOk && deliveryOk) {
      break;
    }

    if (!pickupOk) {
      console.log(
        `[rpa] address-commit:pickup-missing refill round=${round + 1}`,
      );
      await refillSide("pickup", pickup);
      continue;
    }
    if (!deliveryOk) {
      console.log(
        `[rpa] address-commit:delivery-missing refill round=${round + 1}`,
      );
      await refillSide("delivery", delivery);
      continue;
    }
  }

  await assertDualAddressStable(ctx, widgetSelector, pickup, delivery);
}

export async function waitForPickupCommit(
  ctx: RPAContext,
  pickup: AddressFields,
  widgetSelector: string,
  streetInput?: Locator | null,
): Promise<void> {
  await waitForAddressSideCommit(
    ctx,
    "pickup",
    pickup,
    widgetSelector,
    streetInput,
  );
}