Merge branch 'fabio_develop' into multi_db

app/Http/Livewire/Record.php

@@ -83,14 +83,22 @@ class Record extends Component
         $this->payments = \App\Models\PaymentMethod::select('id', 'name', 'type')->where('enabled', true)->where('money', false)->get();
     }
 
-
-    private function generateExportData($fromDate, $toDate)
+    private function generateExportDataAndTotals($fromDate, $toDate)
     {
+        Log::info('generateExportDataAndTotals: Start (combined method)', [
+            'from_date' => $fromDate,
+            'to_date' => $toDate,
+            'memory_before' => memory_get_usage(true)
+        ]);
+
         $exportRecords = array();
         $exportTotals = array();
 
+        Log::info('generateExportDataAndTotals: Getting excluded members');
         $exclude_from_records = \App\Models\Member::where('exclude_from_records', true)->pluck('id')->toArray();
+        Log::info('generateExportDataAndTotals: Excluded members retrieved', ['count' => count($exclude_from_records)]);
 
+        Log::info('generateExportDataAndTotals: Building main query');
         $datas = \App\Models\Record::with('member', 'supplier', 'payment_method')
             ->select(
                 'records.*',
@@ -101,13 +109,6 @@ class Record extends Component
                 'records_rows.note',
                 'records_rows.when',
                 'records_rows.vat_id',
-                'records_rows.imponibile',
-                'records_rows.aliquota_iva',
-                'records_rows.imposta',
-                'records_rows.divisa',
-                'records_rows.numero_linea',
-                'records_rows.prezzo_unitario',
-                'records_rows.quantita',
                 'records_rows.created_at as row_created_at',
                 'records_rows.updated_at as row_updated_at'
             )
@@ -127,6 +128,7 @@ class Record extends Component
                     });
             });
 
+        Log::info('generateExportDataAndTotals: Applying causal filters');
         if ($this->filterCausals != null && sizeof($this->filterCausals) > 0) {
             $causals = array();
             foreach ($this->filterCausals as $z) {
@@ -141,74 +143,133 @@ class Record extends Component
                 }
             }
             $datas->whereIn('causal_id', $causals);
+            Log::info('generateExportDataAndTotals: Causal filters applied', ['causal_count' => count($causals)]);
         }
+
         if ($this->filterMember != null && $this->filterMember > 0) {
             $datas->where('member_id', $this->filterMember);
+            Log::info('generateExportDataAndTotals: Member filter applied', ['member_id' => $this->filterMember]);
         }
+
+        Log::info('generateExportDataAndTotals: Executing query');
+        $queryStart = microtime(true);
+
         $datas = $datas->orderBy('date', 'ASC')
             ->orderBy('records.created_at', 'ASC')
             ->orderBy('records_rows.id', 'ASC')
             ->get();
 
+        $queryTime = microtime(true) - $queryStart;
+        Log::info('generateExportDataAndTotals: Query executed', [
+            'record_count' => $datas->count(),
+            'query_time' => $queryTime,
+            'memory_after_query' => memory_get_usage(true)
+        ]);
+
         $groupedData = [];
         $causalsCount = [];
+        $processedCount = 0;
+
+        // Initialize totals array
+        foreach ($this->payments as $p) {
+            $exportTotals[$p->name] = ["IN" => 0, "OUT" => 0];
+        }
+
+        Log::info('generateExportDataAndTotals: Starting combined data processing loop');
+        $loopStart = microtime(true);
 
         foreach ($datas as $idx => $data) {
-            $causalCheck = \App\Models\Causal::findOrFail($data->causal_id);
-            $paymentCheck = $data->payment_method->money;
+            if ($processedCount % 100 == 0) {
+                Log::info('generateExportDataAndTotals: Processing progress', [
+                    'processed' => $processedCount,
+                    'total' => $datas->count(),
+                    'memory_current' => memory_get_usage(true),
+                    'memory_peak' => memory_get_peak_usage(true)
+                ]);
+            }
 
-            if (!$paymentCheck && ($causalCheck->no_first == null || !$causalCheck->no_first)) {
-                if (!$data->deleted) {
-                    $amount = $data->amount;
-                    $amount += getVatValue($amount, $data->vat_id);
-                } else {
-                    $amount = $data->amount;
-                }
+            try {
+                $causalCheck = \App\Models\Causal::findOrFail($data->causal_id);
+                $paymentCheck = $data->payment_method->money;
 
-                $isCommercial = ($data->commercial == 1 || $data->commercial === '1' || $data->commercial === true);
-                $typeLabel = $isCommercial ? 'Commerciale' : 'Non Commerciale';
+                if (!$paymentCheck && ($causalCheck->no_first == null || !$causalCheck->no_first)) {
+                    if (!$data->deleted) {
+                        $amount = $data->amount;
+                        $amount += getVatValue($amount, $data->vat_id);
+                    } else {
+                        $amount = $data->amount;
+                    }
 
-                $nominativo = '';
-                if ($data->type == "IN") {
-                    if ($data->member) {
-                        $nominativo = $data->member->last_name . " " . $data->member->first_name;
+                    // CALCULATE TOTALS HERE (in the same loop)
+                    if (!$data->deleted) {
+                        $exportTotals[$data->payment_method->name][$data->type] += $amount;
                     }
-                } else {
-                    if ($data->supplier) {
-                        $nominativo = $data->supplier->name;
+
+                    $isCommercial = ($data->commercial == 1 || $data->commercial === '1' || $data->commercial === true);
+                    $typeLabel = $isCommercial ? 'Commerciale' : 'Non Commerciale';
+
+                    $nominativo = '';
+                    if ($data->type == "IN") {
+                        if ($data->member) {
+                            $nominativo = $data->member->last_name . " " . $data->member->first_name;
+                        }
+                    } else {
+                        if ($data->supplier) {
+                            $nominativo = $data->supplier->name;
+                        }
                     }
-                }
 
-                $groupKey = $data->date . '|' . $typeLabel . '|' . $data->payment_method->name . '|' . $data->type . '|' . $nominativo;
+                    $groupKey = $data->date . '|' . $typeLabel . '|' . $data->payment_method->name . '|' . $data->type . '|' . $nominativo;
+
+                    if (!isset($groupedData[$groupKey])) {
+                        $groupedData[$groupKey] = [
+                            'date' => $data->date,
+                            'type_label' => $typeLabel,
+                            'payment_method' => $data->payment_method->name,
+                            'transaction_type' => $data->type,
+                            'nominativo' => $nominativo,
+                            'amount' => 0,
+                            'deleted' => false,
+                            'causals' => [],
+                            'notes' => []
+                        ];
+                        $causalsCount[$groupKey] = [];
+                    }
 
-                if (!isset($groupedData[$groupKey])) {
-                    $groupedData[$groupKey] = [
-                        'date' => $data->date,
-                        'type_label' => $typeLabel,
-                        'payment_method' => $data->payment_method->name,
-                        'transaction_type' => $data->type,
-                        'nominativo' => $nominativo,
-                        'amount' => 0,
-                        'deleted' => false,
-                        'causals' => [],
-                        'notes' => []
-                    ];
-                    $causalsCount[$groupKey] = [];
-                }
+                    $groupedData[$groupKey]['amount'] += $amount;
+                    $causalsCount[$groupKey][$causalCheck->getTree()] = true;
 
-                $groupedData[$groupKey]['amount'] += $amount;
-                $causalsCount[$groupKey][$causalCheck->getTree()] = true;
+                    if (!empty($data->note)) {
+                        $groupedData[$groupKey]['notes'][] = $data->note;
+                    }
 
-                if (!empty($data->note)) {
-                    $groupedData[$groupKey]['notes'][] = $data->note;
+                    if ($data->deleted) {
+                        $groupedData[$groupKey]['deleted'] = true;
+                    }
                 }
 
-                if ($data->deleted) {
-                    $groupedData[$groupKey]['deleted'] = true;
-                }
+                $processedCount++;
+            } catch (\Exception $e) {
+                Log::error('generateExportDataAndTotals: Error processing individual record', [
+                    'record_id' => $data->id ?? 'unknown',
+                    'error' => $e->getMessage(),
+                    'processed_so_far' => $processedCount
+                ]);
+                throw $e;
             }
         }
 
+        $loopTime = microtime(true) - $loopStart;
+        Log::info('generateExportDataAndTotals: Combined processing loop completed', [
+            'total_processed' => $processedCount,
+            'grouped_records' => count($groupedData),
+            'loop_time' => $loopTime,
+            'memory_after_loop' => memory_get_usage(true)
+        ]);
+
+        Log::info('generateExportDataAndTotals: Building final export records');
+        $finalStart = microtime(true);
+
         foreach ($groupedData as $groupKey => $group) {
             $causalsInGroup = array_keys($causalsCount[$groupKey]);
 
@@ -227,17 +288,27 @@ class Record extends Component
             }
 
             $exportRecords[$recordKey][$group['payment_method']][$group['transaction_type']] += $group['amount'];
-
-            if (!isset($exportTotals[$group['payment_method']])) {
-                $exportTotals[$group['payment_method']]["IN"] = 0;
-                $exportTotals[$group['payment_method']]["OUT"] = 0;
-            }
-
-            if (!$group['deleted'])
-                $exportTotals[$group['payment_method']][$group['transaction_type']] += $group['amount'];
         }
 
-        return $exportRecords;
+        $finalTime = microtime(true) - $finalStart;
+        Log::info('generateExportDataAndTotals: Final processing completed', [
+            'final_export_records' => count($exportRecords),
+            'final_export_totals' => count($exportTotals),
+            'final_time' => $finalTime,
+            'total_time' => microtime(true) - $loopStart + $queryTime,
+            'memory_final' => memory_get_usage(true),
+            'memory_peak' => memory_get_peak_usage(true)
+        ]);
+
+        // Cleanup
+        unset($datas, $groupedData, $causalsCount);
+        gc_collect_cycles();
+
+        Log::info('generateExportDataAndTotals: Completed with cleanup', [
+            'memory_after_cleanup' => memory_get_usage(true)
+        ]);
+
+        return ['records' => $exportRecords, 'totals' => $exportTotals];
     }
 
     private function generateExportTotals($fromDate, $toDate)
@@ -256,9 +327,6 @@ class Record extends Component
                 'records_rows.note',
                 'records_rows.when',
                 'records_rows.vat_id',
-                'records_rows.imponibile',
-                'records_rows.aliquota_iva',
-                'records_rows.imposta'
             )
             ->join('records_rows', 'records.id', '=', 'records_rows.record_id')
             ->whereBetween('date', [$fromDate, $toDate])
@@ -470,9 +538,6 @@ class Record extends Component
                 'records_rows.note',
                 'records_rows.when',
                 'records_rows.vat_id',
-                'records_rows.imponibile',
-                'records_rows.aliquota_iva',
-                'records_rows.imposta'
             )
             ->join('records_rows', 'records.id', '=', 'records_rows.record_id')
             ->whereBetween('date', [$this->appliedFromDate, $this->appliedToDate])
@@ -672,37 +737,87 @@ class Record extends Component
     public function exportWithDateRange()
     {
 
-        $this->isExporting = true;
-        $this->emit('$refresh'); // This forces Livewire to re-render
+        Log::info('=== EXPORT START ===', [
+            'user_id' => auth()->id(),
+            'from_date' => $this->exportFromDate,
+            'to_date' => $this->exportToDate,
+            'send_via_email' => $this->sendViaEmail,
+            'memory_usage' => memory_get_usage(true),
+            'memory_peak' => memory_get_peak_usage(true),
+            'time_limit' => ini_get('max_execution_time')
+        ]);
 
-        // Add a small delay to allow the view to update
+        $this->isExporting = true;
+        $this->emit('$refresh');
         usleep(100000);
+
         if ($this->sendViaEmail) {
+            Log::info('Export: Validating email fields');
             $this->validate([
                 'exportEmailAddress' => 'required|email',
                 'exportEmailSubject' => 'required|string|max:255',
             ]);
+            Log::info('Export: Email validation passed');
         }
 
         $this->isExporting = true;
 
         try {
-            $exportRecords = $this->generateExportData($this->exportFromDate, $this->exportToDate);
-            $exportTotals = $this->generateExportTotals($this->exportFromDate, $this->exportToDate);
+            Log::info('Export: Starting COMBINED data generation phase (NO SEPARATE CALLS)');
+            $startTime = microtime(true);
+
+            // *** THIS IS THE KEY CHANGE - USE ONLY THE COMBINED METHOD ***
+            $result = $this->generateExportDataAndTotals($this->exportFromDate, $this->exportToDate);
+            $exportRecords = $result['records'];
+            $exportTotals = $result['totals'];
+
+            $dataGenTime = microtime(true) - $startTime;
+            Log::info('Export: COMBINED data generation completed (NO SEPARATE TOTALS CALL)', [
+                'records_count' => count($exportRecords),
+                'totals_count' => count($exportTotals),
+                'generation_time' => $dataGenTime,
+                'memory_usage' => memory_get_usage(true),
+                'memory_peak' => memory_get_peak_usage(true)
+            ]);
+
 
             if ($this->sendViaEmail) {
-                // Dispatch job to background queue
+                Log::info('Export: Dispatching to background job');
                 $this->dispatchExportJob($exportRecords, $exportTotals);
+                Log::info('Export: Job dispatched successfully');
             } else {
-                // Direct download (synchronous)
-                return $this->exportWithData($exportRecords, $exportTotals);
+                Log::info('Export: Starting direct download export');
+                $exportStartTime = microtime(true);
+
+                $result = $this->exportWithData($exportRecords, $exportTotals);
+
+                $exportTime = microtime(true) - $exportStartTime;
+                Log::info('Export: Direct export completed', [
+                    'export_time' => $exportTime,
+                    'total_time' => microtime(true) - $startTime,
+                    'memory_usage' => memory_get_usage(true),
+                    'memory_peak' => memory_get_peak_usage(true)
+                ]);
+
+                return $result;
             }
         } catch (\Illuminate\Validation\ValidationException $e) {
+            Log::error('Export: Validation error', [
+                'error' => $e->getMessage(),
+                'errors' => $e->errors()
+            ]);
             $this->isExporting = false;
             throw $e;
         } catch (\Exception $e) {
+            Log::error('Export: General error', [
+                'error' => $e->getMessage(),
+                'trace' => $e->getTraceAsString(),
+                'memory_usage' => memory_get_usage(true),
+                'memory_peak' => memory_get_peak_usage(true),
+                'execution_time' => microtime(true) - ($startTime ?? 0)
+            ]);
+
             $this->isExporting = false;
-            Log::error('Export error: ' . $e->getMessage());
 
             if ($this->sendViaEmail) {
                 $this->emit('export-email-error', 'Errore durante l\'invio dell\'email: ' . $e->getMessage());
@@ -710,11 +825,55 @@ class Record extends Component
                 session()->flash('error', 'Errore durante l\'export: ' . $e->getMessage());
             }
         } finally {
+            Log::info('Export: Cleanup phase');
             $this->isExporting = false;
             $this->emit('export-complete');
             $this->emit('hide-export-modal');
+            Log::info('=== EXPORT END ===');
         }
     }
+    private function getEstimatedRecordCount($fromDate, $toDate)
+    {
+        $exclude_from_records = \App\Models\Member::where('exclude_from_records', true)->pluck('id')->toArray();
+
+        $query = \App\Models\Record::join('records_rows', 'records.id', '=', 'records_rows.record_id')
+            ->whereBetween('date', [$fromDate, $toDate])
+            ->where(function ($query) {
+                $query->where('type', 'OUT')
+                    ->orWhere(function ($query) {
+                        $query->where('records.corrispettivo_fiscale', true)
+                            ->orWhere('records.commercial', false);
+                    });
+            })
+            ->where(function ($query) use ($exclude_from_records) {
+                $query->where('type', 'OUT')
+                    ->orWhere(function ($subquery) use ($exclude_from_records) {
+                        $subquery->whereNotIn('member_id', $exclude_from_records);
+                    });
+            });
+
+        if ($this->filterCausals != null && sizeof($this->filterCausals) > 0) {
+            $causals = array();
+            foreach ($this->filterCausals as $z) {
+                $causals[] = $z;
+                $childs = \App\Models\Causal::where('parent_id', $z)->get();
+                foreach ($childs as $c) {
+                    $causals[] = $c->id;
+                    $childsX = \App\Models\Causal::where('parent_id', $c->id)->get();
+                    foreach ($childsX as $cX) {
+                        $causals[] = $cX->id;
+                    }
+                }
+            }
+            $query->whereIn('causal_id', $causals);
+        }
+
+        if ($this->filterMember != null && $this->filterMember > 0) {
+            $query->where('member_id', $this->filterMember);
+        }
+
+        return $query->count();
+    }
 
     private function getMemberName($memberId)
     {
@@ -829,33 +988,54 @@ class Record extends Component
 
     function export()
     {
-        $exportRecords = $this->generateExportData($this->appliedFromDate, $this->appliedToDate);
-        $exportTotals = $this->generateExportTotals($this->appliedFromDate, $this->appliedToDate);
+        $result = $this->generateExportDataAndTotals($this->exportFromDate, $this->exportToDate);
+        $exportRecords = $result['records'];
+        $exportTotals = $result['totals'];
 
         return $this->exportWithData($exportRecords, $exportTotals);
     }
 
     private function exportWithData($exportRecords, $exportTotals)
     {
+        Log::info('exportWithData: Starting Excel generation', [
+            'records_count' => count($exportRecords),
+            'totals_count' => count($exportTotals),
+            'memory_before' => memory_get_usage(true)
+        ]);
+
+        $startTime = microtime(true);
+
+        Log::info('exportWithData: Setting memory and GC');
         ini_set('memory_limit', '512M');
         gc_enable();
 
+        Log::info('exportWithData: Preparing column letters');
         $letters = array('F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'AA');
 
+        Log::info('exportWithData: Creating spreadsheet object');
         $spreadsheet = new Spreadsheet();
         $activeWorksheet = $spreadsheet->getActiveSheet();
 
+        Log::info('exportWithData: Setting basic headers');
         $activeWorksheet->setCellValue('A1', "Data");
         $activeWorksheet->setCellValue('B1', "Causale");
         $activeWorksheet->setCellValue('C1', "Dettaglio");
         $activeWorksheet->setCellValue('D1', "Nominativo");
         $activeWorksheet->setCellValue('E1', "Stato");
 
+        Log::info('exportWithData: Setting payment method headers');
         $idx = 0;
         foreach ($this->payments as $p) {
             if ($idx >= count($letters)) {
+                Log::warning('exportWithData: Reached letter limit', ['payment_index' => $idx]);
                 break;
             }
+            Log::debug('exportWithData: Setting payment header', [
+                'payment_name' => $p->name,
+                'column_index' => $idx,
+                'column_letter' => $letters[$idx]
+            ]);
+
             $activeWorksheet->setCellValue($letters[$idx] . '1', $p->name);
             $idx++;
             if ($idx >= count($letters)) {
@@ -865,6 +1045,7 @@ class Record extends Component
             $idx++;
         }
 
+        Log::info('exportWithData: Setting sub-headers');
         $idx = 0;
         $activeWorksheet->setCellValue('A2', "");
         $activeWorksheet->setCellValue('B2', "");
@@ -900,75 +1081,119 @@ class Record extends Component
             }
         }
 
+        Log::info('exportWithData: Applying header styles');
         $activeWorksheet->getStyle('A1:Q1')->getFont()->setBold(true);
         $activeWorksheet->getStyle('A2:Q2')->getFont()->setBold(true);
 
+        Log::info('exportWithData: Starting data row processing');
         $count = 3;
         $batchSize = 1000;
         $recordsProcessed = 0;
 
         $totalRecords = count($exportRecords);
+        Log::info('exportWithData: Processing records in batches', [
+            'total_records' => $totalRecords,
+            'batch_size' => $batchSize
+        ]);
+
         $recordsArray = array_chunk($exportRecords, $batchSize, true);
+        Log::info('exportWithData: Created batches', ['batch_count' => count($recordsArray)]);
+
+        foreach ($recordsArray as $batchIndex => $recordsBatch) {
+            Log::info('exportWithData: Processing batch', [
+                'batch_index' => $batchIndex,
+                'batch_size' => count($recordsBatch),
+                'memory_current' => memory_get_usage(true),
+                'time_elapsed' => microtime(true) - $startTime
+            ]);
 
-        foreach ($recordsArray as $recordsBatch) {
             foreach ($recordsBatch as $causal => $record) {
-                $check = $causal;
-                $parts = explode("§", $check);
-                $d = $parts[0] ?? '';
-                $c = $parts[1] ?? '';
-                $j = $parts[2] ?? '';
-                $det = $parts[3] ?? '';
-                $deleted = $parts[4] ?? '';
-
-                $detailParts = explode('|', $det);
-                $exportDetail = count($detailParts) > 1 ? implode(', ', array_slice($detailParts, 1)) : $det;
-
-                $activeWorksheet->setCellValue('A' . $count, !empty($d) ? date("d/m/Y", strtotime($d)) : '');
-                $activeWorksheet->setCellValue('B' . $count, $c);
-                $activeWorksheet->setCellValue('C' . $count, $exportDetail);
-                $activeWorksheet->setCellValue('D' . $count, $j);
-
-                $stato = ($deleted === 'DELETED') ? 'ANNULLATA' : '';
-                $activeWorksheet->setCellValue('E' . $count, $stato);
-
-                if ($stato === 'ANNULLATA') {
-                    $activeWorksheet->getStyle('E' . $count)->getFont()->getColor()->setARGB('FFFF0000');
+                if ($recordsProcessed % 250 == 0) {
+                    Log::info('exportWithData: Record processing progress', [
+                        'processed' => $recordsProcessed,
+                        'total' => $totalRecords,
+                        'current_row' => $count,
+                        'memory_usage' => memory_get_usage(true),
+                        'time_elapsed' => microtime(true) - $startTime
+                    ]);
                 }
 
-                $idx = 0;
-                foreach ($this->payments as $p) {
-                    if ($idx >= count($letters) - 1) {
-                        break;
+                try {
+                    $check = $causal;
+                    $parts = explode("§", $check);
+                    $d = $parts[0] ?? '';
+                    $c = $parts[1] ?? '';
+                    $j = $parts[2] ?? '';
+                    $det = $parts[3] ?? '';
+                    $deleted = $parts[4] ?? '';
+
+                    $detailParts = explode('|', $det);
+                    $exportDetail = count($detailParts) > 1 ? implode(', ', array_slice($detailParts, 1)) : $det;
+
+                    Log::debug('exportWithData: Setting row cells', ['row' => $count]);
+                    $activeWorksheet->setCellValue('A' . $count, !empty($d) ? date("d/m/Y", strtotime($d)) : '');
+                    $activeWorksheet->setCellValue('B' . $count, $c);
+                    $activeWorksheet->setCellValue('C' . $count, $exportDetail);
+                    $activeWorksheet->setCellValue('D' . $count, $j);
+
+                    $stato = ($deleted === 'DELETED') ? 'ANNULLATA' : '';
+                    $activeWorksheet->setCellValue('E' . $count, $stato);
+
+                    if ($stato === 'ANNULLATA') {
+                        $activeWorksheet->getStyle('E' . $count)->getFont()->getColor()->setARGB('FFFF0000');
                     }
 
-                    if (isset($record[$p->name])) {
-                        $inValue = isset($record[$p->name]["IN"]) ? formatPrice($record[$p->name]["IN"]) : "";
-                        $outValue = isset($record[$p->name]["OUT"]) ? formatPrice($record[$p->name]["OUT"]) : "";
-
-                        $activeWorksheet->setCellValue($letters[$idx] . $count, $inValue);
-                        $idx++;
-                        $activeWorksheet->setCellValue($letters[$idx] . $count, $outValue);
-                        $idx++;
-                    } else {
-                        $activeWorksheet->setCellValue($letters[$idx] . $count, "");
-                        $idx++;
-                        $activeWorksheet->setCellValue($letters[$idx] . $count, "");
-                        $idx++;
+                    $idx = 0;
+                    foreach ($this->payments as $p) {
+                        if ($idx >= count($letters) - 1) {
+                            break;
+                        }
+
+                        if (isset($record[$p->name])) {
+                            $inValue = isset($record[$p->name]["IN"]) ? formatPrice($record[$p->name]["IN"]) : "";
+                            $outValue = isset($record[$p->name]["OUT"]) ? formatPrice($record[$p->name]["OUT"]) : "";
+
+                            $activeWorksheet->setCellValue($letters[$idx] . $count, $inValue);
+                            $idx++;
+                            $activeWorksheet->setCellValue($letters[$idx] . $count, $outValue);
+                            $idx++;
+                        } else {
+                            $activeWorksheet->setCellValue($letters[$idx] . $count, "");
+                            $idx++;
+                            $activeWorksheet->setCellValue($letters[$idx] . $count, "");
+                            $idx++;
+                        }
                     }
-                }
 
-                $count++;
-                $recordsProcessed++;
+                    $count++;
+                    $recordsProcessed++;
 
-                if ($recordsProcessed % 500 === 0) {
-                    gc_collect_cycles();
+                    if ($recordsProcessed % 500 === 0) {
+                        Log::debug('exportWithData: Garbage collection');
+                        gc_collect_cycles();
+                    }
+                } catch (\Exception $e) {
+                    Log::error('exportWithData: Error processing record row', [
+                        'row' => $count,
+                        'causal' => $causal,
+                        'error' => $e->getMessage(),
+                        'processed_so_far' => $recordsProcessed
+                    ]);
+                    throw $e;
                 }
             }
 
+            Log::info('exportWithData: Batch completed', [
+                'batch_index' => $batchIndex,
+                'records_in_batch' => count($recordsBatch),
+                'total_processed' => $recordsProcessed
+            ]);
+
             unset($recordsBatch);
             gc_collect_cycles();
         }
 
+        Log::info('exportWithData: Adding totals row');
         $count++;
         $idx = 0;
 
@@ -1020,8 +1245,10 @@ class Record extends Component
             }
         }
 
+        Log::info('exportWithData: Applying final styles');
         $activeWorksheet->getStyle('A' . $count . ':Q' . $count)->getFont()->setBold(true);
 
+        Log::info('exportWithData: Setting column dimensions');
         $activeWorksheet->getColumnDimension('A')->setWidth(20);
         $activeWorksheet->getColumnDimension('B')->setWidth(40);
         $activeWorksheet->getColumnDimension('C')->setWidth(40);
@@ -1032,20 +1259,35 @@ class Record extends Component
         }
 
         $filename = 'prima_nota_' . date("YmdHis") . '.xlsx';
+        Log::info('exportWithData: Preparing to save file', [
+            'filename' => $filename,
+            'total_processing_time' => microtime(true) - $startTime,
+            'memory_before_save' => memory_get_usage(true)
+        ]);
 
         try {
             $currentClient = session('currentClient', 'default');
-
             $tempPath = sys_get_temp_dir() . '/' . $filename;
 
+            Log::info('exportWithData: Creating Excel writer');
             $writer = new Xlsx($spreadsheet);
+
+            Log::info('exportWithData: Saving to temp path', ['temp_path' => $tempPath]);
+            $writerStart = microtime(true);
             $writer->save($tempPath);
+            $writerTime = microtime(true) - $writerStart;
+
+            Log::info('exportWithData: File saved to temp', [
+                'writer_time' => $writerTime,
+                'file_size' => file_exists($tempPath) ? filesize($tempPath) : 'unknown',
+                'memory_after_save' => memory_get_usage(true)
+            ]);
 
             unset($spreadsheet, $activeWorksheet, $writer);
             gc_collect_cycles();
 
+            Log::info('exportWithData: Uploading to S3');
             $disk = Storage::disk('s3');
-
             $s3Path = $currentClient . '/prima_nota/' . $filename;
 
             $primaNotaFolderPath = $currentClient . '/prima_nota/.gitkeep';
@@ -1054,18 +1296,23 @@ class Record extends Component
                 Log::info("Created prima_nota folder for client: {$currentClient}");
             }
 
+            $uploadStart = microtime(true);
             $fileContent = file_get_contents($tempPath);
             $uploaded = $disk->put($s3Path, $fileContent, 'private');
+            $uploadTime = microtime(true) - $uploadStart;
 
             if (!$uploaded) {
                 throw new \Exception('Failed to upload file to Wasabi S3');
             }
 
-            Log::info("Prima Nota exported to Wasabi", [
+            Log::info("Export completed successfully", [
                 'client' => $currentClient,
                 'path' => $s3Path,
-                'size' => filesize($tempPath),
-                'records_processed' => $recordsProcessed
+                'file_size' => filesize($tempPath),
+                'records_processed' => $recordsProcessed,
+                'upload_time' => $uploadTime,
+                'total_time' => microtime(true) - $startTime,
+                'memory_peak' => memory_get_peak_usage(true)
             ]);
 
             if (file_exists($tempPath)) {
@@ -1075,13 +1322,16 @@ class Record extends Component
             $downloadUrl = $disk->temporaryUrl($s3Path, now()->addHour());
             return redirect($downloadUrl);
         } catch (\Exception $e) {
-            Log::error('Error exporting Prima Nota to Wasabi S3', [
+            Log::error('Export S3 error - falling back to local', [
                 'error' => $e->getMessage(),
+                'trace' => $e->getTraceAsString(),
                 'client' => session('currentClient', 'unknown'),
                 'filename' => $filename,
-                'records_processed' => $recordsProcessed ?? 0
+                'records_processed' => $recordsProcessed ?? 0,
+                'time_elapsed' => microtime(true) - $startTime
             ]);
 
+            // Fallback logic remains the same...
             $currentClient = session('currentClient', 'default');
             $clientFolder = storage_path('app/prima_nota/' . $currentClient);
 
@@ -1102,14 +1352,13 @@ class Record extends Component
 
             gc_collect_cycles();
 
-            Log::warning("Prima Nota saved locally due to S3 error", [
+            Log::warning("Export saved locally due to S3 error", [
                 'client' => $currentClient,
                 'local_path' => $localPath,
                 'error' => $e->getMessage()
             ]);
 
             session()->flash('warning', 'File salvato localmente a causa di un errore del cloud storage.');
-
             return response()->download($localPath)->deleteFileAfterSend();
         }
     }

app/Jobs/ExportPrimaNota.php

@@ -19,7 +19,7 @@ class ExportPrimaNota implements ShouldQueue
 {
     use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
 
-    public $timeout = 600;
+    public $timeout = 1200;
     public $tries = 3;
     public $maxExceptions = 3;
 
@@ -106,7 +106,6 @@ class ExportPrimaNota implements ShouldQueue
                 'file_size' => $fileSize,
                 'processing_time' => microtime(true) - LARAVEL_START ?? 0
             ]);
-
         } catch (\Exception $e) {
             Log::error('Background export failed', [
                 'user_id' => $this->userId,
@@ -144,11 +143,11 @@ class ExportPrimaNota implements ShouldQueue
         try {
             Mail::raw(
                 "Il tuo export della Prima Nota non è riuscito dopo {$this->tries} tentativi.\n\n" .
-                "Errore: {$exception->getMessage()}\n\n" .
-                "Contatta il supporto tecnico se il problema persiste.",
+                    "Errore: {$exception->getMessage()}\n\n" .
+                    "Contatta il supporto tecnico se il problema persiste.",
                 function ($message) {
                     $message->to($this->emailAddress)
-                           ->subject('Export Prima Nota - Errore');
+                        ->subject('Export Prima Nota - Errore');
                 }
             );
         } catch (\Exception $e) {
@@ -164,13 +163,26 @@ class ExportPrimaNota implements ShouldQueue
      */
     private function createExcelFile($filePath)
     {
+        Log::info('Job createExcelFile: Starting Excel file creation', [
+            'file_path' => $filePath,
+            'export_data_count' => count($this->exportData),
+            'payments_count' => count($this->payments),
+            'memory_before' => memory_get_usage(true),
+            'time_limit' => ini_get('max_execution_time')
+        ]);
+
+        $startTime = microtime(true);
+
+        Log::info('Job createExcelFile: Preparing column letters');
         $letters = array('F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'AA');
 
+        Log::info('Job createExcelFile: Creating Spreadsheet object');
         $spreadsheet = new Spreadsheet();
         $activeWorksheet = $spreadsheet->getActiveSheet();
 
         $activeWorksheet->setTitle('Prima Nota');
 
+        Log::info('Job createExcelFile: Setting document properties');
         $spreadsheet->getProperties()
             ->setCreator('Prima Nota System')
             ->setLastModifiedBy('Sistema')
@@ -178,21 +190,36 @@ class ExportPrimaNota implements ShouldQueue
             ->setSubject('Export Prima Nota')
             ->setDescription('Export dei dati Prima Nota dal ' . $this->dateRange['from'] . ' al ' . $this->dateRange['to']);
 
+        Log::info('Job createExcelFile: Setting basic headers');
         $activeWorksheet->setCellValue('A1', "Data");
         $activeWorksheet->setCellValue('B1', "Causale");
         $activeWorksheet->setCellValue('C1', "Dettaglio Causale");
         $activeWorksheet->setCellValue('D1', "Nominativo");
         $activeWorksheet->setCellValue('E1', "Stato");
 
+        Log::info('Job createExcelFile: Setting payment method headers and merging cells');
         $idx = 0;
         foreach ($this->payments as $p) {
-            if ($idx >= count($letters)) break;
+            if ($idx >= count($letters)) {
+                Log::warning('Job createExcelFile: Reached letter limit during header setup', [
+                    'payment_index' => $idx,
+                    'payment_name' => $p['name']
+                ]);
+                break;
+            }
+
+            Log::debug('Job createExcelFile: Setting payment header', [
+                'payment_name' => $p['name'],
+                'column_index' => $idx,
+                'column_letter' => $letters[$idx]
+            ]);
 
             $activeWorksheet->setCellValue($letters[$idx] . '1', $p['name']);
             $activeWorksheet->mergeCells($letters[$idx] . '1:' . $letters[$idx + 1] . '1');
             $idx += 2;
         }
 
+        Log::info('Job createExcelFile: Setting sub-headers (row 2)');
         $activeWorksheet->setCellValue('A2', "");
         $activeWorksheet->setCellValue('B2', "");
         $activeWorksheet->setCellValue('C2', "");
@@ -201,7 +228,13 @@ class ExportPrimaNota implements ShouldQueue
 
         $idx = 0;
         foreach ($this->payments as $p) {
-            if ($idx >= count($letters) - 1) break;
+            if ($idx >= count($letters) - 1) {
+                Log::warning('Job createExcelFile: Reached letter limit during sub-header setup', [
+                    'payment_index' => $idx,
+                    'payment_name' => $p['name']
+                ]);
+                break;
+            }
 
             if ($p['type'] == 'ALL') {
                 $activeWorksheet->setCellValue($letters[$idx] . '2', "Entrate");
@@ -221,72 +254,131 @@ class ExportPrimaNota implements ShouldQueue
             }
         }
 
-        $activeWorksheet->getStyle('A1:' . $letters[min(count($letters) - 1, count($this->payments) * 2 + 4)] . '2')
-                       ->getFont()->setBold(true);
+        Log::info('Job createExcelFile: Applying header styles');
+        $maxCol = min(count($letters) - 1, count($this->payments) * 2 + 4);
+        $lastColumnLetter = $letters[$maxCol];
 
-        $activeWorksheet->getStyle('A1:' . $letters[min(count($letters) - 1, count($this->payments) * 2 + 4)] . '1')
-                       ->getFill()
-                       ->setFillType(\PhpOffice\PhpSpreadsheet\Style\Fill::FILL_SOLID)
-                       ->getStartColor()->setARGB('FF0C6197');
+        $activeWorksheet->getStyle('A1:' . $lastColumnLetter . '2')
+            ->getFont()->setBold(true);
 
-        $activeWorksheet->getStyle('A1:' . $letters[min(count($letters) - 1, count($this->payments) * 2 + 4)] . '1')
-                       ->getFont()->getColor()->setARGB('FFFFFFFF');
+        $activeWorksheet->getStyle('A1:' . $lastColumnLetter . '1')
+            ->getFill()
+            ->setFillType(\PhpOffice\PhpSpreadsheet\Style\Fill::FILL_SOLID)
+            ->getStartColor()->setARGB('FF0C6197');
+
+        $activeWorksheet->getStyle('A1:' . $lastColumnLetter . '1')
+            ->getFont()->getColor()->setARGB('FFFFFFFF');
+
+        Log::info('Job createExcelFile: Starting data row processing', [
+            'total_export_records' => count($this->exportData),
+            'time_elapsed_so_far' => microtime(true) - $startTime
+        ]);
 
         $count = 3;
         $batchSize = 500;
         $processed = 0;
+        $batchNumber = 0;
 
         foreach ($this->exportData as $causal => $record) {
-            $parts = explode("§", $causal);
-            $d = $parts[0] ?? '';
-            $c = $parts[1] ?? '';
-            $j = $parts[2] ?? '';
-            $det = $parts[3] ?? '';
-            $deleted = $parts[4] ?? '';
-
-            $detailParts = explode('|', $det);
-            $exportDetail = count($detailParts) > 1 ? implode(', ', array_slice($detailParts, 1)) : $det;
+            if ($processed % 100 == 0) {
+                Log::info('Job createExcelFile: Processing progress', [
+                    'processed' => $processed,
+                    'total' => count($this->exportData),
+                    'current_row' => $count,
+                    'memory_usage' => memory_get_usage(true),
+                    'memory_peak' => memory_get_peak_usage(true),
+                    'time_elapsed' => microtime(true) - $startTime
+                ]);
+            }
 
-            $activeWorksheet->setCellValue('A' . $count, !empty($d) ? date("d/m/Y", strtotime($d)) : '');
-            $activeWorksheet->setCellValue('B' . $count, $c);
-            $activeWorksheet->setCellValue('C' . $count, $exportDetail);
-            $activeWorksheet->setCellValue('D' . $count, $j);
+            try {
+                $parts = explode("§", $causal);
+                $d = $parts[0] ?? '';
+                $c = $parts[1] ?? '';
+                $j = $parts[2] ?? '';
+                $det = $parts[3] ?? '';
+                $deleted = $parts[4] ?? '';
 
-            $stato = ($deleted === 'DELETED') ? 'ANNULLATA' : '';
-            $activeWorksheet->setCellValue('E' . $count, $stato);
+                $detailParts = explode('|', $det);
+                $exportDetail = count($detailParts) > 1 ? implode(', ', array_slice($detailParts, 1)) : $det;
 
-            if ($stato === 'ANNULLATA') {
-                $activeWorksheet->getStyle('E' . $count)->getFont()->getColor()->setARGB('FFFF0000');
-            }
+                Log::debug('Job createExcelFile: Setting row data', [
+                    'row' => $count,
+                    'causal_parts' => count($parts)
+                ]);
 
-            $idx = 0;
-            foreach ($this->payments as $p) {
-                if ($idx >= count($letters) - 1) break;
+                $activeWorksheet->setCellValue('A' . $count, !empty($d) ? date("d/m/Y", strtotime($d)) : '');
+                $activeWorksheet->setCellValue('B' . $count, $c);
+                $activeWorksheet->setCellValue('C' . $count, $exportDetail);
+                $activeWorksheet->setCellValue('D' . $count, $j);
 
-                if (isset($record[$p['name']])) {
-                    $inValue = isset($record[$p['name']]["IN"]) ? $this->formatPrice($record[$p['name']]["IN"]) : "";
-                    $outValue = isset($record[$p['name']]["OUT"]) ? $this->formatPrice($record[$p['name']]["OUT"]) : "";
+                $stato = ($deleted === 'DELETED') ? 'ANNULLATA' : '';
+                $activeWorksheet->setCellValue('E' . $count, $stato);
 
-                    $activeWorksheet->setCellValue($letters[$idx] . $count, $inValue);
-                    $idx++;
-                    $activeWorksheet->setCellValue($letters[$idx] . $count, $outValue);
-                    $idx++;
-                } else {
-                    $activeWorksheet->setCellValue($letters[$idx] . $count, "");
-                    $idx++;
-                    $activeWorksheet->setCellValue($letters[$idx] . $count, "");
-                    $idx++;
+                if ($stato === 'ANNULLATA') {
+                    $activeWorksheet->getStyle('E' . $count)->getFont()->getColor()->setARGB('FFFF0000');
                 }
-            }
 
-            $count++;
-            $processed++;
+                Log::debug('Job createExcelFile: Setting payment data for row', ['row' => $count]);
+                $idx = 0;
+                foreach ($this->payments as $p) {
+                    if ($idx >= count($letters) - 1) {
+                        Log::warning('Job createExcelFile: Reached letter limit during payment data', [
+                            'row' => $count,
+                            'payment_index' => $idx
+                        ]);
+                        break;
+                    }
+
+                    if (isset($record[$p['name']])) {
+                        $inValue = isset($record[$p['name']]["IN"]) ? $this->formatPrice($record[$p['name']]["IN"]) : "";
+                        $outValue = isset($record[$p['name']]["OUT"]) ? $this->formatPrice($record[$p['name']]["OUT"]) : "";
+
+                        $activeWorksheet->setCellValue($letters[$idx] . $count, $inValue);
+                        $idx++;
+                        $activeWorksheet->setCellValue($letters[$idx] . $count, $outValue);
+                        $idx++;
+                    } else {
+                        $activeWorksheet->setCellValue($letters[$idx] . $count, "");
+                        $idx++;
+                        $activeWorksheet->setCellValue($letters[$idx] . $count, "");
+                        $idx++;
+                    }
+                }
 
-            if ($processed % $batchSize === 0) {
-                gc_collect_cycles();
+                $count++;
+                $processed++;
+
+                if ($processed % $batchSize === 0) {
+                    $batchNumber++;
+                    Log::info('Job createExcelFile: Batch completed, running garbage collection', [
+                        'batch_number' => $batchNumber,
+                        'processed' => $processed,
+                        'memory_before_gc' => memory_get_usage(true)
+                    ]);
+                    gc_collect_cycles();
+                    Log::info('Job createExcelFile: Garbage collection completed', [
+                        'memory_after_gc' => memory_get_usage(true)
+                    ]);
+                }
+            } catch (\Exception $e) {
+                Log::error('Job createExcelFile: Error processing data row', [
+                    'row' => $count,
+                    'processed_so_far' => $processed,
+                    'causal' => $causal,
+                    'error' => $e->getMessage(),
+                    'trace' => $e->getTraceAsString()
+                ]);
+                throw $e;
             }
         }
 
+        Log::info('Job createExcelFile: Data processing completed, adding totals row', [
+            'total_processed' => $processed,
+            'final_row' => $count,
+            'processing_time' => microtime(true) - $startTime
+        ]);
+
         $count++;
         $activeWorksheet->setCellValue('A' . $count, 'TOTALE');
         $activeWorksheet->setCellValue('B' . $count, '');
@@ -294,9 +386,12 @@ class ExportPrimaNota implements ShouldQueue
         $activeWorksheet->setCellValue('D' . $count, '');
         $activeWorksheet->setCellValue('E' . $count, '');
 
+        Log::info('Job createExcelFile: Setting totals data');
         $idx = 0;
         foreach ($this->payments as $p) {
-            if ($idx >= count($letters) - 1) break;
+            if ($idx >= count($letters) - 1) {
+                break;
+            }
 
             if (isset($this->exportTotals[$p['name']])) {
                 if ($p['type'] == 'ALL') {
@@ -323,14 +418,16 @@ class ExportPrimaNota implements ShouldQueue
             }
         }
 
-        $activeWorksheet->getStyle('A' . $count . ':' . $letters[min(count($letters) - 1, count($this->payments) * 2 + 4)] . $count)
-                       ->getFont()->setBold(true);
+        Log::info('Job createExcelFile: Applying totals row styling');
+        $activeWorksheet->getStyle('A' . $count . ':' . $lastColumnLetter . $count)
+            ->getFont()->setBold(true);
 
-        $activeWorksheet->getStyle('A' . $count . ':' . $letters[min(count($letters) - 1, count($this->payments) * 2 + 4)] . $count)
-                       ->getFill()
-                       ->setFillType(\PhpOffice\PhpSpreadsheet\Style\Fill::FILL_SOLID)
-                       ->getStartColor()->setARGB('FFF0F0F0');
+        $activeWorksheet->getStyle('A' . $count . ':' . $lastColumnLetter . $count)
+            ->getFill()
+            ->setFillType(\PhpOffice\PhpSpreadsheet\Style\Fill::FILL_SOLID)
+            ->getStartColor()->setARGB('FFF0F0F0');
 
+        Log::info('Job createExcelFile: Setting column dimensions');
         $activeWorksheet->getColumnDimension('A')->setWidth(15);
         $activeWorksheet->getColumnDimension('B')->setWidth(25);
         $activeWorksheet->getColumnDimension('C')->setWidth(30);
@@ -341,15 +438,311 @@ class ExportPrimaNota implements ShouldQueue
             $activeWorksheet->getColumnDimension($l)->setWidth(15);
         }
 
+        Log::info('Job createExcelFile: Setting freeze panes');
         $activeWorksheet->freezePane('A3');
 
-        $writer = new Xlsx($spreadsheet);
-        $writer->save($filePath);
+        Log::info('Job createExcelFile: Creating Excel writer and saving file', [
+            'file_path' => $filePath,
+            'memory_before_save' => memory_get_usage(true)
+        ]);
+
+        try {
+            $writerStart = microtime(true);
+            $writer = new Xlsx($spreadsheet);
+            $writer->save($filePath);
+            $writerTime = microtime(true) - $writerStart;
+
+            Log::info('Job createExcelFile: File saved successfully', [
+                'file_path' => $filePath,
+                'file_exists' => file_exists($filePath),
+                'file_size' => file_exists($filePath) ? filesize($filePath) : 0,
+                'writer_time' => $writerTime,
+                'total_time' => microtime(true) - $startTime,
+                'memory_peak' => memory_get_peak_usage(true)
+            ]);
+        } catch (\Exception $e) {
+            Log::error('Job createExcelFile: Error during file save', [
+                'file_path' => $filePath,
+                'error' => $e->getMessage(),
+                'trace' => $e->getTraceAsString(),
+                'memory_usage' => memory_get_usage(true),
+                'time_elapsed' => microtime(true) - $startTime
+            ]);
+            throw $e;
+        }
 
+        Log::info('Job createExcelFile: Cleaning up memory');
         unset($spreadsheet, $activeWorksheet, $writer);
         gc_collect_cycles();
+
+        Log::info('Job createExcelFile: Completed successfully', [
+            'total_time' => microtime(true) - $startTime,
+            'memory_after_cleanup' => memory_get_usage(true)
+        ]);
+    }
+
+    // Generate column letters more efficiently
+    private function generateColumnLetters($count)
+    {
+        $letters = [];
+        for ($i = 0; $i < $count && $i < 100; $i++) { // Limit to prevent infinite loops
+            if ($i < 26) {
+                $letters[] = chr(65 + $i); // A-Z
+            } else {
+                $letters[] = 'A' . chr(65 + ($i - 26)); // AA, AB, AC...
+            }
+        }
+        return $letters;
+    }
+
+    // Build headers more efficiently
+    private function buildHeaders($activeWorksheet, $letters)
+    {
+        // Set basic headers
+        $basicHeaders = [
+            'A1' => 'Data',
+            'B1' => 'Causale',
+            'C1' => 'Dettaglio Causale',
+            'D1' => 'Nominativo',
+            'E1' => 'Stato'
+        ];
+
+        // Use fromArray for faster header setting
+        $activeWorksheet->fromArray(array_values($basicHeaders), null, 'A1', true);
+
+        // Set payment method headers
+        $paymentHeaders = [];
+        $subHeaders = [];
+        $idx = 5; // Start after basic headers (F column = index 5)
+
+        foreach ($this->payments as $p) {
+            if ($idx >= count($letters)) break;
+
+            $paymentHeaders[] = $p['name'];
+            $activeWorksheet->mergeCells($letters[$idx] . '1:' . $letters[$idx + 1] . '1');
+
+            // Sub headers for row 2
+            if ($p['type'] == 'ALL') {
+                $subHeaders[$letters[$idx] . '2'] = 'Entrate';
+                $subHeaders[$letters[$idx + 1] . '2'] = 'Uscite';
+            } elseif ($p['type'] == 'IN') {
+                $subHeaders[$letters[$idx] . '2'] = 'Entrate';
+                $subHeaders[$letters[$idx + 1] . '2'] = '';
+            } elseif ($p['type'] == 'OUT') {
+                $subHeaders[$letters[$idx] . '2'] = '';
+                $subHeaders[$letters[$idx + 1] . '2'] = 'Uscite';
+            }
+
+            $idx += 2;
+        }
+
+        // Set payment headers
+        $col = 5;
+        foreach ($paymentHeaders as $header) {
+            if ($col < count($letters)) {
+                $activeWorksheet->setCellValue($letters[$col] . '1', $header);
+            }
+            $col += 2;
+        }
+
+        // Set sub headers
+        foreach ($subHeaders as $cell => $value) {
+            $activeWorksheet->setCellValue($cell, $value);
+        }
     }
 
+    // Build data rows with batch processing
+    private function buildDataRows($activeWorksheet, $letters)
+    {
+        $rowNum = 3; // Start after headers
+        $batchSize = 100; // Process in smaller batches
+        $batch = [];
+        $batchCount = 0;
+
+        foreach ($this->exportData as $causal => $record) {
+            $parts = explode("§", $causal);
+            $d = $parts[0] ?? '';
+            $c = $parts[1] ?? '';
+            $j = $parts[2] ?? '';
+            $det = $parts[3] ?? '';
+            $deleted = $parts[4] ?? '';
+
+            $detailParts = explode('|', $det);
+            $exportDetail = count($detailParts) > 1 ? implode(', ', array_slice($detailParts, 1)) : $det;
+
+            // Prepare row data
+            $rowData = [
+                !empty($d) ? date("d/m/Y", strtotime($d)) : '',
+                $c,
+                $exportDetail,
+                $j,
+                ($deleted === 'DELETED') ? 'ANNULLATA' : ''
+            ];
+
+            // Add payment method values
+            $idx = 0;
+            foreach ($this->payments as $p) {
+                if ($idx >= count($letters) - 6) break; // Leave room for basic columns
+
+                if (isset($record[$p['name']])) {
+                    $inValue = isset($record[$p['name']]["IN"]) ? $this->formatPrice($record[$p['name']]["IN"]) : "";
+                    $outValue = isset($record[$p['name']]["OUT"]) ? $this->formatPrice($record[$p['name']]["OUT"]) : "";
+                    $rowData[] = $inValue;
+                    $rowData[] = $outValue;
+                } else {
+                    $rowData[] = "";
+                    $rowData[] = "";
+                }
+                $idx += 2;
+            }
+
+            $batch[] = $rowData;
+            $batchCount++;
+
+            // Process batch when it reaches batch size
+            if ($batchCount >= $batchSize) {
+                $this->writeBatchToWorksheet($activeWorksheet, $batch, $rowNum);
+                $rowNum += $batchCount;
+                $batch = [];
+                $batchCount = 0;
+                gc_collect_cycles(); // Force garbage collection
+            }
+        }
+
+        // Process remaining batch
+        if (!empty($batch)) {
+            $this->writeBatchToWorksheet($activeWorksheet, $batch, $rowNum);
+        }
+    }
+
+    // Write batch data efficiently
+    private function writeBatchToWorksheet($activeWorksheet, $batch, $startRow)
+    {
+        if (empty($batch)) return;
+
+        try {
+            // Use fromArray for much faster bulk insertion
+            $activeWorksheet->fromArray($batch, null, 'A' . $startRow, true);
+
+            // Apply conditional formatting for deleted records
+            foreach ($batch as $index => $row) {
+                $currentRow = $startRow + $index;
+                if (isset($row[4]) && $row[4] === 'ANNULLATA') {
+                    $activeWorksheet->getStyle('E' . $currentRow)
+                        ->getFont()->getColor()->setARGB('FFFF0000');
+                }
+            }
+        } catch (\Exception $e) {
+            Log::error('Error writing batch to worksheet', [
+                'error' => $e->getMessage(),
+                'batch_size' => count($batch),
+                'start_row' => $startRow
+            ]);
+
+            // Fallback to individual cell setting
+            foreach ($batch as $index => $row) {
+                $currentRow = $startRow + $index;
+                foreach ($row as $colIndex => $value) {
+                    $col = $this->getColumnLetter($colIndex);
+                    $activeWorksheet->setCellValue($col . $currentRow, $value);
+                }
+            }
+        }
+    }
+
+    // Helper to get column letter by index
+    private function getColumnLetter($index)
+    {
+        if ($index < 26) {
+            return chr(65 + $index);
+        } else {
+            return 'A' . chr(65 + ($index - 26));
+        }
+    }
+
+    // Build totals row efficiently
+    private function buildTotalsRow($activeWorksheet, $letters)
+    {
+        $totalRows = count($this->exportData) + 3; // +3 for headers and spacing
+        $totalRow = $totalRows + 1;
+
+        $totalsData = ['TOTALE', '', '', '', ''];
+
+        $idx = 0;
+        foreach ($this->payments as $p) {
+            if ($idx >= count($letters) - 6) break;
+
+            if (isset($this->exportTotals[$p['name']])) {
+                if ($p['type'] == 'ALL') {
+                    $totalsData[] = $this->formatPrice($this->exportTotals[$p['name']]["IN"] ?? 0);
+                    $totalsData[] = $this->formatPrice($this->exportTotals[$p['name']]["OUT"] ?? 0);
+                } elseif ($p['type'] == 'IN') {
+                    $totalsData[] = $this->formatPrice($this->exportTotals[$p['name']]["IN"] ?? 0);
+                    $totalsData[] = "";
+                } elseif ($p['type'] == 'OUT') {
+                    $totalsData[] = "";
+                    $totalsData[] = $this->formatPrice($this->exportTotals[$p['name']]["OUT"] ?? 0);
+                }
+            } else {
+                $totalsData[] = "0,00";
+                $totalsData[] = "0,00";
+            }
+            $idx += 2;
+        }
+
+        // Write totals row
+        $activeWorksheet->fromArray([$totalsData], null, 'A' . $totalRow, true);
+    }
+
+    // Apply styles more efficiently
+    private function applyStylesEfficiently($activeWorksheet, $letters)
+    {
+        $maxCol = min(count($letters) - 1, count($this->payments) * 2 + 4);
+        $lastCol = $letters[$maxCol];
+        $totalRows = count($this->exportData) + 4; // +4 for headers, spacing, and totals
+
+        // Apply header styles
+        $headerRange = 'A1:' . $lastCol . '2';
+        $activeWorksheet->getStyle($headerRange)->getFont()->setBold(true);
+
+        // Apply header background
+        $activeWorksheet->getStyle('A1:' . $lastCol . '1')
+            ->getFill()
+            ->setFillType(\PhpOffice\PhpSpreadsheet\Style\Fill::FILL_SOLID)
+            ->getStartColor()->setARGB('FF0C6197');
+
+        $activeWorksheet->getStyle('A1:' . $lastCol . '1')
+            ->getFont()->getColor()->setARGB('FFFFFFFF');
+
+        // Apply totals row styles
+        $totalsRange = 'A' . $totalRows . ':' . $lastCol . $totalRows;
+        $activeWorksheet->getStyle($totalsRange)->getFont()->setBold(true);
+        $activeWorksheet->getStyle($totalsRange)
+            ->getFill()
+            ->setFillType(\PhpOffice\PhpSpreadsheet\Style\Fill::FILL_SOLID)
+            ->getStartColor()->setARGB('FFF0F0F0');
+    }
+
+    // Set column dimensions efficiently
+    private function setColumnDimensions($activeWorksheet, $letters)
+    {
+        $dimensions = [
+            'A' => 15,
+            'B' => 25,
+            'C' => 30,
+            'D' => 25,
+            'E' => 15
+        ];
+
+        foreach ($dimensions as $col => $width) {
+            $activeWorksheet->getColumnDimension($col)->setWidth($width);
+        }
+
+        // Set payment method column widths
+        for ($i = 5; $i < count($letters) && $i < 50; $i++) { // Limit to prevent excessive loops
+            $activeWorksheet->getColumnDimension($letters[$i])->setWidth(15);
+        }
+    }
     /**
      * Format price for display
      */
@@ -375,4 +768,124 @@ class ExportPrimaNota implements ShouldQueue
 
         return empty($descriptions) ? 'Nessun filtro applicato' : implode(' | ', $descriptions);
     }
+
+    public function executeWithTimeoutMonitoring($callback, $description = 'Operation')
+    {
+        $startTime = microtime(true);
+        $maxExecutionTime = ini_get('max_execution_time');
+
+        Log::info("Starting monitored operation: {$description}", [
+            'start_time' => $startTime,
+            'max_execution_time' => $maxExecutionTime,
+            'memory_start' => memory_get_usage(true)
+        ]);
+
+        try {
+            // Execute every 5 seconds to monitor progress
+            $lastCheck = $startTime;
+            $result = null;
+
+            // For non-blocking operations, we can't easily interrupt,
+            // but we can log progress
+            register_tick_function(function () use ($startTime, $maxExecutionTime, $description, &$lastCheck) {
+                $currentTime = microtime(true);
+                if ($currentTime - $lastCheck >= 5) { // Log every 5 seconds
+                    $elapsed = $currentTime - $startTime;
+                    $remaining = $maxExecutionTime > 0 ? $maxExecutionTime - $elapsed : 'unlimited';
+
+                    Log::info("Operation progress: {$description}", [
+                        'elapsed_time' => $elapsed,
+                        'remaining_time' => $remaining,
+                        'memory_current' => memory_get_usage(true),
+                        'memory_peak' => memory_get_peak_usage(true)
+                    ]);
+
+                    if ($maxExecutionTime > 0 && $elapsed > ($maxExecutionTime * 0.8)) {
+                        Log::warning("Operation approaching timeout: {$description}", [
+                            'elapsed_time' => $elapsed,
+                            'max_time' => $maxExecutionTime,
+                            'percentage_used' => ($elapsed / $maxExecutionTime) * 100
+                        ]);
+                    }
+
+                    $lastCheck = $currentTime;
+                }
+            });
+
+            declare(ticks=1000);
+            $result = $callback();
+
+            $totalTime = microtime(true) - $startTime;
+            Log::info("Operation completed successfully: {$description}", [
+                'total_time' => $totalTime,
+                'memory_peak' => memory_get_peak_usage(true)
+            ]);
+
+            return $result;
+        } catch (\Exception $e) {
+            $totalTime = microtime(true) - $startTime;
+            Log::error("Operation failed: {$description}", [
+                'error' => $e->getMessage(),
+                'total_time' => $totalTime,
+                'memory_peak' => memory_get_peak_usage(true),
+                'trace' => $e->getTraceAsString()
+            ]);
+            throw $e;
+        }
+    }
+
+    private function checkTimeoutRisk($operationName, $startTime = null)
+    {
+        if ($startTime === null) {
+            $startTime = $_SERVER['REQUEST_TIME_FLOAT'] ?? microtime(true);
+        }
+
+        $maxExecutionTime = ini_get('max_execution_time');
+        if ($maxExecutionTime <= 0) {
+            return false; // No limit set
+        }
+
+        $elapsed = microtime(true) - $startTime;
+        $remaining = $maxExecutionTime - $elapsed;
+        $percentageUsed = ($elapsed / $maxExecutionTime) * 100;
+
+        Log::info("Timeout check: {$operationName}", [
+            'elapsed_time' => $elapsed,
+            'remaining_time' => $remaining,
+            'percentage_used' => $percentageUsed,
+            'memory_usage' => memory_get_usage(true)
+        ]);
+
+        if ($percentageUsed > 80) {
+            Log::warning("High timeout risk detected: {$operationName}", [
+                'elapsed_time' => $elapsed,
+                'remaining_time' => $remaining,
+                'percentage_used' => $percentageUsed
+            ]);
+            return true;
+        }
+
+        return false;
+    }
+
+    // SOLUTION 8: Log configuration and environment info at start
+
+    public function logEnvironmentInfo()
+    {
+        Log::info('=== EXPORT ENVIRONMENT INFO ===', [
+            'php_version' => PHP_VERSION,
+            'memory_limit' => ini_get('memory_limit'),
+            'max_execution_time' => ini_get('max_execution_time'),
+            'max_input_time' => ini_get('max_input_time'),
+            'post_max_size' => ini_get('post_max_size'),
+            'upload_max_filesize' => ini_get('upload_max_filesize'),
+            'default_socket_timeout' => ini_get('default_socket_timeout'),
+            'current_memory_usage' => memory_get_usage(true),
+            'current_memory_peak' => memory_get_peak_usage(true),
+            'server_time' => date('Y-m-d H:i:s'),
+            'timezone' => date_default_timezone_get(),
+            'sapi_name' => php_sapi_name(),
+            'loaded_extensions' => get_loaded_extensions()
+        ]);
+    }
 }