<?php

namespace App\Http\Controllers;

use App\Models\CompanyInfo;
use App\Models\FundTreansfer;
use App\Models\Payment;
use App\Models\Qouta;
use App\Models\TransactionHistory;
use App\Models\User;
use Barryvdh\DomPDF\Facade\Pdf;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;

class PaymentController extends Controller
{
    public function list()
    {
        $user = auth()->user();

        if (in_array($user->role, [1, 2, 3])) {
            $payments = Payment::latest()->get();
        } else {
            $payments = Payment::where('agency_id', $user->company_id)
                ->latest()
                ->get();
        }

        return view('payment.list', compact('payments'));
    }

    public function create()
    {
        $agencies = CompanyInfo::latest()->get();

        return view('payment.create', compact('agencies'));
    }

    public function getByAgency($agencyId)
    {
        return User::where('company_id', $agencyId)->get(['id', 'name', 'phone']);
    }

    public function store(Request $request)
    {
        // dd($request->all());
        $request->validate([
            'agency_id' => 'nullable|exists:company_infos,id',
            'user_id' => 'nullable|exists:users,id',
            'type' => 'required|in:cash,check,iban',
            'bank_name' => 'nullable|string|max:255',
            'amount' => 'required|numeric|min:1',
            'transaction_id' => 'required|string',
            'currency' => 'required|in:BDT,SAR',
            'currency_rate' => 'nullable|string',
            'total_amount' => 'nullable|string',
            'proof' => 'nullable|file|mimes:jpg,png,pdf|max:2048',
            'additional' => 'nullable|string',
            'paid' => 'date',
        ]);

        $payment = new Payment;
        $payment->agency_id = $request->agency_id ?? auth()->user()->company_id;
        $payment->user_id = $request->user_id ?? auth()->user()->id;
        $payment->type = $request->type;
        $payment->bank_name = $request->bank_name;
        $payment->amount = $request->amount;
        $payment->transaction_id = $request->transaction_id;
        $payment->currency = $request->currency;
        $payment->currency_rate = $request->currency_rate;
        if ($request->currency === 'SAR' && $request->currency_rate) {
            $payment->total_amount = $request->total_amount ?? ($request->amount * floatval($request->currency_rate));
        } else {
            $payment->total_amount = $request->total_amount ?? $request->amount;
        }
        $payment->additional = $request->additional;
        $payment->paid = $request->paid ?? now();

        if ($request->hasFile('proof')) {
            $payment->proof = $request->file('proof')->store('payments', 'public');
        }

        $payment->save();

        return redirect()->back()->with('success', 'Payment stored successfully.');
    }
    // public function approve(Request $request, Payment $payment)
    // {
    //     $payment->status = $request->status ?? 0;
    //     $payment->save();
    //     return back()->with('success', 'Payment status updated');
    // }

    public function edit(Payment $payment)
    {
        $agencies = CompanyInfo::latest()->get();

        return view('payment.edit', compact('payment', 'agencies'));
    }

    public function update(Request $request, Payment $payment)
    {
        $validated = $request->validate([
            'agency_id' => 'required|exists:company_infos,id',
            'user_id' => 'required|exists:users,id',
            'type' => 'required|in:cash,check,iban',
            'bank_name' => 'nullable|string|max:255',
            'amount' => 'required|numeric|min:1',
            'transaction_id' => 'required|string',
            'currency' => 'required|in:BDT,SAR',
            'currency_rate' => 'nullable|numeric|min:0',
            'total_amount' => 'nullable|numeric|min:0',
            'proof' => 'nullable|file|mimes:jpg,png,pdf|max:2048',
            'additional' => 'nullable|string',
            'status' => 'nullable|in:0,1,2,3,4',
        ]);

        // Fill direct attributes
        $payment->fill([
            'agency_id' => $validated['agency_id'],
            'user_id' => $validated['user_id'],
            'type' => $validated['type'],
            'bank_name' => $validated['bank_name'] ?? null,
            'amount' => $validated['amount'],
            'transaction_id' => $validated['transaction_id'],
            'currency' => $validated['currency'],
            'currency_rate' => $validated['currency_rate'] ?? null,
            'additional' => $validated['additional'] ?? null,
        ]);

        // Calculate total amount
        $payment->total_amount = $validated['total_amount']
            ?? ($validated['currency'] === 'SAR' && $validated['currency_rate']
                ? $validated['amount'] * floatval($validated['currency_rate'])
                : $validated['amount']);

        // Handle file upload
        if ($request->hasFile('proof')) {
            $payment->proof = $request->file('proof')->store('payments', 'public');
        }

        $user = auth()->user();
        $userRole = $user->role;
        $requestedStatus = $validated['status'] ?? null;

        // Handle approval and status changes
        if ($requestedStatus == 1) {
            if (in_array($userRole, [1, 2, 3])) {
                $payment->status = 1;
                $payment->approved_by = $user->id;

                // Create transaction history
                if (TransactionHistory::where('source_table', 'payments')->where('source_id', $payment->id)->exists()) {
                    return back()->with('error', 'This payment has already been approved and recorded in transaction history.');
                }
                $txn = new TransactionHistory([
                    'agency_id' => $payment->agency_id,
                    'source_table' => 'payments',
                    'source_id' => $payment->id,
                    'currency' => $payment->currency,
                    'tnx_type' => 'Deposit',
                    'amount' => $payment->total_amount,
                    'note' => 'Payment approved '.$user->name.' with Transaction ID: '.$payment->transaction_id,
                    'created_at' => $request->paid ?? now(),
                ]);

                $agency = CompanyInfo::find($payment->agency_id);
                if ($agency) {
                    $oldBalance = $payment->currency === 'SAR' ? $agency->sar_acct : $agency->bdt_acct;
                    $newBalance = $oldBalance + $payment->total_amount;

                    $txn->old_balance = $oldBalance;
                    $txn->new_balance = $newBalance;
                    if ($payment->currency === 'SAR') {
                        $agency->sar_acct = $newBalance;
                    } elseif ($payment->currency === 'BDT') {
                        $agency->bdt_acct = $newBalance;
                    }
                    $agency->save();
                } else {
                    $txn->old_balance = 0;
                    $txn->new_balance = $payment->total_amount;
                }

                $txn->save();

            } else {
                return back()->with('error', 'You are not authorized to approve payments.');
            }

        } elseif (in_array($requestedStatus, [0, 2, 3, 4])) {

            if (in_array($userRole, [1, 2, 3])) {
                if ($payment->status == 1) {
                    // Revoke previous approval
                    TransactionHistory::where('source_table', 'payments')
                        ->where('source_id', $payment->id)
                        ->delete();

                    $agency = CompanyInfo::find($payment->agency_id);
                    if ($agency) {
                        if ($request->currency === 'SAR') {
                            $agency->sar_acct -= $payment->amount;
                        } elseif ($request->currency === 'BDT') {
                            $agency->bdt_acct -= $payment->amount;
                        }
                        $agency->save();
                    }
                    $payment->approved_by = null;
                }

                $payment->status = $requestedStatus;

            } elseif (in_array($userRole, [4, 5])) {
                $payment->status = 0;
                $payment->approved_by = null;
            } else {
                return back()->with('error', 'You are not authorized to change payment status.');
            }
        }

        $payment->save();

        return redirect()->back()->with('success', 'Payment updated successfully.');
    }

    public function delete(Payment $payment)
    {

        if ($payment->proof && Storage::disk('public')->exists($payment->proof)) {
            Storage::disk('public')->delete($payment->proof);
        }
        $payment->delete();

        return redirect()->back()->with('success', 'Payment deleted successfully.');
    }

    // Get Agency Balance
    public function getAgencyBalance($id)
    {
        $agency = CompanyInfo::find($id);
        if (! $agency) {
            return response()->json(['error' => 'Agency not found'], 404);
        }

        return response()->json([
            'bdt_acct' => $agency->bdt_acct,
            'sar_acct' => $agency->sar_acct,
        ]);
    }

    // Transaction History

    public function allTransaction(Request $request)
    {
        $user = auth()->user();
        $query = TransactionHistory::with('agency');

        // Role-based data restriction
        if (! in_array($user->role, [1, 2, 3])) {
            $query->where('agency_id', $user->company_id);
        }

        // AJAX DataTable request
        if ($request->ajax()) {
            if ($request->filled('agency_id')) {
                $query->where('agency_id', $request->agency_id);
            }

            if ($request->filled('tnx_type')) {
                $query->where('tnx_type', $request->tnx_type);
            }

            if ($request->filled('currency')) {
                $query->where('currency', $request->currency);
            }

            if ($request->filled('from_date') && $request->filled('to_date')) {
                $from = date('Y-m-d 00:00:00', strtotime($request->from_date));
                $to = date('Y-m-d 23:59:59', strtotime($request->to_date));
                if ($from && $to) {
                    $query->whereBetween('created_at', [$from, $to]);
                }
            }

            return datatables()->of($query->latest())
                ->addIndexColumn()
                ->addColumn('agency', function ($row) {
                    return $row->agency->name ?? 'N/A';
                })
                ->addColumn('action', function ($row) {
                    return '<a href="'.route('transaction.view', $row->id).'" class="btn btn-sm btn-info">View</a>';
                })
                ->rawColumns(['action'])
                ->make(true);
        }

        // Load agencies for the view
        $agencies = CompanyInfo::all();

        return view('admin.transaction.list', compact('agencies'));
    }

    public function agencyTransactionList(Request $request)
    {
        if ($request->ajax()) {
            $query = $request->get('query');

            $agencies = CompanyInfo::where('name', 'LIKE', '%'.$query.'%')
                ->orderBy('created_at', 'desc')
                ->get();

            return response()->json([
                'html' => view('admin.transaction.partials.agency_rows', compact('agencies'))->render(),
            ]);
        }
        $agencies = CompanyInfo::latest()->get();

        return view('admin.transaction.agency_list', compact('agencies'));
    }

    public function agencyTransaction($agency)
    {
        $transactions = TransactionHistory::with('agency')->where('agency_id', $agency)->latest()->get();
        $agencyName = CompanyInfo::where('id', $agency)->value('name');

        return view('admin.transaction.agency', compact('transactions', 'agencyName'));
    }

    // public function showTransaction($id)
    // {
    //     $transaction = TransactionHistory::with('agency')->find($id);

    //     if (! $transaction) {
    //         return redirect()->back()->with('error', 'Transaction not found.');
    //     }

    //     switch ($this->source_table) {
    //     case 'payments':
    //         return Payment::find($this->source_id);
    //     case 'fund_treansfers':
    //         return FundTreansfer::find($this->source_id);
    //     default:
    //         return null;

    //     return view('admin.transaction.transaction_detials', compact('transaction'));
    // }

    public function showTransaction($id)
    {
        $transaction = TransactionHistory::with('agency')->find($id);

        if (! $transaction) {
            return redirect()->back()->with('error', 'Transaction not found.');
        }

        $source = match ($transaction->source_table) {
            'payments' => Payment::find($transaction->source_id),
            'fund_transfers' => FundTreansfer::find($transaction->source_id),
            default => null,
        };

        return view('admin.transaction.transaction_detials', compact('transaction', 'source'));
    }

    public function downloadInvoicePdf($id)
    {
        $transaction = TransactionHistory::with('agency')->find($id);

        if (! $transaction) {
            return redirect()->back()->with('error', 'Transaction not found.');
        }

        $source = match ($transaction->source_table) {
            'payments' => Payment::find($transaction->source_id),
            'fund_transfers' => FundTreansfer::find($transaction->source_id),
            default => null,
        };

        $pdf = Pdf::loadView('admin.transaction.invoice', compact('transaction', 'source'))
            ->setPaper('A4', 'portrait');

        return $pdf->download("invoice-{$transaction->id}.pdf");
    }
}