1#@!#!123s

: / home / forge / ghanempharmacy.com / app / Utils /
Filename : CartManager.php
back
<?php

namespace App\Utils;

use App\Models\DigitalProductVariation;
use App\Models\ShippingMethod;
use App\Models\Cart;
use App\Models\CartShipping;
use App\Models\CategoryShippingCost;
use App\Models\Color;
use App\Models\Product;
use App\Models\ShippingType;
use App\Models\Shop;
use App\Models\DeliveryArea;
use App\Models\DeliveryCity;
use App\Models\DeliveryState;
use App\Models\DeliveryVillage;
use App\Models\DeliveryCountryCode;
use App\Models\ShippingAddress;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Support\Str;
use Modules\TaxModule\app\Traits\VatTaxManagement;
use Illuminate\Support\Facades\Log;

class CartManager
{
    use VatTaxManagement;

    public static function cartListSessionToDatabase($request = null): void
    {
        $user = Helpers::getCustomerInformation($request);
        if ($user !== 'offline' && (session()->has('guest_id') || (!is_null($request) && !is_null($request->guest_id)))) {
            $guestId = session('guest_id') ?? $request->guest_id;
            $cartList = Cart::where(['is_guest' => 1, 'customer_id' => $guestId])->get();
            foreach ($cartList as $cart) {
                /** @var Cart $cart */
                $databaseCart = Cart::where([
                    'customer_id' => $user->id,
                    'seller_id' => $cart->seller_id,
                    'seller_is' => $cart->seller_is
                ])->first();

                Cart::where([
                    'customer_id' => $user->id,
                    'product_id' => $cart->product_id,
                    'variant' => $cart->variant,
                    'seller_id' => $cart->seller_id,
                    'seller_is' => $cart->seller_is
                ])->delete();

                $cart->cart_group_id = isset($databaseCart) ? $databaseCart->cart_group_id : str_replace('guest', $user->id, $cart->cart_group_id);
                $cart->customer_id = $user->id;
                $cart->is_guest = 0;
                $cart->save();
            }
        }
    }

    public static function getCartListQuery($groupId = null, $type = null): Collection|array
    {
        ProductManager::updateProductPriceInCartList(request: request()->all());
        self::updateOrderSummaryShippingCost($groupId, $type);

        $cartItems = Cart::with([
            'product' => function ($query) {
                return $query->active()->with([
                    'category' => function ($query) {
                        return $query->with([
                            'taxVats' => function ($query) {
                                return $query->with(['tax'])->wherehas('tax', function ($query) {
                                    return $query->where('is_active', 1);
                                });
                            }
                        ]);
                    },
                    'clearanceSale' => function ($query) {
                        return $query->active();
                    },
                    'taxVats' => function ($query) {
                        return $query->with(['tax'])->wherehas('tax', function ($query) {
                            return $query->where('is_active', 1);
                        });
                    }
                ]);
            }
        ])
            ->whereHas('product', function ($query) {
                return $query->active();
            })
            ->when($groupId == null, function ($query) {
                return $query->whereIn('cart_group_id', CartManager::get_cart_group_ids());
            })
            ->when($groupId, function ($query) use ($groupId) {
                return $query->where('cart_group_id', $groupId);
            })
            ->when($type == 'checked', function ($query) {
                return $query->where(['is_checked' => 1]);
            })
            ->get();

        foreach ($cartItems as $item) {
            if ($item->bundle_id) {
                $item->discount = 0;
            } else {
                $item->discount = getProductPriceByType(
                    product: $item->product,
                    type: 'discounted_amount',
                    result: 'value',
                    price: $item->price
                );
            }
        }

        return $cartItems;
    }

    public static function getCartListQueryAPI($request = null, $groupId = null, $type = null): Collection|array
    {
        ProductManager::updateProductPriceInCartList(request: $request ?? request()->all());

        $cartItems = Cart::with([
            'product' => function ($query) {
                return $query->active()->with([
                    'clearanceSale' => function ($query) {
                        return $query->active();
                    }
                ]);
            }
        ])
            ->whereHas('product', function ($query) {
                return $query->active();
            })
            ->when($groupId == null, function ($query) use ($request) {
                return $query->whereIn('cart_group_id', CartManager::get_cart_group_ids($request ?? request()->all()));
            })
            ->when($groupId, function ($query) use ($groupId) {
                return $query->where('cart_group_id', $groupId);
            })
            ->when($type == 'checked', function ($query) {
                return $query->where(['is_checked' => 1]);
            })->get();

        foreach ($cartItems as $item) {
            if ($item->bundle_id) {
                $item->discount = 0;
            } else {
                $item->discount = getProductPriceByType(
                    product: $item->product,
                    type: 'discounted_amount',
                    result: 'value',
                    price: $item->price
                );
            }
        }
        return $cartItems;
    }

    public static function getCartListGroupQuery($groupId = null, $type = null): Collection|array
    {
        $cartItems = Cart::with([
            'product' => function ($query) {
                return $query->active()->with([
                    'clearanceSale' => function ($query) {
                        return $query->active();
                    }
                ]);
            }
        ])
            ->whereHas('product', function ($query) {
                return $query->active();
            })
            ->when($groupId == null, function ($query) {
                return $query->whereIn('cart_group_id', CartManager::get_cart_group_ids());
            })
            ->when($groupId, function ($query) use ($groupId) {
                return $query->where('cart_group_id', $groupId);
            })
            ->when($type == 'checked', function ($query) {
                return $query->where(['is_checked' => 1]);
            })
            ->get();

        foreach ($cartItems as $item) {
            if ($item->bundle_id) {
                $item->discount = 0;
            } else {
                $item->discount = getProductPriceByType(
                    product: $item->product,
                    type: 'discounted_amount',
                    result: 'value',
                    price: $item->price
                );
            }
        }
        return $cartItems->groupBy('cart_group_id');
    }

    public static function get_cart_group_ids($request = null, $type = null)
    {
        $user = Helpers::getCustomerInformation(!is_null($request) ? $request : request());

        return Cart::whereHas('product', function ($query) {
            return $query->active();
        })->when($user == 'offline', function ($query) use ($request) {
            return $query->where(['customer_id' => session('guest_id') ?? (request('guest_id') ?? 0), 'is_guest' => 1]);
        })->when($user != 'offline', function ($query) use ($user) {
            return $query->where(['customer_id' => $user['id'], 'is_guest' => '0']);
        })
            ->when($type == 'checked', function ($query) {
                return $query->where(['is_checked' => 1]);
            })
            ->groupBy('cart_group_id')
            ->pluck('cart_group_id')
            ->toArray();
    }

    public static function get_shipping_cost($groupId = null, $type = null)
    {
        if (request()->routeIs('shop-cart')) {
            return 0;
        }

        self::updateOrderSummaryShippingCost($groupId, $type);
        $cartShippingCost = Cart::where(['product_type' => 'physical'])
            ->whereHas('product', function ($query) {
                return $query->active();
            })->when(($groupId == null && $type != 'checked'), function ($query) {
                return $query->whereIn('cart_group_id', CartManager::get_cart_group_ids());
            })
            ->when(($groupId == null && $type == 'checked'), function ($query) {
                return $query->whereIn('cart_group_id', CartManager::get_cart_group_ids(type: 'checked'));
            })
            ->when($groupId != null, function ($query) use ($groupId) {
                return $query->where(['cart_group_id' => $groupId]);
            })
            ->when($type == 'checked', function ($query) {
                return $query->where(['is_checked' => 1]);
            })->sum('shipping_cost');

        $orderWiseShippingCostData = CartShipping::whereHas('cart', function ($query) use ($type) {
            return $query->where(['product_type' => 'physical'])->whereHas('product', function ($query) {
                return $query->active();
            })->when($type == 'checked', function ($query) {
                return $query->where(['is_checked' => 1]);
            });
        })->when(($groupId == null && $type != 'checked'), function ($query) {
            return $query->whereIn('cart_group_id', CartManager::get_cart_group_ids());
        })
            ->when(($groupId == null && $type == 'checked'), function ($query) {
                return $query->whereIn('cart_group_id', CartManager::get_cart_group_ids(type: 'checked'));
            })
            ->when(($groupId != null), function ($query) use ($groupId) {
                return $query->where('cart_group_id', $groupId);
            });

        // Hierarchical cost logic
        $addressId = OrderManager::getOrderAddressId(type: 'shipping_address');
        $overrides = [
            'country_id' => session('shipping_country_id'),
            'state_id' => session('shipping_state_id'),
            'city_id' => session('shipping_city_id'),
            'area_id' => session('shipping_area_id'),
            'village_id' => session('shipping_village_id'),
        ];
        $hierarchicalCost = self::get_hierarchical_shipping_cost($addressId, $overrides);

        if ($groupId == null) {
            if ($hierarchicalCost !== null) {
                $orderWiseShippingCost = $hierarchicalCost; // Single fee per order
            } else {
                $orderWiseShippingCost = $orderWiseShippingCostData->sum('shipping_cost');
            }
        } else {
            if ($hierarchicalCost !== null) {
                // To ensure the fee is charged once per order, we only assign it to the first group
                $cartGroupIds = self::get_cart_group_ids(type: $type == 'checked' ? 'checked' : 'all');
                if (count($cartGroupIds) > 0 && $cartGroupIds[0] == $groupId) {
                    $orderWiseShippingCost = $hierarchicalCost;
                } else {
                    $orderWiseShippingCost = 0;
                }
            } else {
                $data = $orderWiseShippingCostData->first();
                $orderWiseShippingCost = isset($data) ? $data->shipping_cost : 0;
            }
        }

        return ($orderWiseShippingCost + $cartShippingCost);
    }

    public static function updateOrderSummaryShippingCost($groupId = null, $type = null): void
    {
        $user = Helpers::getCustomerInformation(request());

        $cartItems = Cart::where(['product_type' => 'physical'])
            ->with(['product'])
            ->whereHas('product', function ($query) {
                return $query->active();
            })->when(($groupId == null && $type != 'checked'), function ($query) {
                return $query->whereIn('cart_group_id', CartManager::get_cart_group_ids());
            })
            ->when(($groupId == null && $type == 'checked'), function ($query) {
                return $query->whereIn('cart_group_id', CartManager::get_cart_group_ids(type: 'checked'));
            })
            ->when($groupId != null, function ($query) use ($groupId) {
                return $query->where(['cart_group_id' => $groupId]);
            })
            ->when($user == 'offline', function ($query) {
                return $query->where(['customer_id' => session('guest_id') ?? (request('guest_id') ?? 0), 'is_guest' => 1]);
            })
            ->when($user != 'offline', function ($query) use ($user) {
                return $query->where(['customer_id' => $user['id'], 'is_guest' => '0']);
            })
            ->when($type == 'checked', function ($query) {
                return $query->where(['is_checked' => 1]);
            })->get();

        self::updateProductShippingCost($cartItems);
    }

    public static function updateProductShippingCost($cartList): void
    {
        $shippingMethod = getWebConfig(name: 'shipping_method');
        $adminShipping = ShippingType::where('seller_id', 0)->first();
        foreach ($cartList as $cartItem) {
            $shippingType = '';
            if ($shippingMethod == 'inhouse_shipping') {
                $shippingType = isset($adminShipping) ? $adminShipping->shipping_type : 'order_wise';
            } else if ($shippingMethod == 'sellerwise_shipping') {
                if ($cartItem->seller_is == 'admin') {
                    $shippingType = isset($adminShipping) ? $adminShipping->shipping_type : 'order_wise';
                } else {
                    $sellerShipping = ShippingType::where('seller_id', $cartItem->seller_id)->first();
                    $shippingType = isset($sellerShipping) ? $sellerShipping->shipping_type : 'order_wise';
                }
            }

            if ($shippingType != 'order_wise') {
                CartShipping::where('cart_group_id', $cartItem?->cart_group_id)->delete();
            }

            Cart::where(['id' => $cartItem->id])->update([
                'shipping_cost' => $cartItem['product_type'] == 'physical' ? CartManager::get_shipping_cost_for_product_category_wise($cartItem->product, $cartItem['quantity']) : 0,
                'shipping_type' => $shippingType,
            ]);
        }
    }

    /**
     * Get Hierarchical Shipping Cost based on address
     * @param int|null $addressId
     * @return ?float
     */
    public static function get_hierarchical_shipping_cost($addressId = null, $overrides = []): ?float
    {
        $address = $addressId ? ShippingAddress::find($addressId) : null;
        $totalCost = 0;
        $found = false;

        // 1. Check Country
        $country_id = $overrides['country_id'] ?? ($address ? $address->country_id : null);
        if ($country_id) {
            $country = DeliveryCountryCode::find($country_id);
            if ($country && $country->shipping_cost > 0) {
                $totalCost += (float) $country->shipping_cost;
                $found = true;
            }
        }

        // 2. Check State
        $state_id = $overrides['state_id'] ?? ($address ? $address->state_id : null);
        if ($state_id) {
            $state = DeliveryState::find($state_id);
            if ($state && $state->status && $state->cost > 0) {
                $totalCost += (float) $state->cost;
                $found = true;
            }
        }

        // 3. Check City
        $city_id = $overrides['city_id'] ?? ($address ? $address->city_id : null);
        if ($city_id) {
            $city = DeliveryCity::find($city_id);
            if ($city && $city->status && $city->cost > 0) {
                $totalCost += (float) $city->cost;
                $found = true;
            }
        }

        // 4. Check Area
        $area_id = $overrides['area_id'] ?? ($address ? $address->area_id : null);
        if ($area_id) {
            $area = DeliveryArea::find($area_id);
            if ($area && $area->status && $area->cost > 0) {
                $totalCost += (float) $area->cost;
                $found = true;
            }
        }

        // 5. Check Village
        $village_id = $overrides['village_id'] ?? ($address ? $address->village_id : null);
        if ($village_id) {
            $village = DeliveryVillage::find($village_id);
            if ($village && $village->status && $village->cost > 0) {
                $totalCost += (float) $village->cost;
                $found = true;
            }
        }

        return $found ? $totalCost : null;
    }

    public static function getCartListTotalAppliedDiscount($cart): float|int
    {
        $total = 0;
        if (!empty($cart)) {
            foreach ($cart as $item) {
                $discount = (($item['bundle_id'] ?? null) || $item['price'] == 0) ? 0 : getProductPriceByType(product: $item['product'], type: 'discounted_amount', result: 'value', price: $item['price']);
                $productSubtotal = ($item['price'] - $discount) * $item['quantity'];
                $total += $productSubtotal;
            }
        }
        return $total;
    }

    public static function cart_grand_total($cartGroupId = null, $type = null)
    {
        if ($type == 'checked') {
            $cart = CartManager::getCartListQuery(groupId: $cartGroupId, type: 'checked');
            $shippingCost = CartManager::get_shipping_cost(groupId: $cartGroupId, type: 'checked');
        } else {
            $cart = CartManager::getCartListQuery(groupId: $cartGroupId);
            $shippingCost = CartManager::get_shipping_cost(groupId: $cartGroupId);
        }
        $total = 0;
        if (!empty($cart)) {
            foreach ($cart as $item) {
                $discount = (($item['bundle_id'] ?? null) || $item['price'] == 0) ? 0 : getProductPriceByType(product: $item['product'], type: 'discounted_amount', result: 'value', price: $item['price']);
                $productSubtotal = ($item['price'] - $discount) * $item['quantity'];
                $total += $productSubtotal;
            }
            $total += $shippingCost;
        }
        return $total;
    }

    public static function getOnlyCartProductPriceGrandTotal($cartGroupId = null, $type = null): float|int
    {
        if ($type == 'checked') {
            $cart = CartManager::getCartListQuery(groupId: $cartGroupId, type: 'checked');
        } else {
            $cart = CartManager::getCartListQuery(groupId: $cartGroupId);
        }
        $total = 0;
        if (!empty($cart)) {
            foreach ($cart as $item) {
                $discount = (($item['bundle_id'] ?? null) || $item['price'] == 0) ? 0 : getProductPriceByType(product: $item['product'], type: 'discounted_amount', result: 'value', price: $item['price']);
                $productSubtotal = ($item['price'] - $discount) * $item['quantity'];
                $total += $productSubtotal;
            }
        }
        return $total;
    }

    public static function getCartGrandTotalWithoutShippingCharge($cartGroupId = null, $type = null): float|int
    {
        if ($type) {
            $cart = CartManager::getCartListQuery(groupId: $cartGroupId, type: 'checked');
        } else {
            $cart = CartManager::getCartListQuery(groupId: $cartGroupId);
        }
        $total = 0;
        if (!empty($cart)) {
            foreach ($cart as $item) {
                $productSubtotal = ($item['price'] * $item['quantity']) - $item['discount'] * $item['quantity'];
                $total += $productSubtotal;
            }
        }
        return $total;
    }

    public static function cartCleanByCartGroupIds($cartGroupIDs): void
    {
        CartShipping::whereIn('cart_group_id', $cartGroupIDs)->delete();
        Cart::whereIn('cart_group_id', $cartGroupIDs)->where(['is_checked' => 1])->delete();

        session()->forget('coupon_code');
        session()->forget('coupon_type');
        session()->forget('coupon_bearer');
        session()->forget('coupon_discount');
        session()->forget('payment_method');
        session()->forget('shipping_method_id');
        session()->forget('billing_address_id');
        session()->forget('order_id');
        session()->forget('cart_group_id');
        session()->forget('order_note');

        cacheRemoveByType(type: 'carts');
    }

    public static function addToCartPhysicalProduct($request, $product, $shippingType, $sellerShippingList, $giftId = null, $giftDealId = null): array
    {
        $price = 0;
        $string = '';
        $variations = [];

        $user = Helpers::getCustomerInformation($request);
        $guestId = session('guest_id') ?? ($request->guest_id ?? 0);

        if (($product['product_type'] == 'physical') && ($product['current_stock'] < $request['quantity'])) {
            return ['status' => 0, 'message' => translate('out_of_stock!')];
        }

        if ($product['minimum_order_qty'] > $request['quantity']) {
            return ['status' => 0, 'message' => translate('Minimum_order_quantity') . ' ' . $product['minimum_order_qty']];
        }
        if ($product['maximum_order_qty'] < $request['quantity']) {
            return ['status' => 0, 'message' => translate('maximum_order_quantity') . ' ' . $product['maximum_order_qty']];
        }
        if ($user == 'offline') {
            $customerId = $guestId;
            $isGuest = 1;
        } else {
            $customerId = $user['id'];
            $isGuest = 0;
        }

        if ($request->has('color')) {
            $string .= Color::where(['code' => $request['color']])->first()->name;
            $variations['color'] = $string;
        }

        $choices = [];
        foreach (json_decode($product->choice_options) as $choice) {
            $choices[$choice->name] = $request[$choice->name];
            $variations[$choice->title] = $request[$choice->name];
            if ($string != null) {
                $string .= '-' . str_replace(' ', '', $request[$choice->name]);
            } else {
                $string .= str_replace(' ', '', $request[$choice->name]);
            }
        }

        if (!($request['buy_now'])) {
            if ($request['shipping_method_exist'] && $request->has('product_variation_code') && $request['product_variation_code']) {
                $string = str_replace(' ', '', $request['product_variation_code']);
            }
        }

        $cartArray = [
            'color' => $request['color'] ?? null,
            'product_id' => $product['id'],
            'product_type' => $product['product_type'],
            'choices' => json_encode($choices),
            'variations' => json_encode($variations),
            'variant' => $string,
        ];

        if ($string != null) {
            $count = count(json_decode($product->variation));
            for ($i = 0; $i < $count; $i++) {
                if (json_decode($product->variation)[$i]->type == $string) {
                    $price = json_decode($product->variation)[$i]->price;
                    if (json_decode($product->variation)[$i]->qty < $request['quantity']) {
                        return ['status' => 0, 'message' => translate('out_of_stock!')];
                    }
                }
            }
        } else {
            $price = $product->unit_price;
        }

        $getProductDiscount = ($price == 0) ? 0 : getProductPriceByType(product: $product, type: 'discounted_amount', result: 'value', price: $price);

        $cartArray += [
            'customer_id' => ($user == 'offline' ? $guestId : $user['id']),
            'product_id' => $request['id'],
            'product_type' => $product['product_type'],
            'quantity' => $request['quantity'],
            'price' => $price,
            'discount' => $getProductDiscount,
            'is_checked' => 1,
            'slug' => $product['slug'],
            'name' => $product['name'],
            'thumbnail' => $product['thumbnail'],
            'seller_id' => ($product->added_by == 'admin') ? 1 : $product->user_id,
            'seller_is' => $product['added_by'],
            'created_at' => now(),
            'updated_at' => now(),
            'shop_info' => $product->added_by == 'admin' ? getInHouseShopConfig(key: 'name') : Shop::where(['seller_id' => $product->user_id])->first()->name,
            'shipping_cost' => $product->product_type == 'physical' ? CartManager::get_shipping_cost_for_product_category_wise($product, $request['quantity']) : 0,
            'shipping_type' => $shippingType,
            'is_guest' => ($user == 'offline' ? 1 : 0),
            'gift_id' => $giftId,
            'gift_deal_id' => $giftDealId,
            'original_price' => $price,
        ];

        $cartCheck = Cart::where(['customer_id' => $customerId, 'is_guest' => $isGuest, 'seller_id' => ($product->added_by == 'admin') ? 1 : $product->user_id, 'seller_is' => $product->added_by])->first();
        if ($cartCheck) {
            $cartArray['cart_group_id'] = $cartCheck['cart_group_id'];
        } else {
            $cartArray['cart_group_id'] = ($user == 'offline' ? 'guest' : $user['id']) . '-' . Str::random(5) . '-' . time();
        }

        $cart = Cart::where(['product_id' => $request['id'], 'customer_id' => $customerId, 'is_guest' => $isGuest, 'variant' => $string])->first();
        if ($cart) {
            $cartArray['cart_group_id'] = $cart['cart_group_id'];
            Cart::where(['id' => $cart['id']])->update($cartArray);
        } else {
            $cartID = Cart::insertGetId($cartArray);
            $cart = Cart::where(['id' => $cartID])->first();
        }

        if ($request['buy_now'] == 1) {
            $productTotalPrice = ($price * $request['quantity']) - ($getProductDiscount * $request['quantity']);
            $verifyStatus = OrderManager::checkSingleProductMinimumOrderAmountVerify(request: $request, product: $product, totalAmount: $productTotalPrice);
            if ($verifyStatus['status'] == 0) {
                return ['status' => 0, 'message' => $verifyStatus['message']];
            }

            Cart::where(['customer_id' => ($user == 'offline' ? $guestId : $user['id']), 'is_guest' => ($user == 'offline' ? 1 : 0)])
                ->update(['is_checked' => 0]);

            Cart::where(['id' => $cart['id']])->update(['is_checked' => 1]);

            if ($product['product_type'] == 'digital') {
                return [
                    'status' => 1,
                    'redirect_to' => 'checkout',
                    'cart' => $cart,
                    'message' => translate('successfully_added') . '!',
                ];
            }

            if ($product['product_type'] == 'physical' && $shippingType == 'order_wise') {
                if ($request['shipping_method_exist'] && $request['shipping_method_id'] && count($sellerShippingList) > 0) {
                    $cart->update(['is_checked' => 1]);
                    $cartGroupIds = Cart::where(['customer_id' => ($user == 'offline' ? $guestId : $user['id']), 'is_guest' => ($user == 'offline' ? 1 : 0)])
                        ->pluck('cart_group_id');
                    if (count($cartGroupIds) > 0) {
                        CartShipping::whereIn('cart_group_id', $cartGroupIds)->delete();
                    }

                    $shipping = CartShipping::where(['cart_group_id' => $cart['cart_group_id']])->first();
                    if (!isset($shipping)) {
                        $shipping = new CartShipping();
                    }
                    $getShippingCost = ShippingMethod::find($request['shipping_method_id']);
                    if (!$getShippingCost) {
                        return ['status' => 0, 'message' => translate('Selected_shipping_method_not_found')];
                    }
                    $shipping['cart_group_id'] = $cart['cart_group_id'];
                    $shipping['shipping_method_id'] = $request['shipping_method_id'];
                    $shipping['shipping_cost'] = $getShippingCost->cost ?? 0;
                    $shipping->save();

                    $cart['free_delivery_order_amount'] = OrderManager::getFreeDeliveryOrderAmountArray($cart['cart_group_id']);

                    return [
                        'status' => 1,
                        'redirect_to' => 'checkout',
                        'cart' => $cart,
                        'cart_shipping_cost' => $getShippingCost->cost ?? 0,
                        'message' => translate('successfully_added') . '!',
                    ];
                }
                return [
                    'status' => $sellerShippingList && count($sellerShippingList) > 0 ? 2 : 0,
                    'message' => $sellerShippingList && count($sellerShippingList) > 0 ? translate('Please_select_shipping_method') : translate('Shipping_Not_Available_for_this_Shop'),
                    'shipping_method_list' => $sellerShippingList,
                ];
            } elseif ($product['product_type'] == 'physical' && ($shippingType == 'category_wise' || $shippingType == 'product_wise')) {
                $cart->update([
                    'is_checked' => 1,
                    'shipping_cost' => CartManager::get_shipping_cost_for_product_category_wise($product, $request->quantity) ?? 0,
                ]);

                $cart['free_delivery_order_amount'] = OrderManager::getFreeDeliveryOrderAmountArray($cart['cart_group_id']);

                return [
                    'status' => 1,
                    'redirect_to' => 'checkout',
                    'cart' => $cart,
                    'cart_shipping_cost' => $getShippingCost->cost ?? 0,
                    'message' => translate('successfully_added') . '!',
                ];
            }
            $cart->update(['is_checked' => 1]);
        }

        if ($product->product_type == 'physical') {
            $cart['free_delivery_order_amount'] = OrderManager::getFreeDeliveryOrderAmountArray($cart['cart_group_id']);
        }

        // Gift Deal Logic - Enhanced for multiple products
        try {
            $activeGiftDeals = \App\Models\GiftDeal::where('status', 1)
                ->where('start_date', '<=', now())
                ->where('end_date', '>=', now())
                ->get();

            foreach ($activeGiftDeals as $deal) {
                /** @var \App\Models\GiftDeal $deal */
                // Check if current product qualifies for this deal
                if ($deal->qualifiesForDeal($product['id'], $request['quantity'])) {
                    // Get all gift products for this deal
                    $giftProducts = $deal->getGiftProductsList();

                    foreach ($giftProducts as $giftProdData) {
                        $giftProduct = \App\Models\Product::find($giftProdData['product_id']);

                        if (!$giftProduct || !$giftProduct->status) {
                            continue; // Skip if product deleted or inactive
                        }

                        $giftQuantity = $giftProdData['quantity'] ?? 1;

                        // Check stock availability for physical products
                        if ($giftProduct->product_type == 'physical' && $giftProduct->current_stock < $giftQuantity) {
                            continue; // Skip if insufficient stock
                        }

                        // Remove existing gift product from cart if exists
                        Cart::where([
                            'customer_id' => $cartArray['customer_id'],
                            'is_guest' => $cartArray['is_guest'],
                            'product_id' => $giftProduct->id,
                            'price' => 0  // Only remove free gift items
                        ])->delete();

                        $giftCartArray = [
                            'customer_id' => $cartArray['customer_id'],
                            'product_id' => $giftProduct->id,
                            'product_type' => $giftProduct->product_type,
                            'choices' => json_encode([]),
                            'variations' => json_encode([]),
                            'variant' => '',
                            'quantity' => $giftQuantity,
                            'price' => 0,  // Free gift
                            'discount' => 0,
                            'is_checked' => 1,
                            'slug' => $giftProduct->slug,
                            'name' => $giftProduct->name . ' (Gift)',
                            'thumbnail' => $giftProduct->thumbnail,
                            'seller_id' => ($giftProduct->added_by == 'admin') ? 1 : $giftProduct->user_id,
                            'seller_is' => $giftProduct->added_by,
                            'created_at' => now(),
                            'updated_at' => now(),
                            'shop_info' => $giftProduct->added_by == 'admin' ? getInHouseShopConfig(key: 'name') : \App\Models\Shop::where(['seller_id' => $giftProduct->user_id])->first()->name,
                            'shipping_cost' => 0,  // Free shipping for gifts
                            'shipping_type' => $shippingType,
                            'is_guest' => $cartArray['is_guest'],
                            'cart_group_id' => $cartArray['cart_group_id'],
                            'gift_deal_id' => $deal->id,
                        ];

                        Cart::insert($giftCartArray);
                    }

                    // Only apply first matching deal
                    Cart::where(['id' => $cart['id']])->update(['gift_deal_id' => $deal->id]);
                    break;
                }
            }
        } catch (\Exception $e) {
            // Log error or ignore to not block main flow
            Log::error('Gift Deal Error: ' . $e->getMessage());
        }


        return [
            'status' => 1,
            'in_cart_key' => $cart['id'],
            'cart' => $cart,
            'message' => translate('successfully_added') . '!',
            'product_variant_type' => count(json_decode($product['variation'], true)) > 0 ? 'multi_variant' : 'single_variant',
        ];
    }

    public static function addToCartDigitalProduct($request, $product, $shippingType, $sellerShippingList, $giftId = null, $giftDealId = null): array
    {
        if ($product['minimum_order_qty'] > $request['quantity']) {
            return ['status' => 0, 'message' => translate('Minimum_order_quantity') . ' ' . $product['minimum_order_qty']];
        }
        if ($product['maximum_order_qty'] < $request['quantity']) {
            return ['status' => 0, 'message' => translate('maximum_order_quantity') . ' ' . $product['maximum_order_qty']];
        }

        $price = $product->unit_price;
        $digitalVariation = DigitalProductVariation::where(['product_id' => $product['id'], 'variant_key' => $request['variant_key']])->first();
        if ($request['variant_key'] && $digitalVariation) {
            $price = $digitalVariation['price'];
        }
        $user = Helpers::getCustomerInformation($request);
        $guestId = session('guest_id') ?? ($request->guest_id ?? 0);

        if ($user == 'offline') {
            $customerId = $guestId;
            $isGuest = 1;
        } else {
            $customerId = $user['id'];
            $isGuest = 0;
        }

        $getProductDiscount = ($price == 0) ? 0 : getProductPriceByType(product: $product, type: 'discounted_amount', result: 'value', price: $price);
        $cartArray = [
            'customer_id' => $customerId,
            'product_id' => $request['id'],
            'product_type' => $product['product_type'],
            'digital_product_type' => $product['digital_product_type'],
            'choices' => json_encode([]),
            'variations' => json_encode([]),
            'variant' => $request['variant_key'],
            'quantity' => $request['quantity'],
            'price' => $price,
            'discount' => $getProductDiscount,
            'is_checked' => 1,
            'slug' => $product['slug'],
            'name' => $product['name'],
            'thumbnail' => $product['thumbnail'],
            'seller_id' => ($product->added_by == 'admin') ? 1 : $product->user_id,
            'seller_is' => $product['added_by'],
            'created_at' => now(),
            'updated_at' => now(),
            'shop_info' => $product->added_by == 'admin' ? getInHouseShopConfig(key: 'name') : Shop::where(['seller_id' => $product->user_id])->first()->name,
            'shipping_cost' => $product['product_type'] == 'physical' ? CartManager::get_shipping_cost_for_product_category_wise($product, $request['quantity']) : 0,
            'shipping_type' => $shippingType,
            'is_guest' => $isGuest,
            'gift_id' => $giftId,
            'gift_deal_id' => $giftDealId,
            'original_price' => $price,
        ];

        $cartCheck = Cart::where(['customer_id' => $customerId, 'is_guest' => $isGuest, 'seller_id' => ($product->added_by == 'admin') ? 1 : $product->user_id, 'seller_is' => $product->added_by])->first();
        if ($cartCheck) {
            $cartArray['cart_group_id'] = $cartCheck['cart_group_id'];
        } else {
            $cartArray['cart_group_id'] = ($user == 'offline' ? 'guest' : $user['id']) . '-' . Str::random(5) . '-' . time();
        }

        $cart = Cart::where(['product_id' => $request->id, 'customer_id' => $customerId, 'is_guest' => $isGuest, 'variant' => $request['variant_key']])->first();
        if ($cart) {
            Cart::where(['id' => $cart['id']])->update($cartArray);
        } else {
            $cartID = Cart::insertGetId($cartArray);
            $cart = Cart::where(['id' => $cartID])->first();
        }

        if ($request['buy_now'] == 1) {
            $productTotalPrice = ($price * $request['quantity']) - ($getProductDiscount * $request['quantity']);
            $verifyStatus = OrderManager::checkSingleProductMinimumOrderAmountVerify(request: $request, product: $product, totalAmount: $productTotalPrice);
            if ($verifyStatus['status'] == 0) {
                return ['status' => 0, 'message' => $verifyStatus['message']];
            }

            Cart::where(['customer_id' => ($user == 'offline' ? $guestId : $user['id']), 'is_guest' => ($user == 'offline' ? 1 : 0)])
                ->update(['is_checked' => 0]);

            Cart::where(['id' => $cart['id']])->update(['is_checked' => 1]);

            if ($product['product_type'] == 'digital') {
                return [
                    'status' => 1,
                    'redirect_to' => 'checkout',
                    'cart' => $cart,
                    'message' => translate('successfully_added') . '!',
                ];
            }
        }

        return [
            'status' => 1,
            'in_cart_key' => $cart['id'],
            'cart' => $cart,
            'message' => translate('successfully_added') . '!',
            'product_variant_type' => count(json_decode($product['variation'], true)) > 0 ? 'multi_variant' : 'single_variant',
        ];
    }

    public static function add_to_cart($request, $from_api = false, $giftId = null, $giftDealId = null): array
    {
        cacheRemoveByType(type: 'carts');

        $product = Product::with([
            'digitalVariation',
            'clearanceSale' => function ($query) {
                return $query->active();
            }
        ])->where(['id' => $request['id']])->first();

        if ($product['status'] == 0) {
            return ['status' => 0, 'message' => translate('Product_is_unavailable')];
        }

        $authorType = $product['added_by'] == 'admin' ? 'inhouse' : ($product['added_by'] == 'seller' ? 'vendor' : null);
        if ($authorType === 'vendor' && isset($product->seller->shop)) {
            $isTemporaryClose = (bool) checkVendorAbility(type: $authorType, status: 'temporary_close', vendor: $product->seller->shop);
            $isVacationMode = (bool) checkVendorAbility(type: $authorType, status: 'vacation_status', vendor: $product->seller->shop);
        } else {
            $isTemporaryClose = (bool) checkVendorAbility(type: $authorType, status: 'temporary_close');
            $isVacationMode = (bool) checkVendorAbility(type: $authorType, status: 'vacation_status');
        }
        if ($isTemporaryClose || $isVacationMode) {
            return ['status' => 0, 'message' => translate('Shop_is_unavailable')];
        }
        $shippingMethod = getWebConfig(name: 'shipping_method');
        $adminShipping = ShippingType::where('seller_id', 0)->first();
        $sellerShippingList = null;
        if ($shippingMethod == 'inhouse_shipping') {
            $shippingType = isset($adminShipping) ? $adminShipping->shipping_type : 'order_wise';
            $sellerShippingList = $shippingType == 'order_wise' ? ShippingMethod::where(['status' => 1])->where(['creator_type' => 'admin'])->get() : null;
        } else {
            if ($product['added_by'] == 'admin') {
                $shippingType = isset($adminShipping) ? $adminShipping->shipping_type : 'order_wise';
                $sellerShippingList = $shippingType == 'order_wise' ? ShippingMethod::where(['status' => 1])->where(['creator_type' => 'admin'])->get() : null;
            } else {
                $sellerShipping = ShippingType::where('seller_id', $product['user_id'])->first();
                $shippingType = isset($sellerShipping) ? $sellerShipping->shipping_type : 'order_wise';
                $sellerShippingList = ShippingMethod::where(['status' => 1])->where(['creator_id' => $product['user_id'], 'creator_type' => 'seller'])->get();
            }
        }

        if ($product['product_type'] == 'digital') {
            return self::addToCartDigitalProduct($request, $product, $shippingType, $sellerShippingList, $giftId, $giftDealId);
        } else {
            return self::addToCartPhysicalProduct($request, $product, $shippingType, $sellerShippingList, $giftId, $giftDealId);
        }
    }

    public static function update_cart_qty($request): array
    {
        cacheRemoveByType(type: 'carts');

        $user = Helpers::getCustomerInformation($request);
        $guest_id = session('guest_id') ?? ($request->guest_id ?? 0);
        $status = 1;
        $qty = 0;
        $cart = Cart::where(['id' => $request->key, 'customer_id' => ($user == 'offline' ? $guest_id : $user['id'])])->first();

        if (!$cart) {
            return [
                'status' => 0,
                'qty' => $request['quantity'],
                'message' => translate('Product_not_found_in_cart'),
            ];
        }

        $product = Product::find($cart['product_id']);
        $message = translate('sorry_stock_is_limited');

        if ($product['minimum_order_qty'] > $request['quantity']) {
            $status = 0;
            $qty = $cart['quantity'];
            $message = translate('Minimum_order_quantity') . ' ' . $product['minimum_order_qty'];
        } elseif ($product['maximum_order_qty'] < $request['quantity']) {
            $status = 0;
            $qty = $cart['quantity'];
            $message = translate('maximum_order_quantity') . ' ' . $product['maximum_order_qty'];
        }

        if ($status) {
            $count = count(json_decode($product->variation));
            if ($count) {
                for ($i = 0; $i < $count; $i++) {
                    if (json_decode($product->variation)[$i]->type == $cart['variant']) {
                        if (json_decode($product->variation)[$i]->qty < $request->quantity) {
                            $status = 0;
                            $qty = $cart['quantity'];
                        }
                    }
                }
            } else if (($product['product_type'] == 'physical') && $product['current_stock'] < $request->quantity) {
                $status = 0;
                $qty = $cart['quantity'];
            }
        }

        if ($status) {
            $qty = $request->quantity;
            $cart['quantity'] = $request->quantity;
            $cart['shipping_cost'] = $product->product_type == 'physical' ? CartManager::get_shipping_cost_for_product_category_wise($product, $request->quantity) : 0;
            $message = translate('successfully_updated!');
        }

        $cart->save();

        if ($request['buy_now'] == 1) {
            Cart::where(['customer_id' => ($user == 'offline' ? $guest_id : $user['id']), 'is_guest' => ($user == 'offline' ? 1 : 0)])
                ->update(['is_checked' => 0]);
            Cart::where(['id' => $request->key, 'customer_id' => ($user == 'offline' ? $guest_id : $user['id'])])->update(['is_checked' => 1]);
        }

        return [
            'status' => $status,
            'qty' => $qty,
            'message' => $message,
        ];
    }

    public static function get_shipping_cost_for_product_category_wise($product, $qty)
    {
        $shippingMethod = getWebConfig(name: 'shipping_method');
        $cost = 0;

        if ($shippingMethod == 'inhouse_shipping') {
            $adminShipping = ShippingType::where('seller_id', 0)->first();
            $shippingType = isset($adminShipping) ? $adminShipping->shipping_type : 'order_wise';
        } else {
            if ($product->added_by == 'admin') {
                $adminShipping = ShippingType::where('seller_id', 0)->first();
                $shippingType = isset($adminShipping) ? $adminShipping->shipping_type : 'order_wise';
            } else {
                $sellerShipping = ShippingType::where('seller_id', $product->user_id)->first();
                $shippingType = isset($sellerShipping) ? $sellerShipping->shipping_type : 'order_wise';
            }
        }

        if ($shippingType == 'category_wise') {
            $categoryID = 0;
            foreach (json_decode($product->category_ids) as $ct) {
                if ($ct->position == 1) {
                    $categoryID = $ct->id;
                }
            }

            if ($shippingMethod == 'inhouse_shipping') {
                $categoryShippingCost = CategoryShippingCost::where('seller_id', 0)->where('category_id', $categoryID)->first();
            } else {
                if ($product->added_by == 'admin') {
                    $categoryShippingCost = CategoryShippingCost::where('seller_id', 0)->where('category_id', $categoryID)->first();
                } else {
                    $categoryShippingCost = CategoryShippingCost::where('seller_id', $product->user_id)->where('category_id', $categoryID)->first();
                }
            }

            if (isset($categoryShippingCost->multiply_qty) && $categoryShippingCost->multiply_qty == 1) {
                $cost = $qty * $categoryShippingCost->cost;
            } else {
                $cost = $categoryShippingCost->cost ?? 0;
            }
        } else if ($shippingType == 'product_wise') {
            if ($product->multiply_qty == 1) {
                $cost = $qty * $product->shipping_cost;
            } else {
                $cost = $product->shipping_cost;
            }
        }

        return $cost;
    }

    public static function getShippingCostSavedForFreeDelivery($groupId = null, $type = null)
    {
        $costSaved = 0;

        $cartGroup = Cart::where(['product_type' => 'physical'])
            ->whereHas('product', function ($query) {
                return $query->active();
            })->when($groupId != null, function ($query) use ($groupId) {
                return $query->where('cart_group_id', $groupId);
            })
            ->when(($groupId == null && $type != 'checked'), function ($query) {
                return $query->whereIn('cart_group_id', CartManager::get_cart_group_ids());
            })
            ->when(($groupId == null && $type == 'checked'), function ($query) {
                return $query->whereIn('cart_group_id', CartManager::get_cart_group_ids(type: 'checked'));
            })
            ->when($type == 'checked', function ($query) {
                return $query->where(['is_checked' => 1]);
            })->get()->groupBy('cart_group_id');

        foreach ($cartGroup as $cart) {
            if ($cart->count() > 0) {
                $freeDeliveryCheck = OrderManager::getFreeDeliveryOrderAmountArray($cart[0]->cart_group_id);
                $costSaved += $freeDeliveryCheck['shipping_cost_saved'];
            }
        }

        return $costSaved;
    }

    public static function product_stock_check($carts): bool
    {
        $status = true;

        foreach ($carts as $cart) {
            if ($cart->product) {
                $product = $cart->product;
                $count = count(json_decode($product->variation));
                if ($count) {
                    for ($i = 0; $i < $count; $i++) {
                        if (json_decode($product->variation)[$i]->type == $cart['variant']) {
                            if (json_decode($product->variation)[$i]->qty < $cart->quantity) {
                                $status = false;
                            }
                        }
                    }
                } else if (($product['product_type'] == 'physical') && $product['current_stock'] < $cart->quantity) {
                    $status = false;
                }
            } else {
                $status = false;
            }
        }
        return $status;
    }

    public static function getAppliedTaxIds($product = null, $taxConfig = []): array
    {
        if (!isset($taxConfig['is_included']) || $taxConfig['is_included']) {
            return [];
        }
        $taxType = $taxConfig['SystemTaxVatType'] ?? 'order_wise';

        if ($taxType == 'product_wise') {
            $taxIds = $product['taxVats']?->pluck('tax')->toArray() ?? [];
        } elseif ($taxType == 'category_wise') {
            $taxIds = $product?->category?->taxVats?->pluck('tax')->toArray() ?? [];
        } else {
            if (is_array($taxConfig['taxVats'])) {
                $taxIds = collect($taxConfig['taxVats'])->whereIn('id', $taxConfig['SystemTaxVat']['tax_ids'])->toArray();
            } else {
                $taxIds = $taxConfig['taxVats']->whereIn('id', $taxConfig['SystemTaxVat']['tax_ids'])->toArray();
            }
        }

        return $taxIds ?? [];
    }

    public static function getAppliedShippingTaxIds($taxConfig = []): array
    {
        if (!isset($taxConfig['is_included']) || $taxConfig['is_included']) {
            return [];
        }

        return collect($taxConfig['SystemTaxVat']['additionalData'])->toArray();
    }

    public static function getAppliedTaxAmount($product = null, $taxConfig = [], $totalDiscountedPrice = 0, $appliedDiscountedAmount = 0): float|int
    {
        if (!isset($taxConfig['is_included']) || $taxConfig['is_included']) {
            return 0;
        }
        $taxPercent = 0;
        $taxType = $taxConfig['SystemTaxVatType'] ?? 'order_wise';

        if ($taxType == 'product_wise') {
            foreach ($product['taxVats'] as $taxVat) {
                if ($taxVat?->tax?->tax_rate) {
                    $taxPercent += $taxVat?->tax?->tax_rate;
                }
            }
        } elseif ($taxType == 'category_wise' && isset($product['category']['taxVats'])) {
            foreach ($product['category']['taxVats'] as $taxVat) {
                if ($taxVat?->tax?->tax_rate) {
                    $taxPercent += $taxVat?->tax?->tax_rate;
                }
            }
        } else {
            if (is_array($taxConfig['taxVats'])) {
                $taxPercent = collect($taxConfig['taxVats'])->whereIn('id', $taxConfig['SystemTaxVat']['tax_ids'])->sum('tax_rate');
            } else {
                $taxPercent = $taxConfig['taxVats']->whereIn('id', $taxConfig['SystemTaxVat']['tax_ids'])->sum('tax_rate');
            }
        }

        return (($totalDiscountedPrice - $appliedDiscountedAmount) * $taxPercent) / 100;
    }

    public static function getAppliedShippingTaxAmount($taxConfig = [], $totalShippingCost = 0, $totalDiscountedPrice = 0, $applicableShippingAmount = 0): float|int
    {
        if (!isset($taxConfig['is_included']) || $taxConfig['is_included']) {
            return 0;
        }

        $allTaxIds = collect($taxConfig['SystemTaxVat']['additionalData'])
            ->pluck('tax_ids')->flatten()->toArray();

        if (is_array($taxConfig['taxVats'])) {
            $taxRate = collect($taxConfig['taxVats'])->whereIn('id', $allTaxIds)->sum('tax_rate');
        } else {
            $taxRate = $taxConfig['taxVats']->whereIn('id', $allTaxIds)->sum('tax_rate');
        }

        if ($totalShippingCost <= 0 || $applicableShippingAmount <= 0) {
            return 0;
        }

        return ((($totalShippingCost * $totalDiscountedPrice) / $applicableShippingAmount) * $taxRate) / 100;
    }

    public static function getCartListTaxAmount(array $data = [], ?string $cartGroupId = null): array
    {
        $vendorWiseCartList = OrderManager::processOrderGenerateData(data: [
            'coupon_code' => $data['coupon_code'] ?? (session('coupon_code') ?? ''),
            'requestObj' => $data['requestObj'] ?? null,
        ]);

        $totalTaxAmount = 0;
        $totalShippingTaxAmount = 0;
        foreach ($vendorWiseCartList as $vendorWiseCart) {
            foreach ($vendorWiseCart['applied_tax_cart_list'] as $cartItem) {
                $totalTaxAmount += $cartItem['applied_tax_amount'];
                $totalShippingTaxAmount += $cartItem['applied_shipping_cost_tax'];
            }
        }

        return [
            'item_tax' => $totalTaxAmount,
            'shipping_cost_tax' => $totalShippingTaxAmount,
        ];
    }
}