All changes

frontend/src/hooks/useSavedProperties.ts

@@ -0,0 +1,145 @@
+import { useState, useCallback, useMemo } from 'react';
+import pb from '../lib/pocketbase';
+import { trackEvent } from '../lib/analytics';
+import type { Property } from '../types';
+import { getNum } from '../lib/property-fields';
+
+export interface SavedPropertyData {
+  propertyType?: string;
+  propertySubType?: string;
+  builtForm?: string;
+  duration?: string;
+  energyRating?: string;
+  price?: number;
+  estimatedPrice?: number;
+  askingPrice?: number;
+  askingRent?: number;
+  bedrooms?: number;
+  floorArea?: number;
+  listingUrl?: string;
+}
+
+export interface SavedProperty {
+  id: string;
+  address: string;
+  postcode: string;
+  data: SavedPropertyData;
+  created: string;
+}
+
+export function useSavedProperties(userId: string | null) {
+  const [properties, setProperties] = useState<SavedProperty[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchProperties = useCallback(async () => {
+    if (!userId) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const records = await pb.collection('saved_properties').getFullList({
+        sort: '-created',
+        filter: `user = "${userId}"`,
+      });
+      setProperties(
+        records.map((r) => {
+          const raw = r as Record<string, unknown>;
+          let data: SavedPropertyData = {};
+          try {
+            data = typeof raw.data === 'string' ? JSON.parse(raw.data) : (raw.data as SavedPropertyData) || {};
+          } catch {
+            // Invalid JSON — use empty data
+          }
+          return {
+            id: r.id,
+            address: raw.address as string,
+            postcode: raw.postcode as string,
+            data,
+            created: r.created,
+          };
+        })
+      );
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to load saved properties');
+    } finally {
+      setLoading(false);
+    }
+  }, [userId]);
+
+  const saveProperty = useCallback(
+    async (property: Property) => {
+      if (!userId) return;
+      setError(null);
+      try {
+        const data: SavedPropertyData = {
+          propertyType: property.property_type,
+          propertySubType: property.property_sub_type,
+          builtForm: property.built_form,
+          duration: property.duration,
+          energyRating: property.current_energy_rating,
+          price: getNum(property, 'Last known price'),
+          estimatedPrice: getNum(property, 'Estimated current price'),
+          askingPrice: getNum(property, 'Asking price'),
+          askingRent: getNum(property, 'Asking rent (monthly)'),
+          bedrooms: getNum(property, 'Bedrooms'),
+          floorArea: getNum(property, 'Total floor area (sqm)'),
+          listingUrl: property.listing_url || undefined,
+        };
+
+        await pb.collection('saved_properties').create({
+          user: userId,
+          address: property.address || 'Unknown',
+          postcode: property.postcode || '',
+          data: JSON.stringify(data),
+        });
+        trackEvent('Property Save');
+        await fetchProperties();
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : 'Failed to save property';
+        setError(msg);
+      }
+    },
+    [userId, fetchProperties]
+  );
+
+  const deleteProperty = useCallback(async (id: string) => {
+    setError(null);
+    try {
+      await pb.collection('saved_properties').delete(id);
+      trackEvent('Property Delete');
+      setProperties((prev) => prev.filter((p) => p.id !== id));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to delete property');
+    }
+  }, []);
+
+  const savedPropertyKeys = useMemo(
+    () => new Set(properties.map((p) => `${p.address}|${p.postcode}`)),
+    [properties]
+  );
+
+  const isPropertySaved = useCallback(
+    (address?: string, postcode?: string) =>
+      savedPropertyKeys.has(`${address || ''}|${postcode || ''}`),
+    [savedPropertyKeys]
+  );
+
+  const getSavedPropertyId = useCallback(
+    (address?: string, postcode?: string) => {
+      const key = `${address || ''}|${postcode || ''}`;
+      return properties.find((p) => `${p.address}|${p.postcode}` === key)?.id;
+    },
+    [properties]
+  );
+
+  return {
+    properties,
+    loading,
+    error,
+    fetchProperties,
+    saveProperty,
+    deleteProperty,
+    isPropertySaved,
+    getSavedPropertyId,
+  };
+}