namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Models\Deposit;
use App\Models\Withdrawal;
use App\Models\Transaction;
use App\Services\Wallet\WalletService;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

class PaymentController extends Controller
{
    protected $walletService;

    public function __construct(WalletService $walletService)
    {
        $this->walletService = $walletService;
    }

    // Deposits Management
    public function deposits(Request $request)
    {
        $query = Deposit::with(['user', 'transaction']);

        // Search
        if ($request->has('search')) {
            $search = $request->search;
            $query->whereHas('user', function($q) use ($search) {
                $q->where('username', 'like', "%{$search}%")
                  ->orWhere('email', 'like', "%{$search}%");
            });
        }

        // Filter by status
        if ($request->has('status') && $request->status != 'all') {
            $query->where('status', $request->status);
        }

        // Filter by payment method
        if ($request->has('method') && $request->method != 'all') {
            $query->where('payment_method', $request->method);
        }

        // Filter by date range
        if ($request->has('date_from')) {
            $query->whereDate('created_at', '>=', $request->date_from);
        }
        if ($request->has('date_to')) {
            $query->whereDate('created_at', '<=', $request->date_to);
        }

        $deposits = $query->latest()->paginate(20);

        $stats = [
            'total' => Deposit::count(),
            'pending' => Deposit::where('status', 'pending')->count(),
            'completed' => Deposit::where('status', 'completed')->count(),
            'total_amount' => Deposit::where('status', 'completed')->sum('amount'),
        ];

        return view('admin.payments.deposits', compact('deposits', 'stats'));
    }

    public function showDeposit(Deposit $deposit)
    {
        $deposit->load(['user', 'transaction', 'user.wallet']);

        return view('admin.payments.deposit-details', compact('deposit'));
    }

    public function approveDeposit(Request $request, Deposit $deposit)
    {
        $request->validate([
            'notes' => 'nullable|string|max:500',
        ]);

        if ($deposit->status !== 'pending') {
            return back()->with('error', 'This deposit is already processed.');
        }

        try {
            DB::beginTransaction();

            // Update deposit
            $deposit->update([
                'status' => 'completed',
                'processed_by' => auth()->guard('admin')->id(),
                'processed_at' => now(),
                'notes' => $request->notes,
            ]);

            // Update transaction
            $deposit->transaction->update([
                'status' => 'completed',
                'approved_by' => auth()->guard('admin')->id(),
                'approved_at' => now(),
            ]);

            // Credit user wallet
            $deposit->user->creditWallet(
                $deposit->amount,
                'Deposit approved: ' . $deposit->transaction->transaction_id,
                'deposit',
                $deposit
            );

            DB::commit();

            // Log activity
            auth()->guard('admin')->user()->logActivity(
                'Approved deposit #' . $deposit->id,
                ['deposit_id' => $deposit->id, 'amount' => $deposit->amount]
            );

            return back()->with('success', 'Deposit approved successfully.');

        } catch (\Exception $e) {
            DB::rollBack();
            return back()->with('error', 'Failed to approve deposit: ' . $e->getMessage());
        }
    }

    public function rejectDeposit(Request $request, Deposit $deposit)
    {
        $request->validate([
            'reason' => 'required|string|max:500',
        ]);

        if ($deposit->status !== 'pending') {
            return back()->with('error', 'This deposit is already processed.');
        }

        try {
            DB::beginTransaction();

            // Update deposit
            $deposit->update([
                'status' => 'failed',
                'processed_by' => auth()->guard('admin')->id(),
                'processed_at' => now(),
                'notes' => $request->reason,
            ]);

            // Update transaction
            $deposit->transaction->update([
                'status' => 'failed',
                'approved_by' => auth()->guard('admin')->id(),
                'approved_at' => now(),
            ]);

            DB::commit();

            // Log activity
            auth()->guard('admin')->user()->logActivity(
                'Rejected deposit #' . $deposit->id,
                ['deposit_id' => $deposit->id, 'reason' => $request->reason]
            );

            return back()->with('success', 'Deposit rejected.');

        } catch (\Exception $e) {
            DB::rollBack();
            return back()->with('error', 'Failed to reject deposit: ' . $e->getMessage());
        }
    }

    // Withdrawals Management
    public function withdrawals(Request $request)
    {
        $query = Withdrawal::with(['user', 'transaction']);

        // Search
        if ($request->has('search')) {
            $search = $request->search;
            $query->whereHas('user', function($q) use ($search) {
                $q->where('username', 'like', "%{$search}%")
                  ->orWhere('email', 'like', "%{$search}%");
            });
        }

        // Filter by status
        if ($request->has('status') && $request->status != 'all') {
            $query->where('status', $request->status);
        }

        // Filter by withdrawal method
        if ($request->has('method') && $request->method != 'all') {
            $query->where('withdrawal_method', $request->method);
        }

        // Filter by date range
        if ($request->has('date_from')) {
            $query->whereDate('created_at', '>=', $request->date_from);
        }
        if ($request->has('date_to')) {
            $query->whereDate('created_at', '<=', $request->date_to);
        }

        $withdrawals = $query->latest()->paginate(20);

        $stats = [
            'total' => Withdrawal::count(),
            'pending' => Withdrawal::where('status', 'pending')->count(),
            'completed' => Withdrawal::where('status', 'completed')->count(),
            'total_amount' => Withdrawal::where('status', 'completed')->sum('amount'),
        ];

        return view('admin.payments.withdrawals', compact('withdrawals', 'stats'));
    }

    public function showWithdrawal(Withdrawal $withdrawal)
    {
        $withdrawal->load(['user', 'transaction', 'user.wallet']);

        return view('admin.payments.withdrawal-details', compact('withdrawal'));
    }

    public function approveWithdrawal(Request $request, Withdrawal $withdrawal)
    {
        $request->validate([
            'transaction_id' => 'required|string|max:255',
            'notes' => 'nullable|string|max:500',
        ]);

        if ($withdrawal->status !== 'pending') {
            return back()->with('error', 'This withdrawal is already processed.');
        }

        try {
            DB::beginTransaction();

            // Update withdrawal
            $withdrawal->update([
                'status' => 'completed',
                'processed_by' => auth()->guard('admin')->id(),
                'processed_at' => now(),
                'admin_notes' => $request->notes,
                'gateway_transaction_id' => $request->transaction_id,
            ]);

            // Update transaction
            $withdrawal->transaction->update([
                'status' => 'completed',
                'approved_by' => auth()->guard('admin')->id(),
                'approved_at' => now(),
            ]);

            DB::commit();

            // Log activity
            auth()->guard('admin')->user()->logActivity(
                'Approved withdrawal #' . $withdrawal->id,
                ['withdrawal_id' => $withdrawal->id, 'amount' => $withdrawal->amount]
            );

            return back()->with('success', 'Withdrawal approved successfully.');

        } catch (\Exception $e) {
            DB::rollBack();
            return back()->with('error', 'Failed to approve withdrawal: ' . $e->getMessage());
        }
    }

    public function rejectWithdrawal(Request $request, Withdrawal $withdrawal)
    {
        $request->validate([
            'reason' => 'required|string|max:500',
        ]);

        if ($withdrawal->status !== 'pending') {
            return back()->with('error', 'This withdrawal is already processed.');
        }

        try {
            DB::beginTransaction();

            // Update withdrawal
            $withdrawal->update([
                'status' => 'rejected',
                'processed_by' => auth()->guard('admin')->id(),
                'processed_at' => now(),
                'admin_notes' => $request->reason,
            ]);

            // Update transaction
            $withdrawal->transaction->update([
                'status' => 'cancelled',
                'approved_by' => auth()->guard('admin')->id(),
                'approved_at' => now(),
            ]);

            // Refund to wallet
            $withdrawal->user->creditWallet(
                $withdrawal->amount,
                'Withdrawal rejected: ' . $withdrawal->transaction->transaction_id,
                'refund',
                $withdrawal
            );

            DB::commit();

            // Log activity
            auth()->guard('admin')->user()->logActivity(
                'Rejected withdrawal #' . $withdrawal->id,
                ['withdrawal_id' => $withdrawal->id, 'reason' => $request->reason]
            );

            return back()->with('success', 'Withdrawal rejected and amount refunded.');

        } catch (\Exception $e) {
            DB::rollBack();
            return back()->with('error', 'Failed to reject withdrawal: ' . $e->getMessage());
        }
    }

    // Transactions Overview
    public function transactions(Request $request)
    {
        $query = Transaction::with(['user', 'wallet']);

        // Search
        if ($request->has('search')) {
            $search = $request->search;
            $query->where(function($q) use ($search) {
                $q->where('transaction_id', 'like', "%{$search}%")
                  ->orWhereHas('user', function($uq) use ($search) {
                      $uq->where('username', 'like', "%{$search}%")
                         ->orWhere('email', 'like', "%{$search}%");
                  });
            });
        }

        // Filter by type
        if ($request->has('type') && $request->type != 'all') {
            $query->where('type', $request->type);
        }

        // Filter by status
        if ($request->has('status') && $request->status != 'all') {
            $query->where('status', $request->status);
        }

        // Filter by date range
        if ($request->has('date_from')) {
            $query->whereDate('created_at', '>=', $request->date_from);
        }
        if ($request->has('date_to')) {
            $query->whereDate('created_at', '<=', $request->date_to);
        }

        $transactions = $query->latest()->paginate(20);

        $stats = [
            'total_volume' => Transaction::where('status', 'completed')->sum('amount'),
            'total_fees' => Transaction::where('status', 'completed')->sum('fee'),
            'avg_amount' => Transaction::where('status', 'completed')->avg('amount'),
        ];

        return view('admin.payments.transactions', compact('transactions', 'stats'));
    }
}