<?php

    namespace Modules\Webstatement\Http\Controllers;

use App\Http\Controllers\Controller;
use Carbon\Carbon;
use Exception;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\{Auth, DB, Log, Mail, Storage};
use Modules\Basicdata\Models\Branch;
use Modules\Webstatement\{
    Http\Requests\PrintStatementRequest,
    Mail\StatementEmail,
    Models\PrintStatementLog,
    Models\Account,
    Models\AccountBalance,
    Jobs\ExportStatementPeriodJob
};
use ZipArchive;

    class PrintStatementController extends Controller
    {
        /**
         * Display a listing of the statements.
         */
        public function index(Request $request)
        {
            $branches = Branch::whereNotNull('customer_company')
                              ->where('code', '!=', 'ID0019999')
                              ->orderBy('name')
                              ->get();

            $branch = Branch::find(Auth::user()->branch_id);
            $multiBranch = session('MULTI_BRANCH') ?? false;

            return view('webstatement::statements.index', compact('branches', 'branch', 'multiBranch'));
        }

        /**
         * Store a newly created statement request.
         * Menangani pembuatan request statement baru dengan logging dan transaksi database
         */
        public function store(PrintStatementRequest $request)
        {
            // Add account verification before storing
            $accountNumber = $request->input('account_number'); // Assuming this is the field name for account number
            // First, check if the account exists and get branch information
            $account = Account::where('account_number', $accountNumber)->first();
            if ($account) {
                $branch_code = $account->branch_code;
                $userBranchId = session('branch_id'); // Assuming branch ID is stored in session
                $multiBranch  = session('MULTI_BRANCH');

                if (!$multiBranch) {
                    // Check if account branch matches user's branch
                    if ($account->branch_id !== $userBranchId) {
                        return redirect()->route('statements.index')
                                         ->with('error', 'Nomor rekening tidak sesuai dengan cabang Anda. Transaksi tidak dapat dilanjutkan.');
                    }
                }

                // Check if account belongs to restricted branch ID0019999
                if ($account->branch_id === 'ID0019999') {
                    return redirect()->route('statements.index')
                                     ->with('error', 'Nomor rekening terdaftar pada cabang khusus. Silakan hubungi bagian HC untuk informasi lebih lanjut.');
                }

                // If all checks pass, proceed with storing data
                // Your existing store logic here

            } else {
                // Account not found
                return redirect()->route('statements.index')
                                 ->with('error', 'Nomor rekening tidak ditemukan dalam sistem.');
            }

            DB::beginTransaction();

            try {
                $validated = $request->validated();

                // Add user tracking data dan field baru untuk single account request
                $validated['user_id']            = Auth::id();
                $validated['created_by']         = Auth::id();
                $validated['ip_address']         = $request->ip();
                $validated['user_agent']         = $request->userAgent();
                $validated['request_type']       = 'single_account'; // Default untuk request manual
                $validated['status']             = 'pending';       // Status awal
                $validated['authorization_status'] = 'approved'; // Status otorisasi awal
                $validated['total_accounts']     = 1;                // Untuk single account
                $validated['processed_accounts'] = 0;
                $validated['success_count'] = 0;
                $validated['failed_count'] = 0;
                $validated['stmt_sent_type'] = implode(',', $request->input('stmt_sent_type'));
                $validated['branch_code']       = $branch_code;           // Awal tidak tersedia

                // Create the statement log
                $statement = PrintStatementLog::create($validated);

                // Log aktivitas
                Log::info('Statement request created', [
                    'statement_id'   => $statement->id,
                    'user_id'        => Auth::id(),
                    'account_number' => $statement->account_number,
                    'request_type'   => $statement->request_type
                ]);

                // Process statement availability check
                $this->checkStatementAvailability($statement);
                if(!$statement->is_available){
                    $this->printStatementRekening($statement->account_number,$statement->period_from,$statement->period_to,$statement->stmt_sent_type);
                }

                $statement = PrintStatementLog::find($statement->id);
                if($statement->email){
                    $this->sendEmail($statement->id);
                }
                DB::commit();

                return redirect()->route('statements.index')
                                 ->with('success', 'Statement request has been created successfully.');
            } catch (Exception $e) {
                DB::rollBack();

                Log::error('Failed to create statement request', [
                    'error'   => $e->getMessage(),
                    'user_id' => Auth::id()
                ]);

                return redirect()->back()
                                 ->withInput()
                                 ->with('error', 'Failed to create statement request: ' . $e->getMessage());
            }
        }

        /**
         * Show the form for creating a new statement request.
         */
        public function create()
        {
            $branches = Branch::orderBy('name')->get();
            return view('webstatement::statements.create', compact('branches'));
        }

        /**
         * Check if the statement is available in the system.
         * Memperbarui status availability dengan logging
         */
        protected function checkStatementAvailability(PrintStatementLog $statement)
        {
            DB::beginTransaction();

            try {
                $disk     = Storage::disk('sftpStatement');
                $filePath = "{$statement->period_from}/{$statement->branch_code}/{$statement->account_number}_{$statement->period_from}.pdf";

                // Log untuk debugging
                Log::info('Checking SFTP file path', [
                    'file_path' => $filePath,
                    'sftp_root' => config('filesystems.disks.sftpStatement.root'),
                    'full_path' => config('filesystems.disks.sftpStatement.root') . '/' . $filePath
                ]);

                if ($statement->is_period_range && $statement->period_to) {
                    $periodFrom = Carbon::createFromFormat('Ym', $statement->period_from);
                    $periodTo   = Carbon::createFromFormat('Ym', $statement->period_to);

                    $missingPeriods   = [];
                    $availablePeriods = [];

                    for ($period = clone $periodFrom; $period->lte($periodTo); $period->addMonth()) {
                        $periodFormatted = $period->format('Ym');
                        $periodPath      = $periodFormatted . "/{$statement->branch_code}/{$statement->account_number}_{$periodFormatted}.pdf";

                        if ($disk->exists($periodPath)) {
                            $availablePeriods[] = $periodFormatted;
                        } else {
                            $missingPeriods[] = $periodFormatted;
                        }
                    }

                    if (count($missingPeriods) > 0) {
                        $notes = "Missing periods: " . implode(', ', $missingPeriods);
                        $statement->update([
                            'is_available' => false,
                            'remarks'      => $notes,
                            'updated_by'   => Auth::id(),
                            'status'       => 'failed'
                        ]);

                        Log::warning('Statement not available - missing periods', [
                            'statement_id'    => $statement->id,
                            'missing_periods' => $missingPeriods
                        ]);
                    } else {
                        $statement->update([
                            'is_available'       => true,
                            'updated_by'         => Auth::id(),
                            'status'             => 'completed',
                            'processed_accounts' => 1,
                            'success_count'      => 1
                        ]);

                        Log::info('Statement available - all periods found', [
                            'statement_id'      => $statement->id,
                            'available_periods' => $availablePeriods
                        ]);
                    }
                } else if ($disk->exists($filePath)) {
                    $statement->update([
                        'is_available'       => true,
                        'updated_by'         => Auth::id(),
                        'status'             => 'completed',
                        'processed_accounts' => 1,
                        'success_count'      => 1
                    ]);

                    Log::info('Statement available', [
                        'statement_id' => $statement->id,
                        'file_path'    => $filePath
                    ]);
                } else {
                    $statement->update([
                        'is_available'       => false,
                        'updated_by'         => Auth::id(),
                        'status'             => 'failed',
                        'processed_accounts' => 1,
                        'failed_count'       => 1,
                        'error_message'      => 'Statement file not found'
                    ]);

                    Log::warning('Statement not available', [
                        'statement_id' => $statement->id,
                        'file_path'    => $filePath
                    ]);
                }

                DB::commit();
            } catch (Exception $e) {
                DB::rollBack();

                Log::error('Error checking statement availability', [
                    'statement_id' => $statement->id,
                    'error'        => $e->getMessage()
                ]);

                $statement->update([
                    'is_available'  => false,
                    'status'        => 'failed',
                    'error_message' => $e->getMessage(),
                    'updated_by'    => Auth::id()
                ]);
            }
        }

        /**
         * Display the specified statement.
         */
        public function show(PrintStatementLog $statement)
        {
            $statement->load(['user', 'branch', 'creator', 'authorizer']);
            return view('webstatement::statements.show', compact('statement'));
        }

        /**
         * Download the statement if available and authorized.
         * Memperbarui status download dengan logging dan transaksi
         */
        public function download(PrintStatementLog $statement)
        {
            if (!$statement->is_available) {
                return back()->with('error', 'Statement is not available for download.');
            }

            DB::beginTransaction();

            try {
                // Update download status
                $statement->update([
                    'is_downloaded' => true,
                    'downloaded_at' => now(),
                    'updated_by'    => Auth::id()
                ]);

                Log::info('Statement downloaded', [
                    'statement_id'   => $statement->id,
                    'user_id'        => Auth::id(),
                    'account_number' => $statement->account_number
                ]);

                DB::commit();

                // Generate or fetch the statement file
                $disk     = Storage::disk('sftpStatement');
                $filePath = "{$statement->period_from}/{$statement->branch_code}/{$statement->account_number}_{$statement->period_from}.pdf";

                if ($statement->is_period_range && $statement->period_to) {
                    // Log: Memulai proses download period range
                    Log::info('Starting period range download', [
                        'statement_id' => $statement->id,
                        'period_from'  => $statement->period_from,
                        'period_to'    => $statement->period_to
                    ]);

                    /**
                     * Handle period range download dengan membuat zip file
                     * yang berisi semua statement dalam rentang periode
                     */
                    $periodFrom = Carbon::createFromFormat('Ym', $statement->period_from);
                    $periodTo   = Carbon::createFromFormat('Ym', $statement->period_to);

                    // Loop through each month in the range
                    $missingPeriods   = [];
                    $availablePeriods = [];

                    for ($period = clone $periodFrom; $period->lte($periodTo); $period->addMonth()) {
                        $periodFormatted = $period->format('Ym');
                        $periodPath      = $periodFormatted . "/{$statement->branch_code}/{$statement->account_number}_{$periodFormatted}.pdf";

                        if ($disk->exists($periodPath)) {
                            $availablePeriods[] = $periodFormatted;
                            Log::info('Period available for download', [
                                'period' => $periodFormatted,
                                'path'   => $periodPath
                            ]);
                        } else {
                            $missingPeriods[] = $periodFormatted;
                            Log::warning('Period not available for download', [
                                'period' => $periodFormatted,
                                'path'   => $periodPath
                            ]);
                        }
                    }

                    // If any period is available, create a zip and download it
                    if (count($availablePeriods) > 0) {
                        /**
                         * Membuat zip file temporary untuk download
                         * dengan semua statement yang tersedia dalam periode
                         */
                        $zipFileName = "{$statement->account_number}_{$statement->period_from}_to_{$statement->period_to}.zip";
                        $zipFilePath = storage_path("app/temp/{$zipFileName}");

                        // Ensure the temp directory exists
                        if (!file_exists(storage_path('app/temp'))) {
                            mkdir(storage_path('app/temp'), 0755, true);
                            Log::info('Created temp directory for zip files');
                        }

                        // Create a new zip archive
                        $zip = new ZipArchive();
                        if ($zip->open($zipFilePath, ZipArchive::CREATE | ZipArchive::OVERWRITE) === true) {
                            Log::info('Zip archive created successfully', ['zip_path' => $zipFilePath]);

                            // Add each available statement to the zip
                            foreach ($availablePeriods as $period) {
                                $periodFilePath = "{$period}/{$statement->branch_code}/{$statement->account_number}_{$period}.pdf";
                                $localFilePath  = storage_path("app/temp/{$statement->account_number}_{$period}.pdf");

                                try {
                                    // Download the file from SFTP to local storage temporarily
                                    file_put_contents($localFilePath, $disk->get($periodFilePath));

                                    // Add the file to the zip
                                    $zip->addFile($localFilePath, "{$statement->account_number}_{$period}.pdf");

                                    Log::info('Added file to zip', [
                                        'period'     => $period,
                                        'local_path' => $localFilePath
                                    ]);
                                } catch (Exception $e) {
                                    Log::error('Failed to add file to zip', [
                                        'period' => $period,
                                        'error'  => $e->getMessage()
                                    ]);
                                }
                            }

                            $zip->close();
                            Log::info('Zip archive closed successfully');

                            // Return the zip file for download
                            $response = response()->download($zipFilePath, $zipFileName)->deleteFileAfterSend(true);

                            // Clean up temporary PDF files
                            foreach ($availablePeriods as $period) {
                                $localFilePath = storage_path("app/temp/{$statement->account_number}_{$period}.pdf");
                                if (file_exists($localFilePath)) {
                                    unlink($localFilePath);
                                    Log::info('Cleaned up temporary file', ['file' => $localFilePath]);
                                }
                            }

                            Log::info('Period range download completed successfully', [
                                'statement_id'      => $statement->id,
                                'available_periods' => count($availablePeriods),
                                'missing_periods'   => count($missingPeriods)
                            ]);

                            return $response;
                        } else {
                            Log::error('Failed to create zip archive', ['zip_path' => $zipFilePath]);
                            return back()->with('error', 'Failed to create zip archive for download.');
                        }
                    } else {
                        Log::warning('No statements available for download in period range', [
                            'statement_id'    => $statement->id,
                            'missing_periods' => $missingPeriods
                        ]);
                        return back()->with('error', 'No statements available for download in the specified period range.');
                    }
                } else if ($disk->exists($filePath)) {
                    /**
                     * Handle single period download
                     * Download file PDF tunggal untuk periode tertentu
                     */
                    Log::info('Single period download', [
                        'statement_id' => $statement->id,
                        'file_path'    => $filePath
                    ]);

                    return $disk->download($filePath, "{$statement->account_number}_{$statement->period_from}.pdf");
                } else {
                    Log::warning('Statement file not found', [
                        'statement_id' => $statement->id,
                        'file_path'    => $filePath
                    ]);
                    return back()->with('error', 'Statement file not found.');
                }
            } catch (Exception $e) {
                DB::rollBack();

                Log::error('Failed to download statement', [
                    'statement_id' => $statement->id,
                    'error'        => $e->getMessage(),
                    'trace'        => $e->getTraceAsString()
                ]);

                return back()->with('error', 'Failed to download statement: ' . $e->getMessage());
            }
        }

        /**
         * Authorize a statement request.
         */
        public function authorize(Request $request, PrintStatementLog $statement)
        {
            $request->validate([
                'authorization_status' => ['required', Rule::in(['approved', 'rejected'])],
                'remarks'              => ['nullable', 'string', 'max:255'],
            ]);

            // Update authorization status
            $statement->update([
                'authorization_status' => $request->authorization_status,
                'authorized_by'        => Auth::id(),
                'authorized_at'        => now(),
                'remarks'              => $request->remarks,
                'updated_by'           => Auth::id()
            ]);

            $statusText = $request->authorization_status === 'approved' ? 'approved' : 'rejected';

            return redirect()->route('statements.show', $statement->id)
                             ->with('success', "Statement request has been {$statusText} successfully.");

        }

        /**
         * Provide data for datatables.
         */
        public function dataForDatatables(Request $request)
        {
            // Check permissions if needed
            // if (!auth()->user()->can('view_statements')) {
            //     abort(403, 'Sorry! You are not allowed to view statements.');
            // }

            // Retrieve data from the database
            $query = PrintStatementLog::query();

            if (!auth()->user()->hasRole('administrator')) {
                $query->where(function($q) {
                    $q->where('user_id', Auth::id())
                        ->orWhere('branch_code', Auth::user()->branch->code);
                });
            }

            // Apply search filter if provided
            if ($request->has('search') && !empty($request->get('search'))) {
                $search = $request->get('search');
                $query->where(function ($q) use ($search) {
                    $q->where('account_number', 'LIKE', "%$search%")
                      ->orWhere('branch_code', 'LIKE', "%$search%")
                      ->orWhere('period_from', 'LIKE', "%$search%")
                      ->orWhere('period_to', 'LIKE', "%$search%")
                      ->orWhere('authorization_status', 'LIKE', "%$search%")
                      ->orWhere('request_type', 'LIKE', "%$search%")
                      ->orWhere('status', 'LIKE', "%$search%");
                });
            }

            // Apply column filters if provided
            if ($request->has('filters') && !empty($request->get('filters'))) {
                $filters = json_decode($request->get('filters'), true);

                foreach ($filters as $filter) {
                    if (!empty($filter['value'])) {
                        if ($filter['column'] === 'branch_code') {
                            $query->where('branch_code', $filter['value']);
                        } else if ($filter['column'] === 'authorization_status') {
                            $query->where('authorization_status', $filter['value']);
                        } else if ($filter['column'] === 'request_type') {
                            $query->where('request_type', $filter['value']);
                        } else if ($filter['column'] === 'status') {
                            $query->where('status', $filter['value']);
                        } else if ($filter['column'] === 'is_downloaded') {
                            $query->where('is_downloaded', filter_var($filter['value'], FILTER_VALIDATE_BOOLEAN));
                        }
                    }
                }
            }

            // Apply sorting if provided
            if ($request->has('sortOrder') && !empty($request->get('sortOrder'))) {
                $order  = $request->get('sortOrder');
                $column = $request->get('sortField');

                // Map frontend column names to database column names if needed
                $columnMap = [
                    'branch'       => 'branch_code',
                    'account'      => 'account_number',
                    'period'       => 'period_from',
                    'auth_status'  => 'authorization_status',
                    'request_type' => 'request_type',
                    'status'       => 'status',
                    'remarks'      => 'remarks',
                ];

                $dbColumn = $columnMap[$column] ?? $column;
                $query->orderBy($dbColumn, $order);
            } else {
                // Default sorting
                $query->latest('created_at');
            }

            // Get the total count of records
            $totalRecords = $query->count();

            // Apply pagination if provided
            if ($request->has('page') && $request->has('size')) {
                $page   = $request->get('page');
                $size   = $request->get('size');
                $offset = ($page - 1) * $size; // Calculate the offset

                $query->skip($offset)->take($size);
            }

            // Get the filtered count of records
            $filteredRecords = $query->count();

            // Eager load relationships to avoid N+1 query problems
            $query->with(['user', 'branch', 'authorizer']);

            // Get the data for the current page
            $data = $query->get()->map(function ($item) {
                // Transform data for frontend if needed
                return [
                    'id'                   => $item->id,
                    'branch_code'          => $item->branch_code,
                    'branch_name'          => $item->branch->name ?? 'N/A',
                    'account_number'       => $item->account_number,
                    'period_from'          => $item->period_from,
                    'period_to'            => $item->is_period_range ? $item->period_to : null,
                    'authorization_status' => $item->authorization_status,
                    'is_available'         => $item->is_available,
                    'is_generated'         => $item->is_generated,
                    'is_downloaded'        => $item->is_downloaded,
                    'created_at'           => dateFormat($item->created_at, 1, 1),
                    'created_by'           => $item->user->name ?? 'N/A',
                    'authorized_by'        => $item->authorizer ? $item->authorizer->name : null,
                    'authorized_at'        => $item->authorized_at ? $item->authorized_at->format('Y-m-d H:i:s') : null,
                    'remarks'              => $item->remarks,
                ];
            });

            // Calculate the page count
            $pageCount = ceil($filteredRecords / ($request->get('size') ?: 1));

            // Calculate the current page number
            $currentPage = $request->get('page') ?: 1;

            // Return the response data as a JSON object
            return response()->json([
                'draw'            => $request->get('draw'),
                'recordsTotal'    => $totalRecords,
                'recordsFiltered' => $filteredRecords,
                'pageCount'       => $pageCount,
                'page'            => $currentPage,
                'totalCount'      => $totalRecords,
                'data'            => $data,
            ]);
        }

        public function destroy(PrintStatementLog $statement)
        {
            // Delete the statement
            $statement->delete();

            return response()->json([
                'message' => 'Statement deleted successfully.',
            ]);
        }

        /**
         * Send statement to email
         */
        public function sendEmail($id)
        {
            $statement = PrintStatementLog::findOrFail($id);

            // Check if statement has email
            if (empty($statement->email)) {
                return redirect()->back()->with('error', 'No email address provided for this statement.');
            }

            // Check if statement is available
            if (!$statement->is_available) {
                return redirect()->back()->with('error', 'Statement is not available for sending.');
            }

            try {
                $disk     = Storage::disk('sftpStatement');
                $filePath = "{$statement->period_from}/{$statement->branch_code}/{$statement->account_number}_{$statement->period_from}.pdf";

                if ($statement->is_period_range && $statement->period_to) {
                    $periodFrom = Carbon::createFromFormat('Ym', $statement->period_from);
                    $periodTo   = Carbon::createFromFormat('Ym', $statement->period_to);

                    // Loop through each month in the range
                    $missingPeriods   = [];
                    $availablePeriods = [];

                    for ($period = clone $periodFrom; $period->lte($periodTo); $period->addMonth()) {
                        $periodFormatted = $period->format('Ym');
                        $periodPath      = $periodFormatted . "/{$statement->branch_code}/{$statement->account_number}_{$periodFormatted}.pdf";

                        if ($disk->exists($periodPath)) {
                            $availablePeriods[] = $periodFormatted;
                        } else {
                            $missingPeriods[] = $periodFormatted;
                        }
                    }

                    // If any period is available, create a zip and send it
                    if (count($availablePeriods) > 0) {
                        // Create a temporary zip file
                        $zipFileName = "{$statement->account_number}_{$statement->period_from}_to_{$statement->period_to}.zip";
                        $zipFilePath = storage_path("app/temp/{$zipFileName}");

                        // Ensure the temp directory exists
                        if (!file_exists(storage_path('app/temp'))) {
                            mkdir(storage_path('app/temp'), 0755, true);
                        }

                        // Create a new zip archive
                        $zip = new ZipArchive();
                        if ($zip->open($zipFilePath, ZipArchive::CREATE | ZipArchive::OVERWRITE) === true) {
                            // Add each available statement to the zip
                            foreach ($availablePeriods as $period) {
                                $filePath      = "{$period}/{$statement->branch_code}/{$statement->account_number}_{$statement->period_from}.pdf";
                                $localFilePath = storage_path("app/temp/{$statement->account_number}_{$period}.pdf");

                                // Download the file from SFTP to local storage temporarily
                                file_put_contents($localFilePath, $disk->get($filePath));

                                // Add the file to the zip
                                $zip->addFile($localFilePath, "{$statement->account_number}_{$period}.pdf");
                            }

                            $zip->close();

                            // Send email with zip attachment
                            Mail::to($statement->email)
                                ->send(new StatementEmail($statement, $zipFilePath, true));

                            // Clean up temporary files
                            foreach ($availablePeriods as $period) {
                                $localFilePath = storage_path("app/temp/{$statement->account_number}_{$period}.pdf");
                                if (file_exists($localFilePath)) {
                                    unlink($localFilePath);
                                }
                            }

                            // Delete the zip file after sending
                            if (file_exists($zipFilePath)) {
                                unlink($zipFilePath);
                            }
                        } else {
                            return redirect()->back()->with('error', 'Failed to create zip archive for email.');
                        }
                    } else {
                        return redirect()->back()->with('error', 'No statements available for sending.');
                    }
                } else if ($disk->exists($filePath)) {
                    // For single period statements
                    $localFilePath = storage_path("app/temp/{$statement->account_number}_{$statement->period_from}.pdf");

                    // Ensure the temp directory exists
                    if (!file_exists(storage_path('app/temp'))) {
                        mkdir(storage_path('app/temp'), 0755, true);
                    }

                    // Download the file from SFTP to local storage temporarily
                    file_put_contents($localFilePath, $disk->get($filePath));

                    // Send email with PDF attachment
                    Mail::to($statement->email)
                        ->send(new StatementEmail($statement, $localFilePath, false));

                    // Delete the temporary file
                    if (file_exists($localFilePath)) {
                        unlink($localFilePath);
                    }
                } else {
                    return redirect()->back()->with('error', 'Statement file not found.');
                }

                // Update statement record to mark as emailed
                $statement->update([
                    'email_sent_at' => now(),
                    'updated_by'    => Auth::id()
                ]);

                Log::info('Statement email sent successfully', [
                    'statement_id' => $statement->id,
                    'email'        => $statement->email,
                    'user_id'      => Auth::id()
                ]);

                DB::commit();

                return redirect()->back()->with('success', 'Statement has been sent to ' . $statement->email);
            } catch (Exception $e) {
                // Log the error
                Log::error('Failed to send statement email: ' . $e->getMessage());

                return redirect()->back()->with('error', 'Failed to send email: ' . $e->getMessage());
            }
        }

        /**
         * Generate or fetch the statement file.
         * This is a placeholder method - implement according to your system.
         */
        protected function generateStatementFile(PrintStatementLog $statement)
        {
            // This would be implemented based on your system's logic
            // For example, calling an API to generate a PDF or fetching from storage

            // Placeholder implementation - return a dummy path
            $tempFile = tempnam(sys_get_temp_dir(), 'statement_');
            file_put_contents($tempFile, 'Statement content would go here');
            return $tempFile;
        }

        /**
         * Send statement to email
         */

        /**
         * Generate a filename for the statement download.
         */
        protected function generateFileName(PrintStatementLog $statement)
        {
            $accountNumber = $statement->account_number;

            if ($statement->is_period_range) {
                return "statement_{$accountNumber}_{$statement->period_from}_to_{$statement->period_to}.pdf";
            }

            return "statement_{$accountNumber}_{$statement->period_from}.pdf";
        }


        function printStatementRekening($accountNumber, $period, $periodTo = null, $stmtSentType = null) {
            $period = $period ?? date('Ym');
            $balance = AccountBalance::where('account_number', $accountNumber)
                ->when($period === '202505', function($query) {
                    return $query->where('period', '>=', '20250512')
                        ->orderBy('period', 'asc');
                }, function($query) use ($period) {
                    // Get balance from last day of previous month
                    $firstDayOfMonth = Carbon::createFromFormat('Ym', $period)->startOfMonth();
                    $lastDayPrevMonth = $firstDayOfMonth->copy()->subDay()->format('Ymd');
                    return $query->where('period', $lastDayPrevMonth);
                })
                ->first()
                ->actual_balance ?? '0.00';
            $clientName = 'client1';

            try {
                \Log::info("Starting statement export for account: {$accountNumber}, period: {$period}, client: {$clientName}");

                // Validate inputs
                if (empty($accountNumber) || empty($period) || empty($clientName)) {
                    throw new \Exception('Required parameters missing');
                }

                // Dispatch the job
                $job = ExportStatementPeriodJob::dispatch($accountNumber, $period, $balance, $clientName);

                \Log::info("Statement export job dispatched successfully", [
                    'job_id' => $job->job_id ?? null,
                    'account' => $accountNumber,
                    'period' => $period,
                    'client' => $clientName
                ]);

                return response()->json([
                    'success' => true,
                    'message' => 'Statement export job queued successfully',
                    'data' => [
                        'job_id' => $job->job_id ?? null,
                        'account_number' => $accountNumber,
                        'period' => $period,
                        'client_name' => $clientName
                    ]
                ]);

            } catch (\Exception $e) {
                \Log::error("Failed to export statement", [
                    'error' => $e->getMessage(),
                    'account' => $accountNumber,
                    'period' => $period
                ]);

                return response()->json([
                    'success' => false,
                    'message' => 'Failed to queue statement export job',
                    'error' => $e->getMessage()
                ]);
            }
        }
    }