iao_team/app/Http/Livewire/Record.php

<?php

namespace App\Http\Livewire;

use Livewire\Component;
use DateInterval;
use DatePeriod;
use DateTime;

use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Mail;
use App\Mail\ExportNotification;
use App\Jobs\ExportPrimaNota;

class Record extends Component
{
    public $records, $dataId, $totals;
    public $in;
    public $out;
    public $payments = [];
    public $fromDate;
    public $toDate;
    public $appliedFromDate;
    public $appliedToDate;
    public $exportFromDate;
    public $exportToDate;
    public $isExporting = false;
    public $selectedPeriod = 'OGGI';
    public $filterCausals = null;
    public $filterMember = null;
    public $isFiltering = false;
    public array $recordDatas = [];
    public array $labels = [];
    public array $causals = [];
    public $members = array();
    public $sendViaEmail = false;
    public $exportEmailAddress = '';
    public $exportEmailSubject = 'Prima Nota - Export';
    private $causalAmounts = [];
    public $selectedMonth;
    public $showMonthPicker = false;
    public $selectedDay;
    public $showDayPicker = false;
    public $selectedYear;
    protected $rules = [
        'exportEmailAddress' => 'required_if:sendViaEmail,true|email',
        'exportEmailSubject' => 'required_if:sendViaEmail,true|string|max:255',
    ];

    protected $messages = [
        'exportEmailAddress.required_if' => 'L\'indirizzo email è obbligatorio quando si sceglie di inviare via email.',
        'exportEmailAddress.email' => 'Inserisci un indirizzo email valido.',
        'exportEmailSubject.required_if' => 'L\'oggetto dell\'email è obbligatorio.',
        'exportEmailSubject.max' => 'L\'oggetto dell\'email non può superare i 255 caratteri.',
    ];

    public function hydrate()
    {
        $this->emit('load-select');
    }

    public function mount()
    {
        $this->fromDate = date("Y-m-d");
        $this->toDate = date("Y-m-d");

        $this->appliedFromDate = date("Y-m-d");
        $this->appliedToDate = date("Y-m-d");

        $this->exportFromDate = date("Y-m-d");
        $this->exportToDate = date("Y-m-d");

        $this->exportEmailSubject = 'Prima Nota - Export del ' . date('d/m/Y');

        $this->getCausals(\App\Models\Causal::select('id', 'name')->where('parent_id', null)->get(), 0);

        $this->members = \App\Models\Member::select(['id', 'first_name', 'last_name', 'fiscal_code'])
            ->where(function($query) {
                $query->where('is_archived', false)
                    ->orWhereNull('is_archived');
            })
            ->where(function($query) {
                $query->where('is_deleted', false)
                    ->orWhereNull('is_deleted');
            })->orderBy('last_name')->orderBy('first_name')->get();

        $this->payments = \App\Models\PaymentMethod::select('id', 'name', 'type')->where('enabled', true)->where('money', false)->get();

        $this->selectedMonth = date('Y-m');
        $this->selectedDay = date('Y-m-d');
        $this->selectedYear = date('Y');
    }
    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.*',
                'records_rows.id as row_id',
                'records_rows.record_id',
                'records_rows.causal_id',
                'records_rows.amount',
                'records_rows.note',
                'records_rows.when',
                'records_rows.vat_id',
                'records_rows.created_at as row_created_at',
                'records_rows.updated_at as row_updated_at'
            )
            ->join('records_rows', 'records.id', '=', 'records_rows.record_id')
            //->where('records.deleted', false)
            ->where(function ($query) {
                $query->where('records.deleted', false)->orWhereNull('records.deleted');
            })
            ->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);
                    });
            });

        Log::info('generateExportDataAndTotals: Applying causal filters');
        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;
                    }
                }
            }
            $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) {
            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)
                ]);
            }

            try {
                $causalCheck = \App\Models\Causal::findOrFail($data->causal_id);
                $paymentCheck = $data->payment_method->money;

                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;
                    }

                    // CALCULATE TOTALS HERE (in the same loop)
                    /*if (!$data->deleted) {
                        $exportTotals[$data->payment_method->name][$data->type] += $amount;
                    }*/

                    $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;

                    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;

                    if (!empty($data->note)) {
                        $groupedData[$groupKey]['notes'][] = $data->note;
                    }

                    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);

        $tot = 0;
        $count = 0;

        foreach ($groupedData as $groupKey => $group) {
            $causalsInGroup = array_keys($causalsCount[$groupKey]);

            $causalDisplay = $group['type_label'];

            if (count($causalsInGroup) > 1) {
                $detailDisplay = 'Varie|' . implode('|', $causalsInGroup);
            } else {
                $detailDisplay = $causalsInGroup[0];
            }

            $recordKey = $group['date'] . "§" . $causalDisplay . "§" . $group['nominativo'] . "§" . $detailDisplay . "§" . ($group['deleted'] ? 'DELETED' : '') . "§";

            if (!isset($exportRecords[$recordKey][$group['payment_method']][$group['transaction_type']])) {
                $exportRecords[$recordKey][$group['payment_method']][$group['transaction_type']] = 0;
            }

            $exportRecords[$recordKey][$group['payment_method']][$group['transaction_type']] += $group['amount'];

            if (!$group['deleted'])
                $exportTotals[$group['payment_method']][$group['transaction_type']] += $group['amount'];

        }

        $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)
    {
        $exportTotals = array();

        $exclude_from_records = \App\Models\Member::where('exclude_from_records', true)->pluck('id')->toArray();

        $datas = \App\Models\Record::with('member', 'supplier', 'payment_method')
            ->select(
                'records.*',
                'records_rows.id as row_id',
                'records_rows.record_id',
                'records_rows.causal_id',
                'records_rows.amount',
                'records_rows.note',
                'records_rows.when',
                'records_rows.vat_id',
            )
            ->join('records_rows', 'records.id', '=', 'records_rows.record_id')
            //->where('records.deleted', false)
            ->where(function ($query) {
                $query->where('records.deleted', false)->orWhereNull('records.deleted');
            })
            ->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;
                    }
                }
            }
            $datas->whereIn('causal_id', $causals);
        }
        if ($this->filterMember != null && $this->filterMember > 0) {
            $datas->where('member_id', $this->filterMember);
        }
        $datas = $datas->orderBy('date', 'ASC')
            ->orderBy('records.created_at', 'ASC')
            ->orderBy('records_rows.id', 'ASC')
            ->get();

        foreach ($datas as $data) {
            $causalCheck = \App\Models\Causal::findOrFail($data->causal_id);
            $paymentCheck = $data->payment_method->money;

            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;
                }

                if (!isset($exportTotals[$data->payment_method->name])) {
                    $exportTotals[$data->payment_method->name]["IN"] = 0;
                    $exportTotals[$data->payment_method->name]["OUT"] = 0;
                }

                if (!$data->deleted)
                    $exportTotals[$data->payment_method->name][$data->type] += $amount;
            }
        }

        return $exportTotals;
    }
    public function resetFilters()
    {
        $this->selectedPeriod = 'OGGI';
        $this->selectedMonth = date('Y-m');
        $this->selectedDay = date('Y-m-d');
        $this->selectedYear = date('Y');
        $this->showMonthPicker = false;
        $this->showDayPicker = false;
        $this->filterCausals = [];
        $this->filterMember = null;

        $today = date("Y-m-d");
        $this->fromDate = $today;
        $this->toDate = $today;
        $this->appliedFromDate = $today;
        $this->appliedToDate = $today;

        $this->emit('filters-reset');
    }


    public function applyFilters()
    {
        $this->isFiltering = true;

        $this->setPeriodDates();

        $this->appliedFromDate = $this->fromDate;
        $this->appliedToDate = $this->toDate;

        $this->render();

        $this->isFiltering = false;

        $this->emit('filters-applied');
    }

    private function setPeriodDates()
    {
        $today = now();

        switch ($this->selectedPeriod) {
            case 'OGGI':
                $this->fromDate = $today->format('Y-m-d');
                $this->toDate = $today->format('Y-m-d');
                break;

            case 'IERI':
                $yesterday = $today->copy()->subDay();
                $this->fromDate = $yesterday->format('Y-m-d');
                $this->toDate = $yesterday->format('Y-m-d');
                break;

            case 'MESE CORRENTE':
                $this->fromDate = $today->copy()->startOfMonth()->format('Y-m-d');
                $this->toDate = $today->copy()->endOfMonth()->format('Y-m-d');
                break;

            case 'MESE PRECEDENTE':
                $lastMonth = $today->copy()->subMonth();
                $this->fromDate = $lastMonth->startOfMonth()->format('Y-m-d');
                $this->toDate = $lastMonth->endOfMonth()->format('Y-m-d');
                break;

            case 'MESE_PERSONALIZZATO':
                if (!empty($this->selectedMonth)) {
                    $firstDay = date('Y-m-01', strtotime($this->selectedMonth . '-01'));
                    $lastDay = date('Y-m-t', strtotime($this->selectedMonth . '-01'));
                    $this->fromDate = $firstDay;
                    $this->toDate = $lastDay;
                }
                break;

            case 'GIORNO_PERSONALIZZATO':
                if (!empty($this->selectedDay)) {
                    $this->fromDate = $this->selectedDay;
                    $this->toDate = $this->selectedDay;
                }
                break;

            case 'ULTIMO TRIMESTRE':
                $this->fromDate = $today->copy()->subMonths(3)->format('Y-m-d');
                $this->toDate = $today->format('Y-m-d');
                break;

            case 'ULTIMO QUADRIMESTRE':
                $this->fromDate = $today->copy()->subMonths(4)->format('Y-m-d');
                $this->toDate = $today->format('Y-m-d');
                break;
        }
    }
    public function getCausals($records, $indentation)
    {
        foreach ($records as $record) {
            $this->causals[] = array('id' => $record->id, 'name' => $record->getTree(), 'text' => $record->getTree(), 'level' => $indentation);
            if (count($record->childs))
                $this->getCausals($record->childs, $indentation + 1);
        }
    }

    public function getMonth($m)
    {
        $ret = '';
        switch ($m) {
            case 1:
                $ret = 'Gennaio';
                break;
            case 2:
                $ret = 'Febbraio';
                break;
            case 3:
                $ret = 'Marzo';
                break;
            case 4:
                $ret = 'Aprile';
                break;
            case 5:
                $ret = 'Maggio';
                break;
            case 6:
                $ret = 'Giugno';
                break;
            case 7:
                $ret = 'Luglio';
                break;
            case 8:
                $ret = 'Agosto';
                break;
            case 9:
                $ret = 'Settembre';
                break;
            case 10:
                $ret = 'Ottobre';
                break;
            case 11:
                $ret = 'Novembre';
                break;
            case 12:
                $ret = 'Dicembre';
                break;
            default:
                $ret = '';
                break;
        }
        return $ret;
    }



    public function render()
    {
        $month = 0;
        $year = 0;

        $this->records = array();
        $this->totals = array();
        $this->causalAmounts = array();

        $exclude_from_records = \App\Models\Member::where('exclude_from_records', true)->pluck('id')->toArray();

        $datas = \App\Models\Record::with('member', 'supplier', 'payment_method')
            ->select(
                'records.*',
                'records_rows.id as row_id',
                'records_rows.record_id',
                'records_rows.causal_id',
                'records_rows.amount',
                'records_rows.note',
                'records_rows.when',
                'records_rows.vat_id',
            )
            ->join('records_rows', 'records.id', '=', 'records_rows.record_id')
            //->where('records.deleted', false)
            ->where(function ($query) {
                $query->where('records.deleted', false)->orWhereNull('records.deleted');
            })
            ->whereBetween('date', [$this->appliedFromDate . " 00:00:00", $this->appliedToDate . " 23:59:59"])
            ->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;
                    }
                }
            }
            $datas->whereIn('causal_id', $causals);
        }
        if ($this->filterMember != null && $this->filterMember > 0) {
            $datas->where('member_id', $this->filterMember);
        }
        $datas = $datas->orderBy('date', 'ASC')
            ->orderBy('records.created_at', 'ASC')
            ->orderBy('records_rows.id', 'ASC')
            ->get();

        $groupedData = [];
        $causalsCount = [];
        $causalsAmounts = [];
        $nominativi = [];

        $values = [];

        foreach ($datas as $idx => $data) {

            $causalCheck = \App\Models\Causal::findOrFail($data->causal_id);
            $paymentCheck = $data->payment_method->money;

            if (!$paymentCheck && ($causalCheck->no_first == null || !$causalCheck->no_first)) {

                if (!$data->deleted) {
                    $amount = $data->amount;
                    if ($data->vat_id > 0)
                        $amount += getVatValue($amount, $data->vat_id);
                } else {
                    $amount = $data->amount;
                }

                $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;
                    }
                    if ($data->payment_method_id == 7)
                        $values[] = array('id' => $data->record_id, 'amount' => $amount);
                } else {
                    if ($data->supplier) {
                        $nominativo = $data->supplier->name;
                    }
                }

                $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] = [];
                    $causalsAmounts[$groupKey] = []; // Initialize causal amounts for this group
                    $nominativi[$groupKey] = $nominativo;
                }

                $groupedData[$groupKey]['amount'] += $amount;
                $causalsCount[$groupKey][$causalCheck->getTree()] = true;

                $causalName = $causalCheck->getTree();
                if (!isset($causalsAmounts[$groupKey][$causalName])) {
                    $causalsAmounts[$groupKey][$causalName] = 0;
                }
                $causalsAmounts[$groupKey][$causalName] += $amount;

                if (!empty($data->note)) {
                    $groupedData[$groupKey]['notes'][] = $data->note;
                }
                if ($data->deleted) {
                    $groupedData[$groupKey]['deleted'] = true;
                }
            }
        }

        Log::info('values', [$values]);

        foreach ($groupedData as $groupKey => $group) {
            $causalsInGroup = array_keys($causalsCount[$groupKey]);

            $causalDisplay = $group['type_label'];

            if (count($causalsInGroup) > 1) {
                $causalAmountsForJs = [];
                foreach ($causalsInGroup as $causalName) {
                    $causalAmountsForJs[] = $causalName . ':::' . formatPrice($causalsAmounts[$groupKey][$causalName]);
                }
                $detailDisplay = 'Varie|' . implode('|', $causalAmountsForJs);
            } else {
                $detailDisplay = $causalsInGroup[0];
            }

            $recordKey = $group['date'] . "§" . $causalDisplay . "§" . $group['nominativo'] . "§" . $detailDisplay . "§" . ($group['deleted'] ? 'DELETED' : '') . "§";

            if (!isset($this->records[$recordKey][$group['payment_method']][$group['transaction_type']])) {
                $this->records[$recordKey][$group['payment_method']][$group['transaction_type']] = 0;
            }

            $this->records[$recordKey][$group['payment_method']][$group['transaction_type']] += $group['amount'];

            if (!isset($this->totals[$group['payment_method']])) {
                $this->totals[$group['payment_method']]["IN"] = 0;
                $this->totals[$group['payment_method']]["OUT"] = 0;
            }

            if (!$group['deleted'])
                $this->totals[$group['payment_method']][$group['transaction_type']] += $group['amount'];
        }

        return view('livewire.records');
    }

    private function getLabels($fromDate, $toDate)
    {
        $begin = new DateTime($fromDate);
        $end = new DateTime($toDate);

        $interval = DateInterval::createFromDateString('1 day');
        $date_range = new DatePeriod($begin, $interval, $end);
        foreach ($date_range as $date) {
            $labels[] = $date->format('d/M');
        }

        return $labels;
    }

    private function getRecordData($type, $fromDate, $toDate)
    {
        $data = [];
        $begin = new DateTime($fromDate);
        $end = new DateTime($toDate);

        $interval = DateInterval::createFromDateString('1 day');
        $date_range = new DatePeriod($begin, $interval, $end);

        foreach ($date_range as $date) {
            if ($type == 'IN') {
                $found = false;
                foreach ($this->in as $in) {
                    if (date("Y-m-d", strtotime($in->date)) == $date->format('Y-m-d')) {
                        $data[] = number_format($in->total, 0, "", "");
                        $found = true;
                    }
                }
                if (!$found)
                    $data[] = 0;
            }
            if ($type == 'OUT') {
                $found = false;
                foreach ($this->out as $out) {
                    if (date("Y-m-d", strtotime($out->date)) == $date->format('Y-m-d')) {
                        $data[] = number_format($out->total, 0, "", "");
                        $found = true;
                    }
                }
                if (!$found)
                    $data[] = 0;
            }
        }

        return $data;
    }

    public function openExportModal()
    {
        $this->exportFromDate = $this->appliedFromDate;
        $this->exportToDate = $this->appliedToDate;

        // Reset email options
        $this->sendViaEmail = false;
        $this->exportEmailAddress = $this->getPreferredEmail();
        $this->updateEmailSubject();

        $this->emit('show-export-modal');
    }

    public function exportWithDateRange()
    {

        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')
        ]);

        $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 {
            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'];

            Log::info('TOTALS', [$exportTotals]);

            $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) {
                Log::info('Export: Dispatching to background job');
                $this->dispatchExportJob($exportRecords, $exportTotals);
                Log::info('Export: Job dispatched successfully');
            } else {
                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;

            if ($this->sendViaEmail) {
                $this->emit('export-email-error', 'Errore durante l\'invio dell\'email: ' . $e->getMessage());
            } else {
                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)
    {
        $member = \App\Models\Member::find($memberId);
        return $member ? $member->last_name . ' ' . $member->first_name : 'Sconosciuto';
    }

    private function getCausalsNames($causalIds)
    {
        if (!is_array($causalIds)) {
            return null;
        }

        $causals = \App\Models\Causal::whereIn('id', $causalIds)->pluck('name')->toArray();
        return implode(', ', $causals);
    }

    public function updatedExportFromDate()
    {
        $this->updateEmailSubject();
    }

    public function updatedExportToDate()
    {
        $this->updateEmailSubject();
    }

    public function updatedSendViaEmail($value)
    {
        if ($value && empty($this->exportEmailAddress)) {
            $this->exportEmailAddress = $this->getPreferredEmail();
        }
    }

    public function resetEmailForm()
    {
        $this->sendViaEmail = false;
        $this->exportEmailAddress = $this->getPreferredEmail();
        $this->updateEmailSubject();
    }

    private function updateEmailSubject()
    {
        if (!empty($this->exportFromDate) && !empty($this->exportToDate)) {
            $fromFormatted = date('d/m/Y', strtotime($this->exportFromDate));
            $toFormatted = date('d/m/Y', strtotime($this->exportToDate));

            if ($this->exportFromDate === $this->exportToDate) {
                $this->exportEmailSubject = "Prima Nota - Export del {$fromFormatted}";
            } else {
                $this->exportEmailSubject = "Prima Nota - Export dal {$fromFormatted} al {$toFormatted}";
            }
        }
    }


    /**
     * Dispatch export job to queue
     */
    private function dispatchExportJob($exportRecords, $exportTotals)
    {
        try {
            // Prepare filter descriptions for the job
            $filterDescriptions = [
                'member' => $this->filterMember ? $this->getMemberName($this->filterMember) : null,
                'causals' => $this->filterCausals ? $this->getCausalsNames($this->filterCausals) : null,
            ];

            $paymentsArray = $this->payments->map(function ($payment) {
                return [
                    'id' => $payment->id,
                    'name' => $payment->name,
                    'type' => $payment->type
                ];
            })->toArray();

            // Dispatch job to background queue
            ExportPrimaNota::dispatch(
                $exportRecords,
                $exportTotals,
                $this->exportEmailAddress,
                $this->exportEmailSubject,
                [
                    'from' => date('d/m/Y', strtotime($this->exportFromDate)),
                    'to' => date('d/m/Y', strtotime($this->exportToDate))
                ],
                auth()->id(),
                $paymentsArray,
                $filterDescriptions
            );

            $this->emit('export-email-queued');
            session()->flash('success', 'Export in corso! Riceverai l\'email a breve alla casella: ' . $this->exportEmailAddress);

            Log::info('Export job dispatched', [
                'user_id' => auth()->id(),
                'email' => $this->exportEmailAddress,
                'date_range' => [$this->exportFromDate, $this->exportToDate],
                'total_records' => count($exportRecords)
            ]);
        } catch (\Exception $e) {
            Log::error('Failed to dispatch export job', [
                'user_id' => auth()->id(),
                'email' => $this->exportEmailAddress,
                'error' => $e->getMessage()
            ]);

            throw new \Exception('Errore nell\'avvio dell\'export: ' . $e->getMessage());
        }
    }


    function export()
    {
        $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', "Tipologia");
        $activeWorksheet->setCellValue('C1', "Causale");
        $activeWorksheet->setCellValue('D1', "Nominativo");
        $activeWorksheet->setCellValue('E1', "Stato");

        $activeWorksheet->getStyle('A1:Q1')->getFill()
            ->setFillType(\PhpOffice\PhpSpreadsheet\Style\Fill::FILL_SOLID)
            ->getStartColor()->setARGB('FF0C6197');

        $activeWorksheet->getStyle('A1:Q1')->getFont()->getColor()->setARGB('FFFFFFFF');


        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)) {
                break;
            }
            $activeWorksheet->mergeCells($letters[$idx] . '1:' . $letters[$idx] . '1');
            $idx++;
        }

        Log::info('exportWithData: Setting sub-headers');
        $idx = 0;
        $activeWorksheet->setCellValue('A2', "");
        $activeWorksheet->setCellValue('B2', "");
        $activeWorksheet->setCellValue('C2', "");
        $activeWorksheet->setCellValue('D2', "");
        $activeWorksheet->setCellValue('E2', "");

        foreach ($this->payments as $p) {
            if ($p->type == 'ALL') {
                if ($idx >= count($letters)) {
                    break;
                }
                $activeWorksheet->setCellValue($letters[$idx] . '2', "Entrate");
                $idx++;
                $activeWorksheet->setCellValue($letters[$idx] . '2', "Uscite");
                $idx++;
            } elseif ($p->type == 'IN') {
                if ($idx >= count($letters)) {
                    break;
                }
                $activeWorksheet->setCellValue($letters[$idx] . '2', "Entrate");
                $idx++;
                $activeWorksheet->setCellValue($letters[$idx] . '2', "");
                $idx++;
            } elseif ($p->type == 'OUT') {
                if ($idx >= count($letters)) {
                    break;
                }
                $activeWorksheet->setCellValue($letters[$idx] . '2', "");
                $idx++;
                $activeWorksheet->setCellValue($letters[$idx] . '2', "Uscite");
                $idx++;
            }
        }

        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 ($recordsBatch as $causal => $record) {
                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
                    ]);
                }

                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');
                    }

                    $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++;

                    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;

        $activeWorksheet->setCellValue('A' . $count, 'Totale');
        $activeWorksheet->setCellValue('B' . $count, '');
        $activeWorksheet->setCellValue('C' . $count, '');
        $activeWorksheet->setCellValue('D' . $count, '');
        $activeWorksheet->setCellValue('E' . $count, '');

        foreach ($this->payments as $p) {
            if ($idx >= count($letters) - 1) {
                break;
            }

            if (isset($exportTotals[$p->name])) {
                if ($p->type == 'ALL') {
                    $activeWorksheet->setCellValue($letters[$idx] . $count, formatPrice($exportTotals[$p->name]["IN"] ?? 0));
                    $idx++;
                    $activeWorksheet->setCellValue($letters[$idx] . $count, formatPrice($exportTotals[$p->name]["OUT"] ?? 0));
                    $idx++;
                } elseif ($p->type == 'IN') {
                    $activeWorksheet->setCellValue($letters[$idx] . $count, formatPrice($exportTotals[$p->name]["IN"] ?? 0));
                    $idx++;
                    $activeWorksheet->setCellValue($letters[$idx] . $count, "");
                    $idx++;
                } elseif ($p->type == 'OUT') {
                    $activeWorksheet->setCellValue($letters[$idx] . $count, "");
                    $idx++;
                    $activeWorksheet->setCellValue($letters[$idx] . $count, formatPrice($exportTotals[$p->name]["OUT"] ?? 0));
                    $idx++;
                }
            } else {
                if ($p->type == 'ALL') {
                    $activeWorksheet->setCellValue($letters[$idx] . $count, "0");
                    $idx++;
                    $activeWorksheet->setCellValue($letters[$idx] . $count, "0");
                    $idx++;
                } elseif ($p->type == 'IN') {
                    $activeWorksheet->setCellValue($letters[$idx] . $count, "0");
                    $idx++;
                    $activeWorksheet->setCellValue($letters[$idx] . $count, "");
                    $idx++;
                } elseif ($p->type == 'OUT') {
                    $activeWorksheet->setCellValue($letters[$idx] . $count, "");
                    $idx++;
                    $activeWorksheet->setCellValue($letters[$idx] . $count, "0");
                    $idx++;
                }
            }
        }

        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);
        $activeWorksheet->getColumnDimension('D')->setWidth(40);
        $activeWorksheet->getColumnDimension('E')->setWidth(20);
        foreach ($letters as $l) {
            $activeWorksheet->getColumnDimension($l)->setWidth(20);
        }

        $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';
            if (!$disk->exists($primaNotaFolderPath)) {
                $disk->put($primaNotaFolderPath, '');
                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("Export completed successfully", [
                'client' => $currentClient,
                'path' => $s3Path,
                '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)) {
                unlink($tempPath);
            }

            $downloadUrl = $disk->temporaryUrl($s3Path, now()->addHour());
            return redirect($downloadUrl);
        } catch (\Exception $e) {
            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,
                'time_elapsed' => microtime(true) - $startTime
            ]);

            // Fallback logic remains the same...
            $currentClient = session('currentClient', 'default');
            $clientFolder = storage_path('app/prima_nota/' . $currentClient);

            if (!is_dir($clientFolder)) {
                mkdir($clientFolder, 0755, true);
                Log::info("Created local client prima_nota folder: {$clientFolder}");
            }

            $localPath = $clientFolder . '/' . $filename;

            if (isset($tempPath) && file_exists($tempPath)) {
                rename($tempPath, $localPath);
            } else {
                $writer = new Xlsx($spreadsheet);
                $writer->save($localPath);
                unset($spreadsheet, $activeWorksheet, $writer);
            }

            gc_collect_cycles();

            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();
        }
    }

    private function getPreferredEmail()
    {
        $email = auth()->user()->email ?? null;

        if (empty($email)) {
            $email = session('user_email', null);
        }

        if (empty($email)) {
            $member = \App\Models\Member::where('user_id', auth()->id())->first();
            $email = $member ? $member->email : null;
        }

        if (empty($email)) {
            $email = config('mail.default_recipient', '');
        }

        return $email;
    }

        public function updatedSelectedDay($value)
    {
        if (!empty($value)) {
            $this->selectedPeriod = 'GIORNO_PERSONALIZZATO';
            $this->fromDate = $value;
            $this->toDate = $value;
            $this->applyFilters();
        }
    }

    public function selectDay($day)
    {
        $this->selectedDay = $day;
        $this->showDayPicker = false;
        $this->updatedSelectedDay($day);
    }

    public function toggleDayPicker()
    {
        $this->showDayPicker = !$this->showDayPicker;
    }

    public function selectToday()
    {
        $today = date('Y-m-d');
        $this->selectDay($today);
    }

    public function selectYesterday()
    {
        $yesterday = date('Y-m-d', strtotime('-1 day'));
        $this->selectDay($yesterday);
    }

    // Updated month methods to work with both custom month and day
    public function updatedSelectedMonth($value)
    {
        if (!empty($value)) {
            $this->selectedPeriod = 'MESE_PERSONALIZZATO';
            $firstDay = date('Y-m-01', strtotime($value . '-01'));
            $lastDay = date('Y-m-t', strtotime($value . '-01'));
            $this->fromDate = $firstDay;
            $this->toDate = $lastDay;
            $this->applyFilters();
        }
    }

    public function selectMonth($month)
    {
        $this->selectedMonth = $month;
        $this->showMonthPicker = false;
        $this->updatedSelectedMonth($month);
    }

    public function toggleMonthPicker()
    {
        $this->showMonthPicker = !$this->showMonthPicker;
    }
}