<?php

namespace Modules\Subscription\Http\Controllers;

use App\Models\Cart;
use App\Repositories\CartRepository;
use App\Services\CheckoutService;
use Modules\Subscription\Rules\PhoneFormat;
use Brian2694\Toastr\Facades\Toastr;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller;
use Modules\Subscription\Entities\AmazeSubscription;
use Modules\Subscription\Entities\SubscriptionSetting;
use Modules\PaymentGateway\Http\Controllers\StripeController;
use Modules\Account\Repositories\TransactionRepository;
use Modules\Account\Entities\Transaction;
use Modules\FrontendCMS\Entities\SubsciptionPaymentInfo;
use App\Traits\Accounts;
use App\Traits\SendMail;
use Carbon\Carbon;
use Exception;
use Modules\UserActivityLog\Traits\LogActivity;
use Stripe;
use Illuminate\Auth\Events\Registered;
use Modules\Subscription\Entities\SellerSubscription;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\File;
use Modules\Subscription\Entities\CustomerSubscription;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\Rule;
use Modules\PaymentGateway\Services\PaymentGatewayService;
use Modules\Product\Entities\Product;
use Modules\Seller\Entities\SellerProduct;
use Modules\Subscription\Entities\SubscriptionProductMeta;
use Modules\Subscription\Repositories\SubscriptionPlansRepository;
use Modules\Subscription\Repositories\SubscriptionCouponsRepository;
use Modules\WTIJobBoard\Repositories\JobRequestCategoriesRepository;
use Modules\Subscription\Rules\ZipCodeDeliverability;
use Modules\Subscription\Services\AugmentationService;
use Illuminate\Support\Facades\Session;
use Modules\Account\Entities\ChartOfAccount;
use Modules\Shipping\Entities\ShippingMethod;
use Modules\Subscription\Entities\SubscriptionPlan;
use Modules\Subscription\Entities\SubscriptionPlanPrice;
use Modules\Subscription\Entities\SubscriptionPlanPricePaypal;
use Modules\WTIJobBoard\Entities\JobRequest;
use Modules\Subscription\Services\PaypalPaymentService;

class SubscriptionController extends Controller
{
    use Accounts, SendMail;

    private $checkoutService;
    private $paymentGatewayService;
    private $subscriptionPlansRepository;
    private $subscriptionCouponsRepository;
    private $jobRequestCategoriesRepository;
    private $cartRepository;
    private $stripePayment;
    private $paypalPayment;

    public function __construct(CheckoutService $checkoutService, PaymentGatewayService $paymentGatewayService)
    {
        $this->checkoutService = $checkoutService;
        $this->paymentGatewayService = $paymentGatewayService;
        $this->subscriptionPlansRepository = new SubscriptionPlansRepository();
        $this->subscriptionCouponsRepository = new SubscriptionCouponsRepository();
        $this->jobRequestCategoriesRepository = new JobRequestCategoriesRepository();
        $this->cartRepository = new CartRepository(new Cart);
        $this->paypalPayment = new PaypalPaymentService();



        $credential = getPaymentInfoViaSellerId(1, 4);
        $this->stripePayment = new \Stripe\StripeClient([
          "api_key" => @$credential->perameter_3,
          "stripe_version" => "2022-11-15"
        ]);
    }

    protected function validator(array $data)
    {
        $rules = [
            'plan' => ['required']
        ];

        return Validator::make($data, $rules);
    }

    public function index()
    {
        new AugmentationService();

        try {
            $setting = SubscriptionSetting::getData();
            $plans = $this->subscriptionPlansRepository->getAll();
            return view('subscription::plan.index', compact('plans', 'setting'));

        } catch (\Exception $e) {
            Toastr::error(trans('common.Operation failed'), trans('common.Failed'));
            return redirect()->back();

        }
    }

    public function pixelmeDashboard() {
        return view('subscription::pixelme.dashboard');
    }

    public function checkout(Request $request) {
        $user = auth()->user();
        $billing_address = $user->customerBillingAddress;
        $view = $request->action;

        if ($request->action == 'payment') {
            $name = $request->name;
            $zipcode = $request->postal_code;
            $view = 'payment';

            $data = $request->except('_token');
            $data['name'] = $name;

            $cartData = [];
            $cartData['name'] = $data['name'];
            $cartData['email'] = $data['email'];
            $cartData['phone'] = $data['phone'];
            $cartData['address'] = $data['address'];
            $cartData['city'] = $data['city'];
            $cartData['state'] = $data['state'];
            $cartData['country'] = $data['country'];
            $cartData['postal_code'] = $data['postal_code'];
            session()->put('shipping_address', $cartData);

            $totalItemWeight = 0;
            $totalItemHeight = 0;
            $totalItemLength = 0;
            $totalItemBreadth = 0;
            $session_packages = [
                'totalItemWeight'=> $totalItemWeight,
                'totalItemHeight'=> $totalItemHeight,
                'totalItemLength'=> $totalItemLength,
                'totalItemBreadth'=> $totalItemBreadth,
            ];
            session(['single_package_height_weight_info' => $session_packages]);
            
            //$this->checkoutService->guestAddressStore($request->only('name','address','email','phone','country','state','city','postal_code'));

            $address_data = $request->only('name', 'address_id','address','email','phone','country','state','city','postal_code');

            $country = \Modules\Setup\Entities\Country::where('name', $address_data['country'])->first();
            $state = \Modules\Setup\Entities\State::where('name', $address_data['state'])->first();
            $city = \Modules\Setup\Entities\City::where('name', $address_data['city'])->first();

            $address_data['country'] = $country ? $country->id : null;
            $address_data['state'] = $state ? $state->id : null;
            $address_data['city'] = $city ? $city->id : null;

            $address = $user->customerBillingAddress;

            if ($address) {
                $address_data['address_id'] = $address->id;
                $this->checkoutService->addressUpdate($address_data);
            }
            else {
                $this->checkoutService->addressStore($address_data);
            }
        }
        else {
            $this->validator($request->all())->validate();
            session()->put('subscription_payment', true);
            $name = "{$user->first_name} {$user->last_name}";
            $zipcode = $user->zipcode;
        }

        $gateway_activations = $this->checkoutService->getActivePaymentGetways();
        $gateway_activations = $gateway_activations->whereIn('id', [4]);         // Allow only Stripe payment methods
        $gateway_activations = $gateway_activations->get();

        $first_name = $user->first_name;
        $last_name = $user->last_name;
        $email = $user->email;
        $phone = $user->phone;
        $total_amount = 0;

        $seller_product = SellerProduct::find($request->plan);

        if ($seller_product) {
            session()->put('selected_plan', $seller_product);
            $plan = $seller_product->product->plan;

            $cart_product['product_id'] = $seller_product->id;
            $cart_product['seller_id'] = $seller_product->product->seller->id;
            $cart_product['type'] = 'product';
            $cart_product['qty'] = 1;
            $cart_product['shipping_method_id'] = 0;
            $cart_product['is_buy_now'] = 'yes';
            $cart_product['price'] = $seller_product->skus->first()->selling_price;
            $this->cartRepository->store($cart_product);
        
            $cartDataGroup = $this->checkoutService->getCartItem();
            $cartData = $cartDataGroup['cartData'];
            $address = $this->checkoutService->activeShippingAddress();
            $giftCardExist = $cartDataGroup['gift_card_exist'];

            $total_amount = $seller_product->skus->first()->selling_price;
            $subtotal_without_discount = $total_amount;
            $discount = 0;
            $number_of_package = 1;
            $number_of_item = 1;
            $shipping_cost = 0;
            $selected_shipping_method = ShippingMethod::find(1);
            $tax_total = 0;
            $delivery_date = now();
            $packagewise_tax = 0;
            $actual_total = $total_amount;

            $address = $this->checkoutService->activeShippingAddress();
            $coupon = [];
            $coupon_amount = 0;

            $coupon = [];
            $infoCompleteOrder = [
                'cartData' => $cartData,
                'total_amount' => number_format($total_amount,2),
                'subtotal_without_discount' => $subtotal_without_discount,
                'discount' => $discount,
                'number_of_package' => $number_of_package,
                'number_of_item' => $number_of_item,
                'shipping_cost' => $shipping_cost,
                'selected_shipping_method' => $selected_shipping_method,
                'address' => $address,
                'gateway_activations' => $gateway_activations,
                'tax_total' => $tax_total,
                'delivery_date' => $delivery_date,
                'packagewise_tax' => $packagewise_tax,
                'actual_total' => $actual_total
            ];
            $infoCompleteOrder = array_merge($infoCompleteOrder, $coupon);
            session()->put('infoCompleteOrder', $infoCompleteOrder);
        }

        if ($request->action == 'payment') {
            for ($i = 0; $i < count($gateway_activations); $i++) {
                if ($gateway_activations[$i]->id == 1 || $gateway_activations[$i]->method == 'Cash On Delivery') {
                    unset($gateway_activations[$i]);
                    break;
                }
            }

            return response()->json([
                'gateway_activations' =>  (string)view('subscription::components._payment_method',compact('gateway_activations','total_amount')),
            ]);
        }
        else {
            return view('subscription::checkout', compact('view', 'gateway_activations', 'name', 'first_name', 'last_name', 'email', 'phone', 'zipcode', 'biling_address', 'seller_product', 'plan', 'total_amount'));
        }
    }

    public function mySubscription(Request $request)
    {
        if($request->has('subscription_id')){
            $subscription =   CustomerSubscription::where('txn_id',$request->subscription_id)->where('status','waiting for approval')->first();
            if($subscription){

                //for paypal only
                $response = $this->paypalPayment->showSubscription($request->subscription_id);
                if(isset($response->status)){
                    if($response->status == 'APPROVED'){
                        $this->sendSubscriptionPendingApproval($subscription->user,  ($subscription->user->company != null ? $user->company->storefront : ''));
                    } else if($response->status == 'APPROVAL_PENDING'){
                        $subscription->delete();
                    }
                }
            }
            
        }

        return view('subscription::subscription');
    }

    public function mySubscriptionData()
    {
        try {

            $current_subscription = CustomerSubscription::select(['approved','message','status'])->where('customer_id', auth()->user()->id)->latest()->first();
            $subscription_plans = $this->subscriptionPlansRepository->getAllSubscriptionPlans();
            $categories = $this->jobRequestCategoriesRepository->all(['active' => 1]);
            $subscriptions = CustomerSubscription::with('planPrice','discount.coupon','paymentCode.addons')->where('customer_id', auth()->user()->id)->latest()->get();
            //$has_prepaid = false;
            if ($subscriptions) {

                
                $subscriptions_data = [];

                foreach ($subscriptions as $subscription) {

                    // if($subscription->payment_code_id != null){
                    //     $has_prepaid = true;
                    // } 

                    $payment_details = '';
            
                    if ($subscription->planPrice->billing_type == 'Recurring') {

                        $price = $subscription->planPrice->price;
                        $price_monthly = $subscription->planPrice->price / $subscription->planPrice->custom_interval;

                        if ($subscription->planPrice->interval == 'Custom') {

                            if($subscription->payment_mode == 'Monthly'){
                                
                                $payment_details .= "\$".number_format($price_monthly,2)." / monthly for {$subscription->planPrice->custom_interval} Months";

                            } else {
 
                                $payment_details .= "\$".number_format($price,2)." for {$subscription->planPrice->custom_interval} {$subscription->planPrice->custom_interval_type}";
                            }

                        } else {
                            $payment_details .= "\${$subscription->planPrice->price} {$subscription->planPrice->interval}";
                        }


                        if($subscription->discount != null){
                            $duration = $subscription->discount->coupon->duration;
                            $coupon_payment_mode = $subscription->discount->coupon->payment_mode;
                            $discount = $subscription->discount->coupon->discount;

                            if ($subscription->discount->coupon->type == 'Amount') {
                                $discount_label = "<span class=\"text-success\">Save \${$discount}</span>";
                                $discounted_price_monthly = number_format($price_monthly - $discount,2);
                                $discounted_price_all = number_format($price - $discount,2);

                            } else {
                                $discount_label = "<span class=\"text-success\">Save \${$discount}%</span>";
                                $discounted_price_monthly = number_format($price_monthly - (($discount / 100) * $price_monthly),2);
                                $discounted_price_all =  $subscription->discount->coupon->duration == 'Once' ? number_format($price - (($discount / 100) * $price_monthly),2) : number_format($price - (($discount / 100) * $price),2);
                            }

                            $payment_details .= "<br> <span class=\"badge bg-info\">{$subscription->discount->coupon->code}</span>";

                            if ($subscription->planPrice->payment == 'monthly' ) {
                                $payment_details .= $duration == 'Once' ? " - \${$discounted_price_monthly}  1st month only)" : " | \${$discounted_price_monthly}  per month";
                            } else { 
                               $payment_details .= " - \${$discounted_price_all} for {$subscription->planPrice->custom_interval} Months ";
                            }
                        }

                    } else if ($subscription->planPrice->billing_type == 'One-Time') {

                        $price = $subscription->planPrice->price;
                        if($subscription->paymentCode != null){
                            $payment_details .= "Will expire on ".Carbon::parse($subscription->created_at)->addMonths($subscription->planPrice->access_expire_duration)->format('M d, Y');;
                        } else {

                            if($subscription->payment_status == 'uncaptured'){
                                $payment_details .= 'Expires on '. Carbon::parse($subscription->created_at)->addDays(7)->format('M d, Y').' if not yet authorize / captured';
                            } else {

                                if($subscription->planPrice->access_expire_duration_type == 'Days'){
                                    $payment_details .= "\${$price} {$subscription->planPrice->billing_type} {$subscription->planPrice->access} access, will expire on ".Carbon::parse($subscription->created_at)->addDays($subscription->planPrice->access_expire_duration)->format('M d, Y');
                                } else if($subscription->planPrice->access_expire_duration_type == 'Weeks'){
                                    $payment_details .= "\${$price} {$subscription->planPrice->billing_type} {$subscription->planPrice->access} access, will expire on ".Carbon::parse($subscription->created_at)->addWeeks($subscription->planPrice->access_expire_duration)->format('M d, Y');
                                } else if($subscription->planPrice->access_expire_duration_type == 'Months'){
                                    $payment_details .= "\${$price} {$subscription->planPrice->billing_type} {$subscription->planPrice->access} access, will expire on ".Carbon::parse($subscription->created_at)->addMonths($subscription->planPrice->access_expire_duration)->format('M d, Y');
                                    
                                } else if($subscription->planPrice->access_expire_duration_type == 'Years'){
                                    $payment_details .= "\${$price} {$subscription->planPrice->billing_type} {$subscription->planPrice->access} access, will expire on ".Carbon::parse($subscription->created_at)->addYears($subscription->planPrice->access_expire_duration)->format('M d, Y');
                                }
                            }
                        }
                    }

                    $data = [
                        'id' => $subscription->id,
                        'plan' => [
                            'title' => $subscription->planPrice->plan->title,
                            'image' => $subscription->planPrice->plan->image_url,
                            'price' => $subscription->planPrice->price,
                            'billing_type' => $subscription->planPrice->billing_type,
                            'interval' => $subscription->planPrice->interval,
                            'custom_interval' => $subscription->planPrice->custom_interval,
                            'custom_interval_type' => $subscription->planPrice->custom_interval_type,

                        ],
                        'payment_code' => $subscription->paymentCode != null ? [
                            'code' => $subscription->paymentCode->code,
                            'addons' => $subscription->paymentCode->addons,
                        ] : null,
                        'payment_details' => $payment_details,
                        'status' => $subscription->status == 'trialing' ? 'Waiting for approval' : $subscription->status,
                        'approved' => $subscription->approved,
                        'payment_method' => $subscription->payment_method,
                        'payment_mode' => $subscription->payment_mode,
                        'payment_status' => $subscription->payment_status,
                        'subscription_expired' =>  $current_subscription && $current_subscription->status == 'active' ? true : ($subscription->expired_at != null ? Carbon::now()->gt(Carbon::parse($subscription->expired_at)) : true),
                        'subscription_expired_at' =>  $subscription->expired_at != null ? Carbon::parse($subscription->expired_at)->format('M j, Y, g:i a') : null,
                        'last_payment_date' => Carbon::parse($subscription->last_payment_date)->format('M j, Y'),
                        'next_payment_date' => Carbon::parse($subscription->next_payment_at)->format('M j, Y'),
                        'created_at' => Carbon::parse($subscription->created_at)->format('M j, Y, g:i a'),
                    ];

                    if($subscription->discount != null){
                        $data['discount'] = [
                            'code' => $subscription->discount->coupon->code,
                            'type' => $subscription->discount->coupon->type,
                            'discount' => $subscription->discount->coupon->discount,
                            'duration' => $subscription->discount->coupon->duration,
                        ];
                    }

                    array_push($subscriptions_data, $data);
                    
                }
            }

            return response()->json([
                'current_subscription' => $current_subscription,
                'has_company' => auth()->user()->company != NULL ? true : false,
                //'has_prepaid' => $has_prepaid,
                'subscriptions' =>  $subscriptions_data,
                'subscription_plans' => $subscription_plans,
                'categories' => $categories
            ], 200);


        } catch(Exception $e){

            dd($e->getMessage());
            LogActivity::errorLog($e->getMessage());
            return $e->getMessage();
        }
    }


    public function companyDetails(Request $request)
    {
        try {
            
            $user = auth()->user();
            $user->wti_data = json_encode($request->all());
            $user->save();

            return response()->json([
                'message' => 'Company Details successfuly saved.'
            ]);

        } catch (\Exception $e) {
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }

    public function status(Request $request)
    {
        try {
            
            return response()->json([
                'subscription' => auth()->user()->subscription_status
            ]);

        } catch (\Exception $e) {
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }

    public function store(Request $request)
    {
        $request->validate([
            'title' => 'required|unique:subscription_plans,title',
            'price' => 'required'
        ]);

        try {
            $this->subscriptionPlansRepository->create($request);
            
            return response()->json([
                'message' => 'Plan has been successfully saved.'
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'message' => 'an error occurred. Failed to save plan.'
            ], 500);
        }
    }

    public function update(Request $request)
    {
        $request->validate([
            'title' => 'required|unique:subscription_plans,title,' . $request->id,
            'price' => 'required'
        ]);

        try {
            $ret = $this->subscriptionPlansRepository->update($request);

            if ($ret) {
                return response()->json([
                    'message' => "Plan has been successfully updated."
                ]);
            }
            else {
                return response()->json([
                    'message' => 'Failed to update plan. Plan not found.'
                ], 500);
            }
        } catch (\Exception $e) {
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }

    public function destroy(Request $request)
    {
        try {
            $ret = $this->subscriptionPlansRepository->delete($request);

            if ($ret === true) {
                return response()->json([
                    'message' => 'Plan has been successfully deleted.'
                ]);
            }
            else {
                if ($ret == 'in_use') {
                    return response()->json([
                        'message' => 'Unable to delete plan. Plan is in use.'
                    ], 403);
                }
                else {
                    return response()->json([
                        'message' => 'Failed to delete plan. Plan not found.'
                    ], 500);
                }
            }
        } 
        catch (\Exception $e) {
            return response()->json([
                'message' => 'An error occurred. Failed to delete plan.'
            ], 500);
        }
    }

    public function changePlanPosition(Request $request)
    {
        $ids = $request->get('ids');

        if (count($ids) != 0) {
            foreach ($ids as $key => $id) {
                $plan = SubscriptionPlan::find($id);
                if ($plan) {
                    $plan->order = $key + 1;
                    $plan->save();
                }
            }
        }

        return true;
    }

    public function register(Request $request) {
        $this->validator($request->all())->validate();
        session()->put('subscription_payment', '1');
        
        if ($request->method == "Stripe") {
            $data['gateway_id'] = encrypt(4);
            $response = $this->stripePost($request->all(), $request);
            if (gettype($response) == 'object'){
                return redirect()->back();
            }
        }

        $data['payment_id'] = encrypt($response);
        $data['step'] = 'complete_payment';

        if (session()->has('new_user')) {
            $user = clone session()->get('new_user');
            session()->forget('new_user');
            Auth::login($user);
            
            Toastr::success(__('auth.successfully_registered'), __('common.success'));
            LogActivity::addLoginLog(Auth::user()->id, Auth::user()->first_name . ' - logged in at : ' . Carbon::now());
            return redirect('/profile/dashboard');
        }
        
    }

    public function stripePost($data, Request $request, $mode = null)
    {
        $currency_code = getCurrencyCode();
        Stripe\Stripe::setApiKey(env('STRIPE_SECRET'));
        try{
            $stripe = Stripe\Charge::create ([
                "amount" => round($data['amount'] * 100),
                "currency" => $currency_code,
                "source" => $data['stripeToken'],
                "description" => "Payment from ". url('/'),
                "capture" => false
            ]);
        }catch(Exception $e){
            Toastr::error($e->getMessage(), __('common.error'));
            return redirect()->back();
        }
        if ($stripe['status'] == "succeeded") {
            $return_data = $stripe['id'];
            if (session()->has('subscription_payment')) {
                if ($mode == 'add') {
                    $user = auth()->user();

                    if ($user) {
                        $plan = $data['plan'];
                        $customer_subscription = new CustomerSubscription();
                        $customer_subscription->customer_id = $user->id;
                        $customer_subscription->plan_id = $plan;
                        $customer_subscription->status = 'active';
                        $customer_subscription->is_paid = true;
                        $customer_subscription->save();

                        $defaultIncomeAccount = $this->defaultIncomeAccount();
                        $transactionRepo = new TransactionRepository(new Transaction);
                        $transaction = $transactionRepo->makeTransaction($user->first_name." - Subsriction Payment", "in", "Stripe", "subscription_payment", $defaultIncomeAccount, "Subscription Payment", $customer_subscription, $data['amount'], Carbon::now()->format('Y-m-d'), $user->id, null, null);
                        
                        SubsciptionPaymentInfo::create([
                            'transaction_id' => $transaction->id,
                            'txn_id' => $return_data,
                            'customer_id' => $user->id,
                            'plan_id' => $customer_subscription->plan_id,
                        ]);
                        LogActivity::successLog('Subscription payment successful.');
                        
                        return true;
                    }
                    else {
                        redirect('/login');
                    }
                }
                else if ($mode == 'renew') {
                    $customer_subscription = CustomerSubscription::find($data['subscription_id']);
                    if ($customer_subscription) {
                        $user = $customer_subscription->user;
                        $defaultIncomeAccount = $this->defaultIncomeAccount();
                        $transactionRepo = new TransactionRepository(new Transaction);
                        $transaction = $transactionRepo->makeTransaction($user->first_name." - Subsriction Payment", "in", "Stripe", "subscription_payment", $defaultIncomeAccount, "Subscription Payment", $customer_subscription, $data['amount'], Carbon::now()->format('Y-m-d'), $user->id, null, null);
                        $customer_subscription->update([
                            'last_payment_date' => Carbon::now()->format('Y-m-d'),
                            'is_paid' => 1,
                            'status' => 'active'
                        ]);
                        SubsciptionPaymentInfo::create([
                            'transaction_id' => $transaction->id,
                            'txn_id' => $return_data,
                            'customer_id' => $user->id,
                            'plan_id' => $customer_subscription->plan_id,
                        ]);
                        LogActivity::successLog('Subscription payment successful.');
                        return true;
                    }
                }
                else {
                    $plan = $data['plan'];
                    event(new Registered($user = app(\App\Http\Controllers\Auth\RegisterController::class)->create($request)));

                    $customer_subscription = new CustomerSubscription();
                    $customer_subscription->customer_id = $user->id;
                    $customer_subscription->plan_id = $plan;
                    $customer_subscription->status = 'active';
                    $customer_subscription->is_paid = true;
                    $customer_subscription->save();
                    
                    $defaultIncomeAccount = $this->defaultIncomeAccount();
                    $transactionRepo = new TransactionRepository(new Transaction);
                    $transaction = $transactionRepo->makeTransaction($user->first_name." - Subsriction Payment", "in", "Stripe", "subscription_payment", $defaultIncomeAccount, "Subscription Payment", $customer_subscription, $data['amount'], Carbon::now()->format('Y-m-d'), $user->id, null, null);
                    $customer_subscription->update(['last_payment_date' => Carbon::now()->format('Y-m-d')]);
                    SubsciptionPaymentInfo::create([
                        'transaction_id' => $transaction->id,
                        'txn_id' => $return_data,
                        'customer_id' => $user->id,
                        'plan_id' => $plan,
                    ]);
                    LogActivity::successLog('Subscription payment successful.');

                    session()->put('new_user', $user);

                    return true;
                }
            }
        }else {
            return redirect()->route('frontend.welcome');
        }
    }

    public function add(Request $request) {
        session()->put('subscription_payment', '1');
        
        if ($request->method == "Stripe") {
            $data['gateway_id'] = encrypt(4);
            $response = $this->stripePost($request->all(), $request, 'add');
            if (gettype($response) == 'object'){
                return redirect()->back();
            }
        }

        $data['payment_id'] = encrypt($response);
        $data['step'] = 'complete_payment';

        return redirect('/my-subscription');
    }

    public function subscribe(Request $request) {
    
        try {

            $planPrice = SubscriptionPlanPrice::find($request->subscription_price_id);
            if(!$planPrice){
                return response()->json([
                    'message' => 'Subscription Plan Price not found!'
                ], 404);
            }


            $planPrice = SubscriptionPlanPrice::find($request->subscription_price_id);
            if($planPrice && !in_array($request->payment_method,$planPrice->payment_method)){
                return response()->json([
                    'message' => 'Payment Method not available for this plan!'
                ], 404);
            }

            //lets check first if theres active subscription
            $active_subscription = CustomerSubscription::where('customer_id',auth()->user()->id)->where('status','active')->where('payment_status','succeeded')->first();
            $prorate_discount = 0;
            if ($active_subscription && $active_subscription->planPrice->plan->status && $active_subscription->planPrice->payment =='monthly' && $active_subscription->planPrice->subscription_plan_id != $planPrice->subscription_plan_id && $planPrice->payment == 'monthly') {

                if($active_subscription->payment_method == 'stripe'){
                    $response = $this->stripePayment->subscriptions->retrieve($active_subscription->txn_id, []);
                    $startDate = Carbon::createFromTimestamp($response['current_period_start']);
                } else if($active_subscription->payment_method == 'paypal'){
                    $response = $this->paypalPayment->showSubscription($active_subscription->txn_id);
                    if(isset($response->billing_info->last_payment->time)){
                        $startDate = Carbon::parse($response->billing_info->last_payment->time);
                    }
                }

                if(isset($startDate)){
                    $endDate = Carbon::now();
                    $diffInDays = $startDate->diffInDays($endDate);
                    if($planPrice->subscription_plan_id > $active_subscription->planPrice->subscription_plan_id){
                        //for upgrade
                        $prorate_discount = (($active_subscription->planPrice->price / $active_subscription->planPrice->custom_interval) / 30 ) * $diffInDays;
                    } else {
                        //for downgrade
                        $prorate_discount = (($planPrice->price / $planPrice->custom_interval) / 30 ) * $diffInDays;
                    } 
                }
            }

            $payment_details = $planPrice->plan->title;
            $coupon_id = null;
            if($request->promo_code != null){
                $storefront = auth()->user()->company->storefront;
                $promoCode = $this->subscriptionCouponsRepository->validate($request->promo_code,$storefront);
                if(isset($promoCode->stripe_coupon_id) && in_array($planPrice->id, $promoCode->subscription_plan_price_id)){
                    $coupon_id = $promoCode->stripe_coupon_id;
                    $price_monthly = $planPrice->price / $planPrice->custom_interval;
                    if ($promoCode->type == 'Amount') {
                        $discounted_price_monthly = number_format($price_monthly - $promoCode->discount,2);
                        $discounted_price_all = number_format($planPrice->price - $promoCode->discount,2);

                    } else {
                        $discounted_price_monthly =  number_format($price_monthly - (($promoCode->discount / 100) * $price_monthly),2);
                        $discounted_price_all = number_format($planPrice->price - (($promoCode->discount / 100) * $planPrice->price),2);
                    }


                    if($planPrice->payment == 'monthly'){
                        $payment_details .= $promoCode->duration == 'Once' ? ' - $'.number_format($planPrice->price / $planPrice->custom_interval,2).' for '.$planPrice->custom_interval.' Months ($'.$discounted_price_monthly.' 1st month only)' : ' - '.$planPrice->custom_interval.' Months ($'.$discounted_price_monthly.' per month)';
                    } else {
                        $payment_details .=  '($'.$discounted_price_all.' for '.$planPrice->custom_interval.' Months)';
                    }

                    // if ($promoCode->payment_mode == 'Monthly' || $promoCode->payment_mode == 'Both') {

                    //     $payment_details .= $promoCode->duration == 'Once' ? ' - $'.number_format($planPrice->price / $planPrice->custom_interval,2).' for '.$planPrice->custom_interval.' Months ( $'.$discounted_price_monthly.' 1st month only )' : ' - '.$planPrice->custom_interval.' Months ( $'.$discounted_price_monthly.' per month )';
                    // }

                    // if ($promoCode->payment_mode == 'All' || $promoCode->payment_mode == 'Both') {
                    //     $payment_details .=  '( $'.$discounted_price_all.' for '.$planPrice->custom_interval.' Months )';
                    // }
                }

            } else {

                if($prorate_discount > 0){
                    $payment_details .= $planPrice->payment == 'monthly' ? ' - '.$planPrice->custom_interval.' Months ($'.number_format(($planPrice->price / $planPrice->custom_interval) - $prorate_discount,2).' prorated 1st month only then $'.number_format($planPrice->price / $planPrice->custom_interval,2).' per month)' : ' - '.$planPrice->custom_interval.' Months ($'.number_format($planPrice->price,2).')';
                } else {
                    $payment_details .= $planPrice->payment == 'monthly' ? ' - '.$planPrice->custom_interval.' Months ($'.number_format($planPrice->price / $planPrice->custom_interval,2).' per month)' : ' - '.$planPrice->custom_interval.' Months ($'.number_format($planPrice->price,2).')';
                }
            }


            if($request->payment_method == 'stripe'){

                $sessionData = [
                    'mode' => 'setup',
                    'payment_method_types' => ['card'],
                    'setup_intent_data' => [
                        //'description' => 'This is a test description',
                        'metadata' => [
                            'user_id' => auth()->user()->id,
                            'user_name' => auth()->user()->name,
                            'user_email' => auth()->user()->email,
                            'subscription_plan_price_id' => $planPrice->stripe_price_id,
                            'prorate_discount' => (float)$prorate_discount,
                            'coupon_id' => $coupon_id
                        ]
                    ],
                    'custom_text' => [
                        'submit' => [
                            'message' => $payment_details .', your card will not be charged until your subscription is approved.'
                        ]
                    ],
                    'customer_email' => auth()->user()->email,
                    'client_reference_id' => auth()->user()->id,
                    'success_url' => url('/my-subscription'),
                    'cancel_url' => url('/my-subscription')
                ];

                $response = $this->stripePayment->checkout->sessions->create($sessionData);

                return response()->json([
                    'session_id' => $response['id']
                ]);

            } else {

                if($active_subscription && ($planPrice->subscription_plan_id == $active_subscription->planPrice->subscription_plan_id || $planPrice->payment == 'upfront')){
                    if($active_subscription->payment_method == 'stripe'){
                        $response = $this->stripePayment->subscriptions->retrieve($active_subscription->txn_id, []);
                        $trial_end = $response['current_period_end'];
                    } else if($active_subscription->payment_method == 'paypal' && $active_subscription->expired_at != null){
                        $trial_end = $active_subscription->expired_at->timestamp;
                    }

                    if(isset($trial_end)){
                        $startDate = Carbon::createFromTimestamp($trial_end);
                        $endDate = Carbon::now();
                        $trial_days = $startDate->diffInDays($endDate);
                    }
                }

                $data = [
                    'quantity' => 1,
                    'start_time' => isset($trial_days) ? Carbon::now()->addDays($trial_days)->toIso8601ZuluString() : null,
                    'subscriber' => [
                        'email_address' => auth()->user()->email,
                        'name' => [
                            'given_name' => auth()->user()->first_name,
                            'surname' => auth()->user()->last_name
                        ]

                    ],
                    'application_context' => [
                        'brand_name' => 'Vurn Media LLC',
                        'shipping_preference' => 'NO_SHIPPING',
                        'user_action' => 'CONTINUE',
                        'payment_method' => [
                            'payer_selected' => 'PAYPAL',
                            'payee_preferred' => 'IMMEDIATE_PAYMENT_REQUIRED'
                        ],
                        'return_url' => url('/my-subscription'),
                        'cancel_url' => url('/my-subscription')
                    ]
                ];


                if($coupon_id != null){

                    $data['custom_id'] = json_encode([
                        'user_id' => auth()->user()->id,
                        'coupon_id' => $coupon_id
                    ]);

                    //lets create new plan price with discount
                    $response = $this->paypalPayment->createProductPriceWithDiscount($planPrice,$promoCode->duration,$discounted_price_monthly,$discounted_price_all,$payment_details);
                    if(isset($response->id)){

                        $data['plan_id'] = $response->id;

                        $paypalPlanPrice = new SubscriptionPlanPricePaypal;
                        $paypalPlanPrice->user_id = auth()->user()->id;
                        $paypalPlanPrice->subscription_plan_price_id = $planPrice->id;
                        $paypalPlanPrice->paypal_price_id = $response->id;
                        $paypalPlanPrice->save();
                    } else {
                        return response()->json([
                            'message' => 'Something went wrong, please try again later.'
                        ], 404);
                    }

                } else {

                    $data['plan_id'] = $planPrice->paypal_price_id;
                    $data['custom_id'] = json_encode([
                        'user_id' => auth()->user()->id
                    ]);
                    
                }

                $response = $this->paypalPayment->createSubscription(json_encode($data,true));

                if($response->links[0]->rel != 'approve'){
                    return response()->json([
                        'message' => 'Something went wrong, please try again later.'
                    ], 404);
                }

                return response()->json([
                    'redirect_url' => $response->links[0]->href
                ]);

            }

        } catch (\Exception $e) {
            return response()->json([
                'message' => $e->getMessage()
            ], 404);
        }
    }


    public function cancel(Request $request) {

        try {

            $subscription = CustomerSubscription::find($request->id);
            if ($subscription) {

                if($subscription->planPrice->billing_type == 'Recurring'){
                    $response = $this->stripePayment->subscriptions->cancel(
                      $subscription->txn_id,
                      []
                    );

                    if ($response['status'] != "canceled") {
                        return response()->json([
                            'message' => 'Subscription cannot be cancelled!'
                        ], 500);
                    }

                    $subscription->status = $response['status'];
                    $subscription->payment_status = 'cancelled';
                    $subscription->update();

                    return response()->json([
                        'message' => 'Subscription successfully cancelled.'
                    ], 200);

                } 
               
            } 

            return response()->json([
                'message' => 'Subscription not found!'
            ], 500);

        } catch (\Exception $e) {

            return response()->json([
                'message' => $e->getMessage()
            ], 404);
        }
    }

    public function refund(Request $request) {
        $id = $request->id;
        $subscription = CustomerSubscription::find($id);
        if ($subscription) {
   
            $response = $this->stripePayment->refunds->create([
              'charge' => $subscription->txn_id,
            ]);
            
            if ($response['status'] == "succeeded") {
                $subscription->status = 'inactive';
                $subscription->status = 'refunded';
                $subscription->is_paid = false;
                $subscription->update();
            }

            return redirect('/my-subscription');
        }

        return redirect('/profile/dashboard');
    }

    public function pay(Request $request) {
        session()->put('subscription_payment', '1');

        if ($request->method == "Stripe") {
            $data['gateway_id'] = encrypt(4);
            $response = $this->stripePost($request->all(), $request, 'renew');
            if(gettype($response) == 'object'){
                return redirect()->back();
            }
        }

        $data['payment_id'] = encrypt($response);
        $data['step'] = 'complete_payment';

        return redirect('/my-subscription');
    }

    public function captureFunds(Request $request) {

        try {

            $subscription = CustomerSubscription::find($request->id);
            if ($subscription && $subscription->billing_type == 'One-Time') {

                $charge_id = $subscription->txn_id;

                $credential = $this->getCredential();
                Stripe\Stripe::setApiKey(@$credential->perameter_3);
                $stripe = new Stripe\StripeClient(@$credential->perameter_3);
                $response = $stripe->charges->capture($charge_id, []);

                if ($response['status'] == 'succeeded') {
                    $subscription->status = 'active';
                    $subscription->update();

                    return response()->json([
                        'message' => __('Funds has been successfully released.')
                    ], 200);
                }
            
                return response()->json([
                    'message' => 'Failed to release funds. Please check your account if you have sufficient balance. The charge might have also expired.'
                ], 404);
            }

            return response()->json([
                'message' => 'Subscription not found.'
            ], 404);


        } catch (\Exception $e) {

            return response()->json([
                'message' => trans('common.Operation failed')
            ], 404);
        }
    }

    public function isAddToCartAllowed() {
        $subscription_settings = SubscriptionSetting::getData();

        if ($subscription_settings->customer_subscription) {
            $user = auth()->user();
            if ($user) {
                $subscription = CustomerSubscription::where('customer_id', $user->id)->latest()->first();
                if ($subscription && $subscription->status == 'active' && $subscription->is_paid) {
                    return true;
                }
            }
            return false;
        }
        
        return true;
    }

    private function getCredential(){
        $url = explode('?',url()->previous());
        if(isset($url[0]) && $url[0] == url('/checkout')){
            $is_checkout = true;
        }else{
            $is_checkout = false;
        }
        if(session()->has('order_payment') && app('general_setting')->seller_wise_payment && session()->has('seller_for_checkout') && $is_checkout){
            $credential = getPaymentInfoViaSellerId(session()->get('seller_for_checkout'), 4);
        }else{
            $credential = getPaymentInfoViaSellerId(1, 4);
        }
        return $credential;
    }
}