graph TD
    A[Transaction Data] --> B[Frequent 1-itemsets]
    B --> C[Frequent 2-itemsets]
    C --> D[Frequent 3-itemsets]
    D --> E[Association Rules]
    E --> F[Product Recommendations]
    
    subgraph "Support Filtering"
        B1[Count Item Frequency]
        B2[Apply Minimum Support]
        B1 --> B2
    end
    
    subgraph "Confidence Calculation"
        C1[Generate Candidate Rules]
        C2[Calculate Confidence]
        C3[Apply Minimum Confidence]
        C1 --> C2 --> C3
    end

Support(A) = Number of transactions containing A / Total number of transactions

Support(A,B) = 100/1000 = 0.1 (10%)

Confidence(A → B) = Support(A,B) / Support(A)

Confidence(A → B) = 0.8 (80%)

Lift(A → B) = Confidence(A → B) / Support(B)

use Phpml\Association\Apriori;

class GenerateSuggestedProductsService
{
    private $support = 0.1;      // Minimum support threshold
    private $confidence = 0.5;   // Minimum confidence threshold
    
    public function apply_apriori($customer_orders)
    {
        // Initialize Apriori algorithm
        $associator = new Apriori($this->support, $this->confidence);
        
        // Prepare transaction data
        $transactions = $this->prepareTransactions($customer_orders);
        
        // Train the model
        $associator->train($transactions['products'], $transactions['labels']);
        
        // Generate frequent item sets
        $frequentSets = $associator->apriori();
        
        // Convert to association rules
        $rules = $associator->getRules();
        
        return $this->processResults($frequentSets, $rules);
    }
    
    private function prepareTransactions($orders)
    {
        $products = [];
        $labels = [];
        
        foreach ($orders as $order) {
            $orderProducts = [];
            foreach ($order['products'] as $product) {
                $orderProducts[] = $product['id'];
            }
            $products[] = $orderProducts;
            $labels[] = $order['customer_id'];
        }
        
        return ['products' => $products, 'labels' => $labels];
    }
}

graph LR
    A[Raw Orders] --> B[Data Validation]
    B --> C[Customer Grouping]
    C --> D[Transaction Formation]
    D --> E[Support Calculation]
    E --> F[Frequent Itemsets]
    F --> G[Rule Generation]
    G --> H[Confidence Filtering]
    H --> I[Final Recommendations]

public function getOrders($dates)
{
    $query = DB::table($this->ordersTable)
        ->join($this->orderDetailsTable, 
               $this->ordersTable.'.id', '=', 
               $this->orderDetailsTable.'.'.$this->orderIdField)
        ->whereBetween($this->ordersTable.'.created_at', $dates)
        ->where($this->ordersTable.'.status', '!=', 'cancelled')
        ->select([
            $this->ordersTable.'.'.$this->customerIdField.' as customer_id',
            $this->orderDetailsTable.'.product_id',
            $this->orderDetailsTable.'.quantity',
            $this->ordersTable.'.created_at'
        ]);
    
    return $query->get()->groupBy('customer_id');
}

public function customers($orders)
{
    $customers = collect();
    
    foreach ($orders as $customerId => $customerOrders) {
        // Filter customers with minimum order frequency
        if (count($customerOrders) >= $this->minOrderCount) {
            $customers->push([
                'customer_id' => $customerId,
                'orders' => $customerOrders,
                'total_orders' => count($customerOrders),
                'unique_products' => $customerOrders->pluck('product_id')->unique()->count()
            ]);
        }
    }
    
    return $customers;
}

private function processCustomerOrders($customer)
{
    $transactions = [];
    
    // Group orders by date to form transactions
    $ordersByDate = $customer['orders']->groupBy(function($order) {
        return Carbon::parse($order->created_at)->format('Y-m-d');
    });
    
    foreach ($ordersByDate as $date => $dayOrders) {
        $productIds = $dayOrders->pluck('product_id')->unique()->values()->toArray();
        
        if (count($productIds) >= 2) { // Minimum 2 products for association
            $transactions[] = $productIds;
        }
    }
    
    return $transactions;
}

public function generateFrequentItemsets($transactions)
{
    $apriori = new Apriori($this->support, $this->confidence);
    
    // Generate frequent 1-itemsets
    $frequentItemsets = [];
    $itemCounts = [];
    
    // Count individual items
    foreach ($transactions as $transaction) {
        foreach ($transaction as $item) {
            $itemCounts[$item] = ($itemCounts[$item] ?? 0) + 1;
        }
    }
    
    // Apply minimum support
    $totalTransactions = count($transactions);
    $minSupport = $this->support * $totalTransactions;
    
    foreach ($itemCounts as $item => $count) {
        if ($count >= $minSupport) {
            $frequentItemsets[1][] = [$item];
        }
    }
    
    // Generate higher-order itemsets
    $k = 2;
    while (!empty($frequentItemsets[$k - 1])) {
        $candidates = $this->generateCandidates($frequentItemsets[$k - 1]);
        $frequentItemsets[$k] = $this->pruneInfrequent($candidates, $transactions, $minSupport);
        $k++;
    }
    
    return $frequentItemsets;
}

// Configuration in config/eva.php
'suggested_products_apriori_support' => env('SUGGESTED_PRODUCTS_APRIORI_SUPPORT', 0.1),

'suggested_products_confidence_support' => env('SUGGESTED_PRODUCTS_CONFIDENCE_SUPPORT', 0.5),

public function processInChunks($customers)
{
    $chunkSize = config('eva.suggested_products_chunk_size', 30);
    
    $customers->chunk($chunkSize)->each(function ($chunk) {
        foreach ($chunk as $customer) {
            try {
                $this->processCustomer($customer);
            } catch (OutOfMemoryError $e) {
                Log::error("Memory limit exceeded for customer {$customer['id']}");
                $this->logError($e->getMessage());
            }
        }
        
        // Force garbage collection
        gc_collect_cycles();
    });
}

// Early termination for sparse data
private function shouldContinueProcessing($transactions)
{
    $averageItemsPerTransaction = array_sum(array_map('count', $transactions)) / count($transactions);
    $uniqueItems = count(array_unique(array_merge(...$transactions)));
    
    // Don't process if data is too sparse
    return $averageItemsPerTransaction >= 2 && $uniqueItems >= 5;
}

// Optimized candidate generation
private function generateCandidates($frequentItemsets)
{
    $candidates = [];
    $count = count($frequentItemsets);
    
    for ($i = 0; $i < $count - 1; $i++) {
        for ($j = $i + 1; $j < $count; $j++) {
            $candidate = array_unique(array_merge($frequentItemsets[$i], $frequentItemsets[$j]));
            
            // Prune if any subset is not frequent
            if ($this->allSubsetsFrequent($candidate, $frequentItemsets)) {
                $candidates[] = $candidate;
            }
        }
    }
    
    return $candidates;
}

graph TD
    A[Customer Request] --> B[Fetch Recent Orders]
    B --> C[Extract Order Patterns]
    C --> D[Calculate Frequencies]
    D --> E[Apply Business Rules]
    E --> F[Generate Suggestions]
    
    subgraph "Pattern Recognition"
        C1[Order Cycles]
        C2[Product Frequencies]
        C3[Quantity Patterns]
        C4[Timing Analysis]
    end
    
    subgraph "Business Logic"
        E1[Price Lists]
        E2[Stock Availability]
        E3[Customer Preferences]
        E4[Seasonal Adjustments]
    end

class GetSuggestedProductsFromRecentOrdersService
{
    public function getSuggestions($customerId, $options = [])
    {
        $recentOrders = $this->getRecentOrders($customerId, $options);
        $patterns = $this->analyzePatterns($recentOrders);
        $suggestions = $this->generateSuggestions($patterns, $customerId);
        
        return $this->enrichWithBusinessData($suggestions, $customerId);
    }
    
    private function analyzePatterns($orders)
    {
        $patterns = [];
        
        foreach ($orders as $order) {
            foreach ($order->details as $detail) {
                $productId = $detail->product_id;
                
                if (!isset($patterns[$productId])) {
                    $patterns[$productId] = [
                        'frequencies' => [],
                        'quantities' => [],
                        'intervals' => []
                    ];
                }
                
                $patterns[$productId]['frequencies'][] = 1;
                $patterns[$productId]['quantities'][] = $detail->quantity;
                $patterns[$productId]['intervals'][] = $order->created_at;
            }
        }
        
        return $this->calculateStatistics($patterns);
    }
    
    private function calculateStatistics($patterns)
    {
        foreach ($patterns as $productId => &$pattern) {
            $pattern['frequency_score'] = count($pattern['frequencies']);
            $pattern['avg_quantity'] = array_sum($pattern['quantities']) / count($pattern['quantities']);
            $pattern['consistency_score'] = $this->calculateConsistency($pattern['intervals']);
            $pattern['trend_score'] = $this->calculateTrend($pattern['quantities']);
        }
        
        return $patterns;
    }
}

class ModelEvaluator
{
    public function calculateAccuracy($predictions, $actualOrders)
    {
        $correct = 0;
        $total = count($predictions);
        
        foreach ($predictions as $prediction) {
            if ($this->isProductOrdered($prediction['product_id'], $actualOrders)) {
                $correct++;
            }
        }
        
        return $total > 0 ? $correct / $total : 0;
    }
    
    public function calculatePrecision($predictions, $actualOrders)
    {
        $truePositives = 0;
        $falsePositives = 0;
        
        foreach ($predictions as $prediction) {
            if ($this->isProductOrdered($prediction['product_id'], $actualOrders)) {
                $truePositives++;
            } else {
                $falsePositives++;
            }
        }
        
        return ($truePositives + $falsePositives) > 0 ? 
               $truePositives / ($truePositives + $falsePositives) : 0;
    }
    
    public function calculateRecall($predictions, $actualOrders)
    {
        $predictedProducts = collect($predictions)->pluck('product_id');
        $actualProducts = collect($actualOrders)->pluck('product_id');
        
        $truePositives = $predictedProducts->intersect($actualProducts)->count();
        $falseNegatives = $actualProducts->diff($predictedProducts)->count();
        
        return ($truePositives + $falseNegatives) > 0 ? 
               $truePositives / ($truePositives + $falseNegatives) : 0;
    }
}

private function applySeasonalAdjustment($suggestions)
{
    $currentMonth = now()->month;
    $seasonalFactors = config('eva.seasonal_factors', []);
    
    foreach ($suggestions as &$suggestion) {
        $productCategory = $suggestion['product_category'];
        
        if (isset($seasonalFactors[$productCategory][$currentMonth])) {
            $factor = $seasonalFactors[$productCategory][$currentMonth];
            $suggestion['adjusted_quantity'] = $suggestion['quantity'] * $factor;
            $suggestion['seasonal_factor'] = $factor;
        }
    }
    
    return $suggestions;
}

private function getCustomerSegment($customerId)
{
    $customer = Customer::find($customerId);
    
    // RFM Analysis (Recency, Frequency, Monetary)
    $recency = $this->calculateRecency($customer);
    $frequency = $this->calculateFrequency($customer);
    $monetary = $this->calculateMonetary($customer);
    
    // Segment based on RFM scores
    if ($recency >= 4 && $frequency >= 4 && $monetary >= 4) {
        return 'champions';
    } elseif ($recency >= 3 && $frequency >= 3) {
        return 'loyal_customers';
    } elseif ($recency >= 4) {
        return 'new_customers';
    } else {
        return 'at_risk';
    }
}

class PerformanceTracker
{
    public function trackRecommendationAccuracy()
    {
        $metrics = [
            'total_recommendations' => 0,
            'accepted_recommendations' => 0,
            'conversion_rate' => 0,
            'avg_order_value_increase' => 0
        ];
        
        // Calculate metrics from actual vs predicted orders
        $results = DB::table('order_recommendations')
            ->join('orders', 'order_recommendations.customer_id', '=', 'orders.customer_id')
            ->where('orders.created_at', '>=', now()->subDays(30))
            ->get();
            
        foreach ($results as $result) {
            $metrics['total_recommendations']++;
            
            if ($this->wasRecommendationAccepted($result)) {
                $metrics['accepted_recommendations']++;
            }
        }
        
        $metrics['conversion_rate'] = $metrics['total_recommendations'] > 0 ? 
            $metrics['accepted_recommendations'] / $metrics['total_recommendations'] : 0;
            
        return $metrics;
    }
}

class RecommendationABTest
{
    public function assignTestGroup($customerId)
    {
        $hash = crc32($customerId . config('app.key'));
        return ($hash % 100) < 50 ? 'control' : 'treatment';
    }
    
    public function getRecommendations($customerId, $context)
    {
        $group = $this->assignTestGroup($customerId);
        
        if ($group === 'control') {
            return $this->getBaselineRecommendations($customerId);
        } else {
            return $this->getMLRecommendations($customerId, $context);
        }
    }
    
    public function trackConversion($customerId, $recommendedProducts, $actualOrder)
    {
        ABTestResult::create([
            'customer_id' => $customerId,
            'test_group' => $this->assignTestGroup($customerId),
            'recommended_products' => json_encode($recommendedProducts),
            'actual_order' => json_encode($actualOrder),
            'conversion_rate' => $this->calculateConversion($recommendedProducts, $actualOrder)
        ]);
    }
}