datupapi 1.111.0__py3-none-any.whl → 1.112.1__py3-none-any.whl

datupapi/inventory/src/FutureInventory/future_reorder.py

@@ -1,358 +1,609 @@
 import pandas as pd
+import numpy as np
 import os
 import ast
-import numpy as np
-from datetime import timedelta
+import time
+import sys
+from datetime import timedelta, datetime
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from multiprocessing import cpu_count
+import gc
+from typing import Dict, List, Tuple, Optional, Union
 from datupapi.utils.utils import Utils
 from datupapi.inventory.src.SuggestedForecast.suggested_forecast import SuggestedForecast
 from datupapi.inventory.src.FutureInventory.daily_usage_future import DailyUsageFuture
 
 
-class FutureReorder():
+def _generate_item_dates_worker(key, df_lead_time, periods, period2, start_date, start_date_zero, default_coverage, location):
     """
-    A class for calculating future inventory reorder points and quantities.
-    
-    This class implements a sophisticated inventory management system that:
-    - Calculates optimal reorder points based on forecasted demand
-    - Manages in-transit inventory and arrival schedules
-    - Determines safety stock levels using statistical or reference methods
-    - Generates reorder recommendations for multiple future periods
-    - Supports both single-location and multi-location inventory
+    Generate dates for a single item in the worker process context.
+    This function replicates the logic from future_date() but for a single item.
     
-    The system uses dynamic coverage strategies to optimize inventory levels
-    while maintaining adequate safety stock to prevent stockouts.
-    
-    Output Fields:
-    - FutureInventoryTransit: Total future inventory (stock + transit)
-    - FutureInventory: Future inventory in stock only
-    - FutureTransit: Future inventory in transit only
-    - FutureInventoryTransitArrival: Future inventory in stock + arrivals in the period
+    Args:
+        key: Item identifier (str) or (item, location) tuple
+        df_lead_time: Lead time DataFrame (filtered for this item)
+        periods: Number of periods to generate (for ReorderFreq > 20)
+        period2: Number of periods to generate (for ReorderFreq <= 20)
+        start_date: Start date for period 1 (can be None)
+        start_date_zero: Custom start date for period 0 (can be None)
+        default_coverage: Default coverage days
+        location: Boolean indicating location-based processing
+                 (Note: This parameter is kept for interface consistency but is not
+                 directly used in date generation logic, as dates depend on ReorderFreq
+                 which is already in the filtered df_lead_time)
+        
+    Returns:
+        List[str]: List of dates in 'YYYYMMDD' format
     """
-
-    def __init__(self, df_inv, df_lead_time, df_prep, df_fcst, periods, start_date, location=False, security_stock_ref=False, df_transit=None, integer=True, complete_suggested=False, start_date_zero=None):
-        """
-        Initialize the FutureReorder instance.
+    try:
+        # Determine the starting date for period 0
+        if start_date_zero is not None:
+            # Use custom start date for period 0
+            actual_date = pd.to_datetime(start_date_zero, format='%Y-%m-%d')
+        else:
+            # Use current system date for period 0 (original behavior)
+            DOCKER_CONFIG_PATH = os.path.join('/opt/ml/processing/input', 'config.yml')
+            utils = Utils(config_file=DOCKER_CONFIG_PATH, logfile='data_io', log_path='output/logs')
+            timestamp = utils.set_timestamp()
+            actual_date = pd.to_datetime(str(int(float(timestamp[0:8]))), format='%Y%m%d')
         
-        Args:
-            df_inv (pd.DataFrame): Current inventory data with columns:
-                - Item: Item identifier
-                - Location: Location identifier (if location=True)
-                - Inventory: Current on-hand stock
-                - Transit: In-transit quantity
-                - PurchaseFactor: Minimum order multiple
-            
-            df_lead_time (pd.DataFrame): Lead time and reorder parameters:
-                - Item: Item identifier
-                - Location: Location identifier (if location=True)
-                - ReorderFreq: Days between reorders (default: 30)
-                - AvgLeadTime: Average lead time in days
-                - MaxLeadTime: Maximum lead time in days
-                - Coverage: Total coverage days (optional)
-                - SecurityStockDaysRef: Reference days for safety stock (optional)
-            
-            df_prep (pd.DataFrame): Preparation data for forecast calculations
-            
-            df_fcst (pd.DataFrame): Forecast data containing demand predictions
-            
-            periods (int): Number of future periods to calculate
-            
-            start_date (str): Starting date for calculations (format: 'YYYY-MM-DD')
-            
-            location (bool, optional): Whether to process by location. Defaults to False.
-            
-            security_stock_ref (bool, optional): Use reference days method for safety stock
-                calculation instead of statistical method. Defaults to False.
-                
-            df_transit (pd.DataFrame, optional): Transit arrival schedule with columns:
-                - Item: Item identifier
-                - Location: Location identifier (if location=True)
-                - Transit: Partial transit quantity
-                - ArrivalDate: Arrival date (format: 'YYYY-MM-DD')
-                If None, complete transit arrives in period 1. Defaults to None.
-                
-            integer (bool, optional): Controls numeric formatting of quantity fields.
-                When True, quantity fields are displayed as integers.
-                When False, quantity fields are displayed with decimals.
-                Defaults to True.
-                
-            complete_suggested (bool, optional): When True, uses the last calculated
-                SuggestedForecast value for periods without forecast data instead of
-                raising an error. Defaults to False.
-                
-            start_date_zero (str, optional): Custom start date for period 0 (format: 'YYYY-MM-DD').
-                When None (default), uses the current system date for period 0.
-                When specified, uses this date as the starting point for period 0 instead
-                of the current system date. Defaults to None.
-        """
-        self.df_inv = df_inv
-        self.df_lead_time = df_lead_time
-        self.df_prep = df_prep
-        self.df_fcst = df_fcst
-        self.default_coverage = 30
-        self.periods = periods
-        self.start_date = pd.to_datetime(start_date, format='%Y-%m-%d')
-        self.location = location
-        self.security_stock_ref = security_stock_ref
-        self.df_transit = df_transit
-        self.integer = integer
-        self.complete_suggested = complete_suggested
-        self.start_date_zero = start_date_zero
+        # Determine which period count to use based on ReorderFreq
+        reorder_freq = df_lead_time['ReorderFreq'].iloc[0]
+        if pd.isna(reorder_freq) or reorder_freq == 0:
+            reorder_freq = default_coverage
+        reorder_freq = int(reorder_freq)
         
-        # Initialize metadata columns based on location usage
-        self.metadata = ['Item']
-        if self.location:
-            self.metadata.append('Location')
-
-
-    def _format_value(self, value, field_name):
-        """
-        Apply appropriate formatting based on field type and integer setting.
+        # Use period2 for ReorderFreq <= 20, otherwise use periods
+        if reorder_freq <= 20:
+            effective_periods = period2
+        else:
+            effective_periods = periods
         
-        Args:
-            value: The numeric value to format (scalar or Series)
-            field_name: The name of the field to determine formatting rules
-            
-        Returns:
-            Formatted value (int or float with 2 decimals)
-        """
-        # Handle pandas Series - extract scalar value
-        if isinstance(value, pd.Series):
-            if len(value) == 1:
-                value = value.iloc[0]
-            else:
-                raise ValueError(f"Expected scalar value for {field_name}, got Series with {len(value)} elements")
+        # Use effective_periods + 1 internally to calculate one extra period for transit calculations
+        end_date = actual_date + pd.DateOffset(months=effective_periods + 1)
         
-        # Handle NaN, None, and infinite values
-        if pd.isna(value) or value is None:
-            return 0
-        if np.isinf(value):
-            return 0
-            
-        # Fields that are ALWAYS integers
-        always_integer_fields = [
-            'PurchaseFactor', 'AvgLeadTime', 'MaxLeadTime',
-            'ReorderQtyDays', 'ReorderFreq', 'Coverage', 'FutureStockoutDays'
-        ]
+        # Handle start_date = None case
+        if start_date is None:
+            # If start_date is None, use actual_date as the base for period 1
+            base_start_date = actual_date
+        else:
+            base_start_date = pd.to_datetime(start_date, format='%Y-%m-%d')
         
-        # Fields that are ALWAYS decimals (2 decimal places)
-        always_decimal_fields = ['AvgDailyUsage', 'MaxDailyUsage']
+        # ReorderFreq was already calculated above, no need to recalculate
         
-        # Fields that change based on self.integer setting
-        quantity_fields = [
-            'FutureInventoryTransit', 'FutureInventory', 'FutureTransit',
-            'FutureInventoryTransitArrival', 'SuggestedForecast', 'SuggestedForecastPeriod',
-            'ReorderPoint', 'ReorderQtyBase', 'ReorderQty', 'SecurityStock', 'Inventory', 'Transit'
-        ]
+        # Generate date range for this item
+        date_range = []
         
-        if field_name in always_integer_fields:
-            return int(round(value))
-        elif field_name in always_decimal_fields:
-            return round(value, 2)
-        elif field_name in quantity_fields:
-            if self.integer:
-                return int(round(value))
+        # Always include actual date (period 0)
+        date_range.append(actual_date)
+        
+        # Include base_start_date if after actual_date
+        if base_start_date > actual_date:
+            date_range.append(base_start_date)
+        
+        # Generate subsequent dates using a controlled loop instead of pd.date_range
+        current_date = base_start_date + timedelta(days=reorder_freq)
+        while current_date <= end_date:
+            date_range.append(current_date)
+            current_date += timedelta(days=reorder_freq)
+        
+        # Convert to string format
+        date_strings = [d.strftime('%Y%m%d') for d in date_range]
+        
+        return date_strings
+        
+    except Exception as e:
+        print(f"Error generating dates for item {key}: {str(e)}")
+        # Return a minimal date list with just the current date
+        try:
+            if start_date_zero is not None:
+                actual_date = pd.to_datetime(start_date_zero, format='%Y-%m-%d')
             else:
-                return round(value, 2)
-        else:
-            # Default: return as is
-            return value
+                DOCKER_CONFIG_PATH = os.path.join('/opt/ml/processing/input', 'config.yml')
+                utils = Utils(config_file=DOCKER_CONFIG_PATH, logfile='data_io', log_path='output/logs')
+                timestamp = utils.set_timestamp()
+                actual_date = pd.to_datetime(str(int(float(timestamp[0:8]))), format='%Y%m%d')
+            return [actual_date.strftime('%Y%m%d')]
+        except:
+            # Last resort: return today's date
+            return [datetime.now().strftime('%Y%m%d')]
 
 
-    def future_date(self):
-        """
-        Generate future reorder dates for each item based on reorder frequency.
-        
-        This method creates a schedule of dates when reorders should be evaluated
-        for each item (or item-location combination). The schedule includes:
-        1. Current date (always first)
-        2. Start date (if after current date)
-        3. Subsequent dates at reorder frequency intervals
+def process_item_batch_complete(batch_args):
+    """
+    Process a batch of items in parallel with complete functionality.
+    
+    This function executes in a separate process and handles batch processing
+    of inventory items for reorder calculations. It provides optimized error
+    handling and progress tracking for large-scale inventory processing.
+    
+    Args:
+        batch_args (tuple): Contains all necessary data for batch processing:
+            - batch_items: List of item data tuples (key, lead_time_df, inv_df)
+            - df_fcst: Forecast data DataFrame
+            - df_prep: Preparation data DataFrame
+            - metadata: List of metadata columns
+            - location: Boolean indicating if location processing is enabled
+            - default_coverage: Default coverage days
+            - complete_suggested: Boolean for complete suggested forecast mode
+            - security_stock_ref: Boolean for reference-based security stock calculation
+            - integer: Boolean for integer formatting of quantities
+            - verbose: Boolean for detailed logging
+            - df_transit: Transit schedule DataFrame (optional)
+            - periods: Number of periods to generate
+            - start_date: Start date for period 1 (can be None)
+            - start_date_zero: Custom start date for period 0 (can be None)
+    
+    Returns:
+        pd.DataFrame: Combined results for all items in the batch, or empty DataFrame if errors
+    """
+    try:
+        (batch_items, df_fcst, df_prep, metadata, location, default_coverage,
+         complete_suggested, security_stock_ref, integer, verbose, df_transit,
+         periods, period2, start_date, start_date_zero) = batch_args
         
-        This optimized version groups items by reorder frequency for better performance
-        with large datasets.
+        results = []
+        processed_count = 0
+        error_count = 0
         
-        Returns:
-            dict: Dictionary mapping item (or (item, location) tuple) to list of
-                  reorder dates in 'YYYYMMDD' format.
-                  
-        Example:
-            {
-                'ITEM001': ['20240101', '20240115', '20240214', ...],
-                ('ITEM002', 'LOC1'): ['20240101', '20240120', '20240219', ...]
-            }
-        """
-        # Determine the starting date for period 0
-        if self.start_date_zero is not None:
-            # Use custom start date for period 0
-            actual_date = pd.to_datetime(self.start_date_zero, format='%Y-%m-%d')
+        for item_data in batch_items:
+            key, current_df_lead_time, current_df_inv = item_data
+            
+            try:
+                # Generate dates for this item locally in the worker process
+                dates = _generate_item_dates_worker(
+                    key, current_df_lead_time, periods, period2, start_date,
+                    start_date_zero, default_coverage, location
+                )
+                
+                # Procesar este ítem usando la lógica completa con timeout implícito
+                item_result = _process_item_complete(
+                    key, dates, current_df_lead_time, current_df_inv,
+                    df_fcst, df_prep, metadata, location, default_coverage,
+                    complete_suggested, security_stock_ref, integer,
+                    df_transit
+                )
+                
+                if item_result is not None and not item_result.empty:
+                    results.append(item_result)
+                    processed_count += 1
+                else:
+                    error_count += 1
+                    
+            except Exception as e:
+                error_count += 1
+                if verbose and error_count <= 3:  # Limit error messages to avoid spam
+                    print(f"⚠️  Error procesando {key}: {str(e)[:100]}...")
+                continue
+        
+        # Log batch summary if there were errors
+        if verbose and error_count > 0:
+            print(f"📊 Batch summary: {processed_count} processed, {error_count} errors")
+        
+        # Combine all items in this batch
+        if results:
+            return pd.concat(results, ignore_index=True)
         else:
-            # Use current system date for period 0 (original behavior)
-            DOCKER_CONFIG_PATH = os.path.join('/opt/ml/processing/input', 'config.yml')
-            utils = Utils(config_file=DOCKER_CONFIG_PATH, logfile='data_io', log_path='output/logs')
-            timestamp = utils.set_timestamp()
-            actual_date = pd.to_datetime(str(int(float(timestamp[0:8]))), format='%Y%m%d')
-        
-        end_date = actual_date + pd.DateOffset(months=self.periods)
+            return pd.DataFrame()
+            
+    except Exception as e:
+        print(f"❌ Error crítico en batch: {str(e)}")
+        return pd.DataFrame()
 
-        # Get unique items with their reorder frequencies
-        columns = self.metadata + ['ReorderFreq']
-        df_unique = self.df_lead_time[columns].drop_duplicates().copy()
+
+def _process_item_complete(key, dates, current_df_lead_time, current_df_inv,
+                           df_fcst, df_prep, metadata, location, default_coverage,
+                           complete_suggested, security_stock_ref, integer, df_transit=None):
+    """
+    Process a single item through all periods with complete functionality.
+    
+    This function handles the complete inventory reorder calculation for a single item
+    across all time periods. It optimizes performance by pre-allocating data structures
+    and reducing repetitive calls to forecast and daily usage calculations.
+    
+    The process includes:
+    1. Calculating suggested forecasts for each period
+    2. Computing daily usage rates (average and maximum)
+    3. Determining security stock requirements
+    4. Processing current period inventory
+    5. Calculating future period reorder needs
+    6. Managing transit order schedules
+    7. Computing final inventory metrics
+    
+    Args:
+        key: Item identifier (str) or (item, location) tuple
+        dates: List of calculation dates in 'YYYYMMDD' format
+        current_df_lead_time: Lead time data for this item
+        current_df_inv: Current inventory data for this item
+        df_fcst: Forecast data DataFrame
+        df_prep: Preparation data DataFrame
+        metadata: List of metadata columns
+        location: Boolean indicating location-based processing
+        default_coverage: Default coverage days
+        complete_suggested: Boolean for complete suggested forecast mode
+        security_stock_ref: Boolean for reference-based security stock
+        integer: Boolean for integer formatting
+        df_transit: Transit schedule DataFrame (optional)
+    
+    Returns:
+        pd.DataFrame: Complete reorder calculations for all periods of this item
+    """
+    try:
+        # Pre-allocate dictionaries for intermediate results
+        suggested_forecasts = {}
+        df_avgs = {}
+        df_maxs = {}
+        df_sstocks = {}
+        period_results = {}
         
-        # Process ReorderFreq values
-        df_unique['ReorderFreq'] = df_unique['ReorderFreq'].fillna(self.default_coverage)
-        df_unique.loc[df_unique['ReorderFreq'] == 0, 'ReorderFreq'] = self.default_coverage
-        df_unique['ReorderFreq'] = df_unique['ReorderFreq'].astype(int)
+        # Initialize transit orders for this item
+        transit_orders = {key: []}
         
-        # Pre-allocate result dictionary
-        item_dates = {}
+        # Track last suggested forecast value for complete_suggested feature
+        last_suggested_value = None
         
-        # Group by ReorderFreq for batch processing - more efficient for large datasets
-        for freq, group in df_unique.groupby('ReorderFreq'):
-            # Generate date range for this frequency
-            date_range = []
-            
-            # Always include actual date
-            date_range.append(actual_date)
+        # Pre-calculate common values to avoid repeated calculations
+        coverage = current_df_lead_time['Coverage'].iloc[0] if 'Coverage' in current_df_lead_time.columns else default_coverage
+        if pd.isna(coverage):
+            coverage = default_coverage
+        
+        reorder_freq = current_df_lead_time['ReorderFreq'].iloc[0]
+        if pd.isna(reorder_freq) or reorder_freq == 0:
+            reorder_freq = default_coverage
+        
+        # Process each period with optimized error handling
+        for i, date in enumerate(dates):
+            try:
+                # Calculate suggested forecast with better error handling
+                suggested_forecasts[i] = _calculate_suggested_forecast_complete(
+                    current_df_lead_time, current_df_inv, date, last_suggested_value,
+                    df_fcst, df_prep, metadata, location, default_coverage, complete_suggested
+                )
+                
+                # Update last_suggested_value for next iteration
+                if 'SuggestedForecast' in suggested_forecasts[i].columns:
+                    new_suggested_value = suggested_forecasts[i]['SuggestedForecast'].iloc[0]
+                    
+                    # Only update if the new value is not NaN
+                    if not pd.isna(new_suggested_value):
+                        last_suggested_value = new_suggested_value
+                
+                # Calculate daily usage with optimized calls
+                df_avgs[i], df_maxs[i] = _calculate_daily_usage_complete(
+                    suggested_forecasts[i], date, df_fcst, location
+                )
+                
+                # Calculate security stock data with pre-calculated values
+                df_sstocks[i] = _calculate_security_stock_data_complete(
+                    df_maxs[i], current_df_lead_time, default_coverage, i, dates
+                )
+                
+                # Process period based on whether it's current or future
+                if i == 0:
+                    period_results[i] = _process_current_period_complete(
+                        current_df_inv, df_sstocks[i], key, date, transit_orders, dates,
+                        metadata, integer, security_stock_ref, df_transit
+                    )
+                else:
+                    period_results[i] = _process_future_period_complete(
+                        current_df_inv, df_sstocks[i], period_results[i-1],
+                        key, date, dates, i, transit_orders, metadata, integer, security_stock_ref
+                    )
+                
+                # Add metadata columns efficiently
+                period_results[i]['Date'] = date
+                if location:
+                    item, loc = key
+                    period_results[i]['Item'] = item
+                    period_results[i]['Location'] = loc
+                else:
+                    period_results[i]['Item'] = key
+                    
+            except Exception as e:
+                # Log error but continue with next period
+                import traceback
+                tb = traceback.extract_tb(e.__traceback__)
+                function_name = tb[-1].name if tb else 'unknown'
+                line_number = tb[-1].lineno if tb else 'unknown'
+                
+                print(f"Warning: Error processing period {i} for item {key}:")
+                print(f"   Function: {function_name} (line {line_number})")
+                print(f"   Error: {str(e)}")
+                print(f"   Error type: {type(e).__name__}")
+                print(f"   Date value: {repr(date)} (type: {type(date)})")
+                print(f"   Period index: {i}")
+                print(f"   Total dates available: {len(dates)}")
+                
+                # Print more context for debugging
+                if hasattr(e, '__cause__') and e.__cause__:
+                    print(f"   Caused by: {str(e.__cause__)}")
+                
+                # Print the full traceback for error analysis
+                print(f"   Full traceback:")
+                traceback.print_exc()
+                
+                continue
+    
+        # After processing all periods, update FutureInventoryTransitArrival
+        for i in range(len(dates)):
+            if i < len(dates) - 1:  # If there's a next period
+                # Get next period's TransitArrival
+                next_transit_arrival = period_results[i + 1]['TransitArrival'].iloc[0]
+                transit_arrival_sum = _sum_transit_arrivals(next_transit_arrival)
+            else:  # Last period - no next period
+                transit_arrival_sum = 0
             
-            # Include start_date if after actual_date
-            if self.start_date > actual_date:
-                date_range.append(self.start_date)
+            # Update FutureInventoryTransitArrival
+            period_results[i]['FutureInventoryTransitArrival'] = _format_value_complete(
+                period_results[i]['FutureInventory'].iloc[0] + transit_arrival_sum,
+                'FutureInventoryTransitArrival', integer
+            )
             
-            # Generate subsequent dates using pandas date_range for efficiency
-            num_periods = int((end_date - self.start_date).days / freq) + 1
-            future_dates = pd.date_range(
-                start=self.start_date + timedelta(days=freq),
-                periods=num_periods,
-                freq=f'{freq}D'
+            # Recalculate FutureStockoutDays with the updated FutureInventoryTransitArrival
+            period_results[i]['FutureStockoutDays'] = _calculate_inventory_days_complete(
+                period_results[i], integer
             )
-            date_range.extend(future_dates[future_dates <= end_date])
+        
+        # Combine all periods for this item
+        if period_results:
+            # Stack all period results at once
+            item_df = pd.concat(period_results.values(), ignore_index=True)
             
-            # Convert to string format
-            date_strings = [d.strftime('%Y%m%d') for d in date_range]
+            # Reorder columns for consistency
+            cols = ['Date', 'Item']
+            if location:
+                cols.append('Location')
+            other_cols = [col for col in item_df.columns if col not in cols]
+            item_df = item_df[cols + other_cols]
             
-            # Assign to all items in this group
-            for _, row in group.iterrows():
-                if self.location:
-                    key = (row['Item'], row['Location'])
-                else:
-                    key = row['Item']
-                item_dates[key] = date_strings
+            return item_df
         
-        return item_dates
-
-
-    def _get_current_dataframes(self, item, location=None):
-        """
-        Get filtered dataframes for current item/location combination.
+        return None
         
-        Args:
-            item (str): Item identifier to filter for
-            location (str, optional): Location identifier if using multi-location mode
-            
-        Returns:
-            tuple: (current_df_lead_time, current_df_inv)
-                - current_df_lead_time: Lead time data filtered for item/location
-                - current_df_inv: Inventory data filtered for item/location
-        """
-        # Create filter mask based on item
-        mask_lead_time = self.df_lead_time['Item'] == item
-        mask_inv = self.df_inv['Item'] == item
+    except Exception as e:
+        # Handle any unexpected errors at the item level
+        import traceback
+        tb = traceback.extract_tb(e.__traceback__)
+        function_name = tb[-1].name if tb else 'unknown'
+        line_number = tb[-1].lineno if tb else 'unknown'
+        
+        print(f"Error processing item {key}:")
+        print(f"   Function: {function_name} (line {line_number})")
+        print(f"   Error: {str(e)}")
+        print(f"   Error type: {type(e).__name__}")
+        print(f"   Item dates: {dates[:5] if dates else 'None'}... (showing first 5)")
+        print(f"   Total dates: {len(dates) if dates else 0}")
         
-        # Add location filter if needed
-        if self.location and location is not None:
-            mask_lead_time &= self.df_lead_time['Location'] == location
-            mask_inv &= self.df_inv['Location'] == location
+        # Print more context for debugging
+        if hasattr(e, '__cause__') and e.__cause__:
+            print(f"   Caused by: {str(e.__cause__)}")
         
-        # Apply filters using boolean indexing
-        current_df_lead_time = self.df_lead_time[mask_lead_time]
-        current_df_inv = self.df_inv[mask_inv]
+        # Print the full traceback for error analysis
+        print(f"   Full traceback:")
+        traceback.print_exc()
         
-        return current_df_lead_time, current_df_inv
+        return None
 
 
-    def _calculate_suggested_forecast(self, current_df_lead_time, current_df_inv, date, last_suggested_value=None):
-        """
-        Calculate suggested forecast for the given date using the SuggestedForecast class.
+def _format_value_complete(value, field_name, integer):
+    """Apply appropriate formatting based on field type and integer setting."""
+    # Handle pandas Series - extract scalar value
+    if isinstance(value, pd.Series):
+        if len(value) == 1:
+            value = value.iloc[0]
+        else:
+            raise ValueError(f"Expected scalar value for {field_name}, got Series with {len(value)} elements")
+    
+    # Handle NaN, None, and infinite values
+    if pd.isna(value) or value is None:
+        return 0
+    if np.isinf(value):
+        return 0
+        
+    # Fields that are ALWAYS integers
+    always_integer_fields = [
+        'PurchaseFactor', 'AvgLeadTime', 'MaxLeadTime',
+        'ReorderQtyDays', 'ReorderFreq', 'Coverage', 'FutureStockoutDays'
+    ]
+    
+    # Fields that are ALWAYS decimals (2 decimal places)
+    always_decimal_fields = ['AvgDailyUsage', 'MaxDailyUsage']
+    
+    # Fields that change based on integer setting
+    quantity_fields = [
+        'FutureInventoryTransit', 'FutureInventory', 'FutureTransit',
+        'FutureInventoryTransitArrival', 'SuggestedForecast', 'SuggestedForecastPeriod',
+        'ReorderPoint', 'ReorderQtyBase', 'ReorderQty', 'SecurityStock', 'Inventory', 'Transit'
+    ]
+    
+    if field_name in always_integer_fields:
+        return int(round(value))
+    elif field_name in always_decimal_fields:
+        return round(value, 2)
+    elif field_name in quantity_fields:
+        if integer:
+            return int(round(value))
+        else:
+            return round(value, 2)
+    else:
+        # Default: return as is
+        return value
+
+
+def _suggested_forecast_fallback(current_df_lead_time, current_df_inv, date, df_fcst, metadata, location, default_coverage):
+    """
+    Simplified SuggestedForecast fallback function for multiprocessing compatibility.
+    
+    This function provides a basic forecast calculation when the main SuggestedForecast class fails
+    due to multiprocessing issues. It calculates the forecast using an average-based approach:
+    
+    1. Sum all forecasts in the coverage period
+    2. Calculate daily average (sum / total_days_in_period)
+    3. Multiply by coverage days
+    4. Round up to nearest integer
+    
+    Args:
+        current_df_lead_time: Lead time DataFrame for this item
+        current_df_inv: Inventory DataFrame for this item
+        date: Date string in 'YYYYMMDD' format
+        df_fcst: Forecast DataFrame
+        metadata: List of metadata columns
+        location: Boolean indicating location-based processing
+        default_coverage: Default coverage days
+        
+    Returns:
+        pd.DataFrame: DataFrame with SuggestedForecast column
+    """
+    try:
+        # Parse the date
+        current_date = pd.to_datetime(date, format='%Y%m%d')
         
-        This method now validates that sufficient forecast data exists to cover the
-        required coverage period. If forecast data doesn't extend far enough into
-        the future, it either raises an error or uses the last calculated value
-        based on the complete_suggested parameter.
+        # Get coverage for this item
+        coverage = current_df_lead_time['Coverage'].iloc[0] if 'Coverage' in current_df_lead_time.columns else default_coverage
+        if pd.isna(coverage):
+            coverage = default_coverage
+        coverage = int(coverage)
         
-        Args:
-            current_df_lead_time (pd.DataFrame): Lead time data for current item
-            current_df_inv (pd.DataFrame): Inventory data for current item
-            date (str): Date for forecast calculation in 'YYYYMMDD' format
-            last_suggested_value (float, optional): Last calculated SuggestedForecast value
-                to use when complete_suggested is True and forecast data is insufficient
-            
-        Returns:
-            pd.DataFrame: DataFrame containing suggested forecast values
-            
-        Raises:
-            ValueError: If forecast data doesn't extend far enough to cover the required period
-                and complete_suggested is False or no previous value is available
-        """
-        # Convert current date to datetime
-        current_date = pd.to_datetime(date, format='%Y%m%d')
+        # Calculate forecast end date
+        forecast_end_date = current_date + timedelta(days=coverage)
         
-        # Get the maximum forecast date available
-        max_forecast_date = self.df_fcst['Date'].max()
+        # Filter forecast data for this item and date range
+        if location:
+            item = current_df_inv['Item'].iloc[0]
+            loc = current_df_inv['Location'].iloc[0]
+            forecast_mask = (df_fcst['Item'] == item) & (df_fcst['Location'] == loc)
+        else:
+            item = current_df_inv['Item'].iloc[0]
+            forecast_mask = df_fcst['Item'] == item
         
-        # Get coverage value for this item
-        coverage = current_df_lead_time['Coverage'].iloc[0]
+        # Add date range filter - get all forecast data for this item
+        forecast_mask &= (df_fcst['Date'] >= current_date) & (df_fcst['Date'] <= forecast_end_date)
         
-        # Calculate the required forecast end date
-        required_forecast_end_date = current_date + timedelta(days=int(coverage))
+        item_forecast = df_fcst[forecast_mask]
         
-        # Check if we have sufficient forecast data
-        if max_forecast_date < required_forecast_end_date:
-            # Get item identifier for error message
+        # Calculate suggested forecast using average-based approach
+        if not item_forecast.empty and 'Forecast' in item_forecast.columns:
+            # Step 1: Sum all forecasts in the period
+            total_forecast = item_forecast['Forecast'].sum()
+            
+            # Step 2: Calculate total days in the forecast period
+            # Simplification: assume 30 days per month for calculation
+            total_days_in_period = len(item_forecast)  # Number of forecast records
+            if total_days_in_period == 0:
+                suggested_forecast = 0.0
+            else:
+                # Step 3: Calculate daily average
+                daily_average = total_forecast / total_days_in_period
+                
+                # Step 4: Multiply by coverage days
+                suggested_forecast = daily_average * coverage
+                
+                # Step 5: Round up to nearest integer
+                suggested_forecast = np.ceil(suggested_forecast)
+            
+            
+        else:
+            # Fallback: use 0 if no forecast data available
+            suggested_forecast = 0.0
             item = current_df_inv['Item'].iloc[0]
             location_msg = ""
-            if self.location and 'Location' in current_df_inv.columns:
-                location = current_df_inv['Location'].iloc[0]
-                location_msg = f" at location {location}"
-            
-            if self.complete_suggested:
-                if last_suggested_value is not None:
-                    # Use the last calculated SuggestedForecast value
-                    # Create a DataFrame with the same structure as the normal output
-                    result_df = current_df_inv[self.metadata].copy()
-                    result_df['SuggestedForecast'] = last_suggested_value
-                    
-                    # Add PurchaseFactor and ItemDescription from inventory data
-                    if 'PurchaseFactor' in current_df_inv.columns:
-                        result_df['PurchaseFactor'] = current_df_inv['PurchaseFactor'].iloc[0]
-                    else:
-                        result_df['PurchaseFactor'] = 1  # Default value if not present
-                    
-                    if 'ItemDescription' in current_df_inv.columns:
-                        result_df['ItemDescription'] = current_df_inv['ItemDescription'].iloc[0]
-                    else:
-                        result_df['ItemDescription'] = ''  # Default value if not present
+            if location and 'Location' in current_df_inv.columns:
+                loc = current_df_inv['Location'].iloc[0]
+                location_msg = f" at location {loc}"
+            print(f"   ⚠️ No forecast data found for item {item}{location_msg}, using 0")
+        
+        # Create result DataFrame
+        result_df = current_df_inv[metadata].copy()
+        result_df['SuggestedForecast'] = suggested_forecast
+        
+        # Add required columns
+        result_df['PurchaseFactor'] = current_df_inv.get('PurchaseFactor', pd.Series([1])).iloc[0]
+        result_df['ItemDescription'] = current_df_inv.get('ItemDescription', pd.Series([''])).iloc[0]
+        
+        return result_df
+        
+    except Exception as e:
+        print(f"   ❌ Fallback SuggestedForecast also failed: {str(e)}")
+        # Last resort: return basic structure with 0 forecast
+        result_df = current_df_inv[metadata].copy()
+        result_df['SuggestedForecast'] = 0.0
+        result_df['PurchaseFactor'] = current_df_inv.get('PurchaseFactor', pd.Series([1])).iloc[0]
+        result_df['ItemDescription'] = current_df_inv.get('ItemDescription', pd.Series([''])).iloc[0]
+        return result_df
 
-                    return result_df
-                else:
-                    # For the first period when complete_suggested=True but no previous value exists,
-                    # try to calculate with available data up to max_forecast_date
-                    # This allows at least the first period to be calculated
+
+def _calculate_suggested_forecast_complete(current_df_lead_time, current_df_inv, date, last_suggested_value,
+                                          df_fcst, df_prep, metadata, location, default_coverage, complete_suggested):
+    """Calculate suggested forecast for the given date using the SuggestedForecast class."""
+    # Convert current date to datetime
+    try:
+        current_date = pd.to_datetime(date, format='%Y%m%d')
+    except Exception as e:
+        raise ValueError(f"_calculate_suggested_forecast_complete: Invalid date '{date}' - {str(e)}")
+    
+    # Get the maximum forecast date available
+    max_forecast_date = df_fcst['Date'].max()
+    
+    # Get coverage value for this item
+    coverage = current_df_lead_time['Coverage'].iloc[0] if 'Coverage' in current_df_lead_time.columns else default_coverage
+    if pd.isna(coverage):
+        coverage = default_coverage
+    
+    # Calculate the required forecast end date
+    required_forecast_end_date = current_date + timedelta(days=int(coverage))
+    
+    # Check if we have sufficient forecast data
+    if max_forecast_date < required_forecast_end_date:
+        if complete_suggested:
+            if last_suggested_value is not None:
+                # Use the last calculated SuggestedForecast value
+                result_df = current_df_inv[metadata].copy()
+                result_df['SuggestedForecast'] = last_suggested_value
+                
+                # Add PurchaseFactor and ItemDescription from inventory data using safe access
+                result_df['PurchaseFactor'] = current_df_inv.get('PurchaseFactor', pd.Series([1])).iloc[0]
+                result_df['ItemDescription'] = current_df_inv.get('ItemDescription', pd.Series([''])).iloc[0]
+
+                return result_df
+            else:
+                # For the first period when complete_suggested=True but no previous value exists
+                try:
+                    return SuggestedForecast(
+                        df_LeadTimes=current_df_lead_time,
+                        df_Forecast=df_fcst,
+                        df_Prep=df_prep,
+                        df_inv=current_df_inv,
+                        column_forecast='SuggestedForecast',
+                        columns_metadata=metadata,
+                        frequency_='M',
+                        location=location,
+                        actualdate=date,
+                        default_coverage_=default_coverage,
+                        join_='left'
+                    ).suggested_forecast()
+                except Exception as e:
+                    print(f"   ❌ Initial calculation failed: {str(e)}")
+                    print(f"   🔄 Attempting fallback SuggestedForecast calculation...")
+                    
                     try:
-                        return SuggestedForecast(
-                            df_LeadTimes=current_df_lead_time,
-                            df_Forecast=self.df_fcst,
-                            df_Prep=self.df_prep,
-                            df_inv=current_df_inv,
-                            column_forecast='SuggestedForecast',
-                            columns_metadata=self.metadata,
-                            frequency_='M',
-                            location=self.location,
-                            actualdate=date,
-                            default_coverage_=self.default_coverage,
-                            join_='left'
-                        ).suggested_forecast()
-                    except Exception as e:
-                        # If even the basic calculation fails, raise a more informative error
+                        # Use simplified fallback function
+                        fallback_result = _suggested_forecast_fallback(
+                            current_df_lead_time, current_df_inv, date, df_fcst,
+                            metadata, location, default_coverage
+                        )
+                        
+                        return fallback_result
+                        
+                    except Exception as fallback_error:
+                        print(f"   ❌ Fallback initial calculation also failed: {str(fallback_error)}")
+                        
+                        # Get item identifier for error message
+                        item = current_df_inv['Item'].iloc[0]
+                        location_msg = ""
+                        if location and 'Location' in current_df_inv.columns:
+                            loc = current_df_inv['Location'].iloc[0]
+                            location_msg = f" at location {loc}"
+                        
                         error_msg = (
                             f"Cannot calculate initial forecast for item {item}{location_msg}. "
                             f"Forecast data extends only to {max_forecast_date.strftime('%Y-%m-%d')}, "
@@ -361,574 +612,793 @@ class FutureReorder():
                             f"Original error: {str(e)}"
                         )
                         raise ValueError(error_msg)
-            else:
-                error_msg = (
-                    f"Insufficient forecast data for item {item}{location_msg}. "
-                    f"Forecast data extends only to {max_forecast_date.strftime('%Y-%m-%d')}, "
-                    f"but coverage of {int(coverage)} days from {current_date.strftime('%Y-%m-%d')} "
-                    f"requires forecast data until {required_forecast_end_date.strftime('%Y-%m-%d')}."
-                )
-                raise ValueError(error_msg)
-        
-        # If validation passes, proceed with the original calculation
-        return SuggestedForecast(
+        else:
+            # Get item identifier for error message
+            item = current_df_inv['Item'].iloc[0]
+            location_msg = ""
+            if location and 'Location' in current_df_inv.columns:
+                loc = current_df_inv['Location'].iloc[0]
+                location_msg = f" at location {loc}"
+            
+            error_msg = (
+                f"Insufficient forecast data for item {item}{location_msg}. "
+                f"Forecast data extends only to {max_forecast_date.strftime('%Y-%m-%d')}, "
+                f"but coverage of {int(coverage)} days from {current_date.strftime('%Y-%m-%d')} "
+                f"requires forecast data until {required_forecast_end_date.strftime('%Y-%m-%d')}."
+            )
+            raise ValueError(error_msg)
+    
+    # If validation passes, proceed with the original calculation
+    try:
+        result = SuggestedForecast(
             df_LeadTimes=current_df_lead_time,
-            df_Forecast=self.df_fcst,
-            df_Prep=self.df_prep,
+            df_Forecast=df_fcst,
+            df_Prep=df_prep,
             df_inv=current_df_inv,
             column_forecast='SuggestedForecast',
-            columns_metadata=self.metadata,
+            columns_metadata=metadata,
             frequency_='M',
-            location=self.location,
+            location=location,
             actualdate=date,
-            default_coverage_=self.default_coverage,
+            default_coverage_=default_coverage,
             join_='left'
         ).suggested_forecast()
-
-
-    def _calculate_daily_usage(self, suggested_forecast_df, date):
-        """
-        Calculate average and maximum daily usage rates.
         
-        This method computes both average and maximum daily consumption rates
-        which are used for inventory planning and safety stock calculations.
+            
+        return result
+        
+    except Exception as e:
+        print(f"   ❌ Normal calculation failed: {str(e)}")
+        print(f"   🔄 Attempting fallback SuggestedForecast calculation...")
         
-        Args:
-            suggested_forecast_df (pd.DataFrame): DataFrame with forecast data
-            date (str): Current calculation date in 'YYYYMMDD' format
+        try:
+            # Use simplified fallback function
+            fallback_result = _suggested_forecast_fallback(
+                current_df_lead_time, current_df_inv, date, df_fcst,
+                metadata, location, default_coverage
+            )
             
-        Returns:
-            tuple: (df_avg, df_max)
-                - df_avg: DataFrame with average daily usage
-                - df_max: DataFrame with maximum daily usage
-        """
+            
+            return fallback_result
+            
+        except Exception as fallback_error:
+            print(f"   ❌ Fallback calculation also failed: {str(fallback_error)}")
+            # Re-raise the original error
+            raise e
+
+
+def _calculate_daily_usage_complete(suggested_forecast_df, date, df_fcst, location):
+    """Calculate average and maximum daily usage rates."""
+    
+    try:
         df_avg = DailyUsageFuture(
-            location=self.location,
+            location=location,
             column_forecast='SuggestedForecast',
             date=date,
-            df_fcst=self.df_fcst
+            df_fcst=df_fcst
         ).daily_usage(suggested_forecast_df, 'AvgDailyUsage').fillna(0)
-
+        
         df_max = DailyUsageFuture(
-            location=self.location,
+            location=location,
             column_forecast='SuggestedForecast',
             date=date,
-            df_fcst=self.df_fcst
+            df_fcst=df_fcst
         ).daily_usage(df_avg, 'MaxDailyUsage').fillna(0)
         
-        return df_avg, df_max
-
-
-    def _calculate_security_stock_data(self, df_max, current_df_lead_time, period_index=None, dates=None):
-        """
-        Calculate security stock related data and prepare for reorder calculations.
-        
-        This method:
-        1. Merges daily usage with lead time data
-        2. Determines effective reorder frequency and coverage
-        3. Calculates SuggestedForecastPeriod based on coverage ratio
-        4. For period 0, uses days to next period instead of reorder frequency
+    except Exception as e:
+        print(f"   ❌ DailyUsageFuture error: {str(e)}")
+        print(f"   ❌ Error type: {type(e).__name__}")
         
-        Args:
-            df_max (pd.DataFrame): DataFrame with maximum daily usage
-            current_df_lead_time (pd.DataFrame): Lead time data for current item
-            period_index (int, optional): Current period index (0, 1, 2, ...)
-            dates (list, optional): List of dates for this item
-            
-        Returns:
-            pd.DataFrame: DataFrame with merged data and calculated fields:
-                - All fields from df_max
-                - AvgLeadTime, MaxLeadTime from lead time data
-                - SuggestedForecastPeriod: Adjusted forecast for the period
-        """
-        merge_columns = ['Item', 'Location', 'AvgLeadTime', 'MaxLeadTime'] if self.location else ['Item', 'AvgLeadTime', 'MaxLeadTime']
-        df_sstock = pd.merge(df_max, current_df_lead_time[merge_columns], on=self.metadata, how='inner').drop_duplicates()
+        # Print more detailed error info
+        import traceback
+        print(f"   ❌ Full traceback:")
+        traceback.print_exc()
         
-        # Get ReorderFreq and Coverage
-        reorder_freq = current_df_lead_time['ReorderFreq'].values[0]
-        if pd.isnull(reorder_freq) or reorder_freq == 0:
-            reorder_freq = self.default_coverage
-            
-        coverage = self.default_coverage
-        if 'Coverage' in current_df_lead_time.columns:
-            coverage_val = current_df_lead_time['Coverage'].values[0]
-            if not pd.isnull(coverage_val):
-                coverage = coverage_val
-            else:
-                coverage = reorder_freq + df_sstock['AvgLeadTime'].values[0]
+        # Re-raise the original error to maintain the error flow
+        raise e
+    
+    return df_avg, df_max
+
+
+def _calculate_security_stock_data_complete(df_max, current_df_lead_time, default_coverage, period_index, dates):
+    """
+    Calculate security stock related data and prepare for reorder calculations.
+    
+    This function merges daily usage data with lead time information and calculates
+    the suggested forecast period based on coverage ratios. For period 0, it uses
+    days to the next period instead of reorder frequency for more accurate consumption.
+    
+    The process includes:
+    1. Merging daily usage with lead time data
+    2. Determining effective reorder frequency and coverage
+    3. Calculating SuggestedForecastPeriod based on coverage ratio
+    4. Special handling for period 0 using actual days to next period
+    
+    Args:
+        df_max: DataFrame with maximum daily usage
+        current_df_lead_time: Lead time data for current item
+        default_coverage: Default coverage days
+        period_index: Current period index (0, 1, 2, ...)
+        dates: List of dates for this item
+        
+    Returns:
+        pd.DataFrame: DataFrame with merged data and calculated fields including
+                     SuggestedForecastPeriod adjusted for the specific period
+    """
+    metadata = ['Item', 'Location'] if 'Location' in df_max.columns else ['Item']
+    merge_columns = ['Item', 'Location', 'AvgLeadTime', 'MaxLeadTime'] if 'Location' in df_max.columns else ['Item', 'AvgLeadTime', 'MaxLeadTime']
+    df_sstock = pd.merge(df_max, current_df_lead_time[merge_columns], on=metadata, how='inner').drop_duplicates()
+    
+    # Get ReorderFreq and Coverage
+    reorder_freq = current_df_lead_time['ReorderFreq'].values[0]
+    if pd.isnull(reorder_freq) or reorder_freq == 0:
+        reorder_freq = default_coverage
+        
+    coverage = default_coverage
+    if 'Coverage' in current_df_lead_time.columns:
+        coverage_val = current_df_lead_time['Coverage'].values[0]
+        if not pd.isnull(coverage_val):
+            coverage = coverage_val
         else:
             coverage = reorder_freq + df_sstock['AvgLeadTime'].values[0]
-        
-        # Calculate SuggestedForecastPeriod
-        if period_index == 0 and dates is not None and len(dates) > 1:
-            # For period 0, use days to next period instead of reorder frequency
-            # This allows uniform consumption calculation in all future periods
+    else:
+        coverage = reorder_freq + df_sstock['AvgLeadTime'].values[0]
+    
+    # Calculate SuggestedForecastPeriod
+    if period_index == 0 and dates is not None and len(dates) > 1:
+        # For period 0, use days to next period instead of reorder frequency
+        try:
+            # Validate dates array and indices
+            if len(dates) < 2:
+                raise ValueError(f"Insufficient dates for period 0 calculation: need at least 2 dates, got {len(dates)}")
+            
+            # Validate date formats before conversion
+            if not isinstance(dates[0], str) or len(dates[0]) != 8:
+                raise ValueError(f"Invalid dates[0] format: {repr(dates[0])} (expected 8-character string)")
+            if not isinstance(dates[1], str) or len(dates[1]) != 8:
+                raise ValueError(f"Invalid dates[1] format: {repr(dates[1])} (expected 8-character string)")
+            
             current_date = pd.to_datetime(dates[0], format='%Y%m%d')
             next_date = pd.to_datetime(dates[1], format='%Y%m%d')
-            days_to_next_period = (next_date - current_date).days
             
-            # Formula: SuggestedForecast × (days_to_next_period / coverage)
-            # This represents the forecasted consumption from period 0 to period 1
-            suggested_forecast_period = np.ceil(df_sstock['SuggestedForecast'] * (days_to_next_period / coverage))
+        except Exception as e:
+            error_msg = f"_calculate_security_stock_data_complete: Date processing error - "
+            error_msg += f"dates[0]='{dates[0] if len(dates) > 0 else 'MISSING'}' "
+            error_msg += f"(type: {type(dates[0]) if len(dates) > 0 else 'N/A'}), "
+            error_msg += f"dates[1]='{dates[1] if len(dates) > 1 else 'MISSING'}' "
+            error_msg += f"(type: {type(dates[1]) if len(dates) > 1 else 'N/A'}), "
+            error_msg += f"period_index={period_index}, dates_length={len(dates)}, "
+            error_msg += f"original_error: {str(e)}"
+            raise ValueError(error_msg)
+        days_to_next_period = (next_date - current_date).days
+        
+        # Formula: SuggestedForecast × (days_to_next_period / coverage)
+        suggested_forecast_period = np.ceil(df_sstock['SuggestedForecast'] * (days_to_next_period / coverage))
+    else:
+        # For other periods, use the original calculation with reorder frequency
+        suggested_forecast_period = np.ceil(df_sstock['SuggestedForecast'] * (reorder_freq / coverage))
+    
+    df_sstock['SuggestedForecastPeriod'] = suggested_forecast_period.apply(
+        lambda x: int(round(x))  # SuggestedForecastPeriod is always integer
+    )
+    
+    return df_sstock
+
+
+def _calculate_security_stock_complete(df, security_stock_ref, integer):
+    """Calculate security stock using configured method. Replicates exactly the logic from future_reorder_optimized."""
+    # EXACTLY like future_reorder_optimized line 528-536
+    if security_stock_ref:
+        if 'SecurityStockDaysRef' in df.columns:
+            security_stock_value = df['SecurityStockDaysRef'].iloc[0] * df['AvgDailyUsage'].iloc[0]
+        else:
+            security_stock_value = 0
+    else:
+        security_stock_value = (df['MaxDailyUsage'].iloc[0] * df['MaxLeadTime'].iloc[0]) - (df['AvgDailyUsage'].iloc[0] * df['AvgLeadTime'].iloc[0])
+    
+    # Apply formatting and return as scalar
+    return _format_value_complete(security_stock_value, 'SecurityStock', integer)
+
+
+def _calculate_inventory_days_complete(df, integer):
+    """Calculate inventory days using configured method."""
+    # Calculate future stockout days with safe division
+    future_stockout_days = np.where(
+        df['AvgDailyUsage'] > 0,
+        (df['FutureInventoryTransitArrival'] - df['SecurityStock']) / df['AvgDailyUsage'],
+        0  # If no daily usage, return 0 days
+    )
+
+    # Apply formatting
+    return pd.Series(future_stockout_days).apply(lambda x: _format_value_complete(x, 'FutureStockoutDays', integer))
+
+
+def _sum_transit_arrivals(transit_arrivals_str):
+    """Calculate the total quantity from TransitArrival string."""
+    if transit_arrivals_str == '[]' or not transit_arrivals_str:
+        return 0.0
+        
+    try:
+        arrivals = ast.literal_eval(transit_arrivals_str)
+        return sum(arrival.get('quantity', 0) for arrival in arrivals)
+    except:
+        return 0.0
+
+
+def _prepare_transit_schedule_complete(key, transit_amount, dates, df_transit, location):
+    """Prepare transit schedule based on df_transit or default logic."""
+    if transit_amount <= 0:
+        return []
+        
+    transit_schedule = []
+    
+    if df_transit is None:
+        # Default logic: complete transit arrives in period 1
+        if len(dates) > 1:
+            try:
+                arrival_date = pd.to_datetime(dates[1], format='%Y%m%d')
+            except Exception as e:
+                raise ValueError(f"_prepare_transit_schedule_complete: Invalid date dates[1]='{dates[1]}' - {str(e)}")
+            transit_schedule.append({
+                'quantity': transit_amount,
+                'arrival_date': arrival_date
+            })
+    else:
+        # Use provided transit schedule
+        if location:
+            item, loc = key
+            mask = (df_transit['Item'] == item) & (df_transit['Location'] == loc)
+        else:
+            mask = df_transit['Item'] == key
+            
+        transit_data = df_transit[mask].copy()
+        
+        if not transit_data.empty:
+            # Validate total matches
+            total_scheduled = transit_data['Transit'].sum()
+            if abs(total_scheduled - transit_amount) > 0.01:  # Allow small floating point differences
+                raise ValueError(f"Transit schedule total ({total_scheduled}) does not match inventory transit ({transit_amount}) for {key}")
+            
+            # Create transit orders
+            for _, row in transit_data.iterrows():
+                arrival_date = pd.to_datetime(row['ArrivalDate'], format='%Y-%m-%d')
+                transit_schedule.append({
+                    'quantity': float(row['Transit']),
+                    'arrival_date': arrival_date
+                })
         else:
-            # For other periods, use the original calculation with reorder frequency
-            # Formula: SuggestedForecast × (reorder_freq / coverage)
-            suggested_forecast_period = np.ceil(df_sstock['SuggestedForecast'] * (reorder_freq / coverage))
+            # If no transit data provided for this item, use default logic
+            if len(dates) > 1:
+                try:
+                    arrival_date = pd.to_datetime(dates[1], format='%Y%m%d')
+                except Exception as e:
+                    raise ValueError(f"_prepare_transit_schedule_complete: Invalid fallback date dates[1]='{dates[1]}' - {str(e)}")
+                transit_schedule.append({
+                    'quantity': transit_amount,
+                    'arrival_date': arrival_date
+                })
+                
+    return transit_schedule
+
+
+def _process_current_period_complete(current_df_inv, df_sstock, key, date, transit_orders, dates, metadata, integer, security_stock_ref=False, df_transit=None):
+    """Process inventory for the current period (i=0). Replicates exactly the logic from future_reorder_optimized."""
+    
+    # Get inventory data efficiently - EXACTLY like future_reorder_optimized line 410-414
+    try:
+        inventory_data = {
+            'FutureInventory': current_df_inv['Inventory'].iloc[0],
+            'FutureTransit': current_df_inv['Transit'].iloc[0],
+            'PurchaseFactor': current_df_inv['PurchaseFactor'].iloc[0] if 'PurchaseFactor' in current_df_inv.columns else 1
+        }
+    except KeyError as e:
+        # Handle missing columns gracefully
+        inventory_data = {
+            'FutureInventory': current_df_inv.get('Inventory', pd.Series([0])).iloc[0],
+            'FutureTransit': current_df_inv.get('Transit', pd.Series([0])).iloc[0],
+            'PurchaseFactor': current_df_inv.get('PurchaseFactor', pd.Series([1])).iloc[0]
+        }
+    
+    # Vectorized calculations - EXACTLY like future_reorder_optimized line 417-428
+    df = df_sstock.copy()
+    df['FutureInventory'] = _format_value_complete(inventory_data['FutureInventory'], 'FutureInventory', integer)
+    df['FutureTransit'] = _format_value_complete(inventory_data['FutureTransit'], 'FutureTransit', integer)
+    df['FutureInventoryTransit'] = _format_value_complete(
+        inventory_data['FutureInventory'] + inventory_data['FutureTransit'],
+        'FutureInventoryTransit', integer
+    )
+    df['PurchaseFactor'] = inventory_data['PurchaseFactor']
+    
+    # Initialize transit orders - EXACTLY like future_reorder_optimized line 430-438
+    if key not in transit_orders:
+        transit_orders[key] = []
+    
+    # Handle transit schedule
+    transit_qty = float(inventory_data['FutureTransit'])
+    if transit_qty > 0:
+        transit_schedule = _prepare_transit_schedule_complete(key, transit_qty, dates, df_transit, 'Location' in metadata)
+        transit_orders[key].extend(transit_schedule)
+    
+    # Set initial values - EXACTLY like future_reorder_optimized line 440-452
+    df['TransitArrival'] = '[]'
+    df['SecurityStock'] = _calculate_security_stock_complete(df, security_stock_ref, integer)
+    df['SuggestedForecast'] = _format_value_complete(df['SuggestedForecast'].iloc[0], 'SuggestedForecast', integer)
+    df['ReorderPoint'] = _format_value_complete(
+        max(0, df['SuggestedForecast'].iloc[0] + df['SecurityStock'].iloc[0]), 'ReorderPoint', integer
+    )
+    df['ReorderQtyBase'] = _format_value_complete(
+        max(0, df['ReorderPoint'].iloc[0] - df['FutureInventoryTransit'].iloc[0]), 'ReorderQtyBase', integer
+    )
+    df['ReorderQty'] = 0
+    df['ReorderQtyDays'] = 0
+    df['ArrivalDate'] = ''
+    
+    return df
+
+
+def _process_transit_orders_complete(transit_orders, key, current_date, previous_date):
+    """Process transit orders and calculate arrivals for the current period."""
+    # Get orders for this key, return early if none
+    orders = transit_orders.get(key, [])
+    if not orders:
+        return 0, 0, []
+    
+    new_transit = 0
+    remaining_orders = []
+    transit_arrivals = []
+    stock_from_arrivals = 0
+    
+    for order in orders:
+        if order['arrival_date'] > previous_date and order['arrival_date'] <= current_date:
+            # Order arrives in this period
+            stock_from_arrivals += order['quantity']
+            transit_arrivals.append({
+                'quantity': float(order['quantity']),
+                'arrival_date': order['arrival_date'].strftime('%Y-%m-%d')
+            })
+        else:
+            # Order still in transit
+            new_transit += order['quantity']
+            remaining_orders.append(order)
+    
+    transit_orders[key] = remaining_orders
+    return stock_from_arrivals, new_transit, transit_arrivals
+
+
+def _process_future_period_complete(current_df_inv, df_sstock, df_previous, key, date, dates, i, transit_orders, metadata, integer, security_stock_ref=False):
+    """Process inventory for future periods (i>0). Replicates exactly the logic from future_reorder_optimized."""
+    
+    # EXACTLY like future_reorder_optimized line 460-461
+    df = df_sstock.copy()
+    try:
+        df['PurchaseFactor'] = current_df_inv['PurchaseFactor'].iloc[0] if 'PurchaseFactor' in current_df_inv.columns else 1
+    except (KeyError, IndexError):
+        df['PurchaseFactor'] = 1
+    
+    # Calculate consumption - EXACTLY like future_reorder_optimized line 463-465
+    consumption = df_previous['SuggestedForecastPeriod'].iloc[0]
+    previous_stock = df_previous['FutureInventory'].iloc[0] - consumption
+    
+    # Process transit orders - EXACTLY like future_reorder_optimized line 467-473
+    try:
+        # Validate indices before accessing dates array
+        if i <= 0:
+            raise ValueError(f"Invalid period index {i} for future period processing (must be > 0)")
+        if i-1 >= len(dates):
+            raise ValueError(f"Previous period index {i-1} is out of bounds for dates array of length {len(dates)}")
+        
+        # Validate date values before conversion
+        if not isinstance(date, str) or len(date) != 8:
+            raise ValueError(f"Invalid current date format: {repr(date)} (expected 8-character string)")
+        if not isinstance(dates[i-1], str) or len(dates[i-1]) != 8:
+            raise ValueError(f"Invalid previous date format: {repr(dates[i-1])} (expected 8-character string)")
         
-        df_sstock['SuggestedForecastPeriod'] = df_sstock.apply(
-            lambda row: self._format_value(suggested_forecast_period.iloc[row.name], 'SuggestedForecastPeriod'),
-            axis=1
-        )
+        current_date = pd.to_datetime(date, format='%Y%m%d')
+        previous_date = pd.to_datetime(dates[i-1], format='%Y%m%d')
         
-        return df_sstock
+    except Exception as e:
+        error_msg = f"_process_future_period_complete: Date processing error - "
+        error_msg += f"current='{date}' (type: {type(date)}), "
+        error_msg += f"previous='{dates[i-1] if i-1 < len(dates) else 'INDEX_OUT_OF_BOUNDS'}' "
+        error_msg += f"(type: {type(dates[i-1]) if i-1 < len(dates) else 'N/A'}), "
+        error_msg += f"period_index={i}, dates_length={len(dates)}, "
+        error_msg += f"original_error: {str(e)}"
+        raise ValueError(error_msg)
+    
+    stock_from_arrivals, new_transit, transit_arrivals = _process_transit_orders_complete(
+        transit_orders, key, current_date, previous_date
+    )
+    
+    # Vectorized inventory updates - EXACTLY like future_reorder_optimized line 475-482
+    future_stock = max(0, previous_stock + stock_from_arrivals)
+    df['FutureInventory'] = _format_value_complete(future_stock, 'FutureInventory', integer)
+    df['FutureTransit'] = _format_value_complete(new_transit, 'FutureTransit', integer)
+    df['FutureInventoryTransit'] = _format_value_complete(
+        future_stock + new_transit, 'FutureInventoryTransit', integer
+    )
+    df['TransitArrival'] = str(transit_arrivals) if transit_arrivals else '[]'
+    
+    # Vectorized reorder calculations - EXACTLY like future_reorder_optimized line 484-508
+    df['SecurityStock'] = _calculate_security_stock_complete(df, security_stock_ref, integer)
+    df['SuggestedForecast'] = _format_value_complete(df['SuggestedForecast'].iloc[0], 'SuggestedForecast', integer)
+    df['ReorderPoint'] = _format_value_complete(
+        max(0, df['SuggestedForecast'].iloc[0] + df['SecurityStock'].iloc[0]), 'ReorderPoint', integer
+    )
+    df['ReorderQtyBase'] = _format_value_complete(
+        max(0, df['ReorderPoint'].iloc[0] - df['FutureInventoryTransit'].iloc[0]), 'ReorderQtyBase', integer
+    )
+    
+    # Calculate ReorderQty - EXACTLY like future_reorder_optimized line 494-500
+    reorder_qty_base = df['ReorderQtyBase'].iloc[0]
+    purchase_factor = df['PurchaseFactor'].iloc[0]
+    
+    if reorder_qty_base > 0:
+        reorder_qty = np.ceil(reorder_qty_base / purchase_factor) * purchase_factor
+    else:
+        reorder_qty = 0
+    
+    df['ReorderQty'] = _format_value_complete(reorder_qty, 'ReorderQty', integer)
+    
+    # Calculate ReorderQtyDays - EXACTLY like future_reorder_optimized line 502-508
+    if df['ReorderQty'].iloc[0] > 0 and df['AvgDailyUsage'].iloc[0] > 0:
+        reorder_qty_days = df['ReorderQty'].iloc[0] / df['AvgDailyUsage'].iloc[0]
+    else:
+        reorder_qty_days = 0
+    
+    df['ReorderQtyDays'] = _format_value_complete(reorder_qty_days, 'ReorderQtyDays', integer)
+    
+    # Handle new orders - EXACTLY like future_reorder_optimized line 510-521
+    if df['ReorderQty'].iloc[0] > 0:
+        avg_lead_time = df['AvgLeadTime'].iloc[0]
+        arrival_date = current_date + timedelta(days=int(avg_lead_time))
+        transit_orders[key].append({
+            'quantity': float(df['ReorderQty'].iloc[0]),
+            'arrival_date': arrival_date
+        })
+        df['ArrivalDate'] = arrival_date.strftime('%Y-%m-%d')
+    else:
+        df['ArrivalDate'] = ''
+    
+    return df
+
 
+class FutureReorder():
+    """
+    Versión completa optimizada para procesamiento masivo de datasets grandes.
+    Incluye TODA la funcionalidad de la clase original pero optimizada para paralelización.
+    
+    Nueva funcionalidad period2:
+    - period2 controla el número de períodos para ítems con ReorderFreq <= 20
+    - periods controla el número de períodos para ítems con ReorderFreq > 20
+    - Esto permite reducir el número de resultados para ítems con frecuencias de reorden pequeñas
+    """
 
-    def _calculate_security_stock(self, df):
+    def __init__(self, df_inv, df_lead_time, df_prep, df_fcst, periods, start_date,
+                 location=False, security_stock_ref=False, df_transit=None, integer=True,
+                 complete_suggested=False, start_date_zero=None, batch_size=None, n_workers=None,
+                 verbose=True, period2=2):
         """
-        Calculate security stock using configured method.
-        
-        Two methods are available:
-        1. Statistical method (default):
-           SecurityStock = (MaxDailyUsage × MaxLeadTime) - (AvgDailyUsage × AvgLeadTime)
-           This represents the difference between worst-case and average scenarios.
-           
-        2. Reference days method (if security_stock_ref=True):
-           SecurityStock = SecurityStockDaysRef × AvgDailyUsage
-           Uses a predefined number of days of coverage.
+        Initialize FutureReorder with enhanced period control.
         
         Args:
-            df (pd.DataFrame): DataFrame containing required calculation fields
-            
-        Returns:
-            pd.Series: Calculated security stock values
+            df_inv: Inventory DataFrame
+            df_lead_time: Lead time DataFrame
+            df_prep: Preparation DataFrame
+            df_fcst: Forecast DataFrame
+            periods: Number of periods for items with ReorderFreq > 20
+            start_date: Start date for calculations
+            location: Boolean for location-based processing
+            security_stock_ref: Boolean for reference-based security stock
+            df_transit: Transit DataFrame (optional)
+            integer: Boolean for integer formatting
+            complete_suggested: Boolean for complete suggested forecast mode
+            start_date_zero: Custom start date for period 0
+            batch_size: Batch size for parallel processing (auto-configured if None)
+            n_workers: Number of workers for parallel processing (auto-configured if None)
+            verbose: Boolean for detailed logging
+            period2: Number of periods for items with ReorderFreq <= 20 (default: 2)
         """
-        if self.security_stock_ref:
-            security_stock = df['SecurityStockDaysRef'] * df['AvgDailyUsage']
+        
+        # Original parameters - TODOS los parámetros de la clase original
+        self.df_inv = df_inv
+        self.df_lead_time = df_lead_time
+        self.df_prep = df_prep
+        self.df_fcst = df_fcst
+        self.default_coverage = 30
+        self.periods = periods
+        self.period2 = period2
+        self.start_date = pd.to_datetime(start_date, format='%Y-%m-%d') if start_date is not None else None
+        self.location = location
+        self.security_stock_ref = security_stock_ref
+        self.df_transit = df_transit
+        self.integer = integer
+        self.complete_suggested = complete_suggested
+        self.start_date_zero = start_date_zero
+        
+        # Optimization parameters with intelligent defaults
+        total_items = len(df_inv)
+        
+        # Auto-configure batch_size based on dataset size
+        if batch_size is None:
+            if total_items <= 500:
+                self.batch_size = 50  # Small batches for small datasets
+            elif total_items <= 2000:
+                self.batch_size = 100  # Medium batches
+            else:
+                self.batch_size = 200  # Larger batches for big datasets
+        else:
+            self.batch_size = batch_size
+            
+        # Auto-configure n_workers based on system and dataset
+        if n_workers is None:
+            available_cores = cpu_count()
+            if total_items <= 200:
+                self.n_workers = min(2, available_cores - 1)  # Conservative for small datasets
+            elif total_items <= 1000:
+                self.n_workers = min(4, available_cores - 1)  # Moderate parallelization
+            else:
+                self.n_workers = min(max(4, available_cores - 2), 8)  # Aggressive for large datasets
         else:
-            security_stock = (df['MaxDailyUsage'] * df['MaxLeadTime']) - (df['AvgDailyUsage'] * df['AvgLeadTime'])
+            self.n_workers = n_workers
+            
+        self.verbose = verbose
         
-        # Apply formatting
-        return security_stock.apply(lambda x: self._format_value(x, 'SecurityStock'))
-
-
-    def _calculate_inventory_days(self, df):
-        """
-        Calculate inventory days using configured method.
-     
-        FutureStockoutDays = (FutureInventoryTransitArrival - SecurityStock) / AvgDailyUsage
+        # Initialize metadata columns
+        self.metadata = ['Item']
+        if self.location:
+            self.metadata.append('Location')
+        
+        # Pre-filter dataframes based on df_inv to improve performance
+        self._prefilter_dataframes()
         
-        Args:
-            df (pd.DataFrame): DataFrame containing required calculation fields
-            
-        Returns:
-            pd.Series: Calculated future stockout days
-        """
-        # Calculate future stockout days with safe division
-        # Avoid division by zero by checking AvgDailyUsage
-        future_stockout_days = np.where(
-            df['AvgDailyUsage'] > 0,
-            (df['FutureInventoryTransitArrival'] - df['SecurityStock']) / df['AvgDailyUsage'],
-            0  # If no daily usage, return 0 days
-        )
+        self._log(f"🚀 FutureReorder Massive Complete - Inicializado para {len(self.df_inv)} ítems")
+        self._log(f"⚙️  Configuración: batch_size={batch_size}, workers={self.n_workers}")
 
-        # Apply formatting
-        return pd.Series(future_stockout_days).apply(lambda x: self._format_value(x, 'FutureStockoutDays'))
-
-
-    def _sum_transit_arrivals(self, transit_arrivals_str):
+    def _prefilter_dataframes(self):
         """
-        Calculate the total quantity from TransitArrival string.
-        
-        Args:
-            transit_arrivals_str (str): String representation of transit arrivals list
-                                       e.g., '[{"quantity": 100.0, "arrival_date": "2024-01-15"}]'
-            
-        Returns:
-            float: Total quantity of all arrivals in the period
+        Pre-filter all input dataframes based on df_inv to improve performance.
+        Only process data that exists in df_inv (inventory data).
         """
+        if self.verbose:
+            original_sizes = {
+                'df_lead_time': len(self.df_lead_time),
+                'df_prep': len(self.df_prep),
+                'df_fcst': len(self.df_fcst),
+                'df_transit': len(self.df_transit) if self.df_transit is not None else 0
+            }
+            self._log("📊 Pre-filtering dataframes based on df_inv...")
         
-        if transit_arrivals_str == '[]' or not transit_arrivals_str:
-            return 0.0
-            
-        try:
-            arrivals = ast.literal_eval(transit_arrivals_str)
-            return sum(arrival.get('quantity', 0) for arrival in arrivals)
-        except:
-            return 0.0
-
-
-    def _prepare_transit_schedule(self, key, transit_amount, dates):
-        """
-        Prepare transit schedule based on df_transit or default logic.
+        # Create base filter from df_inv
+        if self.location:
+            base_filter = self.df_inv[['Item', 'Location']].drop_duplicates()
+        else:
+            base_filter = self.df_inv[['Item']].drop_duplicates()
         
-        Args:
-            key (tuple or str): Item identifier (item) or (item, location)
-            transit_amount (float): Total transit amount from df_inv
-            dates (list): List of dates for this item
-            
-        Returns:
-            list: List of transit orders with 'quantity' and 'arrival_date'
-        """
-        if transit_amount <= 0:
-            return []
-            
-        transit_schedule = []
+        # Filter df_lead_time
+        if self.location:
+            self.df_lead_time = self.df_lead_time.merge(
+                base_filter,
+                on=['Item', 'Location'],
+                how='inner'
+            )
+        else:
+            self.df_lead_time = self.df_lead_time.merge(
+                base_filter,
+                on=['Item'],
+                how='inner'
+            )
         
-        if self.df_transit is None:
-            # Default logic: complete transit arrives in period 1
-            if len(dates) > 1:
-                arrival_date = pd.to_datetime(dates[1], format='%Y%m%d')
-                transit_schedule.append({
-                    'quantity': transit_amount,
-                    'arrival_date': arrival_date
-                })
+        # Filter df_prep - handle different column naming conventions
+        if self.location:
+            # Check if df_prep uses 'item_id' and 'location' columns
+            if 'item_id' in self.df_prep.columns and 'location' in self.df_prep.columns:
+                # Create renamed base filter for df_prep
+                base_filter_prep = base_filter.copy()
+                base_filter_prep = base_filter_prep.rename(columns={'Item': 'item_id', 'Location': 'location'})
+                self.df_prep = self.df_prep.merge(
+                    base_filter_prep,
+                    on=['item_id', 'location'],
+                    how='inner'
+                )
+            else:
+                # Use standard column names
+                self.df_prep = self.df_prep.merge(
+                    base_filter,
+                    on=['Item', 'Location'],
+                    how='inner'
+                )
+        else:
+            # Check if df_prep uses 'item_id' column
+            if 'item_id' in self.df_prep.columns:
+                base_filter_prep = base_filter.copy()
+                base_filter_prep = base_filter_prep.rename(columns={'Item': 'item_id'})
+                self.df_prep = self.df_prep.merge(
+                    base_filter_prep,
+                    on=['item_id'],
+                    how='inner'
+                )
+            else:
+                self.df_prep = self.df_prep.merge(
+                    base_filter,
+                    on=['Item'],
+                    how='inner'
+                )
+        
+        # Filter df_fcst
+        if self.location:
+            self.df_fcst = self.df_fcst.merge(
+                base_filter,
+                on=['Item', 'Location'],
+                how='inner'
+            )
         else:
-            # Use provided transit schedule
+            self.df_fcst = self.df_fcst.merge(
+                base_filter,
+                on=['Item'],
+                how='inner'
+            )
+        
+        # Filter df_transit if it exists
+        if self.df_transit is not None:
             if self.location:
-                item, location = key
-                mask = (self.df_transit['Item'] == item) & (self.df_transit['Location'] == location)
+                self.df_transit = self.df_transit.merge(
+                    base_filter,
+                    on=['Item', 'Location'],
+                    how='inner'
+                )
             else:
-                mask = self.df_transit['Item'] == key
-                
-            transit_data = self.df_transit[mask].copy()
+                self.df_transit = self.df_transit.merge(
+                    base_filter,
+                    on=['Item'],
+                    how='inner'
+                )
+        
+        if self.verbose:
+            new_sizes = {
+                'df_lead_time': len(self.df_lead_time),
+                'df_prep': len(self.df_prep),
+                'df_fcst': len(self.df_fcst),
+                'df_transit': len(self.df_transit) if self.df_transit is not None else 0
+            }
             
-            if not transit_data.empty:
-                # Validate total matches
-                total_scheduled = transit_data['Transit'].sum()
-                if abs(total_scheduled - transit_amount) > 0.01:  # Allow small floating point differences
-                    raise ValueError(f"Transit schedule total ({total_scheduled}) does not match inventory transit ({transit_amount}) for {key}")
-                
-                # Create transit orders
-                for _, row in transit_data.iterrows():
-                    arrival_date = pd.to_datetime(row['ArrivalDate'], format='%Y-%m-%d')
-                    transit_schedule.append({
-                        'quantity': float(row['Transit']),
-                        'arrival_date': arrival_date
-                    })
-            else:
-                # If no transit data provided for this item, use default logic
-                if len(dates) > 1:
-                    arrival_date = pd.to_datetime(dates[1], format='%Y%m%d')
-                    transit_schedule.append({
-                        'quantity': transit_amount,
-                        'arrival_date': arrival_date
-                    })
-                    
-        return transit_schedule
+            self._log("📊 Filtrado completado:")
+            for df_name, original_size in original_sizes.items():
+                new_size = new_sizes[df_name]
+                if original_size > 0:
+                    reduction_pct = ((original_size - new_size) / original_size) * 100
+                    self._log(f"   • {df_name}: {original_size:,} → {new_size:,} (-{reduction_pct:.1f}%)")
+                else:
+                    self._log(f"   • {df_name}: {original_size:,} → {new_size:,}")
 
+    def _log(self, message):
+        if self.verbose:
+            print(message)
+            sys.stdout.flush()
 
-    def _process_current_period(self, current_df_inv, df_sstock, key, date, transit_orders, dates):
+    def future_date(self):
         """
-        Process inventory for the current period (i=0).
-        
-        This optimized version uses vectorized operations where possible and
-        minimizes redundant calculations.
-        
-        Args:
-            current_df_inv (pd.DataFrame): Current inventory data
-            df_sstock (pd.DataFrame): Security stock calculation data
-            key (tuple or str): Item identifier (item) or (item, location)
-            date (str): Current date in 'YYYYMMDD' format
-            transit_orders (dict): Dictionary tracking in-transit orders
-            dates (list): List of all dates for this item
-            
-        Returns:
-            pd.DataFrame: Processed inventory data for the current period
+        Generate future reorder dates for each item based on reorder frequency.
+        Versión optimizada de la función original.
         """
-        inventory_columns = ['Item', 'Location', 'Inventory', 'Transit', 'PurchaseFactor'] if self.location else ['Item', 'Inventory', 'Transit', 'PurchaseFactor']
-        df_inventory = current_df_inv[inventory_columns].copy()
-        
-        # Vectorized initialization of inventory values with formatting
-        df_inventory['FutureInventory'] = df_inventory['Inventory'].apply(
-            lambda x: self._format_value(x, 'FutureInventory')
-        )
-        df_inventory['FutureTransit'] = df_inventory['Transit'].apply(
-            lambda x: self._format_value(x, 'FutureTransit')
-        )
-        df_inventory['FutureInventoryTransit'] = df_inventory.apply(
-            lambda row: self._format_value(row['Inventory'] + row['Transit'], 'FutureInventoryTransit'),
-            axis=1
-        )
-        
-        # Initialize transit orders for this item
-        if key not in transit_orders:
-            transit_orders[key] = []
-        
-        # Handle initial transit
-        transit_qty = float(df_inventory['Transit'].iloc[0])
-        
-        # Prepare transit schedule
-        transit_schedule = self._prepare_transit_schedule(key, transit_qty, dates)
+        # Determine the starting date for period 0 - EXACTLY like future_reorder_optimized line 148-155
+        if self.start_date_zero is not None:
+            # Use custom start date for period 0
+            actual_date = pd.to_datetime(self.start_date_zero, format='%Y-%m-%d')
+        else:
+            # Use current system date for period 0 (original behavior)
+            DOCKER_CONFIG_PATH = os.path.join('/opt/ml/processing/input', 'config.yml')
+            utils = Utils(config_file=DOCKER_CONFIG_PATH, logfile='data_io', log_path='output/logs')
+            timestamp = utils.set_timestamp()
+            actual_date = pd.to_datetime(str(int(float(timestamp[0:8]))), format='%Y%m%d')
         
-        # Add scheduled transits to transit_orders
-        transit_orders[key].extend(transit_schedule)
+        # Use periods + 1 internally to calculate one extra period for transit calculations
+        # The extra period will be filtered out in the final results
+        end_date = actual_date + pd.DateOffset(months=self.periods + 1)
         
-        # For period 0, TransitArrival should always be empty list
-        df_inventory['TransitArrival'] = '[]'
-        
-        # Select relevant columns
-        df_inventory = df_inventory[self.metadata + ['FutureInventoryTransit', 'FutureInventory', 'FutureTransit', 'TransitArrival']]
-        
-        # Merge with stock data
-        df = pd.merge(df_inventory, df_sstock, on=self.metadata, how='inner')
-        
-        # Vectorized calculations for all rows at once
-        df['SuggestedForecastPeriod'] = df_sstock['SuggestedForecastPeriod']
-        df['SecurityStock'] = self._calculate_security_stock(df)
-        
-        # Apply formatting to calculated fields
-        df['SuggestedForecast'] = df['SuggestedForecast'].apply(
-            lambda x: self._format_value(x, 'SuggestedForecast')
-        )
-        df['ReorderPoint'] = df.apply(
-            lambda row: self._format_value(max(0, row['SuggestedForecast'] + row['SecurityStock']), 'ReorderPoint'),
-            axis=1
-        )
-        df['ReorderQtyBase'] = df.apply(
-            lambda row: self._format_value(max(0, row['ReorderPoint'] - row['FutureInventoryTransit']), 'ReorderQtyBase'),
-            axis=1
-        )
-        
-        # First period has no reorder - vectorized assignment
-        df['ReorderQty'] = 0
-        df['ReorderQtyDays'] = 0
-        df['ArrivalDate'] = ''  # No order in period 0
-        
-        # Note: FutureInventoryTransitArrival and FutureStockoutDays are calculated later
-        # in _process_item_optimized after all periods are processed
-        
-        return df
-
+        # Handle start_date = None case
+        if self.start_date is None:
+            # If start_date is None, use actual_date as the base for period 1
+            base_start_date = actual_date
+        else:
+            base_start_date = self.start_date
 
-    def _process_transit_orders(self, transit_orders, key, current_date, previous_date):
-        """
-        Process transit orders and calculate arrivals for the current period.
+        # Get unique items with their reorder frequencies
+        columns = self.metadata + ['ReorderFreq']
+        df_unique = self.df_lead_time[columns].drop_duplicates().copy()
+        
+        # Process ReorderFreq values
+        df_unique['ReorderFreq'] = df_unique['ReorderFreq'].fillna(self.default_coverage)
+        df_unique.loc[df_unique['ReorderFreq'] == 0, 'ReorderFreq'] = self.default_coverage
+        df_unique['ReorderFreq'] = df_unique['ReorderFreq'].astype(int)
         
-        This optimized method uses vectorization for better performance with large
-        numbers of transit orders. It manages the lifecycle of transit orders:
-        1. Identifies orders arriving in the current period
-        2. Moves arrived quantities from transit to stock
-        3. Updates remaining transit orders
-        4. Maintains arrival history for reporting
+        # Pre-allocate result dictionary
+        item_dates = {}
         
-        Args:
-            transit_orders (dict): Dictionary of active transit orders by item/location
-            key (tuple or str): Item identifier (item) or (item, location)
-            current_date (pd.Timestamp): Current period date
-            previous_date (pd.Timestamp): Previous period date
+        # Group by ReorderFreq for batch processing - more efficient for large datasets
+        for freq, group in df_unique.groupby('ReorderFreq'):
+            # Generate date range for this frequency
+            date_range = []
             
-        Returns:
-            tuple: (stock_from_arrivals, new_transit, transit_arrivals)
-                - stock_from_arrivals: Total quantity arriving in this period
-                - new_transit: Total quantity still in transit
-                - transit_arrivals: List of arrival records for this period
-        """
-        # Get orders for this key, return early if none
-        orders = transit_orders.get(key, [])
-        if not orders:
-            return 0, 0, []
-        
-        # For small numbers of orders, use loops implementation
-        # as it has less overhead
-        if len(orders) < 10:
-            new_transit = 0
-            remaining_orders = []
-            transit_arrivals = []
-            stock_from_arrivals = 0
+            # Always include actual date (period 0)
+            date_range.append(actual_date)
             
-            for order in orders:
-                if order['arrival_date'] > previous_date and order['arrival_date'] <= current_date:
-                    # Order arrives in this period
-                    stock_from_arrivals += order['quantity']
-                    transit_arrivals.append({
-                        'quantity': float(order['quantity']),
-                        'arrival_date': order['arrival_date'].strftime('%Y-%m-%d')
-                    })
-                else:
-                    # Order still in transit
-                    new_transit += order['quantity']
-                    remaining_orders.append(order)
+            # Include base_start_date if after actual_date
+            if base_start_date > actual_date:
+                date_range.append(base_start_date)
             
-            transit_orders[key] = remaining_orders
-            return stock_from_arrivals, new_transit, transit_arrivals
-        
-        # For larger numbers of orders, use vectorized approach
-        # Extract data into numpy arrays for faster processing
-        quantities = np.array([order['quantity'] for order in orders], dtype=np.float64)
-        arrival_dates = np.array([order['arrival_date'] for order in orders])
-        
-        # Vectorized date comparison
-        mask_arrived = (arrival_dates > previous_date) & (arrival_dates <= current_date)
-        
-        # Calculate totals using numpy operations
-        stock_from_arrivals = float(quantities[mask_arrived].sum()) if mask_arrived.any() else 0
-        new_transit = float(quantities[~mask_arrived].sum()) if (~mask_arrived).any() else 0
-        
-        # Create transit arrivals list
-        transit_arrivals = []
-        if mask_arrived.any():
-            arrived_indices = np.where(mask_arrived)[0]
-            transit_arrivals = [
-                {
-                    'quantity': float(quantities[i]),
-                    'arrival_date': arrival_dates[i].strftime('%Y-%m-%d')
-                }
-                for i in arrived_indices
-            ]
-        
-        # Update transit orders with remaining orders
-        if (~mask_arrived).any():
-            remaining_indices = np.where(~mask_arrived)[0]
-            transit_orders[key] = [orders[i] for i in remaining_indices]
-        else:
-            transit_orders[key] = []
+            # Generate subsequent dates using pandas date_range for efficiency
+            num_periods = int((end_date - base_start_date).days / freq) + 1
+            future_dates = pd.date_range(
+                start=base_start_date + timedelta(days=freq),
+                periods=num_periods,
+                freq=f'{freq}D'
+            )
+            date_range.extend(future_dates[future_dates <= end_date])
+            
+            # Convert to string format
+            date_strings = [d.strftime('%Y%m%d') for d in date_range]
+            
+            # Assign to all items in this group
+            for _, row in group.iterrows():
+                if self.location:
+                    key = (row['Item'], row['Location'])
+                else:
+                    key = row['Item']
+                item_dates[key] = date_strings
         
-        return stock_from_arrivals, new_transit, transit_arrivals
-
+        return item_dates
 
-    def _process_future_period(self, current_df_inv, df_sstock, df_previous, key, date, dates, i, transit_orders):
+    def _prepare_batch_data(self):
         """
-        Process inventory for future periods (i>0).
-        
-        This method:
-        1. Calculates consumption using SuggestedForecastPeriod from previous period
-        2. Updates stock levels considering consumption and arrivals
-        3. Determines if reorder is needed
-        4. Calculates reorder quantity if needed
-        5. Adds new orders to transit tracking
-                
-        Args:
-            current_df_inv (pd.DataFrame): Current inventory data
-            df_sstock (pd.DataFrame): Security stock calculation data
-            df_previous (pd.DataFrame): Previous period's results
-            key (tuple or str): Item identifier (item) or (item, location)
-            date (str): Current date in 'YYYYMMDD' format
-            dates (list): List of all dates for this item
-            i (int): Current period index
-            transit_orders (dict): Dictionary tracking in-transit orders
-            
-        Returns:
-            pd.DataFrame: Processed inventory data for the period including:
-                - Updated inventory levels
-                - Reorder recommendations
-                - Transit arrival information
+        Prepara datos por lotes de manera eficiente sin generar fechas pre-calculadas.
+        Las fechas se generarán localmente en cada worker process.
         """
-        inventory_columns = ['Item', 'Location', 'PurchaseFactor'] if self.location else ['Item', 'PurchaseFactor']
-        df_inventory = current_df_inv[inventory_columns].copy()
-        df = pd.merge(df_inventory, df_sstock, on=inventory_columns, how='inner')
-        df['SuggestedForecastPeriod'] = df_sstock['SuggestedForecastPeriod']
-        
-        # Calculate consumption using SuggestedForecastPeriod from previous period
-        consumption = df_previous['SuggestedForecastPeriod'].values[0]
-        
-        previous_stock = df_previous['FutureInventory'].values[0] - consumption
+        batch_data = []
         
-        # Process transit orders
-        current_date = pd.to_datetime(date, format='%Y%m%d')
-        previous_date = pd.to_datetime(dates[i-1], format='%Y%m%d')
-        
-        stock_from_arrivals, new_transit, transit_arrivals = self._process_transit_orders(
-            transit_orders, key, current_date, previous_date
-        )
-        
-        # Update inventory values with formatting
-        future_stock = max(0, previous_stock + stock_from_arrivals)
-        df['FutureInventory'] = self._format_value(future_stock, 'FutureInventory')
-        df['FutureTransit'] = self._format_value(new_transit, 'FutureTransit')
-        df['FutureInventoryTransit'] = self._format_value(
-            future_stock + new_transit,
-            'FutureInventoryTransit'
-        )
-        df['TransitArrival'] = str(transit_arrivals) if transit_arrivals else '[]'
-        
-        # Calculate security stock and reorder values
-        df['SecurityStock'] = self._calculate_security_stock(df)
-        
-        # Apply formatting to calculated fields
-        df['SuggestedForecast'] = df['SuggestedForecast'].apply(
-            lambda x: self._format_value(x, 'SuggestedForecast')
-        )
-        df['ReorderPoint'] = df.apply(
-            lambda row: self._format_value(max(0, row['SuggestedForecast'] + row['SecurityStock']), 'ReorderPoint'),
-            axis=1
-        )
-        df['ReorderQtyBase'] = df.apply(
-            lambda row: self._format_value(max(0, row['ReorderPoint'] - row['FutureInventoryTransit']), 'ReorderQtyBase'),
-            axis=1
-        )
-        
-        # Calculate ReorderQty only if ReorderQtyBase > 0
-        reorder_qty = np.where(
-            df['ReorderQtyBase'] > 0,
-            ((df['ReorderQtyBase'] / df['PurchaseFactor']).apply(np.ceil)) * df['PurchaseFactor'],
-            0
-        )
-        df['ReorderQty'] = df.apply(
-            lambda row: self._format_value(reorder_qty[row.name], 'ReorderQty'),
-            axis=1
-        )
-        
-        # Calculate ReorderQtyDays, avoiding division by zero
-        reorder_qty_days = np.where(
-            (df['ReorderQty'] > 0) & (df['AvgDailyUsage'] > 0),
-            df['ReorderQty'] / df['AvgDailyUsage'],
-            0
-        )
-        df['ReorderQtyDays'] = df.apply(
-            lambda row: self._format_value(reorder_qty_days[row.name], 'ReorderQtyDays'),
-            axis=1
-        )
-        
-        # Add new order to transit if needed
-        if df['ReorderQty'].values[0] > 0:
-            avg_lead_time = df['AvgLeadTime'].values[0]
-            arrival_date = current_date + timedelta(days=int(avg_lead_time))
-            # Store the raw value for transit calculations
-            transit_orders[key].append({
-                'quantity': float(df['ReorderQty'].values[0]),
-                'arrival_date': arrival_date
-            })
-            # Store arrival date for this period's order
-            df['ArrivalDate'] = arrival_date.strftime('%Y-%m-%d')
+        # Get unique items from df_inv
+        if self.location:
+            unique_items = self.df_inv[['Item', 'Location']].drop_duplicates()
         else:
-            # No order in this period
-            df['ArrivalDate'] = ''
+            unique_items = self.df_inv[['Item']].drop_duplicates()
         
+        for _, row in unique_items.iterrows():
+            try:
+                if self.location:
+                    key = (row['Item'], row['Location'])
+                    item, location = key
+                else:
+                    key = row['Item']
+                    item = key
+                    location = None
+                    
+                # Create filter mask based on item
+                mask_lead_time = self.df_lead_time['Item'] == item
+                mask_inv = self.df_inv['Item'] == item
+                
+                # Add location filter if needed
+                if self.location and location is not None:
+                    mask_lead_time &= self.df_lead_time['Location'] == location
+                    mask_inv &= self.df_inv['Location'] == location
+                
+                # Apply filters using boolean indexing
+                current_df_lead_time = self.df_lead_time[mask_lead_time]
+                current_df_inv = self.df_inv[mask_inv]
+                
+                if not current_df_lead_time.empty and not current_df_inv.empty:
+                    # Only include key and dataframes, dates will be generated in worker
+                    batch_data.append((key, current_df_lead_time, current_df_inv))
+                    
+            except Exception as e:
+                if self.verbose:
+                    print(f"Error preparando {key}: {e}")
+                continue
         
-        # Note: FutureInventoryTransitArrival and FutureStockoutDays are calculated later
-        # in _process_item_optimized after all periods are processed
-        
-        return df
-
+        return batch_data
 
     def _prepare_final_dataframe(self, data_frame):
         """
         Prepare the final output dataframe with proper formatting and column selection.
-        
-        This method:
-        1. Merges with lead time data to add reorder parameters
-        2. Formats dates to YYYY-MM-DD format
-        3. Renames columns for clarity
-        4. Rounds numeric values to 2 decimal places
-        5. Selects and orders final columns
-        
-        Args:
-            data_frame (pd.DataFrame): Raw calculation results
-            
-        Returns:
-            pd.DataFrame: Formatted output with columns:
-                - PurchaseDate, Item, ItemDescription, (Location)
-                - Forecast metrics: SuggestedForecast, SuggestedForecastPeriod
-                - Inventory levels: FutureInventoryTransit (total), FutureInventory (stock), FutureTransit (transit)
-                - FutureInventoryTransitArrival: FutureInventory + arrivals in the period
-                - FutureStockoutDays: Days of inventory coverage
-                - Transit information: TransitArrival
-                - Reorder metrics: ReorderQtyBase, ReorderQty, ReorderQtyDays
-                - Order information: ArrivalDate (arrival date of current period's order)
-                - Planning parameters: PurchaseFactor, ReorderPoint, SecurityStock
-                - Usage rates: AvgDailyUsage, MaxDailyUsage
-                - Lead times: AvgLeadTime, MaxLeadTime
-                - Coverage parameters: ReorderFreq, Coverage
+        Versión completa de la función original.
         """
         leadtimes_columns = ['Item', 'Location', 'ReorderFreq', 'Coverage'] if self.location else ['Item', 'ReorderFreq', 'Coverage']
         leadtimes = self.df_lead_time[leadtimes_columns]
@@ -946,13 +1416,13 @@ class FutureReorder():
         always_integer_fields = ['PurchaseFactor', 'AvgLeadTime', 'MaxLeadTime', 'ReorderQtyDays', 'ReorderFreq', 'Coverage']
         for field in always_integer_fields:
             if field in df_final.columns:
-                df_final[field] = df_final[field].apply(lambda x: self._format_value(x, field))
+                df_final[field] = df_final[field].apply(lambda x: _format_value_complete(x, field, True))
         
         # Apply formatting to fields that are ALWAYS decimals
         always_decimal_fields = ['AvgDailyUsage', 'MaxDailyUsage']
         for field in always_decimal_fields:
             if field in df_final.columns:
-                df_final[field] = df_final[field].apply(lambda x: self._format_value(x, field))
+                df_final[field] = df_final[field].apply(lambda x: _format_value_complete(x, field, False))
         
         # Select final columns
         if self.location:
@@ -976,186 +1446,220 @@ class FutureReorder():
         
         return df_final[final_cols]
 
+    def _filter_periods(self, df):
+        """
+        Filter out period 0 and last period from results.
+        Period 0 is used only as calculation base.
+        Last period is filtered because it doesn't have next period transit data.
+        
+        Special case: When start_date=None, don't filter the first period
+        because it represents the actual current period.
+        """
+        if df.empty:
+            return df
+        
+        # Convert PurchaseDate to datetime for filtering
+        df['PurchaseDate_dt'] = pd.to_datetime(df['PurchaseDate'])
+        
+        # Get unique dates and sort them
+        unique_dates = sorted(df['PurchaseDate_dt'].unique())
+        
+        # Determine filtering logic based on start_date parameter
+        if self.start_date is None:
+            # When start_date=None, only filter the last period
+            # Keep period 0 as it represents the current period
+            if len(unique_dates) <= 1:
+                self._log("⚠️  Warning: Only 1 period available, cannot filter last period")
+                return pd.DataFrame(columns=df.columns.drop('PurchaseDate_dt'))
+            
+            last_date = unique_dates[-1]
+            filtered_df = df[df['PurchaseDate_dt'] != last_date].copy()
+            
+            self._log(f"📊 Filtered periods (start_date=None): Only removed last period ({last_date.strftime('%Y-%m-%d')})")
+            
+        else:
+            # When start_date is specified, filter both first and last periods (original logic)
+            if len(unique_dates) <= 2:
+                self._log("⚠️  Warning: Only 2 or fewer periods available after filtering")
+                return pd.DataFrame(columns=df.columns.drop('PurchaseDate_dt'))
+            
+            first_date = unique_dates[0]
+            last_date = unique_dates[-1]
+            
+            filtered_df = df[
+                (df['PurchaseDate_dt'] != first_date) &
+                (df['PurchaseDate_dt'] != last_date)
+            ].copy()
+            
+            self._log(f"📊 Filtered periods: Removed period 0 ({first_date.strftime('%Y-%m-%d')}) and last period ({last_date.strftime('%Y-%m-%d')})")
+        
+        # Drop the temporary datetime column
+        filtered_df = filtered_df.drop('PurchaseDate_dt', axis=1)
+        
+        return filtered_df
 
     def reorder(self):
         """
-        Main method to calculate future reorder recommendations.
-        
-        This optimized version uses batch processing and vectorization to improve
-        performance, especially for large datasets. The method:
-        1. Generates future dates based on reorder frequencies
-        2. Groups items for batch processing when possible
-        3. Pre-allocates data structures to minimize memory operations
-        4. Uses vectorized calculations where applicable
-        5. Formats and returns consolidated results
+        Main method to calculate future reorder recommendations at massive scale.
+        
+        This high-performance method orchestrates the complete inventory reorder calculation
+        process using parallel processing and intelligent resource management. It handles
+        large datasets efficiently through batching, multiprocessing, and optimized algorithms.
+        
+        Processing Pipeline:
+        1. Generate future dates based on reorder frequencies and period control
+        2. Pre-filter and prepare data for batch processing
+        3. Split items into optimally-sized batches
+        4. Process batches in parallel using multiple CPU cores
+        5. Combine and format results with proper data types
+        6. Apply period filtering (removes period 0 and last period)
+        7. Return comprehensive reorder recommendations
+        
+        Performance Features:
+        - Auto-configures batch sizes based on dataset size
+        - Uses ProcessPoolExecutor for true parallel processing
+        - Provides real-time progress tracking and ETA calculations
+        - Implements intelligent error handling and recovery
+        - Optimizes memory usage through efficient data structures
+        
+        Period Control Logic:
+        - Items with ReorderFreq <= 20: Uses period2 (default: 2 periods)
+        - Items with ReorderFreq > 20: Uses periods parameter
+        - This reduces output volume for high-frequency reorder items
+        
+        Period Filtering Logic:
+        - When start_date=None: Only removes last period (keeps period 0 as current)
+        - When start_date specified: Removes both period 0 and last period
+        - Last period is always removed due to incomplete transit data
         
         Returns:
-            pd.DataFrame: Complete reorder recommendations for all items/locations
-                         and time periods. See _prepare_final_dataframe() for
-                         detailed column descriptions.
-                         
+            pd.DataFrame: Complete reorder recommendations with columns:
+                - PurchaseDate: Date when reorder should be evaluated
+                - Item, ItemDescription, (Location): Item identification
+                - Forecast metrics: SuggestedForecast, SuggestedForecastPeriod
+                - Inventory levels: FutureInventoryTransit, FutureInventory, FutureTransit
+                - FutureInventoryTransitArrival: Stock + arrivals in the period
+                - FutureStockoutDays: Days of inventory coverage
+                - Transit information: TransitArrival details
+                - Reorder metrics: ReorderQtyBase, ReorderQty, ReorderQtyDays
+                - Order information: ArrivalDate of current period's order
+                - Planning parameters: PurchaseFactor, ReorderPoint, SecurityStock
+                - Usage rates: AvgDailyUsage, MaxDailyUsage
+                - Lead times: AvgLeadTime, MaxLeadTime
+                - Coverage parameters: ReorderFreq, Coverage
+                
         Example usage:
             >>> reorder_system = FutureReorder(
             ...     df_inv=inventory_df,
             ...     df_lead_time=lead_time_df,
             ...     df_prep=prep_df,
             ...     df_fcst=forecast_df,
-            ...     periods=6,
-            ...     start_date='2024-01-01'
+            ...     periods=6,        # For items with ReorderFreq > 20
+            ...     start_date=None,  # Use current date
+            ...     period2=2,        # For items with ReorderFreq <= 20
+            ...     batch_size=100,   # Optional: auto-configured if None
+            ...     n_workers=4       # Optional: auto-configured if None
             ... )
             >>> results = reorder_system.reorder()
-            >>> results.head()
-            # Returns DataFrame with reorder recommendations
+            >>> print(f"Generated {len(results)} reorder recommendations")
         """
+        start_time = time.time()
         
-        item_dates = self.future_date()
+        self._log("🚀 FutureReorder Massive Complete - Processing Started")
         
-        # Pre-allocate list for results instead of concatenating DataFrames
-        all_results = []
+        # Prepare batch data without pre-generating dates
+        self._log("🔧 Preparando datos por lotes...")
+        batch_data = self._prepare_batch_data()
         
-        # Group items by number of periods for potential batch processing
-        items_by_period_count = {}
-        for key, dates in item_dates.items():
-            period_count = len(dates)
-            if period_count not in items_by_period_count:
-                items_by_period_count[period_count] = []
-            items_by_period_count[period_count].append((key, dates))
+        # Calculate statistics based on items that will be processed
+        total_items = len(batch_data)
         
-        # Process each group
-        for period_count, items_group in items_by_period_count.items():
-            # For each item in the group
-            for key, dates in items_group:
-                if self.location:
-                    item, location = key
-                else:
-                    item = key
-                    location = None
-                
-                # Get current dataframes
-                current_df_lead_time, current_df_inv = self._get_current_dataframes(item, location)
-                
-                if current_df_lead_time.empty or current_df_inv.empty:
-                    continue
-                
-                # Process this item using optimized approach
-                item_results = self._process_item_optimized(
-                    key, item, location, dates, current_df_lead_time, current_df_inv
-                )
-                
-                if item_results is not None and not item_results.empty:
-                    all_results.append(item_results)
+        self._log(f"📊 Dataset Info:")
+        self._log(f"   • Total Items: {total_items}")
+        self._log(f"   • Periods (ReorderFreq > 20): {self.periods}")
+        self._log(f"   • Period2 (ReorderFreq <= 20): {self.period2}")
+        self._log(f"   • Estimated Total Calculations: {total_items * self.periods}")
         
-        # Combine all results efficiently
-        if all_results:
-            data_frame = pd.concat(all_results, ignore_index=True)
-        else:
+        if not batch_data:
+            self._log("⚠️  No items to process after filtering")
             columns = ['Date', 'Item'] + (['Location'] if self.location else [])
-            data_frame = pd.DataFrame(columns=columns)
-        
-        # Prepare and return final dataframe
-        return self._prepare_final_dataframe(data_frame)
-    
-    
-    def _process_item_optimized(self, key, item, location, dates, current_df_lead_time, current_df_inv):
-        """
-        Process a single item through all periods using optimized approach.
+            return pd.DataFrame(columns=columns)
+        
+        # Split into batches for parallel processing
+        batches = []
+        for i in range(0, len(batch_data), self.batch_size):
+            batch = batch_data[i:i + self.batch_size]
+            batch_args = (
+                batch, self.df_fcst, self.df_prep, self.metadata,
+                self.location, self.default_coverage, self.complete_suggested,
+                self.security_stock_ref, self.integer, self.verbose, self.df_transit,
+                self.periods, self.period2, self.start_date.strftime('%Y-%m-%d') if self.start_date else None,
+                self.start_date_zero
+            )
+            batches.append(batch_args)
         
-        This method pre-allocates arrays and uses vectorized operations where possible
-        to improve performance.
+        total_batches = len(batches)
+        items_per_batch = len(batch_data) / total_batches if total_batches > 0 else 0
         
-        Args:
-            key: Item key (item or (item, location))
-            item: Item identifier
-            location: Location identifier (if applicable)
-            dates: List of dates to process
-            current_df_lead_time: Lead time data for this item
-            current_df_inv: Inventory data for this item
-            
-        Returns:
-            pd.DataFrame: Results for all periods of this item
-        """
+        self._log(f"⚙️  Processing Config:")
+        self._log(f"   • Batch Size: {self.batch_size}")
+        self._log(f"   • Workers: {self.n_workers}")
+        self._log(f"   • Total Batches: {total_batches}")
+        self._log(f"   • Items per Batch: {items_per_batch:.1f}")
         
-        # Pre-allocate dictionaries for intermediate results
-        suggested_forecasts = {}
-        df_avgs = {}
-        df_maxs = {}
-        df_sstocks = {}
-        period_results = {}
+        current_time = datetime.now().strftime('%H:%M:%S')
+        self._log(f"⏱️  Starting processing at {current_time}")
         
-        # Initialize transit orders for this item
-        transit_orders = {key: []}
+        # Process batches in parallel
+        results = []
+        completed_batches = 0
         
-        # Track last suggested forecast value for complete_suggested feature
-        last_suggested_value = None
-                
-        # Process each period
-        for i, date in enumerate(dates):
-            # Calculate suggested forecast (cached if possible)
-            suggested_forecasts[i] = self._calculate_suggested_forecast(
-                current_df_lead_time, current_df_inv, date, last_suggested_value
-            )
-            
-            # Update last_suggested_value for next iteration
-            if 'SuggestedForecast' in suggested_forecasts[i].columns:
-                last_suggested_value = suggested_forecasts[i]['SuggestedForecast'].iloc[0]
-            
-            # Calculate daily usage
-            df_avgs[i], df_maxs[i] = self._calculate_daily_usage(
-                suggested_forecasts[i], date
-            )
-            
-            # Calculate security stock data
-            df_sstocks[i] = self._calculate_security_stock_data(
-                df_maxs[i], current_df_lead_time, period_index=i, dates=dates
-            )
-            
-            # Process period based on whether it's current or future
-            if i == 0:
-                period_results[i] = self._process_current_period(
-                    current_df_inv, df_sstocks[i], key, date, transit_orders, dates
-                )
-            else:
-                period_results[i] = self._process_future_period(
-                    current_df_inv, df_sstocks[i], period_results[i-1],
-                    key, date, dates, i, transit_orders
-                )
+        with ProcessPoolExecutor(max_workers=self.n_workers) as executor:
+            # Submit all batches
+            future_to_batch = {executor.submit(process_item_batch_complete, batch_args): i 
+                             for i, batch_args in enumerate(batches)}
             
-            # Add metadata columns efficiently
-            period_results[i]['Date'] = date
-            period_results[i]['Item'] = item
-            if self.location:
-                period_results[i]['Location'] = location
+            # Collect results as they complete
+            for future in as_completed(future_to_batch):
+                batch_idx = future_to_batch[future]
+                try:
+                    result = future.result()
+                    if not result.empty:
+                        results.append(result)
+                    
+                    completed_batches += 1
+                    progress = (completed_batches / total_batches) * 100
+                    
+                    elapsed_time = time.time() - start_time
+                    if completed_batches > 0:
+                        eta_seconds = (elapsed_time / completed_batches) * (total_batches - completed_batches)
+                        eta_str = f"{int(eta_seconds // 60)}m {int(eta_seconds % 60)}s"
+                    else:
+                        eta_str = "calculating..."
+                    
+                    self._log(f"✅ Batch {completed_batches}/{total_batches} completed ({progress:.1f}%) - ETA: {eta_str}")
+                    
+                except Exception as e:
+                    self._log(f"❌ Error in batch {batch_idx}: {e}")
+                    continue
         
-        # After processing all periods, update FutureInventoryTransitArrival with next period's TransitArrival
-        for i in range(len(dates)):
-            if i < len(dates) - 1:  # If there's a next period
-                # Get next period's TransitArrival
-                next_transit_arrival = period_results[i + 1]['TransitArrival'].iloc[0]
-                transit_arrival_sum = self._sum_transit_arrivals(next_transit_arrival)
-            else:  # Last period - no next period
-                transit_arrival_sum = 0
+        # Combine all results
+        if results:
+            self._log("🔗 Combinando resultados...")
+            final_result = pd.concat(results, ignore_index=True)
             
-            # Update FutureInventoryTransitArrival
-            period_results[i]['FutureInventoryTransitArrival'] = self._format_value(
-                period_results[i]['FutureInventory'].iloc[0] + transit_arrival_sum,
-                'FutureInventoryTransitArrival'
-            )
+            # Prepare final dataframe with proper formatting
+            final_result = self._prepare_final_dataframe(final_result)
             
-            # Recalculate FutureStockoutDays with the updated FutureInventoryTransitArrival
-            period_results[i]['FutureStockoutDays'] = self._calculate_inventory_days(period_results[i])
-        
-        # Combine all periods for this item
-        if period_results:
-            # Stack all period results at once
-            item_df = pd.concat(period_results.values(), ignore_index=True)
+            # Filter out period 0 and last period from results
+            final_result = self._filter_periods(final_result)
             
-            # Reorder columns for consistency
-            cols = ['Date', 'Item']
-            if self.location:
-                cols.append('Location')
-            other_cols = [col for col in item_df.columns if col not in cols]
-            item_df = item_df[cols + other_cols]
+            total_time = time.time() - start_time
+            self._log(f"🎉 Processing completed in {total_time:.2f}s")
+            self._log(f"📈 Final result: {len(final_result)} records")
             
-            return item_df
-        
-        return None
+            return final_result
+        else:
+            self._log("⚠️  No results generated")
+            columns = ['Date', 'Item'] + (['Location'] if self.location else [])
+            return pd.DataFrame(columns=columns)