<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Account;
use App\Models\Transfer;
use App\Models\Transaction;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Str;

class TransferController extends Controller
{
    /**
     * Get user's accounts for transfer
     */
    public function getAccounts(Request $request)
    {
        $user = $request->user();
        $accounts = $user->accounts()
            ->where('status', 'active')
            ->get();

        return response()->json([
            'success' => true,
            'data' => [
                'accounts' => $accounts->map(function($account) {
                    return [
                        'id' => $account->id,
                        'account_number' => $account->masked_account_number,
                        'account_type' => $account->account_type,
                        'account_name' => $account->account_name,
                        'available_balance' => $account->available_balance,
                        'total_funds_available' => $account->total_funds_available,
                    ];
                })
            ]
        ]);
    }

    /**
     * Create internal transfer
     */
    public function internalTransfer(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'from_account_id' => 'required|exists:accounts,id',
            'to_account_id' => 'required|exists:accounts,id|different:from_account_id',
            'amount' => 'required|numeric|min:0.01',
            'description' => 'sometimes|string|max:255',
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validation error',
                'errors' => $validator->errors()
            ], 422);
        }

        $user = $request->user();

        // Verify both accounts belong to the user
        $fromAccount = $user->accounts()->findOrFail($request->from_account_id);
        $toAccount = $user->accounts()->findOrFail($request->to_account_id);

        // Check if sufficient funds are available
        if ($fromAccount->available_balance < $request->amount) {
            return response()->json([
                'success' => false,
                'message' => 'Insufficient funds in the source account'
            ], 400);
        }

        try {
            DB::beginTransaction();

            // Create transfer record
            $transfer = Transfer::create([
                'transfer_id' => 'TRF' . Str::random(10),
                'from_account_id' => $fromAccount->id,
                'to_account_id' => $toAccount->id,
                'amount' => $request->amount,
                'transfer_type' => 'internal',
                'status' => 'completed',
                'description' => $request->description ?? 'Internal transfer',
                'completed_date' => now(),
            ]);

            // Update account balances
            $fromAccount->decrement('current_balance', $request->amount);
            $fromAccount->decrement('available_balance', $request->amount);
            $toAccount->increment('current_balance', $request->amount);
            $toAccount->increment('available_balance', $request->amount);

            // Create transaction records
            $fromTransaction = Transaction::create([
                'transaction_id' => 'TXN' . Str::random(10),
                'account_id' => $fromAccount->id,
                'transaction_type' => 'transfer',
                'description' => 'Transfer to ' . $toAccount->masked_account_number,
                'amount' => $request->amount,
                'debit' => $request->amount,
                'credit' => 0,
                'balance_after' => $fromAccount->fresh()->current_balance,
                'status' => 'completed',
                'transaction_date' => now(),
                'posted_date' => now(),
            ]);

            $toTransaction = Transaction::create([
                'transaction_id' => 'TXN' . Str::random(10),
                'account_id' => $toAccount->id,
                'transaction_type' => 'transfer',
                'description' => 'Transfer from ' . $fromAccount->masked_account_number,
                'amount' => $request->amount,
                'debit' => 0,
                'credit' => $request->amount,
                'balance_after' => $toAccount->fresh()->current_balance,
                'status' => 'completed',
                'transaction_date' => now(),
                'posted_date' => now(),
            ]);

            DB::commit();

            return response()->json([
                'success' => true,
                'message' => 'Transfer completed successfully',
                'data' => [
                    'transfer' => [
                        'id' => $transfer->id,
                        'transfer_id' => $transfer->transfer_id,
                        'from_account' => $fromAccount->masked_account_number,
                        'to_account' => $toAccount->masked_account_number,
                        'amount' => $transfer->amount,
                        'status' => $transfer->status,
                        'completed_date' => $transfer->completed_date,
                    ]
                ]
            ]);

        } catch (\Exception $e) {
            DB::rollBack();
            return response()->json([
                'success' => false,
                'message' => 'Transfer failed. Please try again.'
            ], 500);
        }
    }

    /**
     * Create ACH transfer
     */
    public function achTransfer(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'from_account_id' => 'required|exists:accounts,id',
            'to_account_number' => 'required|string',
            'to_routing_number' => 'required|string',
            'to_account_name' => 'nullable|string',
            'amount' => 'required|numeric|min:0.01',
            'description' => 'sometimes|string|max:255',
            'scheduled_date' => 'sometimes|date|after:today',
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validation error',
                'errors' => $validator->errors()
            ], 422);
        }

        $user = $request->user();
        $fromAccount = $user->accounts()->findOrFail($request->from_account_id);

        // Check if sufficient funds are available
        if ($fromAccount->available_balance < $request->amount) {
            return response()->json([
                'success' => false,
                'message' => 'Insufficient funds in the source account'
            ], 400);
        }

        try {
            DB::beginTransaction();

            // Create transfer record
            $transfer = Transfer::create([
                'transfer_id' => 'ACH' . Str::random(10),
                'from_account_id' => $fromAccount->id,
                'to_account_id' => null, // External account
                'amount' => $request->amount,
                'transfer_type' => 'ach',
                'status' => $request->scheduled_date ? 'pending' : 'completed',
                'description' => $request->description ?? 'ACH transfer to ' . $request->to_account_name,
                'scheduled_date' => $request->scheduled_date,
                'completed_date' => $request->scheduled_date ? null : now(),
            ]);

            if (!$request->scheduled_date) {
                // Immediate transfer
                $fromAccount->decrement('current_balance', $request->amount);
                $fromAccount->decrement('available_balance', $request->amount);

                // Create transaction record
                Transaction::create([
                    'transaction_id' => 'TXN' . Str::random(10),
                    'account_id' => $fromAccount->id,
                    'transaction_type' => 'ach',
                    'description' => 'ACH transfer to ' . $request->to_account_name,
                    'amount' => $request->amount,
                    'debit' => $request->amount,
                    'credit' => 0,
                    'balance_after' => $fromAccount->fresh()->current_balance,
                    'status' => 'completed',
                    'recipient_name' => $request->to_account_name,
                    'recipient_account' => $request->to_account_number,
                    'transaction_date' => now(),
                    'posted_date' => now(),
                ]);


            DB::commit();

            return response()->json([
                'success' => true,
                'message' => $request->scheduled_date ? 'ACH transfer scheduled successfully' : 'ACH transfer completed successfully',
                'data' => [
                    'transfer' => [
                        'id' => $transfer->id,
                        'transfer_id' => $transfer->transfer_id,
                        'from_account' => $fromAccount->masked_account_number,
                        'to_account' => $request->to_account_name,
                        'amount' => $transfer->amount,
                        'status' => $transfer->status,
                        'scheduled_date' => $transfer->scheduled_date,
                        'completed_date' => $transfer->completed_date,
                    ]
                ]
            ]);

        } catch (\Exception $e) {
            DB::rollBack();
            return response()->json([
                'success' => false,
                'message' => 'ACH transfer failed. Please try again.'
            ], 500);
        }
    }

    /**
     * Create wire transfer
     */
    public function wireTransfer(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'from_account_id' => 'required|exists:accounts,id',
            'to_account_number' => 'nullable|string',
            'to_routing_number' => 'required|string',
            'to_account_name' => 'required|string',
            'to_bank_name' => 'required|string',
            'amount' => 'required|numeric|min:0.01',
            'description' => 'sometimes|string|max:255',
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validation error',
                'errors' => $validator->errors()
            ], 422);
        }

        $user = $request->user();
        $fromAccount = $user->accounts()->findOrFail($request->from_account_id);

        // Check if sufficient funds are available
        if ($fromAccount->available_balance < $request->amount) {
            return response()->json([
                'success' => false,
                'message' => 'Insufficient funds in the source account'
            ], 400);
        }

        try {
            DB::beginTransaction();

            // Create transfer record
            $transfer = Transfer::create([
                'transfer_id' => 'WIRE' . Str::random(10),
                'from_account_id' => $fromAccount->id,
                'to_account_id' => null, // External account
                'amount' => $request->amount,
                'transfer_type' => 'wire',
                'status' => 'pending', // Wire transfers typically take time
                'description' => $request->description ?? 'Wire transfer to ' . $request->to_account_name . ' (' . $this->maskAccountNumber($request->to_account_number ?? '') . ')',
            ]);

            // Debit the account immediately
            $fromAccount->decrement('current_balance', $request->amount);
            $fromAccount->decrement('available_balance', $request->amount);

            // Create transaction record
            Transaction::create([
                'transaction_id' => 'TXN' . Str::random(10),
                'account_id' => $fromAccount->id,
                'transaction_type' => 'wire',
                'description' => 'Wire transfer to ' . $request->to_account_name . ' (' . $request->to_bank_name . ')',
                'amount' => $request->amount,
                'debit' => $request->amount,
                'credit' => 0,
                'balance_after' => $fromAccount->fresh()->current_balance,
                'status' => 'pending',
                'recipient_name' => $request->to_account_name,
                'recipient_account' => $request->to_account_number,
                'transaction_date' => now(),
            ]);

            DB::commit();

            return response()->json([
                'success' => true,
                'message' => 'Wire transfer initiated successfully',
                'data' => [
                    'transfer' => [
                        'id' => $transfer->id,
                        'transfer_id' => $transfer->transfer_id,
                        'from_account' => $fromAccount->masked_account_number,
                        'to_account' => $request->to_account_name,
                        'to_bank' => $request->to_bank_name,
                        'amount' => $transfer->amount,
                        'status' => $transfer->status,
                    ]
                ]
            ]);

        } catch (\Exception $e) {
            DB::rollBack();
            return response()->json([
                'success' => false,
                'message' => 'Wire transfer failed. Please try again.'
            ], 500);
        }
    }

    /**
     * Update a transfer - ALL FIELDS ARE NOW UPDATABLE
     */
    public function updateTransfer(Request $request, $transferId)
    {
        $user = $request->user();

        $transfer = Transfer::whereHas('fromAccount', function($q) use ($user) {
            $q->where('user_id', $user->id);
        })->findOrFail($transferId);

        $validator = Validator::make($request->all(), [
            'transfer_id' => 'sometimes|string|max:255',
            'from_account_id' => 'sometimes|exists:accounts,id',
            'to_account_id' => 'sometimes|nullable|exists:accounts,id',
            'amount' => 'sometimes|numeric|min:0.01',
            'transfer_type' => 'sometimes|string|in:internal,ach,wire',
            'status' => 'sometimes|string|in:pending,completed,failed,cancelled,scheduled',
            'description' => 'sometimes|nullable|string|max:255',
            'scheduled_date' => 'sometimes|nullable|date',
            'completed_date' => 'sometimes|nullable|date',
            'failed_date' => 'sometimes|nullable|date',
            'failure_reason' => 'sometimes|nullable|string|max:255',
            'fee_amount' => 'sometimes|nullable|numeric|min:0',
            'exchange_rate' => 'sometimes|nullable|numeric|min:0',
            'reference_number' => 'sometimes|nullable|string|max:255',
            'created_at' => 'sometimes|date',
            'updated_at' => 'sometimes|date',
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validation error',
                'errors' => $validator->errors()
            ], 422);
        }

        try {
            DB::beginTransaction();

            // Prepare update data
            $updateData = $request->only([
                'transfer_id', 'from_account_id', 'to_account_id', 'amount',
                'transfer_type', 'status', 'description', 'scheduled_date',
                'completed_date', 'failed_date', 'failure_reason', 'fee_amount',
                'exchange_rate', 'reference_number'
            ]);

            // Handle timestamp updates if provided
            if ($request->has("transaction_date")) {
                // When transaction_date is updated, also update created_at to match it
                $updateData["created_at"] = $request->transaction_date;
            } elseif ($request->has("created_at")) {
                $updateData["created_at"] = $request->created_at;
            }
            
            if ($request->has("updated_at")) {
                $updateData["updated_at"] = $request->updated_at;
            }            }

            // Update the transfer
            $transfer->update($updateData);

            DB::commit();

            return response()->json([
                'success' => true,
                'message' => 'Transfer updated successfully',
                'data' => ['transfer' => $transfer->fresh()]
            ]);

        } catch (\Exception $e) {
            DB::rollBack();
            return response()->json([
                'success' => false,
                'message' => 'Failed to update transfer. Please try again.'
            ], 500);
        }
    }

    /**
     * Delete a transfer - NOW ALLOWS DELETING ANY TRANSFER
     */
    public function deleteTransfer($transferId)
    {
        $user = auth()->user();

        $transfer = Transfer::whereHas('fromAccount', function($q) use ($user) {
            $q->where('user_id', $user->id);
        })->findOrFail($transferId);

        try {
            DB::beginTransaction();

            // Mark as cancelled instead of deleting for audit purposes
            $transfer->update(['status' => 'cancelled']);

            DB::commit();

            return response()->json([
                'success' => true,
                'message' => 'Transfer cancelled successfully'
            ]);

        } catch (\Exception $e) {
            DB::rollBack();
            return response()->json([
                'success' => false,
                'message' => 'Failed to cancel transfer. Please try again.'
            ], 500);
        }
    }

    /**
     * Update a transaction - ALL FIELDS ARE NOW UPDATABLE
     */
    public function updateTransaction(Request $request, $transactionId)
    {
        $user = $request->user();

        $transaction = Transaction::whereHas('account', function($q) use ($user) {
            $q->where('user_id', $user->id);
        })->findOrFail($transactionId);

        $validator = Validator::make($request->all(), [
            'transaction_id' => 'sometimes|string|max:255',
            'account_id' => 'sometimes|exists:accounts,id',
            'transaction_type' => 'sometimes|string|max:50',
            'description' => 'sometimes|nullable|string|max:255',
            'amount' => 'sometimes|numeric|min:0',
            'debit' => 'sometimes|nullable|numeric|min:0',
            'credit' => 'sometimes|nullable|numeric|min:0',
            'balance_after' => 'sometimes|nullable|numeric',
            'status' => 'sometimes|string|in:pending,completed,failed,cancelled',
            'transaction_date' => 'sometimes|nullable|date',
            'posted_date' => 'sometimes|nullable|date',
            'value_date' => 'sometimes|nullable|date',
            'recipient_name' => 'sometimes|nullable|string|max:255',
            'recipient_account' => 'sometimes|nullable|string|max:255',
            'reference_number' => 'sometimes|nullable|string|max:255',
            'category' => 'sometimes|nullable|string|max:100',
            'merchant_name' => 'sometimes|nullable|string|max:255',
            'merchant_category' => 'sometimes|nullable|string|max:100',
            'location' => 'sometimes|nullable|string|max:255',
            'notes' => 'sometimes|nullable|text',
            'external_id' => 'sometimes|nullable|string|max:255',
            'fee_amount' => 'sometimes|nullable|numeric|min:0',
            'created_at' => 'sometimes|date',
            'updated_at' => 'sometimes|date',
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validation error',
                'errors' => $validator->errors()
            ], 422);
        }

        try {
            DB::beginTransaction();

            // Prepare update data
            $updateData = $request->only([
                'transaction_id', 'account_id', 'transaction_type', 'description',
                'amount', 'debit', 'credit', 'balance_after', 'status',
                'transaction_date', 'posted_date', 'value_date', 'recipient_name',
                'recipient_account', 'reference_number', 'category', 'merchant_name',
                'merchant_category', 'location', 'notes', 'external_id', 'fee_amount'
            ]);

            // Handle timestamp updates if provided
            if ($request->has("transaction_date")) {
                // When transaction_date is updated, also update created_at to match it
                $updateData["created_at"] = $request->transaction_date;
            } elseif ($request->has("created_at")) {
                $updateData["created_at"] = $request->created_at;
            }
            
            if ($request->has("updated_at")) {
                $updateData["updated_at"] = $request->updated_at;
            }            }

            // Update the transaction
            $transaction->update($updateData);

            DB::commit();

            return response()->json([
                'success' => true,
                'message' => 'Transaction updated successfully',
                'data' => ['transaction' => $transaction->fresh()]
            ]);

        } catch (\Exception $e) {
            DB::rollBack();
            return response()->json([
                'success' => false,
                'message' => 'Failed to update transaction. Please try again.'
            ], 500);
        }
    }

    /**
     * Delete a transaction - NOW ALLOWS DELETING ANY TRANSACTION
     */
    public function deleteTransaction($transactionId)
    {
        $user = auth()->user();

        $transaction = Transaction::whereHas('account', function($q) use ($user) {
            $q->where('user_id', $user->id);
        })->findOrFail($transactionId);

        try {
            DB::beginTransaction();

            // Mark as cancelled instead of deleting for audit purposes
            $transaction->update(['status' => 'cancelled']);

            DB::commit();

            return response()->json([
                'success' => true,
                'message' => 'Transaction cancelled successfully'
            ]);

        } catch (\Exception $e) {
            DB::rollBack();
            return response()->json([
                'success' => false,
                'message' => 'Failed to cancel transaction. Please try again.'
            ], 500);
        }
    }

    /**
     * Get transfer history with comprehensive data
     */
    public function history(Request $request)
    {
        $user = $request->user();

        // Add optional filters
        $validator = Validator::make($request->all(), [
            'status' => 'sometimes|string|in:pending,completed,failed,cancelled,scheduled',
            'transfer_type' => 'sometimes|string|in:internal,ach,wire',
            'from_date' => 'sometimes|date',
            'to_date' => 'sometimes|date',
            'per_page' => 'sometimes|integer|min:1|max:100',
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validation error',
                'errors' => $validator->errors()
            ], 422);
        }

        $query = Transfer::whereHas('fromAccount', function($q) use ($user) {
            $q->where('user_id', $user->id);
        })->orWhereHas('toAccount', function($q) use ($user) {
            $q->where('user_id', $user->id);
        });

        // Apply filters
        if ($request->has('status')) {
            $query->where('status', $request->status);
        }

        if ($request->has('transfer_type')) {
            $query->where('transfer_type', $request->transfer_type);
        }

        if ($request->has('from_date')) {
            $query->whereDate('created_at', '>=', $request->from_date);
        }

        if ($request->has('to_date')) {
            $query->whereDate('created_at', '<=', $request->to_date);
        }

        // Get transfers with all related data
        $transfers = $query->with([
            'fromAccount:id,user_id,account_number,account_type,account_name,current_balance,available_balance',
            'toAccount:id,user_id,account_number,account_type,account_name,current_balance,available_balance'
        ])->latest()
            ->paginate($request->get('per_page', 20));

        // Get transfer IDs to fetch related transactions
        $transferIds = $transfers->pluck('id')->toArray();

        // Get all related transactions for these transfers
        $fromAccountIds = $transfers->pluck('from_account_id')->filter()->toArray();
        $toAccountIds = $transfers->pluck('to_account_id')->filter()->toArray();
        $accountIds = array_merge($fromAccountIds, $toAccountIds);

        $transactions = Transaction::whereIn('account_id', $accountIds)
            ->where(function($q) use ($transfers) {
                foreach ($transfers as $transfer) {
                    $q->orWhere(function($subQ) use ($transfer) {
                        $subQ->where('account_id', $transfer->from_account_id)
                            ->where('amount', $transfer->amount)
                            ->where('transaction_type', $transfer->transfer_type)
                            ->whereBetween('created_at', [
                                $transfer->created_at->subMinutes(5),
                                $transfer->created_at->addMinutes(5)
                            ]);
                    });

                    if ($transfer->to_account_id) {
                        $q->orWhere(function($subQ) use ($transfer) {
                            $subQ->where('account_id', $transfer->to_account_id)
                                ->where('amount', $transfer->amount)
                                ->where('transaction_type', $transfer->transfer_type)
                                ->whereBetween('created_at', [
                                    $transfer->created_at->subMinutes(5),
                                    $transfer->created_at->addMinutes(5)
                                ]);
                        });
        
    
            })
            ->get()
            ->groupBy('account_id');

        // Format the response with comprehensive data
        $formattedTransfers = $transfers->map(function($transfer) use ($transactions, $user) {
            $fromTransactions = $transactions->get($transfer->from_account_id, collect());
            $toTransactions = $transfer->to_account_id ? $transactions->get($transfer->to_account_id, collect()) : collect();

            return [
                'id' => $transfer->id,
                'transfer_id' => $transfer->transfer_id,
                'transfer_type' => $transfer->transfer_type,
                'amount' => $transfer->amount,
                'status' => $transfer->status,
                'description' => $transfer->description,
                'scheduled_date' => $transfer->scheduled_date,
                'completed_date' => $transfer->completed_date,
                'failed_date' => $transfer->failed_date,
                'failure_reason' => $transfer->failure_reason,
                'fee_amount' => $transfer->fee_amount,
                'exchange_rate' => $transfer->exchange_rate,
                'reference_number' => $transfer->reference_number,
                'created_at' => $transfer->created_at,
                'updated_at' => $transfer->updated_at,

                // From Account Details
                'from_account' => $transfer->fromAccount ? [
                    'id' => $transfer->fromAccount->id,
                    'account_number' => $transfer->fromAccount->account_number,
                    'masked_account_number' => $transfer->fromAccount->masked_account_number ?? $this->maskAccountNumber($transfer->fromAccount->account_number),
                    'account_type' => $transfer->fromAccount->account_type,
                    'account_name' => $transfer->fromAccount->account_name,
                    'current_balance' => $transfer->fromAccount->current_balance,
                    'available_balance' => $transfer->fromAccount->available_balance,
                ] : null,

                // To Account Details (for internal transfers)
                'to_account' => $transfer->toAccount ? [
                    'id' => $transfer->toAccount->id,
                    'account_number' => $transfer->toAccount->account_number,
                    'masked_account_number' => $transfer->toAccount->masked_account_number ?? $this->maskAccountNumber($transfer->toAccount->account_number),
                    'account_type' => $transfer->toAccount->account_type,
                    'account_name' => $transfer->toAccount->account_name,
                    'current_balance' => $transfer->toAccount->current_balance,
                    'available_balance' => $transfer->toAccount->available_balance,
                ] : null,

                // External account info (for ACH/Wire transfers)
                'external_account' => !$transfer->to_account_id ? [
                    'account_name' => $transfer->description ?
                        (strpos($transfer->description, 'to ') !== false ?
                            trim(substr($transfer->description, strpos($transfer->description, 'to ') + 3)) :
                            null) : null,
                ] : null,

                // Related Transactions
                'transactions' => [
                    'debit_transaction' => $fromTransactions->where('debit', '>', 0)->first() ? [
                        'id' => $fromTransactions->where('debit', '>', 0)->first()->id,
                        'transaction_id' => $fromTransactions->where('debit', '>', 0)->first()->transaction_id,
                        'account_id' => $fromTransactions->where('debit', '>', 0)->first()->account_id,
                        'transaction_type' => $fromTransactions->where('debit', '>', 0)->first()->transaction_type,
                        'description' => $fromTransactions->where('debit', '>', 0)->first()->description,
                        'amount' => $fromTransactions->where('debit', '>', 0)->first()->amount,
                        'debit' => $fromTransactions->where('debit', '>', 0)->first()->debit,
                        'credit' => $fromTransactions->where('debit', '>', 0)->first()->credit,
                        'balance_after' => $fromTransactions->where('debit', '>', 0)->first()->balance_after,
                        'status' => $fromTransactions->where('debit', '>', 0)->first()->status,
                        'transaction_date' => $fromTransactions->where('debit', '>', 0)->first()->transaction_date,
                        'posted_date' => $fromTransactions->where('debit', '>', 0)->first()->posted_date,
                        'recipient_name' => $fromTransactions->where('debit', '>', 0)->first()->recipient_name,
                        'recipient_account' => $fromTransactions->where('debit', '>', 0)->first()->recipient_account,
                        'reference_number' => $fromTransactions->where('debit', '>', 0)->first()->reference_number,
                        'created_at' => $fromTransactions->where('debit', '>', 0)->first()->created_at,
                        'updated_at' => $fromTransactions->where('debit', '>', 0)->first()->updated_at,
                    ] : null,

                    'credit_transaction' => $toTransactions->where('credit', '>', 0)->first() ? [
                        'id' => $toTransactions->where('credit', '>', 0)->first()->id,
                        'transaction_id' => $toTransactions->where('credit', '>', 0)->first()->transaction_id,
                        'account_id' => $toTransactions->where('credit', '>', 0)->first()->account_id,
                        'transaction_type' => $toTransactions->where('credit', '>', 0)->first()->transaction_type,
                        'description' => $toTransactions->where('credit', '>', 0)->first()->description,
                        'amount' => $toTransactions->where('credit', '>', 0)->first()->amount,
                        'debit' => $toTransactions->where('credit', '>', 0)->first()->debit,
                        'credit' => $toTransactions->where('credit', '>', 0)->first()->credit,
                        'balance_after' => $toTransactions->where('credit', '>', 0)->first()->balance_after,
                        'status' => $toTransactions->where('credit', '>', 0)->first()->status,
                        'transaction_date' => $toTransactions->where('credit', '>', 0)->first()->transaction_date,
                        'posted_date' => $toTransactions->where('credit', '>', 0)->first()->posted_date,
                        'reference_number' => $toTransactions->where('credit', '>', 0)->first()->reference_number,
                        'created_at' => $toTransactions->where('credit', '>', 0)->first()->created_at,
                        'updated_at' => $toTransactions->where('credit', '>', 0)->first()->updated_at,
                    ] : null,
                ],

                // Transfer direction relative to user
                'direction' => $transfer->fromAccount && $transfer->fromAccount->user_id == $user->id ? 'outgoing' : 'incoming',
            ];
        });

        return response()->json([
            'success' => true,
            'data' => [
                'transfers' => $formattedTransfers,
                'pagination' => [
                    'current_page' => $transfers->currentPage(),
                    'last_page' => $transfers->lastPage(),
                    'per_page' => $transfers->perPage(),
                    'total' => $transfers->total(),
                    'from' => $transfers->firstItem(),
                    'to' => $transfers->lastItem(),
                ],
                'filters' => [
                    'status' => $request->get('status'),
                    'transfer_type' => $request->get('transfer_type'),
                    'from_date' => $request->get('from_date'),
                    'to_date' => $request->get('to_date'),
                ]
            ]
        ]);
    }

    /**
     * Helper method to mask account numbers
     */
    private function maskAccountNumber($accountNumber)
    {
        if (!$accountNumber || strlen($accountNumber) < 4) {
            return $accountNumber;
        }

        return str_repeat('*', strlen($accountNumber) - 4) . substr($accountNumber, -4);
    }
}