/**
 * Warehouse State Utilities
 *
 * Functions for preserving warehouse quantities when warehouses are selected/deselected.
 * Ensures data is not lost when users toggle warehouse selection.
 */

import type { SheetRow } from "./ItemsTable";

/**
 * Preserves warehouse quantities when warehouse selection changes.
 * 
 * When a warehouse is deselected, its quantities are preserved in a separate state.
 * When it's reselected, the quantities are restored.
 * 
 * @param rows - Current sheet rows
 * @param previousWarehouses - Previously selected warehouse IDs
 * @param newWarehouses - Newly selected warehouse IDs
 * @param preservedQuantities - Map of preserved quantities by warehouse ID
 * @returns Updated rows with preserved quantities restored
 */
export function updateRowsForWarehouseChange(
  rows: SheetRow[],
  previousWarehouses: string[],
  newWarehouses: string[],
  preservedQuantities: Map<string, Record<string, string>>
): { updatedRows: SheetRow[]; updatedPreserved: Map<string, Record<string, string>> } {
  const updatedPreserved = new Map(preservedQuantities);
  
  // Find warehouses that were removed
  const removedWarehouses = previousWarehouses.filter(id => !newWarehouses.includes(id));
  
  // Find warehouses that were added back
  const addedWarehouses = newWarehouses.filter(id => !previousWarehouses.includes(id));
  
  // Preserve quantities for removed warehouses
  removedWarehouses.forEach(warehouseId => {
    const quantities: Record<string, string> = {};
    rows.forEach(row => {
      if (row.warehouseBags[warehouseId]) {
        quantities[row.itemId] = row.warehouseBags[warehouseId];
      }
    });
    updatedPreserved.set(warehouseId, quantities);
  });
  
  // Restore quantities for added warehouses
  const updatedRows = rows.map(row => {
    const newWarehouseBags = { ...row.warehouseBags };
    
    addedWarehouses.forEach(warehouseId => {
      const preserved = updatedPreserved.get(warehouseId);
      if (preserved && preserved[row.itemId]) {
        // Restore preserved quantity
        newWarehouseBags[warehouseId] = preserved[row.itemId];
      } else {
        // Initialize with empty string
        newWarehouseBags[warehouseId] = "";
      }
    });
    
    return { ...row, warehouseBags: newWarehouseBags };
  });
  
  return { updatedRows, updatedPreserved };
}

/**
 * Initializes warehouse bags for all rows based on selected warehouses.
 * 
 * @param rows - Current sheet rows
 * @param selectedWarehouses - Selected warehouse IDs
 * @param preservedQuantities - Map of preserved quantities by warehouse ID
 * @returns Updated rows with initialized warehouse bags
 */
export function initializeWarehouseBags(
  rows: SheetRow[],
  selectedWarehouses: string[],
  preservedQuantities: Map<string, Record<string, string>>
): SheetRow[] {
  return rows.map(row => {
    const warehouseBags: Record<string, string> = {};
    
    selectedWarehouses.forEach(warehouseId => {
      const preserved = preservedQuantities.get(warehouseId);
      if (preserved && preserved[row.itemId]) {
        // Restore preserved quantity
        warehouseBags[warehouseId] = preserved[row.itemId];
      } else if (row.warehouseBags[warehouseId]) {
        // Keep existing quantity
        warehouseBags[warehouseId] = row.warehouseBags[warehouseId];
      } else {
        // Initialize with empty string
        warehouseBags[warehouseId] = "";
      }
    });
    
    return { ...row, warehouseBags };
  });
}

/**
 * Clears all preserved quantities (called on modal close or successful submission).
 * 
 * @returns Empty Map
 */
export function clearPreservedQuantities(): Map<string, Record<string, string>> {
  return new Map();
}

/**
 * Gets preserved quantities for a specific warehouse.
 * 
 * @param warehouseId - Warehouse ID
 * @param preservedQuantities - Map of preserved quantities
 * @returns Record of item ID to quantity, or empty object if not found
 */
export function getPreservedQuantitiesForWarehouse(
  warehouseId: string,
  preservedQuantities: Map<string, Record<string, string>>
): Record<string, string> {
  return preservedQuantities.get(warehouseId) || {};
}

/**
 * Checks if any quantities are preserved for a warehouse.
 * 
 * @param warehouseId - Warehouse ID
 * @param preservedQuantities - Map of preserved quantities
 * @returns True if quantities are preserved, false otherwise
 */
export function hasPreservedQuantities(
  warehouseId: string,
  preservedQuantities: Map<string, Record<string, string>>
): boolean {
  const quantities = preservedQuantities.get(warehouseId);
  if (!quantities) return false;
  return Object.values(quantities).some(qty => qty !== "" && Number(qty) > 0);
}