// src/services/expiryService.server.ts
/**
 * @file Expiry Date Tracking Service
 * Handles inventory management, expiry date calculations, and expiry alerts.
 * Provides functionality for tracking food items and notifying users about expiring items.
 */
import type { Logger } from 'pino';
import { expiryRepo, receiptRepo } from './db/index.db';
import type {
  StorageLocation,
  AlertMethod,
  UserInventoryItem,
  AddInventoryItemRequest,
  UpdateInventoryItemRequest,
  ExpiryDateRange,
  AddExpiryRangeRequest,
  ExpiryAlertSettings,
  UpdateExpiryAlertSettingsRequest,
  ExpiringItemsResponse,
  InventoryQueryOptions,
  ExpiryRangeQueryOptions,
  CalculateExpiryOptions,
} from '../types/expiry';

/**
 * Default expiry warning threshold in days
 */
const DEFAULT_EXPIRY_WARNING_DAYS = 7;

/**
 * Number of days to consider an item "expiring soon"
 */
const EXPIRING_SOON_THRESHOLD = 7;

/**
 * Number of days to consider for "this month" expiry grouping
 */
const THIS_MONTH_THRESHOLD = 30;

// ============================================================================
// INVENTORY MANAGEMENT
// ============================================================================

/**
 * Adds an item to the user's inventory.
 * If no expiry date is provided, attempts to calculate one based on storage location.
 * @param userId The user's ID
 * @param item The item to add
 * @param logger Pino logger instance
 * @returns The created inventory item with computed expiry status
 */
export const addInventoryItem = async (
  userId: string,
  item: AddInventoryItemRequest,
  logger: Logger,
): Promise<UserInventoryItem> => {
  const itemLogger = logger.child({ userId, itemName: item.item_name });
  itemLogger.info('Adding item to inventory');

  // If no expiry date provided and we have purchase date + location, try to calculate
  if (!item.expiry_date && item.purchase_date && item.location) {
    const calculatedExpiry = await calculateExpiryDate(
      {
        master_item_id: item.master_item_id,
        item_name: item.item_name,
        storage_location: item.location,
        purchase_date: item.purchase_date,
      },
      itemLogger,
    );

    if (calculatedExpiry) {
      itemLogger.debug({ calculatedExpiry }, 'Calculated expiry date from storage location');
      item.expiry_date = calculatedExpiry;
    }
  }

  const inventoryItem = await expiryRepo.addInventoryItem(userId, item, itemLogger);
  itemLogger.info({ inventoryId: inventoryItem.inventory_id }, 'Item added to inventory');

  return inventoryItem;
};

/**
 * Updates an existing inventory item.
 * @param inventoryId The inventory item ID
 * @param userId The user's ID (for authorization)
 * @param updates The updates to apply
 * @param logger Pino logger instance
 * @returns The updated inventory item
 */
export const updateInventoryItem = async (
  inventoryId: number,
  userId: string,
  updates: UpdateInventoryItemRequest,
  logger: Logger,
): Promise<UserInventoryItem> => {
  logger.debug({ inventoryId, userId, updates }, 'Updating inventory item');
  return expiryRepo.updateInventoryItem(inventoryId, userId, updates, logger);
};

/**
 * Marks an inventory item as consumed.
 * @param inventoryId The inventory item ID
 * @param userId The user's ID (for authorization)
 * @param logger Pino logger instance
 */
export const markItemConsumed = async (
  inventoryId: number,
  userId: string,
  logger: Logger,
): Promise<void> => {
  logger.debug({ inventoryId, userId }, 'Marking item as consumed');
  await expiryRepo.markAsConsumed(inventoryId, userId, logger);
  logger.info({ inventoryId }, 'Item marked as consumed');
};

/**
 * Deletes an inventory item.
 * @param inventoryId The inventory item ID
 * @param userId The user's ID (for authorization)
 * @param logger Pino logger instance
 */
export const deleteInventoryItem = async (
  inventoryId: number,
  userId: string,
  logger: Logger,
): Promise<void> => {
  logger.debug({ inventoryId, userId }, 'Deleting inventory item');
  await expiryRepo.deleteInventoryItem(inventoryId, userId, logger);
  logger.info({ inventoryId }, 'Item deleted from inventory');
};

/**
 * Gets a single inventory item by ID.
 * @param inventoryId The inventory item ID
 * @param userId The user's ID (for authorization)
 * @param logger Pino logger instance
 * @returns The inventory item
 */
export const getInventoryItemById = async (
  inventoryId: number,
  userId: string,
  logger: Logger,
): Promise<UserInventoryItem> => {
  return expiryRepo.getInventoryItemById(inventoryId, userId, logger);
};

/**
 * Gets the user's inventory with optional filtering and pagination.
 * @param options Query options
 * @param logger Pino logger instance
 * @returns Paginated inventory items
 */
export const getInventory = async (
  options: InventoryQueryOptions,
  logger: Logger,
): Promise<{ items: UserInventoryItem[]; total: number }> => {
  logger.debug({ userId: options.user_id }, 'Fetching user inventory');
  return expiryRepo.getInventory(options, logger);
};

// ============================================================================
// EXPIRING ITEMS
// ============================================================================

/**
 * Gets items grouped by expiry urgency for dashboard display.
 * @param userId The user's ID
 * @param logger Pino logger instance
 * @returns Items grouped by expiry status with counts
 */
export const getExpiringItemsGrouped = async (
  userId: string,
  logger: Logger,
): Promise<ExpiringItemsResponse> => {
  logger.debug({ userId }, 'Fetching expiring items grouped by urgency');

  // Get all expiring items within 30 days + expired items
  const expiringThisMonth = await expiryRepo.getExpiringItems(userId, THIS_MONTH_THRESHOLD, logger);
  const expiredItems = await expiryRepo.getExpiredItems(userId, logger);

  // Group items by urgency
  const today = new Date();
  today.setHours(0, 0, 0, 0);

  const expiringToday: UserInventoryItem[] = [];
  const expiringThisWeek: UserInventoryItem[] = [];
  const expiringLater: UserInventoryItem[] = [];

  for (const item of expiringThisMonth) {
    if (item.days_until_expiry === null) {
      continue;
    }

    if (item.days_until_expiry === 0) {
      expiringToday.push(item);
    } else if (item.days_until_expiry <= EXPIRING_SOON_THRESHOLD) {
      expiringThisWeek.push(item);
    } else {
      expiringLater.push(item);
    }
  }

  const response: ExpiringItemsResponse = {
    expiring_today: expiringToday,
    expiring_this_week: expiringThisWeek,
    expiring_this_month: expiringLater,
    already_expired: expiredItems,
    counts: {
      today: expiringToday.length,
      this_week: expiringThisWeek.length,
      this_month: expiringLater.length,
      expired: expiredItems.length,
      total:
        expiringToday.length + expiringThisWeek.length + expiringLater.length + expiredItems.length,
    },
  };

  logger.info(
    {
      userId,
      counts: response.counts,
    },
    'Expiring items fetched',
  );

  return response;
};

/**
 * Gets items expiring within a specified number of days.
 * @param userId The user's ID
 * @param daysAhead Number of days to look ahead
 * @param logger Pino logger instance
 * @returns Items expiring within the specified timeframe
 */
export const getExpiringItems = async (
  userId: string,
  daysAhead: number,
  logger: Logger,
): Promise<UserInventoryItem[]> => {
  logger.debug({ userId, daysAhead }, 'Fetching expiring items');
  return expiryRepo.getExpiringItems(userId, daysAhead, logger);
};

/**
 * Gets items that have already expired.
 * @param userId The user's ID
 * @param logger Pino logger instance
 * @returns Expired items
 */
export const getExpiredItems = async (
  userId: string,
  logger: Logger,
): Promise<UserInventoryItem[]> => {
  logger.debug({ userId }, 'Fetching expired items');
  return expiryRepo.getExpiredItems(userId, logger);
};

// ============================================================================
// EXPIRY DATE CALCULATION
// ============================================================================

/**
 * Calculates an estimated expiry date based on item and storage location.
 * Uses expiry_date_ranges table for reference data.
 * @param options Calculation options
 * @param logger Pino logger instance
 * @returns Calculated expiry date string (ISO format) or null if unable to calculate
 */
export const calculateExpiryDate = async (
  options: CalculateExpiryOptions,
  logger: Logger,
): Promise<string | null> => {
  const { master_item_id, category_id, item_name, storage_location, purchase_date } = options;

  logger.debug(
    {
      masterItemId: master_item_id,
      categoryId: category_id,
      itemName: item_name,
      storageLocation: storage_location,
    },
    'Calculating expiry date',
  );

  // Look up expiry range for this item/category/pattern
  const expiryRange = await expiryRepo.getExpiryRangeForItem(storage_location, logger, {
    masterItemId: master_item_id,
    categoryId: category_id,
    itemName: item_name,
  });

  if (!expiryRange) {
    logger.debug('No expiry range found for item');
    return null;
  }

  // Calculate expiry date using typical_days
  const purchaseDateTime = new Date(purchase_date);
  purchaseDateTime.setDate(purchaseDateTime.getDate() + expiryRange.typical_days);

  const expiryDateStr = purchaseDateTime.toISOString().split('T')[0];

  logger.debug(
    {
      purchaseDate: purchase_date,
      typicalDays: expiryRange.typical_days,
      expiryDate: expiryDateStr,
    },
    'Expiry date calculated',
  );

  return expiryDateStr;
};

/**
 * Gets expiry date ranges with optional filtering.
 * @param options Query options
 * @param logger Pino logger instance
 * @returns Paginated expiry date ranges
 */
export const getExpiryRanges = async (
  options: ExpiryRangeQueryOptions,
  logger: Logger,
): Promise<{ ranges: ExpiryDateRange[]; total: number }> => {
  return expiryRepo.getExpiryRanges(options, logger);
};

/**
 * Adds a new expiry date range (admin operation).
 * @param range The range to add
 * @param logger Pino logger instance
 * @returns The created expiry range
 */
export const addExpiryRange = async (
  range: AddExpiryRangeRequest,
  logger: Logger,
): Promise<ExpiryDateRange> => {
  logger.info(
    { storageLocation: range.storage_location, typicalDays: range.typical_days },
    'Adding expiry range',
  );
  return expiryRepo.addExpiryRange(range, logger);
};

// ============================================================================
// EXPIRY ALERTS
// ============================================================================

/**
 * Gets the user's expiry alert settings.
 * @param userId The user's ID
 * @param logger Pino logger instance
 * @returns Array of alert settings
 */
export const getAlertSettings = async (
  userId: string,
  logger: Logger,
): Promise<ExpiryAlertSettings[]> => {
  return expiryRepo.getUserAlertSettings(userId, logger);
};

/**
 * Updates the user's expiry alert settings for a specific alert method.
 * @param userId The user's ID
 * @param alertMethod The alert delivery method
 * @param settings The settings to update
 * @param logger Pino logger instance
 * @returns Updated alert settings
 */
export const updateAlertSettings = async (
  userId: string,
  alertMethod: AlertMethod,
  settings: UpdateExpiryAlertSettingsRequest,
  logger: Logger,
): Promise<ExpiryAlertSettings> => {
  logger.debug({ userId, alertMethod, settings }, 'Updating alert settings');
  return expiryRepo.upsertAlertSettings(userId, alertMethod, settings, logger);
};

/**
 * Processes expiry alerts for all users.
 * This should be called by a scheduled worker job.
 * @param logger Pino logger instance
 * @returns Number of alerts sent
 */
export const processExpiryAlerts = async (logger: Logger): Promise<number> => {
  logger.info('Starting expiry alert processing');

  // Get all users with expiring items who have alerts enabled
  const usersToNotify = await expiryRepo.getUsersWithExpiringItems(logger);
  logger.debug({ userCount: usersToNotify.length }, 'Found users to notify');

  let alertsSent = 0;

  for (const user of usersToNotify) {
    try {
      // Get the expiring items for this user
      const expiringItems = await expiryRepo.getExpiringItems(
        user.user_id,
        user.days_before_expiry,
        logger,
      );

      if (expiringItems.length === 0) {
        continue;
      }

      // Send notification based on alert method
      switch (user.alert_method) {
        case 'email':
          await sendExpiryEmailAlert(user.user_id, user.email, expiringItems, logger);
          break;
        case 'push':
          // TODO: Implement push notifications
          logger.debug({ userId: user.user_id }, 'Push notifications not yet implemented');
          break;
        case 'in_app':
          // TODO: Implement in-app notifications
          logger.debug({ userId: user.user_id }, 'In-app notifications not yet implemented');
          break;
      }

      // Log the alert and mark as sent
      for (const item of expiringItems) {
        await expiryRepo.logAlert(
          user.user_id,
          'expiring_soon',
          user.alert_method,
          item.item_name,
          logger,
          {
            pantryItemId: item.inventory_id,
            expiryDate: item.expiry_date,
            daysUntilExpiry: item.days_until_expiry,
          },
        );
      }

      await expiryRepo.markAlertSent(user.user_id, user.alert_method, logger);
      alertsSent++;
    } catch (error) {
      const err = error instanceof Error ? error : new Error(String(error));
      logger.error({ err, userId: user.user_id }, 'Error processing expiry alert for user');
    }
  }

  logger.info({ alertsSent }, 'Expiry alert processing completed');
  return alertsSent;
};

/**
 * Sends an email alert about expiring items.
 * @param userId The user's ID
 * @param email The user's email
 * @param items The expiring items
 * @param logger Pino logger instance
 */
const sendExpiryEmailAlert = async (
  userId: string,
  email: string,
  items: UserInventoryItem[],
  logger: Logger,
): Promise<void> => {
  const alertLogger = logger.child({ userId, email, itemCount: items.length });
  alertLogger.info('Sending expiry alert email');

  // Group items by urgency
  const expiredItems = items.filter((i) => i.days_until_expiry !== null && i.days_until_expiry < 0);
  const todayItems = items.filter((i) => i.days_until_expiry === 0);
  const soonItems = items.filter(
    (i) => i.days_until_expiry !== null && i.days_until_expiry > 0 && i.days_until_expiry <= 3,
  );
  const laterItems = items.filter((i) => i.days_until_expiry !== null && i.days_until_expiry > 3);

  // Build the email content
  const subject =
    todayItems.length > 0 || expiredItems.length > 0
      ? '⚠️ Food Items Expiring Today or Already Expired!'
      : `🕐 ${items.length} Food Item${items.length > 1 ? 's' : ''} Expiring Soon`;

  const buildItemList = (itemList: UserInventoryItem[], emoji: string): string => {
    if (itemList.length === 0) return '';
    return itemList
      .map((item) => {
        const daysText =
          item.days_until_expiry === 0
            ? 'today'
            : item.days_until_expiry === 1
              ? 'tomorrow'
              : item.days_until_expiry !== null && item.days_until_expiry < 0
                ? `${Math.abs(item.days_until_expiry)} day${Math.abs(item.days_until_expiry) > 1 ? 's' : ''} ago`
                : `in ${item.days_until_expiry} days`;
        const location = item.location ? ` (${item.location})` : '';
        return `${emoji} <strong>${item.item_name}</strong>${location} - expires ${daysText}`;
      })
      .join('<br>');
  };

  let htmlBody = '';

  if (expiredItems.length > 0) {
    htmlBody += `<h3 style="color: #dc3545;">Already Expired (${expiredItems.length})</h3>
      <p>${buildItemList(expiredItems, '❌')}</p>`;
  }

  if (todayItems.length > 0) {
    htmlBody += `<h3 style="color: #fd7e14;">Expiring Today (${todayItems.length})</h3>
      <p>${buildItemList(todayItems, '⚠️')}</p>`;
  }

  if (soonItems.length > 0) {
    htmlBody += `<h3 style="color: #ffc107;">Expiring Within 3 Days (${soonItems.length})</h3>
      <p>${buildItemList(soonItems, '🕐')}</p>`;
  }

  if (laterItems.length > 0) {
    htmlBody += `<h3 style="color: #28a745;">Expiring This Week (${laterItems.length})</h3>
      <p>${buildItemList(laterItems, '📅')}</p>`;
  }

  const html = `
    <div style="font-family: sans-serif; padding: 20px; max-width: 600px;">
      <h2 style="color: #333;">Food Expiry Alert</h2>
      <p>The following items in your pantry need attention:</p>
      ${htmlBody}
      <hr style="margin: 20px 0; border: none; border-top: 1px solid #eee;">
      <p style="color: #666; font-size: 14px;">
        Visit your <a href="${process.env.FRONTEND_URL || 'https://flyer-crawler.projectium.com'}/inventory">inventory page</a>
        to manage these items. You can also find
        <a href="${process.env.FRONTEND_URL || 'https://flyer-crawler.projectium.com'}/recipes/suggestions">recipe suggestions</a>
        to use them before they expire!
      </p>
      <p style="color: #999; font-size: 12px;">
        To manage your alert preferences, visit your <a href="${process.env.FRONTEND_URL || 'https://flyer-crawler.projectium.com'}/settings">settings page</a>.
      </p>
    </div>
  `;

  // Build plain text version
  const buildTextList = (itemList: UserInventoryItem[]): string => {
    return itemList
      .map((item) => {
        const daysText =
          item.days_until_expiry === 0
            ? 'today'
            : item.days_until_expiry === 1
              ? 'tomorrow'
              : item.days_until_expiry !== null && item.days_until_expiry < 0
                ? `${Math.abs(item.days_until_expiry)} day(s) ago`
                : `in ${item.days_until_expiry} days`;
        return `  - ${item.item_name} - expires ${daysText}`;
      })
      .join('\n');
  };

  let textBody = 'Food Expiry Alert\n\nThe following items need attention:\n\n';
  if (expiredItems.length > 0) {
    textBody += `Already Expired:\n${buildTextList(expiredItems)}\n\n`;
  }
  if (todayItems.length > 0) {
    textBody += `Expiring Today:\n${buildTextList(todayItems)}\n\n`;
  }
  if (soonItems.length > 0) {
    textBody += `Expiring Within 3 Days:\n${buildTextList(soonItems)}\n\n`;
  }
  if (laterItems.length > 0) {
    textBody += `Expiring This Week:\n${buildTextList(laterItems)}\n\n`;
  }
  textBody += 'Visit your inventory page to manage these items.\n\nFlyer Crawler';

  try {
    await emailService.sendEmail(
      {
        to: email,
        subject,
        text: textBody,
        html,
      },
      alertLogger,
    );
    alertLogger.info('Expiry alert email sent successfully');
  } catch (error) {
    alertLogger.error({ err: error }, 'Failed to send expiry alert email');
    throw error;
  }
};

// ============================================================================
// RECEIPT INTEGRATION
// ============================================================================

/**
 * Adds items from a confirmed receipt to the user's inventory.
 * @param userId The user's ID
 * @param receiptId The receipt ID
 * @param itemConfirmations Array of item confirmations with storage locations
 * @param logger Pino logger instance
 * @returns Array of created inventory items
 */
export const addItemsFromReceipt = async (
  userId: string,
  receiptId: number,
  itemConfirmations: Array<{
    receipt_item_id: number;
    item_name?: string;
    quantity?: number;
    location?: StorageLocation;
    expiry_date?: string;
    include: boolean;
  }>,
  logger: Logger,
): Promise<UserInventoryItem[]> => {
  const receiptLogger = logger.child({ userId, receiptId });
  receiptLogger.info(
    { itemCount: itemConfirmations.length },
    'Adding items from receipt to inventory',
  );

  const createdItems: UserInventoryItem[] = [];

  // Get receipt details for purchase date
  const receipt = await receiptRepo.getReceiptById(receiptId, userId, receiptLogger);

  for (const confirmation of itemConfirmations) {
    if (!confirmation.include) {
      receiptLogger.debug(
        { receiptItemId: confirmation.receipt_item_id },
        'Skipping excluded item',
      );
      continue;
    }

    try {
      // Get the receipt item details
      const receiptItems = await receiptRepo.getReceiptItems(receiptId, receiptLogger);
      const receiptItem = receiptItems.find(
        (ri) => ri.receipt_item_id === confirmation.receipt_item_id,
      );

      if (!receiptItem) {
        receiptLogger.warn(
          { receiptItemId: confirmation.receipt_item_id },
          'Receipt item not found',
        );
        continue;
      }

      // Create inventory item
      const inventoryItem = await addInventoryItem(
        userId,
        {
          product_id: receiptItem.product_id ?? undefined,
          master_item_id: receiptItem.master_item_id ?? undefined,
          item_name: confirmation.item_name || receiptItem.raw_item_description,
          quantity: confirmation.quantity || receiptItem.quantity,
          purchase_date: receipt.transaction_date || receipt.created_at.split('T')[0],
          expiry_date: confirmation.expiry_date,
          source: 'receipt_scan',
          location: confirmation.location,
        },
        receiptLogger,
      );

      // Update receipt item to mark as added to pantry
      await receiptRepo.updateReceiptItem(
        confirmation.receipt_item_id,
        {
          added_to_pantry: true,
          pantry_item_id: inventoryItem.inventory_id,
        },
        receiptLogger,
      );

      createdItems.push(inventoryItem);
    } catch (error) {
      const err = error instanceof Error ? error : new Error(String(error));
      receiptLogger.error(
        { err, receiptItemId: confirmation.receipt_item_id },
        'Error adding receipt item to inventory',
      );
    }
  }

  receiptLogger.info({ createdCount: createdItems.length }, 'Items added from receipt');
  return createdItems;
};

/**
 * Gets recipe suggestions based on expiring items.
 * Prioritizes recipes that use items closest to expiry.
 * @param userId The user's ID
 * @param daysAhead Number of days to look ahead for expiring items
 * @param logger Pino logger instance
 * @param options Pagination options
 * @returns Recipes with matching expiring ingredients
 */
export const getRecipeSuggestionsForExpiringItems = async (
  userId: string,
  daysAhead: number,
  logger: Logger,
  options: { limit?: number; offset?: number } = {},
): Promise<{
  recipes: Array<{
    recipe_id: number;
    recipe_name: string;
    description: string | null;
    prep_time_minutes: number | null;
    cook_time_minutes: number | null;
    servings: number | null;
    photo_url: string | null;
    matching_items: UserInventoryItem[];
    match_count: number;
  }>;
  total: number;
  considered_items: UserInventoryItem[];
}> => {
  const { limit = 10, offset = 0 } = options;
  const suggestionLogger = logger.child({ userId, daysAhead });
  suggestionLogger.debug('Fetching recipe suggestions for expiring items');

  // Get expiring items to include in the response
  const expiringItems = await getExpiringItems(userId, daysAhead, logger);

  if (expiringItems.length === 0) {
    suggestionLogger.debug('No expiring items found, returning empty suggestions');
    return {
      recipes: [],
      total: 0,
      considered_items: [],
    };
  }

  // Get recipes that use the expiring items
  const recipeData = await expiryRepo.getRecipesForExpiringItems(
    userId,
    daysAhead,
    limit,
    offset,
    suggestionLogger,
  );

  // Map the expiring items by master_item_id for quick lookup
  const itemsByMasterId = new Map<number, UserInventoryItem>();
  for (const item of expiringItems) {
    if (item.master_item_id && !itemsByMasterId.has(item.master_item_id)) {
      itemsByMasterId.set(item.master_item_id, item);
    }
  }

  // Build the response with matching items
  const recipes = recipeData.recipes.map((recipe) => ({
    recipe_id: recipe.recipe_id,
    recipe_name: recipe.recipe_name,
    description: recipe.description,
    prep_time_minutes: recipe.prep_time_minutes,
    cook_time_minutes: recipe.cook_time_minutes,
    servings: recipe.servings,
    photo_url: recipe.photo_url,
    matching_items: recipe.matching_master_item_ids
      .map((id) => itemsByMasterId.get(id))
      .filter((item): item is UserInventoryItem => item !== undefined),
    match_count: recipe.match_count,
  }));

  suggestionLogger.info(
    {
      recipeCount: recipes.length,
      total: recipeData.total,
      expiringItemCount: expiringItems.length,
    },
    'Recipe suggestions fetched for expiring items',
  );

  return {
    recipes,
    total: recipeData.total,
    considered_items: expiringItems,
  };
};

// ============================================================================
// JOB PROCESSING
// ============================================================================

import type { Job } from 'bullmq';
import type { ExpiryAlertJobData } from '../types/job-data';
import * as emailService from './emailService.server';

/**
 * Processes an expiry alert job from the queue.
 * This is the main entry point for background expiry alert processing.
 * @param job The BullMQ job
 * @param logger Pino logger instance
 * @returns Processing result with counts of alerts sent
 */
export const processExpiryAlertJob = async (
  job: Job<ExpiryAlertJobData>,
  logger: Logger,
): Promise<{ success: boolean; alertsSent: number; usersNotified: number }> => {
  const {
    alertType,
    userId,
    daysAhead = DEFAULT_EXPIRY_WARNING_DAYS,
    scheduledAt: _scheduledAt,
  } = job.data;
  const jobLogger = logger.child({
    jobId: job.id,
    alertType,
    userId,
    daysAhead,
    requestId: job.data.meta?.requestId,
  });

  jobLogger.info('Starting expiry alert job');

  try {
    let alertsSent = 0;
    let usersNotified = 0;

    if (alertType === 'user_specific' && userId) {
      // Process alerts for a single user
      const result = await processUserExpiryAlerts(userId, daysAhead, jobLogger);
      alertsSent = result.alertsSent;
      usersNotified = result.alertsSent > 0 ? 1 : 0;
    } else if (alertType === 'daily_check') {
      // Process daily alerts for all users with expiring items
      const result = await processDailyExpiryAlerts(daysAhead, jobLogger);
      alertsSent = result.totalAlerts;
      usersNotified = result.usersNotified;
    }

    jobLogger.info({ alertsSent, usersNotified }, 'Expiry alert job completed');

    return { success: true, alertsSent, usersNotified };
  } catch (error) {
    jobLogger.error({ err: error }, 'Expiry alert job failed');
    throw error;
  }
};

/**
 * Processes expiry alerts for a single user.
 * @param userId The user's ID
 * @param daysAhead Days ahead to check for expiring items
 * @param logger Pino logger instance
 * @returns Number of alerts sent
 */
const processUserExpiryAlerts = async (
  userId: string,
  daysAhead: number,
  logger: Logger,
): Promise<{ alertsSent: number }> => {
  const userLogger = logger.child({ userId });

  // Get user's alert settings
  const settings = await expiryRepo.getUserAlertSettings(userId, userLogger);
  const enabledSettings = settings.filter((s) => s.is_enabled);

  if (enabledSettings.length === 0) {
    userLogger.debug('No enabled alert settings for user');
    return { alertsSent: 0 };
  }

  // Get expiring items
  const expiringItems = await getExpiringItems(userId, daysAhead, userLogger);

  if (expiringItems.length === 0) {
    userLogger.debug('No expiring items for user');
    return { alertsSent: 0 };
  }

  let alertsSent = 0;

  // Group items by urgency for the alert (kept for future use in alert formatting)
  const _expiredItems = expiringItems.filter((i) => i.expiry_status === 'expired');
  const _soonItems = expiringItems.filter((i) => i.expiry_status === 'expiring_soon');

  // Check if we should send alerts based on settings
  for (const setting of enabledSettings) {
    const relevantItems = expiringItems.filter(
      (item) =>
        item.days_until_expiry !== null && item.days_until_expiry <= setting.days_before_expiry,
    );

    if (relevantItems.length > 0) {
      // Log the alert
      for (const item of relevantItems) {
        const alertType: ExpiryAlertType =
          item.expiry_status === 'expired' ? 'expired' : 'expiring_soon';
        await expiryRepo.logAlert(
          userId,
          alertType,
          setting.alert_method,
          item.item_name,
          userLogger,
          {
            pantryItemId: item.inventory_id,
            expiryDate: item.expiry_date || null,
            daysUntilExpiry: item.days_until_expiry,
          },
        );
        alertsSent++;
      }

      // Update last alert sent time via upsert
      await expiryRepo.upsertAlertSettings(userId, setting.alert_method, {}, userLogger);
    }
  }

  userLogger.info({ alertsSent, itemCount: expiringItems.length }, 'Processed user expiry alerts');
  return { alertsSent };
};

/**
 * Processes daily expiry alerts for all users.
 * @param daysAhead Days ahead to check for expiring items
 * @param logger Pino logger instance
 * @returns Total alerts and users notified
 */
const processDailyExpiryAlerts = async (
  daysAhead: number,
  logger: Logger,
): Promise<{ totalAlerts: number; usersNotified: number }> => {
  // Get all users with items expiring within the threshold
  const usersWithExpiringItems = await expiryRepo.getUsersWithExpiringItems(logger);

  // Get unique user IDs
  const uniqueUserIds = [...new Set(usersWithExpiringItems.map((u) => u.user_id))];

  let totalAlerts = 0;
  let usersNotified = 0;

  for (const userId of uniqueUserIds) {
    try {
      const result = await processUserExpiryAlerts(userId, daysAhead, logger);
      totalAlerts += result.alertsSent;
      if (result.alertsSent > 0) {
        usersNotified++;
      }
    } catch (error) {
      logger.error({ err: error, userId }, 'Failed to process alerts for user');
      // Continue with other users
    }
  }

  logger.info(
    { totalAlerts, usersNotified, totalUsers: uniqueUserIds.length },
    'Daily expiry alert processing complete',
  );

  return { totalAlerts, usersNotified };
};