<?php

namespace App\Http\Controllers;

use App\Models\Payment;
use Razorpay\Api\Api;
use Illuminate\Support\Facades\Log;
use App\Models\SubscriptionPlan;
use App\Models\UserSubscription;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Cookie;

class SubscriptionPlanController extends Controller
{
    public $userId = '';
    public $orderId = '';
    public $amount = '';
    public $status = '';
    public $razorpaySignature = '';
    public $subscriptionPlanId = '';
    public $razorpayPaymentId = '';
    public $subscription = '';
    public $paymentEntity = '';
    public $subscriptionPlanPeriod = '';
    public $subscriptionId ='';
    public $endTime = '';

    public function buy_subscription_plan($id)
    {
        try {
            $plan = SubscriptionPlan::where('subscription_plan_id', $id)->first();
            if (!$plan) {
                return response()->json(['error' => 'Invalid plan selected.'], 400);
            }
    
            $razorpayKeyId = env('RAZORPAY_KEY_ID');
            $razorpayKeySecret = env('RAZORPAY_KEY_SECRET');
            $api = new Api($razorpayKeyId, $razorpayKeySecret);
    
            $subscription = $api->subscription->create([
                'plan_id' => $id,
                'total_count' => 12,
                'notes' => [
                    'name' => auth()->user()->first_name,
                    'email' => auth()->user()->email,
                    'id' => auth()->user()->id,
                    'planAmount' => $plan->price


                ],
            ]);
            if ($subscription) {
                return redirect()->away($subscription->short_url);
            }
        } catch (\Exception $e) {
            Log::error('Subscription Plan Error', ['message' => $e->getMessage()]);
            return response()->json(['error' => 'Unable to process subscription. Please try again later.'], 500);
        }
    }
    public function paymentCallback(Request $request)
    {
        // dd(Auth::check());
        $paymentData = $request->all();
        $razorpayKeyId = env('RAZORPAY_KEY_ID');
        $razorpayKeySecret = env('RAZORPAY_KEY_SECRET');
        $api = new Api($razorpayKeyId, $razorpayKeySecret);
    
        try {
            $attributes = [
                'razorpay_order_id' => $paymentData['razorpay_order_id'],
                'razorpay_payment_id' => $paymentData['razorpay_payment_id'],
                'razorpay_signature' => $paymentData['razorpay_signature'],
            ];
    
            $api->utility->verifyPaymentSignature($attributes);
    
            $payment = Payment::where('razorpay_payment_link_id', $paymentData['razorpay_order_id'])->firstOrFail();
            $payment->status = 'completed';
            $payment->save();
    
            $userSubscription = new UserSubscription;
            $userSubscription->user_id = $payment->user_id;
            $userSubscription->subscription_plan_id = $payment->subscription_plan_id;
            $userSubscription->start_date = now();
            $userSubscription->end_date = now()->addMonths($payment->subscription_plan->duration);
            $userSubscription->status = 'active';
            $userSubscription->save();
    
            return response()->json(['message' => 'Payment verified successfully']);
        } catch (\Exception $e) {
            Log::error('Payment Callback Error', ['message' => $e->getMessage()]);
            return response()->json(['error' => 'Payment verification failed'], 400);
        }
    }
 public function handleWebhook(Request $request)
    {
        $input = $request->all();
        Log::info('Webhook Payload:', $input); // Logs payload for debugging
        // dd($input);
        return $this->handleEvent($input);
    }
    /**
     * Handle the Razorpay subscription event
     */

    private function handleEvent(array $input)
 { 
     Log::info('Webhook event key missing', ['payload' => $input]); 
 
    $this->subscriptionPlanId = $input['payload']['subscription']['entity']['plan_id'] ?? '';
    $this->status = $input['payload']['subscription']['entity']['status'] ?? '';
    $this->subscriptionId = $input['payload']['subscription']['entity']['id'] ?? '';
    $this->amount = $input['payload']['subscription']['entity']['notes']['planAmount'] ?? '';
    $this->userId = $input['payload']['subscription']['entity']['notes']['id'] ?? '';
    $this->razorpayPaymentId = $input['subscription']['payment']['entity']['id'] ?? '';
    $this->orderId = $input['subscription']['payment']['entity']['order_id'] ?? '';
    $this->endTime = $input['subscription']['subscription']['entity']['end_at'] ?? '';
    if ($this->endTime) {
        $this->endTime = Carbon::createFromTimestamp($this->endTime)->toDateTimeString();
    }
    switch ($input['event']) {
        case 'subscription.paused':
            return $this->handleSubscriptionPaused($input); //
        case 'subscription.activated':
            return $this->handleSubscriptionActivated($input);//
        case 'subscription.cancelled':
            return $this->handleSubscriptionCancelled($input); //
        case 'subscription.updated':
            return $this->handleSubscriptionUpdated($input); //
        default:
            Log::info('Unrecognized Razorpay Event', ['event' => $input['event']]);
            return response()->json(['message' => 'Event not recognized']);
    }
 }

    /**
     * Handle subscription authenticated event
     */

    /**
     * Handle subscription paused event
     */
    private function handleSubscriptionPaused(array $input)
    {
        Log::info('Subscription Paused', ['subscription' => $input['payload']]);
         // Extract the subscription ID from the payload
         $subscription = UserSubscription::where('subscription_id', $this->subscriptionId)->first();
         if ($subscription) {
            // Update the subscription status to 'Paused'
            $subscription->status = UserSubscription::Paused;
            $subscription->cancelled_at = now();
            $subscription->save();
    
            return response()->json(['message' => 'Subscription cancellation handled successfully']);
        } 
        return response()->json(['message' => 'Subscription paused handled']);
    }

    /**
     * Handle subscription activated event
     */
    private function handleSubscriptionActivated(array $input)
    {
        Log::info('Subscription Activated', ['subscription' => $input['payload']]);
        Log::info('End Time Value', ['endTime' => $this->endTime]);
        $this->findOrCreate($input);
        try {
            $userSubscription = new UserSubscription;
            $userSubscription->user_id = $this->userId;
            $userSubscription->subscription_plan_id = $this->subscriptionPlanId;
            $userSubscription->start_date = now();
            $userSubscription->end_date = !empty($this->endTime) ? $this->endTime : now()->addMonths(1);
            $userSubscription->status =  UserSubscription::Active;// Set the status to active
            $userSubscription->subscription_id = $this->subscriptionId;
            $userSubscription->save();

            Log::info('User subscription Completed', ['subscription' => $userSubscription]);
            return $userSubscription;
        } catch (\Exception $e) {
            Log::error('Failed to create user subscription', ['error' => $e->getMessage()]);
            throw new \Exception("Failed to create user subscription");
        }
       
        // Add your logic here (e.g., update status to active, start service, etc.)
        return response()->json(['message' => 'Subscription activated handled']);
    }

    /**
     * Handle subscription cancelled event
     */
    private function handleSubscriptionCancelled(array $input)
    {
        Log::info('Subscription Cancelled', ['subscription' => $input['payload']]);
         // Extract the subscription ID from the payload
         $subscription = UserSubscription::where('subscription_id', $this->subscriptionId)->first();
         if ($subscription) {
            // Update the subscription status to 'cancelled'
            $subscription->status = UserSubscription::Cancel;
            $subscription->save();
    
            return response()->json(['message' => 'Subscription cancellation handled successfully']);
        }
        return response()->json(['message' => 'Subscription cancelled handled']);
    }

    /**
     * Handle subscription updated event
     */
    private function handleSubscriptionUpdated(array $input)
    {
        Log::info('Subscription Updated', ['subscription' => $input['payload']]);
        // Add your logic here (e.g., update subscription details, notify user, etc.)
        return response()->json(['message' => 'Subscription updated handled']);
    }

    private function findOrCreate()
    {
        // Save the payment details to the database
        $payment = Payment::firstOrCreate(
            [
                'user_id' => $this->userId,
                'subscription_plan_id' => $this->subscriptionPlanId,
                'razorpay_payment_id' => $this->razorpayPaymentId,
                'razorpay_order_id' => $this->orderId,
                'razorpay_signature' => $this->orderId,
                'amount' => $this->amount,
                'status' => $this->status,
            ]
        );
        Log::info('Payment record saved or updated', ['payment' => $payment]);
    
        return response()->json(['message' => 'Payment verified successfully and subscription created']);
    }
}