Function bodies 92 total

function AuthNavigator({ hasSeenOnboarding }: { hasSeenOnboarding: boolean }) {
  return (
    <AuthStack.Navigator
      initialRouteName={hasSeenOnboarding ? "Welcome" : "Onboarding"}
      screenOptions={{
        headerShown: false,
        contentStyle: { backgroundColor: "#FFFFFF" },
        animation: "slide_from_right",
      }}
    >
      <AuthStack.Screen name="Onboarding" component={OnboardingScreen} />
      <AuthStack.Screen name="Welcome" component={WelcomeScreen} />
      <AuthStack.Screen name="SignUp" component={SignUpScreen} />
      <AuthStack.Screen name="Login" component={LoginScreen} />
    </AuthStack.Navigator>
  );
}

function AppNavigator() {
  return (
    <AppStack.Navigator
      screenOptions={{
        headerShown: false,
        contentStyle: { backgroundColor: "#FFFFFF" },
      }}
    >
      <AppStack.Screen name="Home" component={HomeScreen} />
      <AppStack.Screen name="PrepHome" component={PrepHomeScreen} />
      <AppStack.Screen name="Pricing" component={PricingScreen} />
      <AppStack.Screen name="PricingResults" component={PricingResultsScreen} />
      <AppStack.Screen name="ListingBuilder" component={ListingBuilderScreen} />
      <AppStack.Screen name="Documents" component={DocumentsScreen} />
      <AppStack.Screen name="DocumentViewer" component={DocumentViewerScreen} />
      <AppStack.Screen name="Showings" component={ShowingsScreen} />
      <AppStack.Screen name="ShowingDetail" component={ShowingDetailScreen} />
      <AppStack.Screen name="Offers" component={OffersScreen} />
      <AppStack.Screen name="OfferInput" component={OfferInputScreen} />
      <AppStack.Screen

function RootNavigator() {
  const { session, loading: authLoading } = useAuth();
  const [hasSeenOnboarding, setHasSeenOnboarding] = useState<boolean | null>(null);

  useEffect(() => {
    AsyncStorage.getItem(ONBOARDING_KEY)
      .then((value) => setHasSeenOnboarding(value === "true"))
      .catch(() => setHasSeenOnboarding(false));
  }, []);

  if (authLoading || hasSeenOnboarding === null) {
    return (
      <View style={{ flex: 1, justifyContent: "center", alignItems: "center", backgroundColor: "#FFFFFF" }}>
        <ActivityIndicator size="large" color="#2563EB" />
      </View>
    );
  }

  return session ? (
    <AppNavigator />
  ) : (
    <AuthNavigator hasSeenOnboarding={hasSeenOnboarding} />
  );
}

export default function App() {
  return (
    <AuthProvider>
      <NavigationContainer>
        <RootNavigator />
        <StatusBar style="dark" />
      </NavigationContainer>
    </AuthProvider>
  );
}

export default function AddressAutocomplete({
  value,
  onChangeText,
  onSelect,
  onPropertyData,
  placeholder = "Enter address",
  style,
}: AddressAutocompleteProps) {
  const [predictions, setPredictions] = useState<Prediction[]>([]);
  const [loading, setLoading] = useState(false);
  const [showDropdown, setShowDropdown] = useState(false);
  const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
  const abortRef = useRef<AbortController | null>(null);

  // Cleanup on unmount
  useEffect(() => {
    return () => {
      if (debounceRef.current) clearTimeout(debounceRef.current);
      if (abortRef.current) abortRef.current.abort();
    };
  }, []);

  const fetchPredictions = useCallback(async (input: string) => {
    if (input.length < 3) {
      setPredictions([]);
      setShowDropdown(false);
      return;
    }

    // Cancel any in-flight request
    if (abortRef.current) abortRef.current.abort();
    abortRef.current = new AbortController();

    setLoad

export default function TierGate({ feature, children }: TierGateProps) {
  const { loading, canAccess, requiredPlan } = useTierAccess();
  const navigation = useNavigation<NavProp>();

  if (loading) {
    return (
      <View style={styles.centered}>
        <ActivityIndicator size="large" color={colors.primaryLight} />
      </View>
    );
  }

  if (canAccess(feature)) {
    return <>{children}</>;
  }

  const needed = requiredPlan(feature);
  const label = PLAN_LABELS[needed];

  return (
    <View style={styles.centered}>
      <TouchableOpacity
        style={styles.backButton}
        onPress={() => navigation.goBack()}
      >
        <Text style={styles.backText}>{"\u2190"} Back</Text>
      </TouchableOpacity>
      <View style={[styles.card, shadows.lg]}>
        <Text style={styles.lockIcon}>{"\uD83D\uDD12"}</Text>
        <Text style={styles.title}>Upgrade to {label}</Text>
        <Text style={styles.description}>
          This feature requires the {label} plan or highe

export function AuthProvider({ children }: { children: React.ReactNode }) {
  const [session, setSession] = useState<Session | null>(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    supabase.auth.getSession().then(({ data: { session } }) => {
      setSession(session);
      setLoading(false);
    });

    const {
      data: { subscription },
    } = supabase.auth.onAuthStateChange((_event, session) => {
      setSession(session);
    });

    return () => subscription.unsubscribe();
  }, []);

  const signUp = async (email: string, password: string) => {
    const { error } = await supabase.auth.signUp({ email, password });
    if (error) return { error: error.message };
    return { error: null };
  };

  const signIn = async (email: string, password: string) => {
    const { error } = await supabase.auth.signInWithPassword({ email, password });
    if (error) return { error: error.message };
    return { error: null };
  };

  const signOut = async ()

export function useAuth() {
  const context = useContext(AuthContext);
  if (!context) {
    throw new Error("useAuth must be used within an AuthProvider");
  }
  return context;
}

function planLevel(plan: PlanType): number {
  return PLAN_HIERARCHY.indexOf(plan);
}

export function useTierAccess() {
  const { user } = useAuth();
  const [plan, setPlan] = useState<PlanType>("free");
  const [loading, setLoading] = useState(true);

  useFocusEffect(
    useCallback(() => {
      if (!user) {
        setPlan("free");
        setLoading(false);
        return;
      }

      let cancelled = false;

      const fetchPlan = async () => {
        setLoading(true);
        try {
          const { data, error } = await supabase
            .from("profiles")
            .select("plan")
            .eq("id", user.id)
            .single();

          if (!cancelled) {
            if (error || !data?.plan) {
              setPlan("free");
            } else {
              setPlan(data.plan as PlanType);
            }
          }
        } catch {
          if (!cancelled) {
            setPlan("free");
          }
        } finally {
          if (!cancelled) {
            setLoading(false);
          }
        }
      };

      fetchPlan();

      return ()

export default function BookShowingScreen() {
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const route = useRoute<RouteProp<AppStackParamList, 'BookShowing'>>();
  const { listingId } = route.params;

  const [listing, setListing] = useState<ListingSummary | null>(null);
  const [slots, setSlots] = useState<DateGroup[]>([]);
  const [loadingSlots, setLoadingSlots] = useState(true);
  const [selectedSlot, setSelectedSlot] = useState<TimeSlot | null>(null);

  // Form fields
  const [name, setName] = useState('');
  const [email, setEmail] = useState('');
  const [phone, setPhone] = useState('');

  const [submitting, setSubmitting] = useState(false);
  const [success, setSuccess] = useState(false);
  const [bookedDetails, setBookedDetails] = useState<{ date: string; time: string } | null>(null);

  // Fetch listing summary
  useEffect(() => {
    (async () => {
      try {
        const { data } = await supabase
          .from('listings')
      

export default function ClosingGuideScreen() {
  const { user } = useAuth();
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const route = useRoute<RouteProp<AppStackParamList, "ClosingGuide">>();
  const { listingId } = route.params;

  const [guide, setGuide] = useState<ClosingGuideStep[]>([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);

  const fetchGuide = useCallback(
    async (forceRefresh = false) => {
      if (!user || !listingId) return;
      setLoading(true);
      setError(null);

      try {
        if (!forceRefresh) {
          const { data: cached } = await supabase
            .from("closing_guides")
            .select("*")
            .eq("user_id", user.id)
            .eq("listing_id", listingId)
            .single();

          if (cached?.guide_content) {
            setGuide(cached.guide_content as ClosingGuideStep[]);
            setLoading(false);
         

export default function ContactSellerScreen() {
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const route = useRoute<RouteProp<AppStackParamList, "ContactSeller">>();
  const { listingId } = route.params;
  const { user } = useAuth();

  const [listing, setListing] = useState<ListingSummary | null>(null);
  const [loadingListing, setLoadingListing] = useState(true);

  const [name, setName] = useState("");
  const [email, setEmail] = useState("");
  const [message, setMessage] = useState("");
  const [sending, setSending] = useState(false);
  const [sent, setSent] = useState(false);
  const [error, setError] = useState("");

  // Pre-fill user info
  useEffect(() => {
    if (user?.email) setEmail(user.email);

    (async () => {
      if (user) {
        const { data: profile } = await supabase
          .from("profiles")
          .select("full_name")
          .eq("id", user.id)
          .single();
        if (profile?.full_name) setName(prof

function formatMessageTime(iso: string): string {
  const date = new Date(iso);
  const now = new Date();
  const isToday =
    date.getDate() === now.getDate() &&
    date.getMonth() === now.getMonth() &&
    date.getFullYear() === now.getFullYear();

  const time = date.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });

  if (isToday) return time;

  const yesterday = new Date(now);
  yesterday.setDate(yesterday.getDate() - 1);
  const isYesterday =
    date.getDate() === yesterday.getDate() &&
    date.getMonth() === yesterday.getMonth() &&
    date.getFullYear() === yesterday.getFullYear();

  if (isYesterday) return `Yesterday ${time}`;
  return `${date.toLocaleDateString()} ${time}`;
}

export default function ConversationScreen() {
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const route = useRoute<RouteProp<AppStackParamList, "Conversation">>();
  const { listingId, otherPartyId, otherPartyName } = route.params;
  const { user } = useAuth();

  const [messages, setMessages] = useState<Message[]>([]);
  const [loading, setLoading] = useState(true);
  const [text, setText] = useState("");
  const [sending, setSending] = useState(false);
  const [listingAddress, setListingAddress] = useState("");
  const scrollViewRef = useRef<ScrollView>(null);

  // Fetch listing address
  useEffect(() => {
    (async () => {
      try {
        const { data } = await supabase
          .from("listings")
          .select("address")
          .eq("id", listingId)
          .single();
        if (data?.address) setListingAddress(data.address);
      } catch (err) {
        // Non-critical: address is supplementary info
      }
    })();
  }, [l

export default function DocumentViewerScreen() {
  const route = useRoute<RouteProp<AppStackParamList, "DocumentViewer">>();
  const navigation = useNavigation();
  const { user } = useAuth();
  const { document: doc } = route.params;
  const [downloading, setDownloading] = useState(false);
  const [sharing, setSharing] = useState(false);

  const generatePdf = async () => {
    const htmlContent = doc.html_content || `<pre>${doc.content}</pre>`;
    const fullHtml = PDF_HTML_WRAPPER(htmlContent, doc.title || "Document");
    const { uri } = await Print.printToFileAsync({ html: fullHtml });

    // Upload to Supabase Storage
    if (user) {
      try {
        const fileResponse = await fetch(uri);
        const blob = await fileResponse.blob();
        const filePath = `${user.id}/${doc.id}.pdf`;

        await supabase.storage.from("documents").upload(filePath, blob, {
          contentType: "application/pdf",
          upsert: true,
        });

        const {
          data: { pub

export default function ListingDetailScreen() {
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const route = useRoute<RouteProp<AppStackParamList, 'ListingDetail'>>();
  const { listingId } = route.params;

  const [listing, setListing] = useState<Listing | null>(null);
  const [loading, setLoading] = useState(true);
  const [fetchError, setFetchError] = useState(false);
  const [activePhotoIndex, setActivePhotoIndex] = useState(0);

  useEffect(() => {
    (async () => {
      try {
        setFetchError(false);
        const { data, error } = await supabase
          .from('listings')
          .select('*')
          .eq('id', listingId)
          .single();

        if (error) {
          setFetchError(true);
        } else {
          setListing(data as Listing);
        }
      } catch {
        setFetchError(true);
      } finally {
        setLoading(false);
      }
    })();
  }, [listingId]);

  const handleShare = async () => {
    if (!

export default function LoginScreen({ navigation }: Props) {
  const { signIn } = useAuth();
  const [email, setEmail] = useState("");
  const [password, setPassword] = useState("");
  const [loading, setLoading] = useState(false);
  const [emailError, setEmailError] = useState("");
  const [passwordError, setPasswordError] = useState("");
  const [generalError, setGeneralError] = useState("");
  const [emailFocused, setEmailFocused] = useState(false);
  const [passwordFocused, setPasswordFocused] = useState(false);

  // Forgot password state
  const [showForgotPassword, setShowForgotPassword] = useState(false);
  const [forgotEmail, setForgotEmail] = useState("");
  const [forgotEmailFocused, setForgotEmailFocused] = useState(false);
  const [forgotLoading, setForgotLoading] = useState(false);
  const [forgotError, setForgotError] = useState("");
  const [forgotSuccess, setForgotSuccess] = useState(false);

  const passwordRef = useRef<TextInput>(null);

  const clearErrors = () => {

function formatPrice(price: number): string {
  if (price >= 1_000_000) {
    return `$${(price / 1_000_000).toFixed(2)}M`;
  }
  return `$${(price / 1_000).toFixed(0)}k`;
}

function matchesPriceFilter(price: number, filter: PriceFilter): boolean {
  switch (filter) {
    case 'Any':
      return true;
    case 'Under 300k':
      return price < 300_000;
    case '300k-500k':
      return price >= 300_000 && price < 500_000;
    case '500k-750k':
      return price >= 500_000 && price < 750_000;
    case '750k+':
      return price >= 750_000;
    default:
      return true;
  }
}

export default function MarketplaceScreen() {
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();

  const [listings, setListings] = useState<Listing[]>([]);
  const [loading, setLoading] = useState(true);
  const [refreshing, setRefreshing] = useState(false);
  const [fetchError, setFetchError] = useState(false);
  const [searchQuery, setSearchQuery] = useState('');
  const [propertyFilter, setPropertyFilter] = useState<PropertyFilter>('All');
  const [priceFilter, setPriceFilter] = useState<PriceFilter>('Any');

  const fetchListings = useCallback(async () => {
    try {
      setFetchError(false);
      const { data, error } = await supabase
        .from('listings')
        .select('*')
        .eq('status', 'active')
        .order('created_at', { ascending: false });

      if (error) {
        setFetchError(true);
      } else {
        setListings((data as Listing[]) || []);
      }
    } catch {
      setFetchError(true);
    } finally {
      s

function formatTimestamp(iso: string): string {
  const date = new Date(iso);
  const now = new Date();
  const diffMs = now.getTime() - date.getTime();
  const diffMins = Math.floor(diffMs / 60000);
  const diffHours = Math.floor(diffMs / 3600000);
  const diffDays = Math.floor(diffMs / 86400000);

  if (diffMins < 1) return "Just now";
  if (diffMins < 60) return `${diffMins}m ago`;
  if (diffHours < 24) return `${diffHours}h ago`;
  if (diffDays < 7) return `${diffDays}d ago`;
  return date.toLocaleDateString();
}

function truncate(text: string, max: number): string {
  if (text.length <= max) return text;
  return text.slice(0, max).trimEnd() + "...";
}

export default function MessagesScreen() {
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const { user } = useAuth();
  const [conversations, setConversations] = useState<Conversation[]>([]);
  const [loading, setLoading] = useState(true);
  const [refreshing, setRefreshing] = useState(false);
  const [fetchError, setFetchError] = useState(false);

  const fetchConversations = useCallback(async () => {
    if (!user) return;

    try {
      // Fetch messages involving the current user, grouped by listing + other party
      const { data: messages, error } = await supabase
        .from("messages")
        .select("id, listing_id, sender_id, receiver_id, content, created_at, read, listing:listings(address)")
        .or(`sender_id.eq.${user.id},receiver_id.eq.${user.id}`)
        .order("created_at", { ascending: false });

      if (error) {
        setFetchError(true);
        setLoading(false);
        return;
      }

      if (!messages || me

function ScoreCircle({ score }: { score: number }) {
  const color = score >= 8 ? colors.success : score >= 5 ? colors.warning : colors.error;
  const bgColor = score >= 8 ? colors.accentLight : score >= 5 ? colors.amberLight : colors.errorLight;
  return (
    <View style={[styles.scoreCircle, { borderColor: color, backgroundColor: bgColor }]}>
      <Text style={[styles.scoreNumber, { color }]}>{score}</Text>
      <Text style={[styles.scoreDenom, { color: color + "99" }]}>/10</Text>
    </View>
  );
}

export default function OfferAnalysisScreen() {
  const { user } = useAuth();
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const route = useRoute<RouteProp<AppStackParamList, "OfferAnalysis">>();
  const { listingId, offerId, analysis: passedAnalysis, offerInput } = route.params;

  const [analysis, setAnalysis] = useState<OfferAnalysis | null>(passedAnalysis || null);
  const [offer, setOffer] = useState<Offer | null>(null);
  const [saving, setSaving] = useState(false);
  const [saved, setSaved] = useState(!!offerId);
  const [loading, setLoading] = useState(!!offerId && !passedAnalysis);

  useEffect(() => {
    if (offerId && !passedAnalysis) {
      loadOffer();
    }
  }, [offerId]);

  const loadOffer = async () => {
    try {
      const { data } = await supabase
        .from("offers")
        .select("*")
        .eq("id", offerId)
        .single();

      if (data) {
        setOffer(data);
        setAnalysis({
          score: data

function ScoreBadge({ score, isBest }: { score: number; isBest: boolean }) {
  const color = score >= 8 ? colors.success : score >= 5 ? colors.warning : colors.error;
  const bg = isBest ? colors.accentLight : "transparent";
  return (
    <View
      style={[
        styles.cellScoreBadge,
        { backgroundColor: bg, borderColor: color },
      ]}
    >
      <Text style={[styles.cellScoreText, { color }]}>{score}/10</Text>
    </View>
  );
}

export default function OfferCompareScreen() {
  const { user } = useAuth();
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const route = useRoute<RouteProp<AppStackParamList, "OfferCompare">>();
  const { listingId } = route.params;

  const [offers, setOffers] = useState<Offer[]>([]);
  const [loading, setLoading] = useState(true);

  useFocusEffect(
    useCallback(() => {
      fetchOffers();
    }, [user])
  );

  const fetchOffers = async () => {
    if (!user) return;

    try {
      const { data } = await supabase
        .from("offers")
        .select("*")
        .eq("listing_id", listingId)
        .eq("user_id", user.id)
        .order("created_at", { ascending: true });

      setOffers(data ?? []);
    } catch (err) {
      Alert.alert("Error", "Failed to load offers. Please try again.");
    } finally {
      setLoading(false);
    }
  };

  const bestOverallIndex = offers.length
    ? offers.reduce(
        (best, o, i) => ((o.sc

export default function OfferInputScreen() {
  const { user } = useAuth();
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const route = useRoute<RouteProp<AppStackParamList, "OfferInput">>();
  const { listingId } = route.params;

  const [listingPrice, setListingPrice] = useState<number>(0);
  const [propertyAddress, setPropertyAddress] = useState("");
  const [offeredPrice, setOfferedPrice] = useState("");
  const [financingType, setFinancingType] = useState<FinancingType>("conventional");
  const [downPaymentPct, setDownPaymentPct] = useState("");
  const [inspectionContingency, setInspectionContingency] = useState(true);
  const [appraisalContingency, setAppraisalContingency] = useState(true);
  const [closingDate, setClosingDate] = useState("");
  const [sellerConcessions, setSellerConcessions] = useState("");
  const [notes, setNotes] = useState("");
  const [analyzing, setAnalyzing] = useState(false);

  useEffect(() => {
    fetchListing()

function ScoreBadge({ score }: { score: number }) {
  const color = score >= 8 ? colors.success : score >= 5 ? colors.warning : colors.error;
  const bg = score >= 8 ? colors.accentLight : score >= 5 ? colors.amberLight : colors.errorLight;
  return (
    <View style={[styles.scoreBadge, { backgroundColor: bg, borderColor: color }]}>
      <Text style={[styles.scoreBadgeText, { color }]}>{score}/10</Text>
    </View>
  );
}

export default function OffersScreen() {
  const { user } = useAuth();
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const [offers, setOffers] = useState<Offer[]>([]);
  const [loading, setLoading] = useState(true);
  const [refreshing, setRefreshing] = useState(false);
  const [listingId, setListingId] = useState<string | null>(null);
  const [fetchError, setFetchError] = useState(false);

  useFocusEffect(
    useCallback(() => {
      fetchOffers();
    }, [user])
  );

  const fetchOffers = async () => {
    if (!user) return;
    setFetchError(false);
    try {
      const { data: listing } = await supabase
        .from("listings")
        .select("id, price")
        .eq("user_id", user.id)
        .order("created_at", { ascending: false })
        .limit(1)
        .single();

      if (listing) {
        setListingId(listing.id);

        const { data, error } = await supabase
          .from("offers")
          .select("*")
          .e

export default function OnboardingScreen({ navigation }: Props) {
  const scrollRef = useRef<ScrollView>(null);
  const [activeIndex, setActiveIndex] = useState(0);

  const handleScroll = (event: NativeSyntheticEvent<NativeScrollEvent>) => {
    const offsetX = event.nativeEvent.contentOffset.x;
    const index = Math.round(offsetX / SCREEN_WIDTH);
    if (index !== activeIndex) {
      setActiveIndex(index);
    }
  };

  const handleNext = () => {
    if (activeIndex < PAGES.length - 1) {
      scrollRef.current?.scrollTo({
        x: SCREEN_WIDTH * (activeIndex + 1),
        animated: true,
      });
    } else {
      finishOnboarding();
    }
  };

  const handleSkip = () => {
    finishOnboarding();
  };

  const finishOnboarding = async () => {
    try {
      await AsyncStorage.setItem(ONBOARDING_KEY, "true");
    } catch {
      // Continue even if storage fails
    }
    navigation.replace("Welcome");
  };

  const isLastPage = activeIndex === PAGES.length - 1;

  return (
 

export default function PrepHomeScreen() {
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const { user } = useAuth();

  const [checklist, setChecklist] = useState<ChecklistState>(() => {
    const init: ChecklistState = {};
    PREP_ITEMS.forEach((item) => (init[item.id] = false));
    return init;
  });
  const [expandedId, setExpandedId] = useState<string | null>(null);
  const [loading, setLoading] = useState(true);
  const [saving, setSaving] = useState(false);

  // Derived
  const completedCount = useMemo(
    () => Object.values(checklist).filter(Boolean).length,
    [checklist],
  );
  const totalCount = PREP_ITEMS.length;
  const allDone = completedCount === totalCount;
  const progressPct = totalCount > 0 ? completedCount / totalCount : 0;

  // ---- Supabase: load ----
  useEffect(() => {
    if (!user) return;
    (async () => {
      try {
        const { data, error } = await supabase
          .from('home_prep_checklist')
         

function formatPrice(price: number): string {
  return (
    "$" +
    price.toLocaleString("en-US", {
      minimumFractionDigits: 0,
      maximumFractionDigits: 0,
    })
  );
}

export default function PricingResultsScreen() {
  const navigation =
    useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const route = useRoute();
  const { input, result } = route.params as {
    input: PricingInput;
    result: PricingResult;
  };
  const { user } = useAuth();
  const [selected, setSelected] = useState<PriceType>("recommended");
  const [saving, setSaving] = useState(false);
  const [errorMessage, setErrorMessage] = useState<string | null>(null);

  const selectedPrice = result[
    PRICE_OPTIONS.find((o) => o.type === selected)!.key
  ] as number;

  const handleConfirm = async () => {
    if (!user) return;

    setSaving(true);
    setErrorMessage(null);
    try {
      const { error: insertError } = await supabase
        .from("pricing_results")
        .insert({
          user_id: user.id,
          address: input.address,
          sqft: input.sqft,
          bedrooms: input.bedrooms,
          bathrooms: input.bathrooms,
          year_built

export default function PricingScreen() {
  const navigation =
    useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const [address, setAddress] = useState("");
  const [sqft, setSqft] = useState("");
  const [bedrooms, setBedrooms] = useState("");
  const [bathrooms, setBathrooms] = useState("");
  const [yearBuilt, setYearBuilt] = useState("");
  const [condition, setCondition] = useState<PropertyCondition>("Good");
  const [features, setFeatures] = useState("");
  const [loading, setLoading] = useState(false);
  const [errorMessage, setErrorMessage] = useState<string | null>(null);

  const handleSubmit = async () => {
    setErrorMessage(null);

    if (!address || !sqft || !bedrooms || !bathrooms || !yearBuilt) {
      setErrorMessage("Please fill in all property details to get an accurate pricing estimate.");
      return;
    }

    const input: PricingInput = {
      address,
      sqft: parseInt(sqft, 10),
      bedrooms: parseInt(bedrooms, 10),
      bathrooms:

export default function ProfileScreen() {
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const { user, signOut } = useAuth();

  const [fullName, setFullName] = useState("");
  const [phone, setPhone] = useState("");
  const [plan, setPlan] = useState<Plan>("free");
  const [loading, setLoading] = useState(true);
  const [saving, setSaving] = useState(false);

  const email = user?.email ?? "";

  const fetchProfile = useCallback(async () => {
    if (!user) return;
    try {
      const { data } = await supabase
        .from("profiles")
        .select("full_name, phone, plan")
        .eq("id", user.id)
        .single();

      if (data) {
        setFullName(data.full_name ?? "");
        setPhone(data.phone ?? "");
        if (data.plan) setPlan(data.plan as Plan);
      }
    } catch {
      // Continue with defaults if profile fetch fails
    } finally {
      setLoading(false);
    }
  }, [user]);

  useFocusEffect(
    useCallback(() => 

function formatTime(time: string): string {
  const [h, m] = time.split(":");
  const hour = parseInt(h, 10);
  const ampm = hour >= 12 ? "PM" : "AM";
  const hour12 = hour % 12 || 12;
  return `${hour12}:${m} ${ampm}`;
}

export default function ShowingDetailScreen() {
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const route = useRoute<RouteProp<AppStackParamList, "ShowingDetail">>();
  const { user } = useAuth();
  const [showing, setShowing] = useState<Showing | null>(null);
  const [loading, setLoading] = useState(true);
  const [cancelling, setCancelling] = useState(false);

  const fetchShowing = useCallback(async () => {
    try {
      const { data } = await supabase
        .from("showings")
        .select("*")
        .eq("id", route.params.showingId)
        .single();
      if (data) setShowing(data);
    } catch {
      // Will show "Showing not found" state
    } finally {
      setLoading(false);
    }
  }, [route.params.showingId]);

  useEffect(() => {
    fetchShowing();
  }, [fetchShowing]);

  const cancelShowing = () => {
    Alert.alert("Cancel Showing", "Are you sure you want to cancel this showing?", [
      { text: "No", style: "cancel" }

function getNext30Days(): Date[] {
  const days: Date[] = [];
  const today = new Date();
  for (let i = 0; i < 30; i++) {
    const d = new Date(today);
    d.setDate(today.getDate() + i);
    days.push(d);
  }
  return days;
}

function formatDate(date: Date): string {
  return date.toISOString().split("T")[0];
}

function formatTime(time: string): string {
  const [h, m] = time.split(":");
  const hour = parseInt(h, 10);
  const ampm = hour >= 12 ? "PM" : "AM";
  const hour12 = hour % 12 || 12;
  return `${hour12}:${m} ${ampm}`;
}

export default function ShowingsScreen() {
  const { user } = useAuth();
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const [listingId, setListingId] = useState<string | null>(null);
  const [selectedDate, setSelectedDate] = useState<Date>(new Date());
  const [timeWindows, setTimeWindows] = useState<TimeWindow[]>([]);
  const [existingSlots, setExistingSlots] = useState<ShowingAvailability[]>([]);
  const [showings, setShowings] = useState<Showing[]>([]);
  const [loading, setLoading] = useState(true);
  const [refreshing, setRefreshing] = useState(false);
  const [saving, setSaving] = useState(false);
  const [copied, setCopied] = useState(false);
  const [showTimePicker, setShowTimePicker] = useState<{ index: number; field: "startTime" | "endTime" } | null>(null);
  const days = useRef(getNext30Days()).current;

  const fetchData = useCallback(async () => {
    if (!user) return;
    try {
      const { data: listing } = await supabase
      

export default function SignUpScreen({ navigation }: Props) {
  const { signUp } = useAuth();
  const [fullName, setFullName] = useState("");
  const [email, setEmail] = useState("");
  const [password, setPassword] = useState("");
  const [confirmPassword, setConfirmPassword] = useState("");
  const [showPassword, setShowPassword] = useState(false);
  const [showConfirmPassword, setShowConfirmPassword] = useState(false);
  const [loading, setLoading] = useState(false);
  const [success, setSuccess] = useState(false);

  const [nameError, setNameError] = useState("");
  const [emailError, setEmailError] = useState("");
  const [passwordError, setPasswordError] = useState("");
  const [confirmError, setConfirmError] = useState("");
  const [generalError, setGeneralError] = useState("");

  const [nameFocused, setNameFocused] = useState(false);
  const [emailFocused, setEmailFocused] = useState(false);
  const [passwordFocused, setPasswordFocused] = useState(false);
  const [confirmFocus

export default function SyndicationScreen() {
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const { user } = useAuth();
  const [listing, setListing] = useState<ListingSummary | null>(null);
  const [expandedKey, setExpandedKey] = useState<string | null>(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    if (!user) return;
    (async () => {
      try {
        const { data } = await supabase
          .from('listings')
          .select('*')
          .eq('user_id', user.id)
          .order('created_at', { ascending: false })
          .limit(1)
          .maybeSingle();
        if (data) setListing(data as ListingSummary);
      } catch (err) {
        Alert.alert("Error", "Failed to load listing data. Please try again.");
      } finally {
        setLoading(false);
      }
    })();
  }, [user]);

  const toggleExpand = useCallback((key: string) => {
    LayoutAnimation.configureNext(LayoutAnimation.Presets.easeI

export default function UpgradeScreen() {
  const navigation = useNavigation<NativeStackNavigationProp<AppStackParamList>>();
  const { user } = useAuth();
  const [modalVisible, setModalVisible] = useState(false);
  const [selectedPlan, setSelectedPlan] = useState<Plan>("seller_pro");
  const [email, setEmail] = useState("");
  const [saving, setSaving] = useState(false);
  const [confirmed, setConfirmed] = useState(false);
  const [currentPlan, setCurrentPlan] = useState<Plan>("free");

  useFocusEffect(
    useCallback(() => {
      if (!user) return;
      (async () => {
        try {
          const { data } = await supabase
            .from("profiles")
            .select("plan")
            .eq("id", user.id)
            .single();
          if (data?.plan) setCurrentPlan(data.plan as Plan);
        } catch {
          // Continue with default plan if fetch fails
        }
      })();
    }, [user])
  );

  const handleUpgrade = (plan: Plan) => {
    setSelectedPlan(plan);
    

export default function WelcomeScreen({ navigation }: Props) {
  return (
    <SafeAreaView style={styles.container}>
      <StatusBar barStyle="dark-content" />
      <View style={styles.content}>
        {/* Brand */}
        <View style={styles.brandSection}>
          <Text style={styles.brandName}>Chiavo</Text>
          <Text style={styles.tagline}>
            Sell Your Home.{"\n"}Save Thousands.
          </Text>
        </View>

        {/* Value Props */}
        <View style={styles.featuresSection}>
          {FEATURES.map((feature, index) => (
            <View key={index} style={styles.featureRow}>
              <View style={styles.featureIconContainer}>
                <Text style={styles.featureIcon}>{feature.icon}</Text>
              </View>
              <View style={styles.featureText}>
                <Text style={styles.featureTitle}>{feature.title}</Text>
                <Text style={styles.featureSubtitle}>{feature.subtitle}</Text>
              </View>
         

function normalizeStepName(step: string): string {
  return step.toLowerCase().replace(/[^a-z\s]/g, "").trim();
}

export async function POST(request: NextRequest) {
  try {
    const body: GuideRequest = await request.json();
    const { state, remaining_steps, property_address, sale_price } = body;

    if (!remaining_steps || remaining_steps.length === 0) {
      return json(
        { error: "At least one remaining step is required" },
        400
      );
    }

    let result: { guide: GuideStep[]; source?: string };

    try {
      const message = await anthropic.messages.create({
        model: "claude-sonnet-4-20250514",
        max_tokens: 2500,
        messages: [
          {
            role: "user",
            content: `You are a friendly real estate closing advisor helping a FSBO (For Sale By Owner) seller understand what to expect during the closing process. Generate a personalized closing guide.

Property Details:
- Address: ${property_address || "Not specified"}
- Sale Price: $${sale_price ? sale_price.toLocaleString() : "Not specified"}
- State: ${state || "Not specified"}

The 

export function json(data: unknown, status = 200) {
  return NextResponse.json(data, { status, headers: CORS_HEADERS });
}