datupapi 1.110.2__py3-none-any.whl → 1.112.0__py3-none-any.whl

datupapi/inventory/src/FutureInventory/future_reorder.py

@@ -1,224 +1,1282 @@
 import pandas as pd
-import os
 import numpy as np
-from datetime import timedelta
+import os
+import ast
+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 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, dates, 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)
+    
+    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) = batch_args
+        
+        results = []
+        processed_count = 0
+        error_count = 0
+        
+        for item_data in batch_items:
+            key, dates, current_df_lead_time, current_df_inv = item_data
+            
+            try:
+                # 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:
+            return pd.DataFrame()
+            
+    except Exception as e:
+        print(f"❌ Error crítico en batch: {str(e)}")
+        return pd.DataFrame()
 
-    def __init__(self, df_inv, df_lead_time, df_prep, df_fcst, periods, start_date, location=False, security_stock_ref=False):
-        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
 
+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 = {}
+        
+        # Initialize transit orders for this item
+        transit_orders = {key: []}
+        
+        # Track last suggested forecast value for complete_suggested feature
+        last_suggested_value = None
+        
+        # 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:
+                    last_suggested_value = suggested_forecasts[i]['SuggestedForecast'].iloc[0]
+                
+                # 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
+                print(f"Warning: Error processing period {i} for item {key}: {str(e)}")
+                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
+            
+            # Update FutureInventoryTransitArrival
+            period_results[i]['FutureInventoryTransitArrival'] = _format_value_complete(
+                period_results[i]['FutureInventory'].iloc[0] + transit_arrival_sum,
+                'FutureInventoryTransitArrival', integer
+            )
+            
+            # Recalculate FutureStockoutDays with the updated FutureInventoryTransitArrival
+            period_results[i]['FutureStockoutDays'] = _calculate_inventory_days_complete(
+                period_results[i], integer
+            )
+        
+        # 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)
+            
+            # 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]
+            
+            return item_df
+        
+        return None
+        
+    except Exception as e:
+        # Handle any unexpected errors at the item level
+        print(f"Error processing item {key}: {str(e)}")
+        return None
 
-    def future_date(self):
 
-        '''Function to calculate the future dates by Item or Item-Location'''
+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
+
 
-        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')
+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
+    current_date = pd.to_datetime(date, format='%Y%m%d')
+    
+    # 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]
 
-        timestamp = utils.set_timestamp()
-        actual_date = pd.to_datetime(str(int(float(timestamp[0:8]))), format='%Y%m%d')
+                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:
+                    # 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')}, "
+                        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')}. "
+                        f"Original error: {str(e)}"
+                    )
+                    raise ValueError(error_msg)
+        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
+    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()
 
-        item_dates = {}
 
-        columns = ['Item', 'ReorderFreq']
-        if self.location:
-            columns.append('Location')
+def _calculate_daily_usage_complete(suggested_forecast_df, date, df_fcst, location):
+    """Calculate average and maximum daily usage rates."""
+    df_avg = DailyUsageFuture(
+        location=location,
+        column_forecast='SuggestedForecast',
+        date=date,
+        df_fcst=df_fcst
+    ).daily_usage(suggested_forecast_df, 'AvgDailyUsage').fillna(0)
 
-        for _, row in self.df_lead_time[columns].drop_duplicates().iterrows():
-            item = row['Item']
-            location = row['Location'] if self.location else None
-            cobertura = int(row['ReorderFreq']) if not pd.isnull(row['ReorderFreq']) and row['ReorderFreq'] != 0 else self.default_coverage
-            date = self.start_date
-            dates = []
+    df_max = DailyUsageFuture(
+        location=location,
+        column_forecast='SuggestedForecast',
+        date=date,
+        df_fcst=df_fcst
+    ).daily_usage(df_avg, 'MaxDailyUsage').fillna(0)
+    
+    return df_avg, df_max
 
-            while date <= actual_date + pd.DateOffset(months=self.periods):
-                dates.append(date.strftime('%Y%m%d'))
-                date += timedelta(days=cobertura)
 
-            item_dates[(item, location) if self.location else item] = dates
+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]
+    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
+        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)
+        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
 
-        return item_dates
 
+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 reorder(self):
 
-        '''Function to calculate the future reorder for inventory with dynamics coverage'''
+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:
+            arrival_date = pd.to_datetime(dates[1], format='%Y%m%d')
+            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:
+            # 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
+
+
+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
 
-        item_dates = self.future_date()
 
-        metadata = ['Item']
+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
+    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 = _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.
+    """
+
+    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):
+        
+        # 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.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:
+            self.n_workers = n_workers
+            
+        self.verbose = verbose
+        
+        # Initialize metadata columns
+        self.metadata = ['Item']
         if self.location:
-            metadata.append('Location')
-
-        df_lead_time_rf = self.df_lead_time.copy()
-        df_lead_time_rf['Coverage'] = df_lead_time_rf['ReorderFreq']    
-        df_lead_time_rf['AvgLeadTime'] = df_lead_time_rf['ReorderFreq']
-        df_lead_time_rf['MaxLeadTime'] = df_lead_time_rf['ReorderFreq']
-
-        SuggestedForecast_cov = {}
-        SuggestedForecast_rf = {}
-        df_forecast = {}
-        df_avg_gen = {}
-        df_max_gen = {}
-        df_sstock = {}
-        df_inventory = {}
-        df = {}
-
-        # Inicializar DataFrame
-        columns = ['Date', 'Item'] + (['Location'] if self.location else [])
-        data_frame = pd.DataFrame(columns=columns)
-
-        # Iterar por cada combinación (Item, Location) o (Item) según use_location
-        for key, dates in item_dates.items():
+            self.metadata.append('Location')
+        
+        # Pre-filter dataframes based on df_inv to improve performance
+        self._prefilter_dataframes()
+        
+        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}")
+
+    def _prefilter_dataframes(self):
+        """
+        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...")
+        
+        # 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()
+        
+        # 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'
+            )
+        
+        # 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:
+            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
+                self.df_transit = self.df_transit.merge(
+                    base_filter,
+                    on=['Item', 'Location'],
+                    how='inner'
+                )
             else:
-                item = key
-                location = None
+                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
+            }
+            
+            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:,}")
 
-            for i, date in enumerate(dates):
-                if self.location:
-                    current_df_lead_time_cov = self.df_lead_time[(self.df_lead_time['Item'] == item) &
-                                                            (self.df_lead_time['Location'] == location)]
+    def _log(self, message):
+        if self.verbose:
+            print(message)
+            sys.stdout.flush()
 
-                    current_df_lead_time_rf = df_lead_time_rf[(df_lead_time_rf['Item'] == item) &
-                                                            (df_lead_time_rf['Location'] == location)]
+    def future_date(self):
+        """
+        Generate future reorder dates for each item based on reorder frequency.
+        Versión optimizada de la función original.
+        """
+        # 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')
+        
+        # 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)
+        
+        # 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
 
-                    current_df_inv = self.df_inv[(self.df_inv['Item'] == item) &
-                                                (self.df_inv['Location'] == location)]
+        # 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)
+        
+        # Pre-allocate result dictionary
+        item_dates = {}
+        
+        # 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 (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 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 item_dates
 
+    def _prepare_batch_data(self, item_dates):
+        """Prepara datos por lotes de manera eficiente. Replicates exactly the logic from future_reorder_optimized."""
+        batch_data = []
+        
+        for key, dates in item_dates.items():
+            try:
+                # Get dataframes for this item - EXACTLY like future_reorder_optimized _get_current_dataframes_optimized
+                if self.location:
+                    item, location = key
                 else:
-                    current_df_lead_time_cov = self.df_lead_time[self.df_lead_time['Item'] == item]
-                    current_df_lead_time_rf = df_lead_time_rf[df_lead_time_rf['Item'] == item]
-                    current_df_inv = self.df_inv[self.df_inv['Item'] == item]
+                    item = key
+                    location = None
                     
-                if current_df_lead_time_cov.empty or current_df_lead_time_rf.empty or current_df_inv.empty:                    
-                    continue
-
-                # SuggestedForecast_Coverage
-                SuggestedForecast_cov[i] = SuggestedForecast(df_LeadTimes=current_df_lead_time_cov,
-                                                            df_Forecast=self.df_fcst,
-                                                            df_Prep=self.df_prep,
-                                                            df_inv=current_df_inv,
-                                                            column_forecast='SuggestedForecast',
-                                                            columns_metadata=metadata,
-                                                            frequency_='M',
-                                                            location=self.location,
-                                                            actualdate=date,
-                                                            default_coverage_=self.default_coverage,
-                                                            join_='left').suggested_forecast()
+                # Create filter mask based on item
+                mask_lead_time = self.df_lead_time['Item'] == item
+                mask_inv = self.df_inv['Item'] == item
                 
-                SuggestedForecast_cov[i].rename(columns={'SuggestedForecast':'Suggested_Coverage'},inplace=True)
-                                
-                # SuggestedForecast_ReorderFreq
-                SuggestedForecast_rf[i] = SuggestedForecast(df_LeadTimes=current_df_lead_time_rf,
-                                                            df_Forecast=self.df_fcst,
-                                                            df_Prep=self.df_prep,
-                                                            df_inv=current_df_inv,
-                                                            column_forecast='SuggestedForecast',
-                                                            columns_metadata=metadata,
-                                                            frequency_='M',
-                                                            location=self.location,
-                                                            actualdate=date,
-                                                            default_coverage_=self.default_coverage,
-                                                            join_='left').suggested_forecast()
-    
-                SuggestedForecast_rf[i].rename(columns={'SuggestedForecast':'Suggested_ReorderFreq'},inplace=True)
-                SuggestedForecast_rf[i] = SuggestedForecast_rf[i][metadata + ['Suggested_ReorderFreq']]
-
-                # Concatenar                                
-                df_forecast[i] = pd.merge(SuggestedForecast_cov[i], SuggestedForecast_rf[i], on=metadata, how='outer')                
+                # 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
                 
-                # Calcular AvgDailyUsage y MaxDailyUsage
-                df_avg_gen[i] = DailyUsageFuture(location=self.location,
-                                                  column_forecast='SuggestedForecast',
-                                                  date=date,
-                                                  df_fcst=self.df_fcst).daily_usage(df_forecast[i], 'AvgDailyUsage').fillna(0)
-
-                df_max_gen[i] = DailyUsageFuture(location=self.location,
-                                                  column_forecast='SuggestedForecast',
-                                                  date=date,
-                                                  df_fcst=self.df_fcst).daily_usage(df_avg_gen[i], 'MaxDailyUsage').fillna(0)
-
-                #Ajustar AvgDailyUsage y MaxDailyUsage si es cero.
-                df_avg_gen[i] = df_avg_gen[i].replace(0,0.001)
-                df_max_gen[i] = df_max_gen[i].replace(0,0.0012)                
- 
-                # Calcular Stock de Seguridad
-                merge_columns = ['Item', 'Location', 'AvgLeadTime', 'MaxLeadTime'] if self.location else ['Item', 'AvgLeadTime', 'MaxLeadTime']
-                df_sstock[i] = pd.merge(df_max_gen[i], current_df_lead_time_cov[merge_columns], on=metadata, how='inner').drop_duplicates()
-
-                # Current Period
-                if i == 0:
-                    inventory_columns = ['Item', 'Location', 'Inventory', 'Transit', 'PurchaseFactor'] if self.location else ['Item', 'Inventory', 'Transit', 'PurchaseFactor']
-                    df_inventory[i] = current_df_inv[inventory_columns]
-                    df_inventory[i]['InventoryTransit'] = df_inventory[i]['Inventory'] + df_inventory[i]['Transit']
-                    df_inventory[i] = df_inventory[i][metadata + ['InventoryTransit']]
-                    df[i] = pd.merge(df_inventory[i], df_sstock[i], on=metadata, how='inner')
-         
-                    if self.security_stock_ref:
-                        df[i]['SecurityStock'] = df[i]['SecurityStockDaysRef'] * df[i]['AvgDailyUsage']
-                    else:
-                        df[i]['SecurityStock'] = (df[i]['MaxDailyUsage'] * df[i]['MaxLeadTime']) - (df[i]['AvgDailyUsage'] * df[i]['AvgLeadTime'])
-
-                    df[i]['ReorderPoint'] = (df[i]['Suggested_Coverage'] + df[i]['SecurityStock']).clip(lower=0)
-                    df[i]['ReorderQtyBase'] = (df[i]['ReorderPoint'] - df[i]['InventoryTransit']).clip(lower=1)
-                    df[i]['ReorderQty'] = ((df[i]['ReorderQtyBase'] / df[i]['PurchaseFactor']).apply(np.ceil)) * df[i]['PurchaseFactor']
-                    df[i]['ReorderQtyDays'] = (df[i]['ReorderQty'] / df[i]['AvgDailyUsage']).astype(int)
+                # 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:
+                    batch_data.append((key, dates, current_df_lead_time, current_df_inv))
                     
-                # Future Dates
-                else:
-                    inventory_columns = ['Item', 'Location', 'PurchaseFactor'] if self.location else ['Item', 'PurchaseFactor']
-                    df_inventory[i] = current_df_inv[inventory_columns]
-                    df[i] = pd.merge(df_inventory[i], df_sstock[i], on=inventory_columns, how='inner')
+            except Exception as e:
+                if self.verbose:
+                    print(f"Error preparando {key}: {e}")
+                continue
+        
+        return batch_data
 
-                    if self.security_stock_ref:
-                        df[i]['SecurityStock'] = df[i]['SecurityStockDaysRef'] * df[i]['AvgDailyUsage']
-                    else:
-                        df[i]['SecurityStock'] = (df[i]['MaxDailyUsage'] * df[i]['MaxLeadTime']) - (df[i]['AvgDailyUsage'] * df[i]['AvgLeadTime'])
+    def _prepare_final_dataframe(self, data_frame):
+        """
+        Prepare the final output dataframe with proper formatting and column selection.
+        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]
+        df_final = pd.merge(data_frame, leadtimes, on=self.metadata, how='left').fillna(0)
+        
+        # Format date and rename to PurchaseDate
+        df_final['PurchaseDate'] = pd.to_datetime(df_final['Date'], format='%Y%m%d').dt.strftime('%Y-%m-%d')
+        df_final = df_final.drop('Date', axis=1)
+        
+        # Ensure ArrivalDate is present (in case some records don't have it)
+        if 'ArrivalDate' not in df_final.columns:
+            df_final['ArrivalDate'] = ''
+        
+        # Apply formatting to fields that are ALWAYS integers
+        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: _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: _format_value_complete(x, field, False))
+        
+        # Select final columns
+        if self.location:
+            final_cols = [
+                'PurchaseDate', 'Item', 'ItemDescription', 'Location', 'SuggestedForecast',
+                'SuggestedForecastPeriod', 'FutureInventoryTransit', 'FutureInventory',
+                'FutureTransit', 'FutureInventoryTransitArrival', 'FutureStockoutDays', 'TransitArrival',
+                'ReorderQtyBase', 'ReorderQty', 'ReorderQtyDays', 'ArrivalDate', 'PurchaseFactor',
+                'ReorderPoint', 'SecurityStock', 'AvgDailyUsage', 'MaxDailyUsage', 'AvgLeadTime',
+                'MaxLeadTime', 'ReorderFreq', 'Coverage'
+            ]
+        else:
+            final_cols = [
+                'PurchaseDate', 'Item', 'ItemDescription', 'SuggestedForecast',
+                'SuggestedForecastPeriod', 'FutureInventoryTransit', 'FutureInventory',
+                'FutureTransit', 'FutureInventoryTransitArrival', 'FutureStockoutDays', 'TransitArrival',
+                'ReorderQtyBase', 'ReorderQty', 'ReorderQtyDays', 'ArrivalDate', 'PurchaseFactor',
+                'ReorderPoint', 'SecurityStock', 'AvgDailyUsage', 'MaxDailyUsage', 'AvgLeadTime',
+                'MaxLeadTime', 'ReorderFreq', 'Coverage'
+            ]
+        
+        return df_final[final_cols]
 
-                    df[i]['InventoryTransit'] = ((df[i-1]['InventoryTransit'] - df[i-1]['Suggested_ReorderFreq']) + df[i-1]['ReorderQty']).clip(lower=0)
-                    df[i]['ReorderPoint'] = (df[i]['Suggested_Coverage'] + df[i]['SecurityStock']).clip(lower=0)
-                    df[i]['ReorderQtyBase'] = (df[i]['ReorderPoint'] - df[i]['InventoryTransit']).clip(lower=1)
-                    df[i]['ReorderQty'] = ((df[i]['ReorderQtyBase'] / df[i]['PurchaseFactor']).apply(np.ceil)) * df[i]['PurchaseFactor']
-                    df[i]['ReorderQtyDays'] = (df[i]['ReorderQty'] / df[i]['AvgDailyUsage']).astype(int)
-                    
+    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
 
-                # Insert columns
-                df[i].insert(loc=0, column='Date', value=date)
-                df[i]['Item'] = item
+    def reorder(self):
+        """
+        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
+        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 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 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
                 
-                if self.location:
-                    df[i]['Location'] = location
-
-                data_frame = pd.concat([data_frame, df[i]], ignore_index=True)
-
-                # Final DataFrame
-                leadtimes_columns = ['Item', 'Location', 'ReorderFreq', 'Coverage'] if self.location else ['Item', 'ReorderFreq', 'Coverage']
-                leadtimes = self.df_lead_time[leadtimes_columns]
-                df_final = pd.merge(data_frame, leadtimes, on=metadata, how='left').fillna(0)
-
-                df_final['Date'] = pd.to_datetime(df_final['Date'], format='%Y%m%d').dt.strftime('%Y-%m-%d')
-                df_final = df_final.rename(columns={'InventoryTransit': 'FutureInventory'})                
-                cols_to_round = ['SecurityStock', 'FutureInventory', 'Suggested_Coverage', 'Suggested_ReorderFreq', 'ReorderPoint', 'ReorderQtyBase']
-                df_final[cols_to_round] = df_final[cols_to_round].apply(np.ceil)
-                final_cols = ['Date', 'Item', 'ItemDescription', 'Location', 'Suggested_Coverage', 'Suggested_ReorderFreq', 'FutureInventory', 'ReorderQtyBase', 'ReorderQty', 'ReorderQtyDays', 'PurchaseFactor', 'ReorderPoint', 'SecurityStock',
-                              'AvgDailyUsage', 'MaxDailyUsage', 'AvgLeadTime', 'MaxLeadTime', 'ReorderFreq', 'Coverage'] if self.location \
-                              else ['Date', 'Item', 'ItemDescription', 'Suggested_Coverage', 'Suggested_ReorderFreq', 'FutureInventory', 'ReorderQtyBase', 'ReorderQty', 'ReorderQtyDays', 'PurchaseFactor', 'ReorderPoint', 'SecurityStock',
-                              'AvgDailyUsage', 'MaxDailyUsage', 'AvgLeadTime', 'MaxLeadTime', 'ReorderFreq', 'Coverage']
-                df_final = df_final[final_cols]
-
-        return df_final
+        Example usage:
+            >>> reorder_system = FutureReorderMassiveComplete(
+            ...     df_inv=inventory_df,
+            ...     df_lead_time=lead_time_df,
+            ...     df_prep=prep_df,
+            ...     df_fcst=forecast_df,
+            ...     periods=6,
+            ...     start_date=None,  # Use current date
+            ...     batch_size=100,   # Optional: auto-configured if None
+            ...     n_workers=4       # Optional: auto-configured if None
+            ... )
+            >>> results = reorder_system.reorder()
+            >>> print(f"Generated {len(results)} reorder recommendations")
+        """
+        start_time = time.time()
+        
+        self._log("🚀 FutureReorder Massive Complete - Processing Started")
+        
+        # Generate future dates
+        self._log("📅 Generando fechas futuras...")
+        item_dates = self.future_date()
+        
+        if not item_dates:
+            columns = ['Date', 'Item'] + (['Location'] if self.location else [])
+            return pd.DataFrame(columns=columns)
+        
+        # Prepare batch data first to get accurate count of items that will actually be processed
+        batch_data = self._prepare_batch_data(item_dates)
+        
+        # Calculate accurate statistics based on items that will actually be processed
+        total_items = len(batch_data)
+        if batch_data:
+            # Get dates for items that will actually be processed
+            processed_item_dates = {item_data[0]: item_data[1] for item_data in batch_data}
+            avg_periods = np.mean([len(dates) for dates in processed_item_dates.values()])
+            total_calculations = sum(len(dates) for dates in processed_item_dates.values())
+        else:
+            avg_periods = 0
+            total_calculations = 0
+        
+        self._log(f"📊 Dataset Info:")
+        self._log(f"   • Total Items: {total_items}")
+        self._log(f"   • Average Periods per Item: {avg_periods:.1f}")
+        self._log(f"   • Total Calculations: {total_calculations}")
+        
+        # batch_data already prepared above for accurate counting
+        if not batch_data:
+            self._log("⚠️  No items to process after filtering")
+            columns = ['Date', 'Item'] + (['Location'] if self.location else [])
+            return pd.DataFrame(columns=columns)
+        
+        self._log("🔧 Datos preparados por lotes...")
+        
+        # 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
+            )
+            batches.append(batch_args)
+        
+        total_batches = len(batches)
+        items_per_batch = len(batch_data) / total_batches if total_batches > 0 else 0
+        
+        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}")
+        
+        current_time = datetime.now().strftime('%H:%M:%S')
+        self._log(f"⏱️  Starting processing at {current_time}")
+        
+        # Process batches in parallel
+        results = []
+        completed_batches = 0
+        
+        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)}
+            
+            # 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
+        
+        # Combine all results
+        if results:
+            self._log("🔗 Combinando resultados...")
+            final_result = pd.concat(results, ignore_index=True)
+            
+            # Prepare final dataframe with proper formatting
+            final_result = self._prepare_final_dataframe(final_result)
+            
+            # Filter out period 0 and last period from results
+            final_result = self._filter_periods(final_result)
+            
+            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 final_result
+        else:
+            self._log("⚠️  No results generated")
+            columns = ['Date', 'Item'] + (['Location'] if self.location else [])
+            return pd.DataFrame(columns=columns)