Get Property Availability

const AvailabilityCalendar = ({ propertyId, month, year }) => {
  const [availability, setAvailability] = useState(null);
  const [loading, setLoading] = useState(true);
  
  useEffect(() => {
    const fetchAvailability = async () => {
      const startDate = `${year}-${month.toString().padStart(2, '0')}-01`;
      const endDate = new Date(year, month, 0).toISOString().split('T')[0];
      
      try {
        const data = await getPropertyAvailability(propertyId, {
          dateFrom: startDate,
          dateTo: endDate,
          checkBookingConflicts: true
        });
        setAvailability(data);
      } catch (error) {
        console.error('Failed to fetch availability:', error);
      } finally {
        setLoading(false);
      }
    };
    
    fetchAvailability();
  }, [propertyId, month, year]);
  
  if (loading) return <div>Loading availability...</div>;
  if (!availability) return <div>No availability data</div>;
  
  const renderDay = (date) => {
    const dayData = availability.availabilities.find(a => a.date === date);
    if (!dayData) return null;
    
    const hasConflict = availability.bookingConflicts.some(conflict => 
      date >= conflict.checkInDate && date < conflict.checkOutDate
    );
    
    return (
      <div 
        className={`calendar-day ${dayData.isAvailable ? 'available' : 'unavailable'} ${hasConflict ? 'conflict' : ''}`}
        title={`$${dayData.price} per night`}
      >
        <div className="date">{new Date(date).getDate()}</div>
        <div className="price">${dayData.price}</div>
        {dayData.restrictions.minNights > 1 && (
          <div className="min-nights">{dayData.restrictions.minNights}n min</div>
        )}
      </div>
    );
  };
  
  return (
    <div className="availability-calendar">
      <div className="source-info">
        Data from: {availability.source}
        {availability.lastSyncAt && (
          <span>Last updated: {new Date(availability.lastSyncAt).toLocaleString()}</span>
        )}
      </div>
      
      {/* Calendar grid rendering logic */}
      <div className="calendar-grid">
        {availability.availabilities.map(day => renderDay(day.date))}
      </div>
      
      {availability.bookingConflicts.length > 0 && (
        <div className="conflicts-notice">
          <h4>Booking Conflicts:</h4>
          {availability.bookingConflicts.map((conflict, index) => (
            <div key={index} className="conflict-item">
              {conflict.checkInDate} to {conflict.checkOutDate} 
              ({conflict.type})
              {conflict.expiresAt && (
                <span> - expires {new Date(conflict.expiresAt).toLocaleString()}</span>
              )}
            </div>
          ))}
        </div>
      )}
    </div>
  );
};

const validateBookingDates = (availability, checkIn, checkOut) => {
  const checkInData = availability.availabilities.find(a => a.date === checkIn);
  const stayDates = availability.availabilities.filter(a => 
    a.date >= checkIn && a.date < checkOut
  );
  
  const validation = {
    valid: true,
    errors: [],
    warnings: [],
    totalCost: 0
  };
  
  // Check if check-in date exists and is available
  if (!checkInData) {
    validation.valid = false;
    validation.errors.push('Check-in date not found in availability data');
    return validation;
  }
  
  if (!checkInData.isAvailable) {
    validation.valid = false;
    validation.errors.push('Check-in date is not available');
  }
  
  if (checkInData.restrictions?.closedForArrival) {
    validation.valid = false;
    validation.errors.push('Check-in date is closed for arrivals');
  }
  
  // Check minimum nights requirement
  const nights = stayDates.length;
  if (checkInData.restrictions?.minNights > nights) {
    validation.valid = false;
    validation.errors.push(`Minimum ${checkInData.restrictions.minNights} nights required`);
  }
  
  // Check maximum nights requirement
  if (checkInData.restrictions?.maxNights && nights > checkInData.restrictions.maxNights) {
    validation.valid = false;
    validation.errors.push(`Maximum ${checkInData.restrictions.maxNights} nights allowed`);
  }
  
  // Check all stay dates are available
  const unavailableDates = stayDates.filter(day => !day.isAvailable);
  if (unavailableDates.length > 0) {
    validation.valid = false;
    validation.errors.push(`Unavailable dates: ${unavailableDates.map(d => d.date).join(', ')}`);
  }
  
  // Check for booking conflicts
  const conflicts = availability.bookingConflicts.filter(conflict => {
    const conflictStart = new Date(conflict.checkInDate);
    const conflictEnd = new Date(conflict.checkOutDate);
    const stayStart = new Date(checkIn);
    const stayEnd = new Date(checkOut);
    
    return stayStart < conflictEnd && stayEnd > conflictStart;
  });
  
  if (conflicts.length > 0) {
    const pendingConflicts = conflicts.filter(c => c.type === 'pending_payment_intent');
    const confirmedConflicts = conflicts.filter(c => c.type === 'confirmed_booking');
    
    if (confirmedConflicts.length > 0) {
      validation.valid = false;
      validation.errors.push('Dates conflict with confirmed booking');
    }
    
    if (pendingConflicts.length > 0) {
      validation.warnings.push('Dates have pending payment intent (may expire soon)');
    }
  }
  
  // Calculate total cost
  validation.totalCost = stayDates.reduce((sum, day) => sum + day.price, 0);
  
  return validation;
};

const analyzePriceTrends = (availability) => {
  const prices = availability.availabilities
    .filter(day => day.isAvailable)
    .map(day => ({ date: day.date, price: day.price }));
    
  if (prices.length === 0) return null;
  
  const minPrice = Math.min(...prices.map(p => p.price));
  const maxPrice = Math.max(...prices.map(p => p.price));
  const avgPrice = prices.reduce((sum, p) => sum + p.price, 0) / prices.length;
  
  const bestValueDates = prices
    .filter(p => p.price === minPrice)
    .map(p => p.date);
    
  const premiumDates = prices
    .filter(p => p.price === maxPrice)
    .map(p => p.date);
  
  return {
    minPrice,
    maxPrice,
    avgPrice: Math.round(avgPrice * 100) / 100,
    bestValueDates,
    premiumDates,
    priceSpread: maxPrice - minPrice,
    availability: {
      total: availability.availabilities.length,
      available: prices.length,
      percentage: Math.round((prices.length / availability.availabilities.length) * 100)
    }
  };
};

const resolveConflicts = (conflicts) => {
  const now = new Date();
  
  return conflicts.map(conflict => {
    if (conflict.type === 'pending_payment_intent' && conflict.expiresAt) {
      const expiresAt = new Date(conflict.expiresAt);
      const isExpired = now > expiresAt;
      
      return {
        ...conflict,
        isExpired,
        remainingTime: isExpired ? 0 : Math.max(0, expiresAt - now)
      };
    }
    
    return conflict;
  });
};