brickwise 0.1.0

package/src/components/TransactionsTable.tsx

@@ -0,0 +1,40 @@
+import { fmtAED, fmtDate, fmtSqft } from "@/lib/format";
+import { TxRow } from "@/lib/pf/transactions";
+
+export default function TransactionsTable({ title, rows, kind }: { title: string; rows: TxRow[]; kind: "buy" | "rent" }) {
+  return (
+    <div className="rounded-xl border border-neutral-200 bg-white p-4 dark:border-neutral-800 dark:bg-neutral-900">
+      <h3 className="mb-3 text-sm font-bold">
+        {title} <span className="font-normal text-neutral-500">({rows.length})</span>
+      </h3>
+      {rows.length === 0 ? (
+        <p className="text-sm text-neutral-500">Sin transacciones registradas.</p>
+      ) : (
+        <div className="max-h-96 overflow-auto">
+          <table className="w-full text-left text-sm">
+            <thead className="sticky top-0 bg-white text-xs text-neutral-500 dark:bg-neutral-900">
+              <tr>
+                <th className="py-1.5 pr-3 font-semibold">Fecha</th>
+                <th className="py-1.5 pr-3 font-semibold">{kind === "rent" ? "Renta anual" : "Precio"}</th>
+                <th className="py-1.5 pr-3 font-semibold">Tamaño</th>
+                <th className="py-1.5 pr-3 font-semibold">Hab</th>
+                <th className="py-1.5 font-semibold">Unidad</th>
+              </tr>
+            </thead>
+            <tbody>
+              {rows.map((t) => (
+                <tr key={t.id} className="border-t border-neutral-100 dark:border-neutral-800">
+                  <td className="py-1.5 pr-3 whitespace-nowrap">{fmtDate(t.date)}</td>
+                  <td className="py-1.5 pr-3 whitespace-nowrap font-medium">{fmtAED(t.amount)}</td>
+                  <td className="py-1.5 pr-3 whitespace-nowrap">{fmtSqft(t.size_sqft)}</td>
+                  <td className="py-1.5 pr-3">{t.bedrooms ?? "—"}</td>
+                  <td className="py-1.5">{t.unit ?? "—"}</td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      )}
+    </div>
+  );
+}

package/src/components/YieldBadge.tsx

@@ -0,0 +1,24 @@
+import { fmtPct } from "@/lib/format";
+
+export default function YieldBadge({ value, n }: { value: number | null; n?: number }) {
+  if (value == null)
+    return (
+      <span className="inline-flex items-center rounded-full bg-neutral-200 px-2 py-0.5 text-xs font-semibold text-neutral-600 dark:bg-neutral-800 dark:text-neutral-400">
+        sin datos
+      </span>
+    );
+  const color =
+    value >= 0.07
+      ? "bg-emerald-100 text-emerald-800 dark:bg-emerald-950 dark:text-emerald-300"
+      : value >= 0.055
+        ? "bg-lime-100 text-lime-800 dark:bg-lime-950 dark:text-lime-300"
+        : value >= 0.04
+          ? "bg-amber-100 text-amber-800 dark:bg-amber-950 dark:text-amber-300"
+          : "bg-red-100 text-red-800 dark:bg-red-950 dark:text-red-300";
+  return (
+    <span className={`inline-flex items-center gap-1 rounded-full px-2 py-0.5 text-xs font-semibold ${color}`}>
+      {fmtPct(value)}
+      {n != null && <span className="font-normal opacity-70">({n} tx)</span>}
+    </span>
+  );
+}

package/src/lib/analyze.ts

@@ -0,0 +1,51 @@
+import { scrapeListing } from "./pf/listing";
+import { getTransactions, syncTransactions } from "./pf/transactions";
+import { computeYield, similarToTxRows } from "./yield";
+import { nearestGym } from "./gyms";
+import { getAnalysis, getListing, saveAnalysis, upsertListing } from "./store";
+import { AnalysisRow, ListingRow } from "./types";
+
+const ANALYSIS_TTL_MS = 24 * 3600 * 1000;
+
+export interface AnalyzeResult {
+  listing: ListingRow;
+  analysis: AnalysisRow;
+}
+
+/**
+ * Full analysis of one listing: detail scrape (for photos/description/fallback
+ * transactions), tower transaction history, yield computation and gym distance.
+ */
+export async function analyzeListing(id: string, url?: string, force = false): Promise<AnalyzeResult> {
+  let listing = getListing(id);
+  const cached = getAnalysis(id);
+  if (!force && listing && cached && Date.now() - Date.parse(cached.computed_at) < ANALYSIS_TTL_MS) {
+    return { listing, analysis: cached };
+  }
+
+  const listingUrl = url || listing?.url;
+  if (!listingUrl) throw new Error(`Unknown listing ${id} and no URL provided`);
+
+  const detail = await scrapeListing(listingUrl);
+  listing = upsertListing(detail.property, detail.citySlug);
+
+  let buy = similarToTxRows(detail.property.similar_price_transactions?.buy || [], "buy");
+  let rent = similarToTxRows(detail.property.similar_price_transactions?.rent || [], "rent");
+
+  if (listing.tower_slug) {
+    await syncTransactions(detail.citySlug, listing.tower_slug);
+    const fullBuy = getTransactions(listing.tower_slug, "buy");
+    const fullRent = getTransactions(listing.tower_slug, "rent");
+    if (fullBuy.length) buy = fullBuy;
+    if (fullRent.length) rent = fullRent;
+  }
+
+  const yieldRes = computeYield(listing.price, listing.size_sqft, listing.bedrooms, buy, rent);
+  const gym =
+    listing.lat != null && listing.lon != null
+      ? await nearestGym(listing.lat, listing.lon)
+      : { gym_name: null, distance_m: null };
+
+  saveAnalysis(listing.id, yieldRes, gym);
+  return { listing, analysis: getAnalysis(listing.id)! };
+}

package/src/lib/db.ts

@@ -0,0 +1,143 @@
+import Database from "better-sqlite3";
+import path from "path";
+import os from "os";
+import fs from "fs";
+
+let db: Database.Database | null = null;
+
+/**
+ * Stable per-user location so data survives no matter how the app is launched
+ * (including `npx`, which runs from an ephemeral cache). Override with BRICKWISE_DB.
+ * One-time migrates a legacy ./brickwise.db from earlier local runs.
+ */
+function resolveDbPath(): string {
+  if (process.env.BRICKWISE_DB) return process.env.BRICKWISE_DB;
+  const dir = path.join(os.homedir(), ".brickwise");
+  fs.mkdirSync(dir, { recursive: true });
+  const target = path.join(dir, "brickwise.db");
+  if (!fs.existsSync(target)) {
+    const legacy = path.join(process.cwd(), "brickwise.db");
+    if (fs.existsSync(legacy)) {
+      try {
+        fs.copyFileSync(legacy, target);
+      } catch {
+        /* start fresh if the copy fails */
+      }
+    }
+  }
+  return target;
+}
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS locations (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  path_name TEXT NOT NULL DEFAULT '',
+  slug TEXT NOT NULL DEFAULT '',
+  city_slug TEXT NOT NULL DEFAULT '',
+  type TEXT NOT NULL DEFAULT '',
+  path TEXT NOT NULL DEFAULT ''
+);
+CREATE INDEX IF NOT EXISTS idx_locations_name ON locations(name);
+
+CREATE TABLE IF NOT EXISTS listings (
+  id TEXT PRIMARY KEY,
+  url TEXT NOT NULL,
+  title TEXT NOT NULL,
+  price REAL NOT NULL,
+  size_sqft REAL,
+  bedrooms INTEGER,
+  bathrooms INTEGER,
+  property_type TEXT NOT NULL DEFAULT '',
+  tower_id TEXT,
+  tower_slug TEXT,
+  tower_name TEXT,
+  city_slug TEXT,
+  lat REAL,
+  lon REAL,
+  images_json TEXT NOT NULL DEFAULT '[]',
+  amenities_json TEXT NOT NULL DEFAULT '[]',
+  agent_json TEXT NOT NULL DEFAULT '{}',
+  price_per_sqft REAL,
+  description TEXT,
+  first_seen_at TEXT NOT NULL,
+  last_scraped_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS transactions (
+  id TEXT PRIMARY KEY,
+  tower_slug TEXT NOT NULL,
+  kind TEXT NOT NULL CHECK (kind IN ('buy','rent')),
+  date TEXT NOT NULL,
+  amount REAL NOT NULL,
+  size_sqft REAL,
+  price_per_sqft REAL,
+  bedrooms INTEGER,
+  unit TEXT,
+  scraped_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_tx_tower ON transactions(tower_slug, kind);
+
+CREATE TABLE IF NOT EXISTS tx_sync (
+  tower_slug TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  synced_at TEXT NOT NULL,
+  PRIMARY KEY (tower_slug, kind)
+);
+
+CREATE TABLE IF NOT EXISTS gym_cache (
+  geo_key TEXT PRIMARY KEY,
+  gym_name TEXT,
+  gym_lat REAL,
+  gym_lon REAL,
+  distance_m REAL,
+  fetched_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS gyms_list_cache (
+  geo_key TEXT PRIMARY KEY,
+  gyms_json TEXT NOT NULL,
+  fetched_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS favorites (
+  listing_id TEXT PRIMARY KEY REFERENCES listings(id),
+  notes TEXT NOT NULL DEFAULT '',
+  added_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS analyses (
+  listing_id TEXT PRIMARY KEY REFERENCES listings(id),
+  gross_yield REAL,
+  yield_vs_market REAL,
+  market_value_est REAL,
+  median_rent REAL,
+  median_buy_psqft REAL,
+  rent_n INTEGER NOT NULL DEFAULT 0,
+  buy_n INTEGER NOT NULL DEFAULT 0,
+  premium_pct REAL,
+  gym_distance_m REAL,
+  gym_name TEXT,
+  computed_at TEXT NOT NULL
+);
+`;
+
+export function getDb(): Database.Database {
+  if (!db) {
+    db = new Database(resolveDbPath());
+    db.pragma("journal_mode = WAL");
+    db.exec(SCHEMA);
+    migrate(db);
+  }
+  return db;
+}
+
+function migrate(db: Database.Database) {
+  const cols = (db.prepare(`PRAGMA table_info(analyses)`).all() as { name: string }[]).map((c) => c.name);
+  if (!cols.includes("median_sale_price")) db.exec(`ALTER TABLE analyses ADD COLUMN median_sale_price REAL`);
+  if (!cols.includes("asking_yield")) db.exec(`ALTER TABLE analyses ADD COLUMN asking_yield REAL`);
+}
+
+export function now(): string {
+  return new Date().toISOString();
+}

package/src/lib/dedupe.ts

@@ -0,0 +1,34 @@
+interface UnitLike {
+  id: string;
+  tower_slug: string | null;
+  bedrooms: number | null;
+  size_sqft: number | null;
+  price: number;
+}
+
+/**
+ * The same physical apartment is often listed by several agents under different
+ * Property Finder ids. Those share the building, bedroom count, size and asking
+ * price (agents copy the same DLD figures), so collapse them to one card.
+ *
+ * When any of those fields is missing we cannot be confident two rows are the
+ * same unit, so we key on the id and never merge.
+ */
+function unitSignature(r: UnitLike): string {
+  if (!r.tower_slug || r.size_sqft == null || !r.price) return `id:${r.id}`;
+  const bd = r.bedrooms == null ? "?" : r.bedrooms;
+  return `${r.tower_slug}|${bd}|${Math.round(r.size_sqft)}|${r.price}`;
+}
+
+/** Keep the first occurrence of each physical unit (newest first with ob=mr). */
+export function dedupeListings<T extends UnitLike>(rows: T[]): { unique: T[]; removed: number } {
+  const seen = new Set<string>();
+  const unique: T[] = [];
+  for (const r of rows) {
+    const sig = unitSignature(r);
+    if (seen.has(sig)) continue;
+    seen.add(sig);
+    unique.push(r);
+  }
+  return { unique, removed: rows.length - unique.length };
+}

package/src/lib/format.ts

@@ -0,0 +1,13 @@
+export const fmtAED = (n: number | null | undefined) =>
+  n == null ? "—" : new Intl.NumberFormat("en-AE", { maximumFractionDigits: 0 }).format(n) + " AED";
+
+export const fmtPct = (x: number | null | undefined, digits = 1) =>
+  x == null ? "—" : (x * 100).toFixed(digits) + " %";
+
+export const fmtSqft = (n: number | null | undefined) =>
+  n == null ? "—" : new Intl.NumberFormat("en-AE", { maximumFractionDigits: 0 }).format(n) + " sqft";
+
+export const fmtDist = (m: number | null | undefined) =>
+  m == null ? "—" : m < 1000 ? `${Math.round(m)} m` : `${(m / 1000).toFixed(1)} km`;
+
+export const fmtDate = (d: string | null | undefined) => (d ? d.slice(0, 10) : "—");

package/src/lib/gyms.ts

@@ -0,0 +1,104 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { getDb, now } from "./db";
+
+// Overpass instances are flaky under load; try each twice, in order.
+const OVERPASS_ENDPOINTS = [
+  "https://overpass-api.de/api/interpreter",
+  "https://overpass-api.de/api/interpreter",
+  "https://overpass.private.coffee/api/interpreter",
+  "https://overpass.kumi.systems/api/interpreter",
+];
+const RADIUS_M = 2000;
+const TTL_MS = 30 * 24 * 3600 * 1000;
+
+export interface Gym {
+  name: string;
+  lat: number;
+  lon: number;
+  distance_m: number;
+}
+
+export interface GymResult {
+  gym_name: string | null;
+  distance_m: number | null;
+}
+
+function haversineM(lat1: number, lon1: number, lat2: number, lon2: number): number {
+  const R = 6371000;
+  const toRad = (d: number) => (d * Math.PI) / 180;
+  const dLat = toRad(lat2 - lat1);
+  const dLon = toRad(lon2 - lon1);
+  const a =
+    Math.sin(dLat / 2) ** 2 +
+    Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLon / 2) ** 2;
+  return 2 * R * Math.asin(Math.sqrt(a));
+}
+
+// Overpass allows very few concurrent requests per IP — serialize ours.
+let queue: Promise<unknown> = Promise.resolve();
+
+/** All gyms (OSM fitness centres) within 2 km, nearest first; cached by ~100 m grid cell. */
+export function gymsNear(lat: number, lon: number): Promise<Gym[] | null> {
+  const task = queue.then(() => doGymsNear(lat, lon));
+  queue = task.catch(() => null);
+  return task;
+}
+
+/** null = Overpass unavailable (not cached); [] = confirmed no gyms nearby. */
+async function doGymsNear(lat: number, lon: number): Promise<Gym[] | null> {
+  const db = getDb();
+  const geoKey = `${lat.toFixed(3)},${lon.toFixed(3)}`;
+  const cached = db.prepare(`SELECT * FROM gyms_list_cache WHERE geo_key = ?`).get(geoKey) as any;
+  if (cached && Date.now() - Date.parse(cached.fetched_at) < TTL_MS) {
+    return JSON.parse(cached.gyms_json);
+  }
+
+  const query = `[out:json][timeout:15];(node["leisure"="fitness_centre"](around:${RADIUS_M},${lat},${lon});way["leisure"="fitness_centre"](around:${RADIUS_M},${lat},${lon}););out center 60;`;
+  for (const endpoint of OVERPASS_ENDPOINTS) {
+    try {
+      const res = await fetch(endpoint, {
+        method: "POST",
+        body: "data=" + encodeURIComponent(query),
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          // overpass-api.de answers 406 to requests without a User-Agent
+          "User-Agent": "brickwise-local/0.1 (personal use)",
+        },
+        signal: AbortSignal.timeout(20000),
+      });
+      if (!res.ok) continue;
+      const j = await res.json();
+      // Overloaded instances answer 200 + empty elements + a "remark" runtime error.
+      if (j.remark && !(j.elements || []).length) continue;
+      const gyms: Gym[] = [];
+      for (const el of j.elements || []) {
+        const eLat = el.lat ?? el.center?.lat;
+        const eLon = el.lon ?? el.center?.lon;
+        if (eLat == null || eLon == null) continue;
+        gyms.push({
+          name: el.tags?.name || "Gym",
+          lat: eLat,
+          lon: eLon,
+          distance_m: Math.round(haversineM(lat, lon, eLat, eLon)),
+        });
+      }
+      gyms.sort((a, b) => a.distance_m - b.distance_m);
+      db.prepare(
+        `INSERT OR REPLACE INTO gyms_list_cache (geo_key, gyms_json, fetched_at) VALUES (?, ?, ?)`
+      ).run(geoKey, JSON.stringify(gyms), now());
+      return gyms;
+    } catch {
+      continue;
+    }
+  }
+  return null; // all endpoints down: unknown, not cached
+}
+
+/** Nearest gym within 2 km (derived from the cached list). */
+export async function nearestGym(lat: number, lon: number): Promise<GymResult> {
+  const gyms = await gymsNear(lat, lon);
+  const best = gyms?.[0];
+  return best
+    ? { gym_name: best.name, distance_m: best.distance_m }
+    : { gym_name: null, distance_m: null };
+}

package/src/lib/pf/client.ts

@@ -0,0 +1,45 @@
+const UA =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36";
+
+const MIN_INTERVAL_MS = 1000;
+
+let queue: Promise<unknown> = Promise.resolve();
+let lastRequestAt = 0;
+
+function sleep(ms: number) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function doFetch(url: string): Promise<string> {
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    const wait = lastRequestAt + MIN_INTERVAL_MS - Date.now();
+    if (wait > 0) await sleep(wait);
+    lastRequestAt = Date.now();
+    try {
+      const res = await fetch(url, {
+        headers: {
+          "User-Agent": UA,
+          "Accept-Language": "en",
+          Accept: "text/html,application/xhtml+xml,application/json;q=0.9,*/*;q=0.8",
+        },
+        redirect: "follow",
+        signal: AbortSignal.timeout(30000),
+      });
+      if (res.status === 404) throw Object.assign(new Error(`404: ${url}`), { permanent: true });
+      if (!res.ok) throw new Error(`HTTP ${res.status}: ${url}`);
+      return await res.text();
+    } catch (err) {
+      const e = err as Error & { permanent?: boolean };
+      if (e.permanent || attempt === 3) throw e;
+      await sleep(1500 * attempt);
+    }
+  }
+  throw new Error("unreachable");
+}
+
+/** Serialized, rate-limited fetch against propertyfinder.ae. */
+export function fetchPfPage(url: string): Promise<string> {
+  const task = queue.then(() => doFetch(url));
+  queue = task.catch(() => {});
+  return task;
+}

package/src/lib/pf/listing.ts

@@ -0,0 +1,16 @@
+import { fetchPfPage } from "./client";
+import { extractPageProps } from "./parse";
+import { PfProperty } from "../types";
+
+export interface ListingDetail {
+  property: PfProperty;
+  citySlug: string;
+}
+
+export async function scrapeListing(url: string): Promise<ListingDetail> {
+  const html = await fetchPfPage(url);
+  const pp = extractPageProps(html);
+  const property = pp.propertyResult?.property;
+  if (!property) throw new Error(`propertyResult.property missing for ${url}`);
+  return { property, citySlug: pp.citySlug || "dubai" };
+}

package/src/lib/pf/locations.ts

@@ -0,0 +1,73 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { fetchPfPage } from "./client";
+import { getDb } from "../db";
+
+const LIST_URL =
+  "https://www.propertyfinder.ae/api/pwa/location/list?l_t=TOWER%2CSUBCOMMUNITY%2CCOMMUNITY%2CCITY&c=1&locale=en";
+
+export interface LocationRow {
+  id: string;
+  name: string;
+  path_name: string;
+  slug: string;
+  city_slug: string;
+  type: string;
+  path: string;
+}
+
+const DEPTH_TYPES = ["CITY", "COMMUNITY", "SUBCOMMUNITY"];
+
+export async function syncLocations(): Promise<number> {
+  const raw = JSON.parse(await fetchPfPage(LIST_URL));
+  const items: any[] = Array.isArray(raw) ? raw : raw?.data || [];
+  const db = getDb();
+  const insert = db.prepare(
+    `INSERT OR REPLACE INTO locations (id, name, path_name, slug, city_slug, type, path) VALUES (?, ?, ?, ?, ?, ?, ?)`
+  );
+  const insertDerived = db.prepare(
+    `INSERT OR IGNORE INTO locations (id, name, path_name, slug, city_slug, type, path) VALUES (?, ?, ?, ?, ?, ?, ?)`
+  );
+  const write = db.transaction(() => {
+    for (const l of items) {
+      insert.run(String(l.id), l.n || "", l.p_n || l.en_p_n || "", l.en_s || l.s || "", l.en_c_s || "", l.l_t || "", l.p || "");
+    }
+    // The feed only contains leaf-ish locations (towers/subcommunities and a few
+    // communities). Cities and most communities — e.g. "Dubai Marina" — only appear
+    // as ancestors inside each row's id path (p: "1.86.1198.4328") and path name
+    // (p_n: "Dubai, Palm Jumeirah, Marina Residences"), so derive them from there.
+    for (const l of items) {
+      const ids = String(l.p || "").split(".");
+      const names = String(l.p_n || l.en_p_n || "").split(",").map((s: string) => s.trim()).filter(Boolean);
+      if (ids.length < 2 || names.length !== ids.length - 1) continue;
+      for (let i = 0; i < names.length; i++) {
+        insertDerived.run(
+          ids[i],
+          names[i],
+          names.slice(0, i).join(", "),
+          "",
+          l.en_c_s || "",
+          DEPTH_TYPES[Math.min(i, DEPTH_TYPES.length - 1)],
+          ids.slice(0, i + 1).join(".")
+        );
+      }
+    }
+  });
+  write();
+  return items.length;
+}
+
+export async function searchLocations(q: string, limit = 12): Promise<LocationRow[]> {
+  const db = getDb();
+  const count = (db.prepare(`SELECT COUNT(*) AS c FROM locations`).get() as { c: number }).c;
+  if (count === 0) await syncLocations();
+  const like = `%${q.trim().replace(/\s+/g, "%")}%`;
+  return db
+    .prepare(
+      `SELECT * FROM locations
+       WHERE name LIKE ? OR path_name LIKE ?
+       ORDER BY CASE type WHEN 'CITY' THEN 0 WHEN 'COMMUNITY' THEN 1 WHEN 'SUBCOMMUNITY' THEN 2 ELSE 3 END,
+                length(name)
+       LIMIT ?`
+    )
+    .all(like, like, limit) as LocationRow[];
+}

package/src/lib/pf/parse.ts

@@ -0,0 +1,15 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/** Extract the JSON payload of <script id="__NEXT_DATA__"> and return props.pageProps. */
+export function extractPageProps(html: string): any {
+  const marker = '<script id="__NEXT_DATA__" type="application/json">';
+  const start = html.indexOf(marker);
+  if (start === -1) throw new Error("__NEXT_DATA__ not found in page");
+  const from = start + marker.length;
+  const end = html.indexOf("</script>", from);
+  if (end === -1) throw new Error("__NEXT_DATA__ script tag not closed");
+  const json = JSON.parse(html.slice(from, end));
+  const pageProps = json?.props?.pageProps;
+  if (!pageProps) throw new Error("pageProps missing in __NEXT_DATA__");
+  return pageProps;
+}

package/src/lib/pf/search.ts

@@ -0,0 +1,57 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { fetchPfPage } from "./client";
+import { extractPageProps } from "./parse";
+import { PfProperty, SearchFilters } from "../types";
+
+const BASE = "https://www.propertyfinder.ae";
+
+export function buildSearchUrl(f: SearchFilters, page: number): string {
+  const params = new URLSearchParams();
+  params.set("l", f.locationId || "1"); // default: Dubai
+  params.set("c", "1"); // category: buy
+  params.set("fu", "0");
+  params.set("ob", "mr"); // most recent
+  if (f.minPrice) params.set("pf", String(f.minPrice));
+  if (f.maxPrice) params.set("pt", String(f.maxPrice));
+  if (f.minArea) params.set("af", String(f.minArea));
+  if (f.maxArea) params.set("at", String(f.maxArea));
+  if (f.propertyTypeId) params.set("t", f.propertyTypeId);
+  for (const b of f.bedrooms || []) params.append("bdr[]", b);
+  for (const b of f.bathrooms || []) params.append("btr[]", b);
+  for (const a of f.amenities || []) params.append("am[]", a);
+  if (page > 1) params.set("page", String(page));
+  return `${BASE}/en/search?${params.toString()}`;
+}
+
+export interface SearchPageResult {
+  properties: PfProperty[];
+  pageCount: number;
+  totalCount: number;
+}
+
+export async function scrapeSearchPage(f: SearchFilters, page: number): Promise<SearchPageResult> {
+  const html = await fetchPfPage(buildSearchUrl(f, page));
+  const pp = extractPageProps(html);
+  const sr = pp.searchResult;
+  if (!sr) throw new Error("searchResult missing on search page");
+  const properties: PfProperty[] = (sr.listings || [])
+    .filter((l: any) => l.listing_type === "property" && l.property)
+    .map((l: any) => l.property);
+  return {
+    properties,
+    pageCount: sr.meta?.page_count ?? 1,
+    totalCount: sr.meta?.total_count ?? properties.length,
+  };
+}
+
+export async function scrapeSearch(f: SearchFilters): Promise<{ properties: PfProperty[]; totalCount: number }> {
+  const maxPages = Math.min(f.maxPages || 2, 10);
+  const first = await scrapeSearchPage(f, 1);
+  const all = [...first.properties];
+  const pages = Math.min(maxPages, first.pageCount);
+  for (let p = 2; p <= pages; p++) {
+    const r = await scrapeSearchPage(f, p);
+    all.push(...r.properties);
+  }
+  return { properties: all, totalCount: first.totalCount };
+}