tracker.ts

import { randomUUID } from "node:crypto";
import type { ChildProcess } from "node:child_process";
import { spawn } from "node:child_process";
import { ROOT_DIR_PATH } from "./paths.js";
import { notifyAccessIssue } from "./notifier.js";
import { AccessIssueError, RegionMismatchError, scrapeRegion, scrapeSingleProduct } from "./supremeScraper.js";
import { StateStore } from "./store.js";
import type { AppState, ChangeEvent, LogEntry, ProductSnapshot, RegionConfig, TrackedProduct } from "./types.js";

interface QueueTask {
  key: string;
  priority: number;
  order: number;
  run: () => Promise<void>;
}

const ACCESS_ISSUE_RETRY_MINUTES = 180;
const ACCESS_ISSUE_NOTIFY_COOLDOWN_MS = 45 * 60 * 1000;
const MAX_LOGS = 200;
const REGION_SCAN_PRIORITY = 2;
const PRODUCT_SCAN_PRIORITY = 1;

function plusMinutes(isoString: string, minutes: number): string {
  const date = new Date(isoString);
  date.setMinutes(date.getMinutes() + minutes);
  return date.toISOString();
}

function availabilitySignature(snapshot: ProductSnapshot): string {
  return snapshot.colors
    .map((color) => `${color.color}:${color.availableSizes.join("|")}`)
    .sort()
    .join("||");
}

function colorSignature(snapshot: ProductSnapshot): string {
  return snapshot.colors
    .map((color) => color.color)
    .sort()
    .join("|");
}

function hasAvailability(snapshot: ProductSnapshot): boolean {
  return snapshot.colors.some((color) => color.availableSizes.length > 0);
}

function productLabel(snapshot: ProductSnapshot): string {
  const colors = snapshot.colors.map((entry) => entry.color).join(", ");
  return colors ? `${snapshot.title} (${colors})` : snapshot.title;
}

function normalizedProductKey(title: string, category: string | null | undefined): string {
  const normalizedTitle = title.trim().replace(/\s+/g, " ").toLowerCase();
  const normalizedCategory = (category ?? "").trim().replace(/\s+/g, " ").toLowerCase();
  return `${normalizedTitle}::${normalizedCategory}`;
}

function findExistingProduct(state: AppState, snapshot: ProductSnapshot): TrackedProduct | null {
  const byHandle = state.products[snapshot.handle];
  if (byHandle) {
    return byHandle;
  }

  const targetKey = normalizedProductKey(snapshot.title, snapshot.category);
  return (
    Object.values(state.products).find((product) => normalizedProductKey(product.title, product.category) === targetKey) ??
    null
  );
}

function findProductByRegionHandle(state: AppState, regionId: string, handle: string): TrackedProduct | null {
  const direct = state.products[handle];
  if (direct) {
    return direct;
  }

  return (
    Object.values(state.products).find((product) => product.regions[regionId]?.handle === handle) ??
    null
  );
}

function availabilityMap(snapshot: ProductSnapshot): Map<string, Set<string>> {
  return new Map(
    snapshot.colors.map((color) => [
      color.color,
      new Set(color.availableSizes)
    ])
  );
}

function diffAvailability(previous: ProductSnapshot, current: ProductSnapshot): NonNullable<ChangeEvent["delta"]> {
  const previousMap = availabilityMap(previous);
  const currentMap = availabilityMap(current);
  const colors = new Set([...previousMap.keys(), ...currentMap.keys()]);
  const delta: NonNullable<ChangeEvent["delta"]> = [];

  for (const color of [...colors].sort((left, right) => left.localeCompare(right))) {
    const previousSizes = previousMap.get(color) ?? new Set<string>();
    const currentSizes = currentMap.get(color) ?? new Set<string>();
    const addedSizes = [...currentSizes].filter((size) => !previousSizes.has(size)).sort();
    const removedSizes = [...previousSizes].filter((size) => !currentSizes.has(size)).sort();
    const availableNow = [...currentSizes].sort();
    const colorAdded = !previousMap.has(color) && currentMap.has(color);
    const colorRemoved = previousMap.has(color) && !currentMap.has(color);
    const touchesLiveStock = previousSizes.size > 0 || currentSizes.size > 0;

    if (!addedSizes.length && !removedSizes.length && !colorAdded && !colorRemoved) {
      continue;
    }

    if (!touchesLiveStock && (colorAdded || colorRemoved)) {
      continue;
    }

    delta.push({
      color,
      availableNow,
      addedSizes,
      removedSizes,
      colorAdded,
      colorRemoved
    });
  }

  return delta;
}

function withFeedListingState(
  snapshot: ProductSnapshot,
  previousSnapshot?: ProductSnapshot | null,
  listedInFeed?: boolean
): ProductSnapshot {
  const next: ProductSnapshot = {
    ...snapshot,
    listedInFeed: listedInFeed ?? previousSnapshot?.listedInFeed ?? true,
    lastSeenInFeedAt: previousSnapshot?.lastSeenInFeedAt ?? snapshot.lastSeenInFeedAt ?? snapshot.scannedAt,
    lastMissingFromFeedAt: previousSnapshot?.lastMissingFromFeedAt ?? snapshot.lastMissingFromFeedAt ?? null
  };

  if (listedInFeed === true) {
    next.listedInFeed = true;
    next.lastSeenInFeedAt = snapshot.scannedAt;
  } else if (listedInFeed === false) {
    next.listedInFeed = false;
    next.lastMissingFromFeedAt = snapshot.scannedAt;
  }

  return next;
}

function markProductCheck(
  product: TrackedProduct,
  checkedAt: string,
  status: "ok" | "error",
  error: string | null = null
): void {
  product.lastCheckAt = checkedAt;
  product.lastCheckStatus = status;
  product.lastCheckError = error;
}

function makeChange(
  regionId: string,
  snapshot: ProductSnapshot,
  type: ChangeEvent["type"],
  summary: string,
  delta?: ChangeEvent["delta"]
): ChangeEvent {
  return {
    id: randomUUID(),
    at: snapshot.scannedAt,
    regionId,
    handle: snapshot.handle,
    title: snapshot.title,
    type,
    summary,
    snapshotAtEvent: {
      imageUrl: snapshot.colors.find((color) => color.imageUrl)?.imageUrl ?? snapshot.imageUrl ?? null,
      colors: snapshot.colors.map((color) => ({
        color: color.color,
        imageUrl: color.imageUrl ?? snapshot.imageUrl ?? null,
        availableSizes: [...color.availableSizes]
      }))
    },
    delta
  };
}

function appendLog(
  state: { logs: LogEntry[] },
  entry: Omit<LogEntry, "id" | "at"> & { at?: string }
): void {
  state.logs.unshift({
    id: randomUUID(),
    at: entry.at ?? new Date().toISOString(),
    ...entry
  });
  state.logs = state.logs.slice(0, MAX_LOGS);
}

function applySnapshotToState(
  state: AppState,
  regionId: string,
  snapshot: ProductSnapshot,
  options: { listedInFeed?: boolean } = {}
): ChangeEvent[] {
  const existing = findExistingProduct(state, snapshot);
  const changeEvents: ChangeEvent[] = [];
  const previousSnapshot = existing?.regions[regionId] ?? null;
  const nextSnapshot = withFeedListingState(snapshot, previousSnapshot, options.listedInFeed);

  if (!existing) {
    state.products[nextSnapshot.handle] = {
      handle: nextSnapshot.handle,
      title: nextSnapshot.title,
      category: nextSnapshot.category,
      firstSeenAt: nextSnapshot.scannedAt,
      lastSeenAt: nextSnapshot.scannedAt,
      lastChangedAt: nextSnapshot.scannedAt,
      lastCheckAt: nextSnapshot.scannedAt,
      lastCheckStatus: "ok",
      lastCheckError: null,
      regions: {
        [regionId]: nextSnapshot
      },
      tracking: {
        enabled: true,
        intervalMinutes: null
      },
      archived: false
    };

    changeEvents.push(
      makeChange(regionId, nextSnapshot, "discovered", `New item discovered: ${productLabel(nextSnapshot)}`)
    );
  } else {
    existing.title = nextSnapshot.title;
    existing.category = nextSnapshot.category;
    existing.lastSeenAt = nextSnapshot.scannedAt;
    markProductCheck(existing, nextSnapshot.scannedAt, "ok");
    existing.regions[regionId] = nextSnapshot;

    if (!previousSnapshot) {
      changeEvents.push(
        makeChange(
          regionId,
          nextSnapshot,
          "discovered",
          `Added to ${regionId.toUpperCase()} New: ${productLabel(nextSnapshot)}`
        )
      );
    } else {
      const previousHasStock = hasAvailability(previousSnapshot);
      const currentHasStock = hasAvailability(nextSnapshot);
      const delta = diffAvailability(previousSnapshot, nextSnapshot);
      const hasSizeDelta = delta.some((entry) => entry.addedSizes.length > 0 || entry.removedSizes.length > 0);
      const hasColorDelta = delta.some((entry) => entry.colorAdded || entry.colorRemoved);

      if (!previousHasStock && currentHasStock) {
        changeEvents.push(
          makeChange(regionId, nextSnapshot, "restocked", `Restock detected: ${productLabel(nextSnapshot)}`, delta)
        );
      } else if (previousHasStock && !currentHasStock) {
        changeEvents.push(
          makeChange(regionId, nextSnapshot, "sold_out", `Sold out: ${productLabel(nextSnapshot)}`, delta)
        );
      } else if (hasSizeDelta) {
        changeEvents.push(
          makeChange(
            regionId,
            nextSnapshot,
            "sizes_changed",
            `Available sizes changed for ${productLabel(nextSnapshot)}`,
            delta
          )
        );
      }

      if (hasColorDelta) {
        changeEvents.push(
          makeChange(
            regionId,
            nextSnapshot,
            "colors_changed",
            `Available colors changed for ${nextSnapshot.title}`,
            delta
          )
        );
      }
    }

    if (changeEvents.length > 0) {
      existing.lastChangedAt = nextSnapshot.scannedAt;
    }
  }

  state.changes.unshift(...changeEvents.reverse());
  state.changes = state.changes.slice(0, 500);
  return changeEvents;
}

function chooseProductRegion(product: TrackedProduct, explicitRegionId?: string): string | null {
  if (explicitRegionId && product.regions[explicitRegionId]) {
    return explicitRegionId;
  }

  return Object.keys(product.regions)[0] ?? null;
}

function isRegionRouteIssue(message: string | null | undefined): boolean {
  return /captcha|challenge|expected .* got|http 404|503|blocked/i.test(message ?? "");
}

function actualHostFromRouteIssue(message: string | null | undefined): string | null {
  const match = (message ?? "").match(/\bgot ([a-z0-9.-]+\.[a-z]{2,})\b/i);
  return match?.[1]?.toLowerCase() ?? null;
}

function regionIdForHost(state: AppState, host: string | null | undefined): string | null {
  if (!host) {
    return null;
  }

  return state.regions.find((region) => {
    try {
      return new URL(region.shopUrl).host.toLowerCase() === host.toLowerCase();
    } catch {
      return false;
    }
  })?.id ?? null;
}

function rankRegionCandidates(
  state: AppState,
  product: TrackedProduct,
  explicitRegionId?: string,
  excludeRegionIds: string[] = []
): string[] {
  const excluded = new Set(excludeRegionIds);
  const candidates = Object.keys(product.regions).filter((regionId) => !excluded.has(regionId));

  if (explicitRegionId && product.regions[explicitRegionId]) {
    return [explicitRegionId, ...candidates.filter((regionId) => regionId !== explicitRegionId)];
  }

  return candidates.sort((leftId, rightId) => {
    const leftRegion = state.regions.find((entry) => entry.id === leftId);
    const rightRegion = state.regions.find((entry) => entry.id === rightId);
    const leftEnabled = leftRegion?.enabled ? 1 : 0;
    const rightEnabled = rightRegion?.enabled ? 1 : 0;

    if (leftEnabled !== rightEnabled) {
      return rightEnabled - leftEnabled;
    }

    const leftHealthy = leftRegion && !isRegionRouteIssue(leftRegion.lastError) && leftRegion.lastStatus !== "error" ? 1 : 0;
    const rightHealthy = rightRegion && !isRegionRouteIssue(rightRegion.lastError) && rightRegion.lastStatus !== "error" ? 1 : 0;

    if (leftHealthy !== rightHealthy) {
      return rightHealthy - leftHealthy;
    }

    const leftHealthyAt = Date.parse(leftRegion?.lastHealthyAt ?? leftRegion?.lastRunAt ?? "") || 0;
    const rightHealthyAt = Date.parse(rightRegion?.lastHealthyAt ?? rightRegion?.lastRunAt ?? "") || 0;

    if (leftHealthyAt !== rightHealthyAt) {
      return rightHealthyAt - leftHealthyAt;
    }

    return leftId.localeCompare(rightId);
  });
}

function spawnManualSession(region: RegionConfig): ChildProcess {
  const child = spawn(
    process.execPath,
    ["--import", "tsx", "src/manual-session.ts", region.id, region.shopUrl],
    {
      cwd: ROOT_DIR_PATH,
      detached: true,
      stdio: "ignore"
    }
  );

  child.unref();
  return child;
}

export class Tracker {
  private readonly queue: QueueTask[] = [];
  private readonly queuedKeys = new Set<string>();
  private processing = false;
  private ticking = false;
  private timer: NodeJS.Timeout | null = null;
  private enqueueOrder = 0;

  constructor(private readonly store: StateStore) {}

  start(): void {
    if (this.timer) {
      return;
    }

    void this.tick();
    this.timer = setInterval(() => {
      void this.tick();
    }, 15_000);
  }

  stop(): void {
    if (this.timer) {
      clearInterval(this.timer);
      this.timer = null;
    }
  }

  async tick(): Promise<void> {
    if (this.ticking) {
      return;
    }

    this.ticking = true;

    try {
      const state = await this.store.getState();
      if (!state.settings.autoScanEnabled) {
        return;
      }
      const now = Date.now();

      for (const region of state.regions) {
        if (!region.enabled) {
          continue;
        }

        if (state.scansInFlight.includes(region.id)) {
          continue;
        }

        const nextRun = region.nextRunAt ? Date.parse(region.nextRunAt) : 0;
        if (!region.nextRunAt || Number.isNaN(nextRun) || nextRun <= now) {
          this.enqueue(`region:${region.id}`, REGION_SCAN_PRIORITY, () => this.runRegionScan(region.id));
        }
      }

      const regionWorkPending =
        this.queue.some((task) => task.priority === REGION_SCAN_PRIORITY) ||
        state.scansInFlight.length > 0;

      if (regionWorkPending) {
        return;
      }

      for (const product of Object.values(state.products)) {
        if (!product.tracking.enabled || product.archived || product.tracking.intervalMinutes == null) {
          continue;
        }

        for (const [regionId, snapshot] of Object.entries(product.regions)) {
          const region = state.regions.find((entry) => entry.id === regionId);
          if (
            region &&
            region.lastStatus === "error" &&
            /captcha|challenge|expected .* got|http 404/i.test(region.lastError ?? "")
          ) {
            continue;
          }

          const lastScan = Date.parse(product.lastCheckAt ?? snapshot.scannedAt);
          if (Number.isNaN(lastScan)) {
            continue;
          }

          if (lastScan + product.tracking.intervalMinutes * 60_000 <= now) {
            this.enqueue(`product:${regionId}:${product.handle}`, PRODUCT_SCAN_PRIORITY, () =>
              this.runProductScan(regionId, product.handle)
            );
          }
        }
      }
    } finally {
      this.ticking = false;
      void this.processQueue();
    }
  }

  queueRegionScan(regionId: string): void {
    this.enqueue(`region:${regionId}`, REGION_SCAN_PRIORITY, () => this.runRegionScan(regionId));
    void this.processQueue();
  }

  queueProductScan(handle: string, regionId?: string): void {
    void this.resolveAndQueueProduct(handle, regionId).catch((error) => {
      console.error(error);
    });
  }

  openManualSession(regionId: string): void {
    void this.store.withState((state) => {
      const region = state.regions.find((entry) => entry.id === regionId);

      if (!region) {
        throw new Error(`Unknown region: ${regionId}`);
      }

      region.manualSessionLastOpenedAt = new Date().toISOString();
      spawnManualSession(region);
    }).catch((error) => {
      console.error(error);
    });
  }

  private async resolveAndQueueProduct(handle: string, explicitRegionId?: string): Promise<void> {
    const state = await this.store.getState();
    const product = state.products[handle];

    if (!product) {
      throw new Error(`Unknown product: ${handle}`);
    }

    const regionId = rankRegionCandidates(state, product, explicitRegionId)[0] ?? null;
    if (!regionId) {
      throw new Error(`No region snapshot available for ${handle}`);
    }

    this.enqueue(`product:${regionId}:${handle}`, PRODUCT_SCAN_PRIORITY, () => this.runProductScan(regionId, handle));
    await this.processQueue();
  }

  private enqueue(key: string, priority: number, run: QueueTask["run"]): void {
    if (this.queuedKeys.has(key)) {
      return;
    }

    this.queue.push({
      key,
      priority,
      order: this.enqueueOrder,
      run
    });
    this.enqueueOrder += 1;
    this.queue.sort((left, right) => right.priority - left.priority || left.order - right.order);
    this.queuedKeys.add(key);
  }

  private async processQueue(): Promise<void> {
    if (this.processing) {
      return;
    }

    this.processing = true;

    try {
      while (this.queue.length > 0) {
        const task = this.queue.shift();

        if (!task) {
          continue;
        }

        this.queuedKeys.delete(task.key);
        await task.run();
      }
    } finally {
      this.processing = false;
    }
  }

  private async markRegionStart(regionId: string): Promise<RegionConfig> {
    return this.store.withState((state) => {
      const region = state.regions.find((entry) => entry.id === regionId);

      if (!region) {
        throw new Error(`Unknown region: ${regionId}`);
      }

      region.lastStatus = "running";
      region.lastError = null;

      if (!state.scansInFlight.includes(regionId)) {
        state.scansInFlight.push(regionId);
      }

      const regionScan = state.regionScans[regionId] ?? {
        lastScanAt: null,
        lastNewHandles: [],
        currentScanProcessed: null,
        currentScanTotal: null
      };
      regionScan.currentScanProcessed = 0;
      regionScan.currentScanTotal = null;
      state.regionScans[regionId] = regionScan;

      return { ...region };
    });
  }

  private async finishRegion(regionId: string, status: "ok" | "error", error?: string): Promise<void> {
    const now = new Date().toISOString();

    await this.store.withState((state) => {
      const region = state.regions.find((entry) => entry.id === regionId);

      if (!region) {
        throw new Error(`Unknown region: ${regionId}`);
      }

      region.lastStatus = status;
      region.lastError = error ?? null;
      region.lastRunAt = now;
      if (status === "ok") {
        region.lastHealthyAt = now;
      }

      const retryMinutes =
        status === "error" && /captcha|challenge/i.test(error ?? "")
          ? Math.max(region.defaultIntervalMinutes, ACCESS_ISSUE_RETRY_MINUTES)
          : region.defaultIntervalMinutes;

      region.nextRunAt = plusMinutes(now, retryMinutes);
      state.scansInFlight = state.scansInFlight.filter((entry) => entry !== regionId);
      const regionScan = state.regionScans[regionId];
      if (regionScan) {
        regionScan.currentScanProcessed = null;
        regionScan.currentScanTotal = null;
      }
    });
  }

  private async maybeNotifyRegionError(regionId: string, regionName: string, message: string): Promise<void> {
    const shouldPlaySound = await this.store.withState((state) => {
      const region = state.regions.find((entry) => entry.id === regionId);

      if (!region) {
        return false;
      }

      const now = Date.now();
      const lastNotifiedAt = region.lastNotifiedAt ? Date.parse(region.lastNotifiedAt) : 0;
      const recentlyNotified = lastNotifiedAt && now - lastNotifiedAt < ACCESS_ISSUE_NOTIFY_COOLDOWN_MS;
      const sameError = region.lastNotifiedError === message;

      if (recentlyNotified && sameError) {
        return false;
      }

      region.lastNotifiedAt = new Date(now).toISOString();
      region.lastNotifiedError = message;
      return true;
    });

    await notifyAccessIssue(regionName, message, shouldPlaySound);
  }

  private async runRegionScan(regionId: string): Promise<void> {
    const region = await this.markRegionStart(regionId);

    try {
      const scanSettings = await this.store.getState();
      const pace = scanSettings.settings.scanPace;
      const result = await scrapeRegion(region, pace, async ({ snapshot, processed, total }) => {
        await this.store.withState((state) => {
          const regionScan = state.regionScans[regionId] ?? {
            lastScanAt: null,
            lastNewHandles: [],
            currentScanProcessed: null,
            currentScanTotal: null
          };
          regionScan.currentScanProcessed = processed;
          regionScan.currentScanTotal = total;
          state.regionScans[regionId] = regionScan;

          if (snapshot) {
            applySnapshotToState(state, regionId, snapshot, { listedInFeed: true });
          }
        });
      });
      await this.store.withState((state) => {
        const regionState = state.regionScans[regionId] ?? {
          lastScanAt: null,
          lastNewHandles: [],
          currentScanProcessed: null,
          currentScanTotal: null
        };
        const previousHandles = new Set(regionState.lastNewHandles);
        const currentHandles = new Set<string>();

        for (const snapshot of result.snapshots) {
          const product = findExistingProduct(state, snapshot);
          currentHandles.add(product?.handle ?? snapshot.handle);
        }

        for (const missingHandle of previousHandles) {
          if (currentHandles.has(missingHandle)) {
            continue;
          }

          const product = findProductByRegionHandle(state, regionId, missingHandle);
          const previousSnapshot = product?.regions[regionId];

          if (!product || !previousSnapshot) {
            continue;
          }

          product.regions[regionId] = {
            ...previousSnapshot,
            listedInFeed: false,
            lastMissingFromFeedAt: result.scannedAt
          };
          product.lastChangedAt = result.scannedAt;
          state.changes.unshift({
            id: randomUUID(),
            at: result.scannedAt,
            regionId,
            handle: missingHandle,
            title: product.title,
            type: "missing_from_new",
            summary: `${product.title} disappeared from the current New list`,
            snapshotAtEvent: {
              imageUrl:
                previousSnapshot.colors.find((color) => color.imageUrl)?.imageUrl ?? previousSnapshot.imageUrl ?? null,
              colors: previousSnapshot.colors.map((color) => ({
                color: color.color,
                imageUrl: color.imageUrl ?? previousSnapshot.imageUrl ?? null,
                availableSizes: [...color.availableSizes]
              }))
            }
          });
        }

        state.regionScans[regionId] = {
          lastScanAt: result.scannedAt,
          lastNewHandles: [...currentHandles],
          currentScanProcessed: null,
          currentScanTotal: null
        };
      });

      const warningMessage =
        result.warnings.length > 0
          ? `${result.warnings.length} product pages were partially blocked during the last scan. Latest: ${result.warnings[0]}`
          : undefined;

      if (result.warnings.length > 0) {
        await this.store.withState((state) => {
          for (const warning of result.warnings.slice(0, 6)) {
            appendLog(state, {
              level: /captcha|challenge|503|blocked/i.test(warning) ? "warn" : "info",
              source: "region_scan",
              regionId,
              handle: null,
              title: `${region.name} warning`,
              message: warning
            });
          }
        });
      }

      await this.finishRegion(regionId, "ok", warningMessage);
    } catch (error) {
      const message = error instanceof Error ? error.message : String(error);
      const actualRegionId = regionIdForHost(await this.store.getState(), actualHostFromRouteIssue(message));

      if (error instanceof AccessIssueError) {
        await this.maybeNotifyRegionError(regionId, region.name, message);
      }

      if (error instanceof RegionMismatchError && actualRegionId && actualRegionId !== regionId) {
        this.queueRegionScan(actualRegionId);
      }

      await this.store.withState((state) => {
        appendLog(state, {
          level: "error",
          source: "region_scan",
          regionId,
          handle: null,
          title: `${region.name} scan failed`,
          message
        });
      });

      await this.finishRegion(regionId, "error", message);
    }
  }

  private async runProductScan(regionId: string, handle: string): Promise<void> {
    const state = await this.store.getState();
    const product = state.products[handle];
    const regionSnapshot = product?.regions[regionId];
    const region = state.regions.find((entry) => entry.id === regionId);

    if (!product || !regionSnapshot || !region || !product.tracking.enabled || product.archived) {
      return;
    }

    try {
      const state = await this.store.getState();
      const snapshot = await scrapeSingleProduct(region, regionSnapshot.productUrl, state.settings.scanPace);

      await this.store.withState((draft) => {
        const current = draft.products[handle];

        if (!current) {
          return;
        }
        applySnapshotToState(draft, regionId, snapshot);
      });
    } catch (error) {
      const checkedAt = new Date().toISOString();
      const message = error instanceof Error ? error.message : String(error);
      const regionRouteIssue =
        error instanceof AccessIssueError ||
        error instanceof RegionMismatchError ||
        isRegionRouteIssue(message);
      const latestState = await this.store.getState();
      const actualRegionId = regionIdForHost(latestState, actualHostFromRouteIssue(message));

      if (regionRouteIssue) {
        await this.store.updateRegion(regionId, {
          lastStatus: "error",
          lastError: message,
          nextRunAt: plusMinutes(new Date().toISOString(), ACCESS_ISSUE_RETRY_MINUTES)
        });

        const latestProduct = latestState.products[handle];
        const fallbackRegionId = latestProduct
          ? rankRegionCandidates(latestState, latestProduct, undefined, [regionId])[0] ?? null
          : null;

        if (actualRegionId && actualRegionId !== regionId) {
          this.queueRegionScan(actualRegionId);
        }

        if (fallbackRegionId) {
          this.enqueue(
            `product:${fallbackRegionId}:${handle}`,
            PRODUCT_SCAN_PRIORITY,
            () => this.runProductScan(fallbackRegionId, handle)
          );
          await this.processQueue();
          return;
        }

        if (region.enabled) {
          this.queueRegionScan(regionId);
        }

        return;
      }

      await this.store.withState((draft) => {
        const current = draft.products[handle];

        if (!current) {
          return;
        }

        markProductCheck(current, checkedAt, "error", message);
        appendLog(draft, {
          at: checkedAt,
          level: /captcha|challenge|503|blocked/i.test(message) ? "warn" : "error",
          source: "product_scan",
          regionId,
          handle,
          title: `${current.title} check failed`,
          message
        });
      });
    }
  }
}