const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
const { getConnection } = require('./utils/db');

// Helper function to handle NaN and undefined values
function sanitizeValue(value) {
    if (value === undefined || value === null || Number.isNaN(value)) {
        return null;
    }
    return value;
}

async function calculateProductMetrics(startTime, totalProducts, processedCount = 0, isCancelled = false) {
    const connection = await getConnection();
    let success = false;
    let processedOrders = 0;
    const BATCH_SIZE = 5000;
    
    try {
        // Get last calculation timestamp
        const [lastCalc] = await connection.query(`
            SELECT last_calculation_timestamp 
            FROM calculate_status 
            WHERE module_name = 'product_metrics'
        `);
        const lastCalculationTime = lastCalc[0]?.last_calculation_timestamp || '1970-01-01';

        // Get total product count if not provided
        if (!totalProducts) {
            const [productCount] = await connection.query(`
                SELECT COUNT(DISTINCT p.pid) as count 
                FROM products p
                LEFT JOIN orders o ON p.pid = o.pid AND o.updated > ?
                LEFT JOIN purchase_orders po ON p.pid = po.pid AND po.updated > ?
                WHERE p.updated > ?
                   OR o.pid IS NOT NULL
                   OR po.pid IS NOT NULL
            `, [lastCalculationTime, lastCalculationTime, lastCalculationTime]);
            totalProducts = productCount[0].count;
        }

        if (totalProducts === 0) {
            console.log('No products need updating');
            return {
                processedProducts: 0,
                processedOrders: 0,
                processedPurchaseOrders: 0,
                success: true
            };
        }

        // Skip flags are inherited from the parent scope
        const SKIP_PRODUCT_BASE_METRICS = 0;
        const SKIP_PRODUCT_TIME_AGGREGATES = 0;

        if (isCancelled) {
            outputProgress({
                status: 'cancelled',
                operation: 'Product metrics calculation cancelled',
                current: processedCount,
                total: totalProducts,
                elapsed: formatElapsedTime(startTime),
                remaining: null,
                rate: calculateRate(startTime, processedCount),
                percentage: ((processedCount / totalProducts) * 100).toFixed(1),
                timing: {
                    start_time: new Date(startTime).toISOString(),
                    end_time: new Date().toISOString(),
                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
                }
            });
            return {
                processedProducts: processedCount,
                processedOrders,
                processedPurchaseOrders: 0,
                success
            };
        }

        // First ensure all products have a metrics record
        await connection.query(`
            INSERT IGNORE INTO product_metrics (pid, last_calculated_at)
            SELECT pid, NOW()
            FROM products
        `);

        // Get threshold settings once
        const [thresholds] = await connection.query(`
            SELECT critical_days, reorder_days, overstock_days, low_stock_threshold
            FROM stock_thresholds 
            WHERE category_id IS NULL AND vendor IS NULL
            LIMIT 1
        `);
        const defaultThresholds = thresholds[0];

        // Calculate base product metrics
        if (!SKIP_PRODUCT_BASE_METRICS) {
            outputProgress({
                status: 'running',
                operation: 'Starting base product metrics calculation',
                current: processedCount,
                total: totalProducts,
                elapsed: formatElapsedTime(startTime),
                remaining: estimateRemaining(startTime, processedCount, totalProducts),
                rate: calculateRate(startTime, processedCount),
                percentage: ((processedCount / totalProducts) * 100).toFixed(1),
                timing: {
                    start_time: new Date(startTime).toISOString(),
                    end_time: new Date().toISOString(),
                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
                }
            });

            // Get order count that will be processed
            const [orderCount] = await connection.query(`
                SELECT COUNT(*) as count 
                FROM orders o 
                WHERE o.canceled = false
            `);
            processedOrders = orderCount[0].count;

            // Clear temporary tables
            await connection.query('DROP TEMPORARY TABLE IF EXISTS temp_sales_metrics');
            await connection.query('DROP TEMPORARY TABLE IF EXISTS temp_purchase_metrics');

            // Create optimized temporary tables with indexes
            await connection.query(`
                CREATE TEMPORARY TABLE temp_sales_metrics (
                    pid BIGINT NOT NULL,
                    daily_sales_avg DECIMAL(10,3),
                    weekly_sales_avg DECIMAL(10,3),
                    monthly_sales_avg DECIMAL(10,3),
                    total_revenue DECIMAL(10,2),
                    avg_margin_percent DECIMAL(5,2),
                    first_sale_date DATE,
                    last_sale_date DATE,
                    PRIMARY KEY (pid),
                    INDEX (daily_sales_avg),
                    INDEX (total_revenue)
                ) ENGINE=MEMORY
            `);

            await connection.query(`
                CREATE TEMPORARY TABLE temp_purchase_metrics (
                    pid BIGINT NOT NULL,
                    avg_lead_time_days DECIMAL(5,1),
                    last_purchase_date DATE,
                    first_received_date DATE,
                    last_received_date DATE,
                    PRIMARY KEY (pid),
                    INDEX (avg_lead_time_days)
                ) ENGINE=MEMORY
            `);

            // Populate temp_sales_metrics with base stats and sales averages using FORCE INDEX
            await connection.query(`
                INSERT INTO temp_sales_metrics
                SELECT 
                    p.pid,
                    COALESCE(SUM(o.quantity) / NULLIF(COUNT(DISTINCT DATE(o.date)), 0), 0) as daily_sales_avg,
                    COALESCE(SUM(o.quantity) / NULLIF(CEIL(COUNT(DISTINCT DATE(o.date)) / 7), 0), 0) as weekly_sales_avg,
                    COALESCE(SUM(o.quantity) / NULLIF(CEIL(COUNT(DISTINCT DATE(o.date)) / 30), 0), 0) as monthly_sales_avg,
                    COALESCE(SUM(o.quantity * o.price), 0) as total_revenue,
                    CASE 
                        WHEN SUM(o.quantity * o.price) > 0 
                        THEN ((SUM(o.quantity * o.price) - SUM(o.quantity * p.cost_price)) / SUM(o.quantity * o.price)) * 100 
                        ELSE 0 
                    END as avg_margin_percent,
                    MIN(o.date) as first_sale_date,
                    MAX(o.date) as last_sale_date
                FROM products p
                    FORCE INDEX (PRIMARY)
                    LEFT JOIN orders o FORCE INDEX (idx_orders_metrics) ON p.pid = o.pid 
                        AND o.canceled = false
                        AND o.date >= DATE_SUB(CURDATE(), INTERVAL 90 DAY)
                WHERE p.updated > ?
                   OR EXISTS (
                       SELECT 1 FROM orders o2 FORCE INDEX (idx_orders_metrics)
                       WHERE o2.pid = p.pid 
                       AND o2.canceled = false 
                       AND o2.updated > ?
                   )
                GROUP BY p.pid
            `, [lastCalculationTime, lastCalculationTime]);

            // Populate temp_purchase_metrics with optimized index usage
            await connection.query(`
                INSERT INTO temp_purchase_metrics
                SELECT 
                    p.pid,
                    AVG(DATEDIFF(po.received_date, po.date)) as avg_lead_time_days,
                    MAX(po.date) as last_purchase_date,
                    MIN(po.received_date) as first_received_date,
                    MAX(po.received_date) as last_received_date
                FROM products p
                    FORCE INDEX (PRIMARY)
                    LEFT JOIN purchase_orders po FORCE INDEX (idx_po_metrics) ON p.pid = po.pid 
                        AND po.received_date IS NOT NULL
                        AND po.date >= DATE_SUB(CURDATE(), INTERVAL 365 DAY)
                WHERE p.updated > ?
                   OR EXISTS (
                       SELECT 1 FROM purchase_orders po2 FORCE INDEX (idx_po_metrics)
                       WHERE po2.pid = p.pid 
                       AND po2.updated > ?
                   )
                GROUP BY p.pid
            `, [lastCalculationTime, lastCalculationTime]);

            // Process updates in batches, but only for affected products
            let lastPid = 0;
            while (true) {
                if (isCancelled) break;

                const [batch] = await connection.query(`
                    SELECT DISTINCT p.pid 
                    FROM products p
                    LEFT JOIN orders o ON p.pid = o.pid AND o.updated > ?
                    LEFT JOIN purchase_orders po ON p.pid = po.pid AND po.updated > ?
                    WHERE p.pid > ?
                      AND (
                          p.updated > ?
                          OR o.pid IS NOT NULL
                          OR po.pid IS NOT NULL
                      )
                    ORDER BY p.pid 
                    LIMIT ?
                `, [lastCalculationTime, lastCalculationTime, lastPid, lastCalculationTime, BATCH_SIZE]);

                if (batch.length === 0) break;

                await connection.query(`
                    UPDATE product_metrics pm
                    JOIN products p ON pm.pid = p.pid
                    LEFT JOIN temp_sales_metrics sm ON pm.pid = sm.pid
                    LEFT JOIN temp_purchase_metrics lm ON pm.pid = lm.pid
                    SET 
                        pm.inventory_value = p.stock_quantity * p.cost_price,
                        pm.daily_sales_avg = COALESCE(sm.daily_sales_avg, 0),
                        pm.weekly_sales_avg = COALESCE(sm.weekly_sales_avg, 0),
                        pm.monthly_sales_avg = COALESCE(sm.monthly_sales_avg, 0),
                        pm.total_revenue = COALESCE(sm.total_revenue, 0),
                        pm.avg_margin_percent = COALESCE(sm.avg_margin_percent, 0),
                        pm.first_sale_date = sm.first_sale_date,
                        pm.last_sale_date = sm.last_sale_date,
                        pm.avg_lead_time_days = COALESCE(lm.avg_lead_time_days, 30),
                        pm.days_of_inventory = CASE 
                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 
                            THEN FLOOR(p.stock_quantity / sm.daily_sales_avg)
                            ELSE NULL 
                        END,
                        pm.weeks_of_inventory = CASE 
                            WHEN COALESCE(sm.weekly_sales_avg, 0) > 0 
                            THEN FLOOR(p.stock_quantity / sm.weekly_sales_avg)
                            ELSE NULL 
                        END,
                        pm.stock_status = CASE
                            WHEN p.stock_quantity <= 0 THEN 'Out of Stock'
                            WHEN COALESCE(sm.daily_sales_avg, 0) = 0 AND p.stock_quantity <= ? THEN 'Low Stock'
                            WHEN COALESCE(sm.daily_sales_avg, 0) = 0 THEN 'In Stock'
                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) <= ? THEN 'Critical'
                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) <= ? THEN 'Reorder'
                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) > ? THEN 'Overstocked'
                            ELSE 'Healthy'
                        END,
                        pm.reorder_qty = CASE
                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 THEN
                                GREATEST(
                                    CEIL(sm.daily_sales_avg * COALESCE(lm.avg_lead_time_days, 30) * 1.96),
                                    ?
                                )
                            ELSE ?
                        END,
                        pm.overstocked_amt = CASE
                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) > ? 
                            THEN GREATEST(0, p.stock_quantity - CEIL(sm.daily_sales_avg * ?))
                            ELSE 0
                        END,
                        pm.last_calculated_at = NOW()
                    WHERE p.pid IN (?)
                `, [
                    defaultThresholds.low_stock_threshold,
                    defaultThresholds.critical_days,
                    defaultThresholds.reorder_days,
                    defaultThresholds.overstock_days,
                    defaultThresholds.low_stock_threshold,
                    defaultThresholds.low_stock_threshold,
                    defaultThresholds.overstock_days,
                    defaultThresholds.overstock_days,
                    batch.map(row => row.pid)
                ]);

                lastPid = batch[batch.length - 1].pid;
                processedCount += batch.length;

                outputProgress({
                    status: 'running',
                    operation: 'Processing base metrics batch',
                    current: processedCount,
                    total: totalProducts,
                    elapsed: formatElapsedTime(startTime),
                    remaining: estimateRemaining(startTime, processedCount, totalProducts),
                    rate: calculateRate(startTime, processedCount),
                    percentage: ((processedCount / totalProducts) * 100).toFixed(1),
                    timing: {
                        start_time: new Date(startTime).toISOString(),
                        end_time: new Date().toISOString(),
                        elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
                    }
                });
            }

            // Calculate forecast accuracy and bias in batches
            lastPid = 0;
            while (true) {
                if (isCancelled) break;

                const [batch] = await connection.query(
                    'SELECT pid FROM products WHERE pid > ? ORDER BY pid LIMIT ?',
                    [lastPid, BATCH_SIZE]
                );

                if (batch.length === 0) break;

                await connection.query(`
                    UPDATE product_metrics pm
                    JOIN (
                        SELECT 
                            sf.pid,
                            AVG(CASE 
                                WHEN o.quantity > 0 
                                THEN ABS(sf.forecast_units - o.quantity) / o.quantity * 100
                                ELSE 100 
                            END) as avg_forecast_error,
                            AVG(CASE 
                                WHEN o.quantity > 0 
                                THEN (sf.forecast_units - o.quantity) / o.quantity * 100
                                ELSE 0 
                            END) as avg_forecast_bias,
                            MAX(sf.forecast_date) as last_forecast_date
                        FROM sales_forecasts sf
                        JOIN orders o ON sf.pid = o.pid 
                            AND DATE(o.date) = sf.forecast_date
                        WHERE o.canceled = false
                            AND sf.forecast_date >= DATE_SUB(CURRENT_DATE, INTERVAL 90 DAY)
                            AND sf.pid IN (?)
                        GROUP BY sf.pid
                    ) fa ON pm.pid = fa.pid
                    SET 
                        pm.forecast_accuracy = GREATEST(0, 100 - LEAST(fa.avg_forecast_error, 100)),
                        pm.forecast_bias = GREATEST(-100, LEAST(fa.avg_forecast_bias, 100)),
                        pm.last_forecast_date = fa.last_forecast_date,
                        pm.last_calculated_at = NOW()
                    WHERE pm.pid IN (?)
                `, [batch.map(row => row.pid), batch.map(row => row.pid)]);

                lastPid = batch[batch.length - 1].pid;
            }
        }

        // Calculate product time aggregates
        if (!SKIP_PRODUCT_TIME_AGGREGATES) {
            outputProgress({
                status: 'running',
                operation: 'Starting product time aggregates calculation',
                current: processedCount || 0,
                total: totalProducts || 0,
                elapsed: formatElapsedTime(startTime),
                remaining: estimateRemaining(startTime, processedCount || 0, totalProducts || 0),
                rate: calculateRate(startTime, processedCount || 0),
                percentage: (((processedCount || 0) / (totalProducts || 1)) * 100).toFixed(1),
                timing: {
                    start_time: new Date(startTime).toISOString(),
                    end_time: new Date().toISOString(),
                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
                }
            });

            // Calculate time-based aggregates
            await connection.query(`
                INSERT INTO product_time_aggregates (
                    pid,
                    year,
                    month,
                    total_quantity_sold,
                    total_revenue,
                    total_cost,
                    order_count,
                    avg_price,
                    profit_margin,
                    inventory_value,
                    gmroi
                )
                SELECT 
                    p.pid,
                    YEAR(o.date) as year,
                    MONTH(o.date) as month,
                    SUM(o.quantity) as total_quantity_sold,
                    SUM(o.quantity * o.price) as total_revenue,
                    SUM(o.quantity * p.cost_price) as total_cost,
                    COUNT(DISTINCT o.order_number) as order_count,
                    AVG(o.price) as avg_price,
                    CASE 
                        WHEN SUM(o.quantity * o.price) > 0 
                        THEN ((SUM(o.quantity * o.price) - SUM(o.quantity * p.cost_price)) / SUM(o.quantity * o.price)) * 100
                        ELSE 0 
                    END as profit_margin,
                    p.cost_price * p.stock_quantity as inventory_value,
                    CASE 
                        WHEN p.cost_price * p.stock_quantity > 0 
                        THEN (SUM(o.quantity * (o.price - p.cost_price))) / (p.cost_price * p.stock_quantity)
                        ELSE 0 
                    END as gmroi
                FROM products p
                LEFT JOIN orders o ON p.pid = o.pid AND o.canceled = false
                WHERE o.date >= DATE_SUB(CURRENT_DATE, INTERVAL 12 MONTH)
                GROUP BY p.pid, YEAR(o.date), MONTH(o.date)
                ON DUPLICATE KEY UPDATE
                    total_quantity_sold = VALUES(total_quantity_sold),
                    total_revenue = VALUES(total_revenue),
                    total_cost = VALUES(total_cost),
                    order_count = VALUES(order_count),
                    avg_price = VALUES(avg_price),
                    profit_margin = VALUES(profit_margin),
                    inventory_value = VALUES(inventory_value),
                    gmroi = VALUES(gmroi)
            `);

            processedCount = Math.floor(totalProducts * 0.6);
            outputProgress({
                status: 'running',
                operation: 'Product time aggregates calculated',
                current: processedCount || 0,
                total: totalProducts || 0,
                elapsed: formatElapsedTime(startTime),
                remaining: estimateRemaining(startTime, processedCount || 0, totalProducts || 0),
                rate: calculateRate(startTime, processedCount || 0),
                percentage: (((processedCount || 0) / (totalProducts || 1)) * 100).toFixed(1),
                timing: {
                    start_time: new Date(startTime).toISOString(),
                    end_time: new Date().toISOString(),
                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
                }
            });
        } else {
            processedCount = Math.floor(totalProducts * 0.6);
            outputProgress({
                status: 'running',
                operation: 'Skipping product time aggregates calculation',
                current: processedCount || 0,
                total: totalProducts || 0,
                elapsed: formatElapsedTime(startTime),
                remaining: estimateRemaining(startTime, processedCount || 0, totalProducts || 0),
                rate: calculateRate(startTime, processedCount || 0),
                percentage: (((processedCount || 0) / (totalProducts || 1)) * 100).toFixed(1),
                timing: {
                    start_time: new Date(startTime).toISOString(),
                    end_time: new Date().toISOString(),
                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
                }
            });
        }

        // Calculate ABC classification
        outputProgress({
            status: 'running',
            operation: 'Starting ABC classification',
            current: processedCount,
            total: totalProducts,
            elapsed: formatElapsedTime(startTime),
            remaining: estimateRemaining(startTime, processedCount, totalProducts),
            rate: calculateRate(startTime, processedCount),
            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
            timing: {
                start_time: new Date(startTime).toISOString(),
                end_time: new Date().toISOString(),
                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
            }
        });

        if (isCancelled) return {
            processedProducts: processedCount,
            processedOrders,
            processedPurchaseOrders: 0,  // This module doesn't process POs
            success
        };

        const [abcConfig] = await connection.query('SELECT a_threshold, b_threshold FROM abc_classification_config WHERE id = 1');
        const abcThresholds = abcConfig[0] || { a_threshold: 20, b_threshold: 50 };

        // First, create and populate the rankings table with an index
        await connection.query('DROP TEMPORARY TABLE IF EXISTS temp_revenue_ranks');
        await connection.query(`
            CREATE TEMPORARY TABLE temp_revenue_ranks (
                pid BIGINT NOT NULL,
                total_revenue DECIMAL(10,3),
                rank_num INT,
                dense_rank_num INT,
                percentile DECIMAL(5,2),
                total_count INT,
                PRIMARY KEY (pid),
                INDEX (rank_num),
                INDEX (dense_rank_num),
                INDEX (percentile)
            ) ENGINE=MEMORY
        `);

        // Calculate rankings with proper tie handling
        await connection.query(`
            INSERT INTO temp_revenue_ranks
            WITH revenue_data AS (
                SELECT 
                    pid,
                    total_revenue,
                    COUNT(*) OVER () as total_count,
                    PERCENT_RANK() OVER (ORDER BY total_revenue DESC) * 100 as percentile,
                    RANK() OVER (ORDER BY total_revenue DESC) as rank_num,
                    DENSE_RANK() OVER (ORDER BY total_revenue DESC) as dense_rank_num
                FROM product_metrics 
                WHERE total_revenue > 0
            )
            SELECT 
                pid,
                total_revenue,
                rank_num,
                dense_rank_num,
                percentile,
                total_count
            FROM revenue_data
        `);

        // Get total count for percentage calculation
        const [rankingCount] = await connection.query('SELECT MAX(rank_num) as total_count FROM temp_revenue_ranks');
        const totalCount = rankingCount[0].total_count || 1;
        const max_rank = totalCount;

        // Process updates in batches
        let abcProcessedCount = 0;
        const batchSize = 5000;

        while (true) {
            if (isCancelled) return {
                processedProducts: processedCount,
                processedOrders,
                processedPurchaseOrders: 0,  // This module doesn't process POs
                success
            };

            // Get a batch of PIDs that need updating
            const [pids] = await connection.query(`
                SELECT pm.pid 
                FROM product_metrics pm
                LEFT JOIN temp_revenue_ranks tr ON pm.pid = tr.pid
                WHERE pm.abc_class IS NULL 
                OR pm.abc_class != 
                    CASE 
                        WHEN tr.pid IS NULL THEN 'C'
                        WHEN tr.percentile <= ? THEN 'A'
                        WHEN tr.percentile <= ? THEN 'B'
                        ELSE 'C'
                    END
                LIMIT ?
            `, [abcThresholds.a_threshold, abcThresholds.b_threshold, batchSize]);

            if (pids.length === 0) break;

            await connection.query(`
                UPDATE product_metrics pm
                LEFT JOIN temp_revenue_ranks tr ON pm.pid = tr.pid
                SET pm.abc_class = 
                    CASE 
                        WHEN tr.pid IS NULL THEN 'C'
                        WHEN tr.percentile <= ? THEN 'A'
                        WHEN tr.percentile <= ? THEN 'B'
                        ELSE 'C'
                    END,
                    pm.last_calculated_at = NOW()
                WHERE pm.pid IN (?)
            `, [abcThresholds.a_threshold, abcThresholds.b_threshold, pids.map(row => row.pid)]);

            // Now update turnover rate with proper handling of zero inventory periods
            await connection.query(`
                UPDATE product_metrics pm
                JOIN (
                    SELECT 
                        o.pid,
                        SUM(o.quantity) as total_sold,
                        COUNT(DISTINCT DATE(o.date)) as active_days,
                        AVG(CASE 
                            WHEN p.stock_quantity > 0 THEN p.stock_quantity 
                            ELSE NULL 
                        END) as avg_nonzero_stock
                    FROM orders o
                    JOIN products p ON o.pid = p.pid
                    WHERE o.canceled = false 
                    AND o.date >= DATE_SUB(CURRENT_DATE, INTERVAL 90 DAY)
                    AND o.pid IN (?)
                    GROUP BY o.pid
                ) sales ON pm.pid = sales.pid
                SET 
                    pm.turnover_rate = CASE 
                        WHEN sales.avg_nonzero_stock > 0 AND sales.active_days > 0 
                        THEN LEAST(
                            (sales.total_sold / sales.avg_nonzero_stock) * (365.0 / sales.active_days),
                            999.99
                        )
                        ELSE 0 
                    END,
                    pm.last_calculated_at = NOW()
                WHERE pm.pid IN (?)
            `, [pids.map(row => row.pid), pids.map(row => row.pid)]);
        }

        // If we get here, everything completed successfully
        success = true;
        
        // Update calculate_status with current timestamp
        await connection.query(`
            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
            VALUES ('product_metrics', NOW())
            ON DUPLICATE KEY UPDATE last_calculation_timestamp = NOW()
        `);

        return {
            processedProducts: processedCount || 0,
            processedOrders: processedOrders || 0,
            processedPurchaseOrders: 0,  // This module doesn't process POs
            success
        };

    } catch (error) {
        success = false;
        logError(error, 'Error calculating product metrics');
        throw error;
    } finally {
        if (connection) {
            connection.release();
        }
    }
}

function calculateStockStatus(stock, config, daily_sales_avg, weekly_sales_avg, monthly_sales_avg) {
    if (stock <= 0) {
        return 'Out of Stock';
    }

    // Use the most appropriate sales average based on data quality
    let sales_avg = daily_sales_avg;
    if (sales_avg === 0) {
        sales_avg = weekly_sales_avg / 7;
    }
    if (sales_avg === 0) {
        sales_avg = monthly_sales_avg / 30;
    }

    if (sales_avg === 0) {
        return stock <= config.low_stock_threshold ? 'Low Stock' : 'In Stock';
    }

    const days_of_stock = stock / sales_avg;

    if (days_of_stock <= config.critical_days) {
        return 'Critical';
    } else if (days_of_stock <= config.reorder_days) {
        return 'Reorder';
    } else if (days_of_stock > config.overstock_days) {
        return 'Overstocked';
    }

    return 'Healthy';
}

function calculateReorderQuantities(stock, stock_status, daily_sales_avg, avg_lead_time, config) {
    // Calculate safety stock based on service level and lead time
    const z_score = 1.96; // 95% service level
    const lead_time = avg_lead_time || config.target_days;
    const safety_stock = Math.ceil(daily_sales_avg * Math.sqrt(lead_time) * z_score);

    // Calculate reorder point
    const lead_time_demand = daily_sales_avg * lead_time;
    const reorder_point = Math.ceil(lead_time_demand + safety_stock);

    // Calculate reorder quantity using EOQ formula if we have the necessary data
    let reorder_qty = 0;
    if (daily_sales_avg > 0) {
        const annual_demand = daily_sales_avg * 365;
        const order_cost = 25; // Fixed cost per order
        const holding_cost_percent = 0.25; // 25% annual holding cost
        
        reorder_qty = Math.ceil(Math.sqrt((2 * annual_demand * order_cost) / holding_cost_percent));
    } else {
        // If no sales data, use a basic calculation
        reorder_qty = Math.max(safety_stock, config.low_stock_threshold);
    }

    // Calculate overstocked amount
    const overstocked_amt = stock_status === 'Overstocked' ? 
        stock - Math.ceil(daily_sales_avg * config.overstock_days) : 
        0;

    return {
        safety_stock,
        reorder_point,
        reorder_qty,
        overstocked_amt
    };
}

module.exports = calculateProductMetrics;