📦Delivery rFBS API

// Complete rFBS Delivery Lifecycle
async function completeRfbsDeliveryLifecycle(postingNumber: string) {
  try {
    // Step 1: Set cutoff date for shipment
    const cutoff = await deliveryRfbsApi.setCutoff({
      posting_number: postingNumber,
      cutoff_at: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString() // +1 day
    });
    
    if (cutoff.result !== 'success') {
      throw new Error(`Cutoff setting failed: ${cutoff.error}`);
    }
    
    // Step 2: Add tracking number
    const tracking = await deliveryRfbsApi.setTrackingNumbers({
      tracking_numbers: [{
        posting_number: postingNumber,
        tracking_number: `TRACK${Date.now()}`,
        delivery_service: 'CDEK'
      }]
    });
    
    const trackingResult = tracking.results?.[0];
    if (trackingResult?.result !== 'success') {
      throw new Error(`Tracking number failed: ${trackingResult?.error}`);
    }
    
    // Step 3: Status progression with delays
    const statusUpdates = [
      { method: 'setSentBySeller', timestamp: Date.now() },
      { method: 'setDelivering', timestamp: Date.now() + 2 * 24 * 60 * 60 * 1000 }, // +2 days
      { method: 'setLastMile', timestamp: Date.now() + 4 * 24 * 60 * 60 * 1000 }, // +4 days
      { method: 'setDelivered', timestamp: Date.now() + 5 * 24 * 60 * 60 * 1000 } // +5 days
    ];
    
    for (const update of statusUpdates) {
      const result = await deliveryRfbsApi[update.method]({
        posting_number: postingNumber,
        [`${update.method.replace('set', '').toLowerCase()}_at`]: new Date(update.timestamp).toISOString()
      });
      
      if (result.result !== 'success') {
        console.warn(`Status update ${update.method} failed: ${result.error}`);
      } else {
        console.log(`✅ ${update.method} completed`);
      }
    }
    
    return {
      status: 'completed',
      postingNumber,
      trackingNumber: trackingResult.tracking_number
    };
    
  } catch (error) {
    console.error('rFBS delivery lifecycle failed:', error);
    throw error;
  }
}

// Smart Delivery Rescheduling
async function smartDeliveryRescheduling(postingNumber: string, preferredDate?: string) {
  try {
    // Check rescheduling availability
    const restrictions = await deliveryRfbsApi.getTimeslotChangeRestrictions({
      posting_number: postingNumber
    });
    
    const availableDates = restrictions.restrictions?.available_dates ?? [];
    const remainingReschedules = restrictions.restrictions?.available_reschedules ?? 0;
    
    if (remainingReschedules <= 0) {
      throw new Error('No reschedules remaining for this posting');
    }
    
    if (availableDates.length === 0) {
      throw new Error('No available dates for rescheduling');
    }
    
    // Select optimal date
    let selectedDate = preferredDate;
    
    // If preferred date is not available, select the earliest available
    if (!selectedDate || !availableDates.includes(selectedDate)) {
      selectedDate = availableDates.sort()[0];
      console.log(`Preferred date not available. Selected: ${selectedDate}`);
    }
    
    // Perform rescheduling
    const result = await deliveryRfbsApi.setTimeslot({
      posting_number: postingNumber,
      timeslot_date: selectedDate
    });
    
    if (result.result !== 'success') {
      throw new Error(`Rescheduling failed: ${result.error}`);
    }
    
    return {
      success: true,
      originalPreference: preferredDate,
      actualDate: result.new_timeslot_date,
      remainingReschedules: remainingReschedules - 1
    };
    
  } catch (error) {
    console.error('Smart rescheduling failed:', error);
    return {
      success: false,
      error: error.message
    };
  }
}

// Set cutoff date
const cutoffResult = await deliveryRfbsApi.setCutoff({
  posting_number: 'FBS-123456789',
  cutoff_at: '2024-01-15T10:00:00Z'
});

// Check rescheduling availability
const restrictions = await deliveryRfbsApi.getTimeslotChangeRestrictions({
  posting_number: 'FBS-123456789'
});

console.log('Available dates:', restrictions.restrictions?.available_dates);
console.log('Remaining reschedules:', restrictions.restrictions?.available_reschedules);

// Reschedule delivery
const rescheduleResult = await deliveryRfbsApi.setTimeslot({
  posting_number: 'FBS-123456789',
  timeslot_date: '2024-01-25'
});

if (rescheduleResult.result === 'success') {
  console.log('New delivery date:', rescheduleResult.new_timeslot_date);
}

// Update status to "Sent by seller"
const sentResult = await deliveryRfbsApi.setSentBySeller({
  posting_number: 'FBS-123456789',
  sent_by_seller_at: '2024-01-15T12:00:00Z'
});

// Update status to "Delivering"
const deliveringResult = await deliveryRfbsApi.setDelivering({
  posting_number: 'FBS-123456789',
  delivering_at: '2024-01-18T09:00:00Z'
});

// Update status to "Delivered"
const deliveredResult = await deliveryRfbsApi.setDelivered({
  posting_number: 'FBS-123456789',
  delivered_at: '2024-01-20T15:30:00Z'
});

if (deliveredResult.result === 'success') {
  console.log('Delivery completed:', deliveredResult.status);
}

// Add tracking numbers to multiple postings
const trackingResult = await deliveryRfbsApi.setTrackingNumbers({
  tracking_numbers: [
    {
      posting_number: 'FBS-123456789',
      tracking_number: 'TRACK123456',
      delivery_service: 'CDEK'
    },
    {
      posting_number: 'FBS-987654321',
      tracking_number: 'TRACK789012',
      delivery_service: 'Russian Post'
    },
    {
      posting_number: 'FBS-555666777',
      tracking_number: 'TRACK345678',
      delivery_service: 'DPD'
    }
  ]
});

// Process results
trackingResult.results?.forEach(res => {
  if (res.result === 'success') {
    console.log(`✅ ${res.posting_number}: Tracking ${res.tracking_number} added`);
  } else {
    console.error(`❌ ${res.posting_number}: ${res.error}`);
  }
});

const successful = trackingResult.results?.filter(r => r.result === 'success').length ?? 0;
const failed = trackingResult.results?.filter(r => r.result === 'error').length ?? 0;
console.log(`Summary: ${successful} successful, ${failed} failed`);