<?php

namespace App\Http\Controllers;

use App\Models\Product;
use App\Models\User;
use App\Models\ShippingFee;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class CartController extends Controller
{
    public function index()
    {
        // ===== VÉRIFIER LE PRODUIT D'INVESTISSEMENT =====
        // Si l'utilisateur est connecté comme membre, vérifier qu'il a payé son produit d'investissement
        if (Auth::check() && Auth::user()->role === 'member') {
            $user = Auth::user();
            $investmentService = new \App\Services\InvestmentProductService();
            
            if (!$investmentService->hasUserPaidInvestment($user)) {
                return redirect()->route('investment-product')
                    ->with('info', 'Vous devez d\'abord payer votre produit d\'investissement pour accéder à la boutique.');
            }
        }

        $cart = session()->get('cart', []);
        $memberCode = session()->get('member_discount_code');
        $memberDiscount = 0;
        $discountPercentage = 0;
        $member = null;
        
        // Calcul du sous-total avec conversion en float
        $subtotal = 0;
        foreach ($cart as $item) {
            $subtotal += floatval($item['price']) * intval($item['quantity']);
        }
        $subtotal = floatval($subtotal);
        
        // Si l'utilisateur est connecté et est membre, appliquer sa réduction automatiquement
        if (Auth::check() && Auth::user()->role === 'member') {
            $member = Auth::user();
            // Utiliser le paramètre global member_discount_percentage
            $discountPercentage = floatval(\App\Models\Setting::get('member_discount_percentage', 5));
            $memberDiscount = ($subtotal * $discountPercentage) / 100;
            session()->put('member_discount_code', $member->member_code);
        } 
        // Sinon, utiliser le code manuel s'il existe
        elseif ($memberCode) {
            $member = User::where('member_code', $memberCode)->first();
            if ($member && $member->role === 'member') {
                $discountPercentage = floatval(\App\Models\Setting::get('member_discount_percentage', 5));
                $memberDiscount = ($subtotal * $discountPercentage) / 100;
            }
        }
        
        $memberDiscount = floatval($memberDiscount);
        
        // ===== RÉCUPÉRER LE COUPON APPLIQUÉ =====
        $appliedCoupon = session()->get('applied_coupon');
        $couponDiscount = 0;
        
        if ($appliedCoupon) {
            // Recalculer la réduction du coupon basée sur le panier actuel
            $couponDiscount = $this->recalculateCouponDiscount($cart, $appliedCoupon);
            // Mettre à jour la session avec le nouveau montant
            $appliedCoupon['discount'] = $couponDiscount;
            session()->put('applied_coupon', $appliedCoupon);
        }
        
        // Total des réductions
        $discount = $memberDiscount + $couponDiscount;
        $total = $subtotal - $discount;
        
        return view('shop.cart', compact('cart', 'subtotal', 'total', 'discount', 'discountPercentage', 'member', 'appliedCoupon', 'couponDiscount', 'memberDiscount'));
    }
    
    /**
     * Recalculer la réduction du coupon basée sur le panier actuel
     */
    private function recalculateCouponDiscount(array $cart, array $appliedCoupon): float
    {
        $coupon = \App\Models\Coupon::find($appliedCoupon['id']);
        if (!$coupon || !$coupon->is_active) {
            session()->forget('applied_coupon');
            return 0;
        }
        
        $applicableSubtotal = 0;
        
        foreach ($cart as $productId => $item) {
            $product = Product::find($productId);
            if ($product && $coupon->isApplicableToProduct($product)) {
                $applicableSubtotal += floatval($item['price']) * intval($item['quantity']);
            }
        }
        
        if ($applicableSubtotal <= 0) {
            return 0;
        }
        
        $discount = 0;
        if ($coupon->type === 'percentage') {
            $discount = ($applicableSubtotal * $coupon->value) / 100;
            if ($coupon->max_discount && $discount > $coupon->max_discount) {
                $discount = $coupon->max_discount;
            }
        } elseif ($coupon->type === 'fixed') {
            $discount = min($coupon->value, $applicableSubtotal);
        }
        
        return floatval($discount);
    }
    
    public function add(Request $request, $productId)
    {
        try {
            // Charger le produit avec le vendeur
            $product = Product::with('seller.user')->findOrFail($productId);

            // ===== VÉRIFIER LE PRODUIT D'INVESTISSEMENT =====
            if (Auth::check() && Auth::user()->role === 'member') {
                $user = Auth::user();
                try {
                    $investmentService = new \App\Services\InvestmentProductService();
                    if (!$investmentService->hasUserPaidInvestment($user)) {
                        return redirect()->route('investment-product')
                            ->with('error', 'Vous devez d\'abord payer votre produit d\'investissement pour accéder à la boutique.');
                    }
                } catch (\Exception $e) {
                    \Log::error('Investment service error: ' . $e->getMessage());
                    // Continuer malgré l'erreur du service d'investissement
                }
            }

            $cart = session()->get('cart', []);
            
            // Vérifier le stock
            $requestedQuantity = intval($request->quantity ?? 1);
            $currentQuantity = isset($cart[$product->id]) ? intval($cart[$product->id]['quantity']) : 0;
            
            if ($product->stock < ($currentQuantity + $requestedQuantity)) {
                if ($request->ajax() || $request->wantsJson()) {
                    return response()->json([
                        'success' => false,
                        'message' => 'Stock insuffisant pour ce produit.'
                    ], 422);
                }
                return redirect()->back()->with('error', 'Stock insuffisant pour ce produit.');
            }
            
            // Obtenir le nom du vendeur
            $sellerName = $this->getSellerInfo($product->seller_id);
            
            if (isset($cart[$product->id])) {
                $cart[$product->id]['quantity'] += $requestedQuantity;
            } else {
                $cart[$product->id] = [
                    'id' => $product->id,
                    'name' => $product->name,
                    'price' => floatval($product->price),
                    'image' => $product->image,
                    'quantity' => $requestedQuantity,
                    'seller_id' => $product->seller_id,
                    'seller_name' => $sellerName, // Stocker le nom du vendeur pour affichage
                ];
            }
            
            session()->put('cart', $cart);
            
            // Si l'utilisateur est membre, appliquer automatiquement sa réduction
            if (Auth::check() && Auth::user()->role === 'member') {
                $member = Auth::user();
                session()->put('member_discount_code', $member->member_code);
            }
            
            // Réponse AJAX
            if ($request->ajax() || $request->wantsJson()) {
                return response()->json([
                    'success' => true,
                    'message' => 'Produit ajouté au panier !',
                    'cart_count' => count($cart),
                    'cart_total' => $this->getCartTotal($cart)
                ]);
            }
            
            // Déterminer si on doit rediriger vers le checkout ou non
            $action = $request->input('action', 'add_to_cart');
            if ($action === 'checkout' || $request->has('redirect_to_checkout')) {
                return redirect()->route('checkout')->with('success', 'Produit ajouté au panier !');
            }
            
            return redirect()->back()->with('success', 'Produit ajouté au panier !');
            
        } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $e) {
            if ($request->ajax() || $request->wantsJson()) {
                return response()->json(['success' => false, 'message' => 'Produit non trouvé.'], 404);
            }
            return redirect()->back()->with('error', 'Produit non trouvé.');
        } catch (\Exception $e) {
            \Log::error('Cart add error', [
                'product_id' => $productId ?? null,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);
            if ($request->ajax() || $request->wantsJson()) {
                return response()->json(['success' => false, 'message' => 'Erreur lors de l\'ajout au panier.'], 500);
            }
            return redirect()->back()->with('error', 'Erreur lors de l\'ajout au panier. Veuillez réessayer.');
        }
    }
    
    /**
     * Obtenir les infos du vendeur pour l'affichage
     */
    private function getSellerInfo($sellerId): string
    {
        if ($sellerId === null) {
            return 'BIJOUX EXPRESS';
        }
        
        $seller = \App\Models\Seller::with('user')->find($sellerId);
        if ($seller && $seller->user) {
            return $seller->shop_name ?? $seller->user->name ?? 'Vendeur #' . $sellerId;
        }
        
        return 'Vendeur #' . $sellerId;
    }
    
    /**
     * Calculer le total du panier
     */
    private function getCartTotal(array $cart): float
    {
        $total = 0;
        foreach ($cart as $item) {
            $total += floatval($item['price']) * intval($item['quantity']);
        }
        return $total;
    }
    
    /**
     * Vider complètement le panier (pour permettre d'ajouter des produits d'un autre vendeur)
     */
    public function clear()
    {
        session()->forget('cart');
        session()->forget('applied_coupon');
        session()->forget('member_discount_code');
        
        if (request()->ajax() || request()->wantsJson()) {
            return response()->json([
                'success' => true,
                'message' => 'Panier vidé avec succès.'
            ]);
        }
        
        return redirect()->back()->with('success', 'Panier vidé avec succès.');
    }
    
    /**
     * Vérifier si un produit peut être ajouté au panier (même vendeur)
     */
    public function canAddProduct(Request $request, $productId)
    {
        $product = Product::find($productId);
        if (!$product) {
            return response()->json(['can_add' => false, 'message' => 'Produit non trouvé'], 404);
        }
        
        $cart = session()->get('cart', []);
        
        if (empty($cart)) {
            return response()->json(['can_add' => true]);
        }
        
        $firstItemId = array_key_first($cart);
        $firstProduct = Product::find($firstItemId);
        $cartSellerId = $firstProduct ? $firstProduct->seller_id : null;
        
        if ($cartSellerId === $product->seller_id) {
            return response()->json(['can_add' => true]);
        }
        
        return response()->json([
            'can_add' => false,
            'seller_conflict' => true,
            'current_seller' => $this->getSellerInfo($cartSellerId),
            'new_seller' => $this->getSellerInfo($product->seller_id),
            'message' => 'Ce produit provient d\'une autre boutique.'
        ]);
    }
    
    public function update(Request $request, $id)
    {
        $cart = session()->get('cart', []);
        
        if (isset($cart[$id])) {
            $cart[$id]['quantity'] = intval($request->quantity); // Conversion en int
            session()->put('cart', $cart);
        }
        
        return redirect()->back()->with('success', 'Panier mis à jour !');
    }
    
    public function remove($id)
    {
        $cart = session()->get('cart', []);
        
        if (isset($cart[$id])) {
            unset($cart[$id]);
            session()->put('cart', $cart);
        }
        
        return redirect()->back()->with('success', 'Produit retiré du panier !');
    }
    
    public function applyDiscount(Request $request)
    {
        $request->merge([
            'member_code' => strtoupper(trim($request->member_code))
        ]);

        $request->validate([
            'member_code' => 'required|string|exists:users,member_code'
        ], [
            'member_code.exists' => 'Ce code membre est introuvable.'
        ]);
        
        $member = User::where('member_code', $request->member_code)->first();
        
        if (!$member) {
            return back()->with('error', 'Code membre invalide.');
        }
        
        if ($member->role !== 'member') {
            return back()->with('error', 'Ce code n\'appartient pas à un membre.');
        }
        
        // Vérifier que la réduction est active dans les settings
        $memberDiscount = floatval(\App\Models\Setting::get('member_discount_percentage', 5));
        if ($memberDiscount <= 0) {
            return back()->with('error', 'Aucune réduction membre n\'est actuellement active.');
        }
        
        // Vérifier si le code n'est pas déjà appliqué
        $currentMemberCode = session()->get('member_discount_code');
        if ($currentMemberCode === $request->member_code) {
            return back()->with('info', 'Ce code est déjà appliqué.');
        }
        
        session()->put('member_discount_code', $request->member_code);
        
        $discountPercent = floatval(\App\Models\Setting::get('member_discount_percentage', 5));
        return back()->with('success', "Réduction de {$discountPercent}% appliquée !");
    }
    
    public function removeDiscount()
    {
        if (!session()->has('member_discount_code')) {
            return back()->with('info', 'Aucun code membre à retirer.');
        }
        
        session()->forget('member_discount_code');
        return back()->with('success', 'Code membre retiré.');
    }

    /**
     * Appliquer un coupon de réduction
     */
    public function applyCoupon(Request $request)
    {
        $request->merge([
            'coupon_code' => strtoupper(trim($request->coupon_code))
        ]);

        $request->validate([
            'coupon_code' => 'required|string|max:50'
        ], [
            'coupon_code.required' => 'Veuillez entrer un code coupon.'
        ]);

        $coupon = \App\Models\Coupon::where('code', $request->coupon_code)
            ->where('is_active', true)
            ->first();

        if (!$coupon) {
            return back()->with('error', 'Ce code coupon est invalide.');
        }

        // Vérifier la date d'expiration
        if ($coupon->expires_at && $coupon->expires_at < now()) {
            return back()->with('error', 'Ce coupon a expiré.');
        }

        // Vérifier la date de début
        if ($coupon->starts_at && $coupon->starts_at > now()) {
            return back()->with('error', 'Ce coupon n\'est pas encore actif.');
        }

        // Vérifier le nombre d'utilisations
        if ($coupon->usage_limit && $coupon->usage_count >= $coupon->usage_limit) {
            return back()->with('error', 'Ce coupon a atteint sa limite d\'utilisation.');
        }

        // Récupérer le panier et enrichir avec les produits
        $cart = session()->get('cart', []);
        $enrichedCart = [];
        $subtotal = 0;
        $applicableSubtotal = 0;
        
        foreach ($cart as $productId => $item) {
            $product = Product::find($productId);
            $itemTotal = floatval($item['price']) * intval($item['quantity']);
            $subtotal += $itemTotal;
            
            // Enrichir l'item avec le produit
            $enrichedItem = $item;
            $enrichedItem['product'] = $product;
            $enrichedItem['product_id'] = $productId;
            $enrichedCart[] = $enrichedItem;
            
            // Vérifier si le coupon est applicable à ce produit selon son scope
            if ($product && $coupon->isApplicableToProduct($product)) {
                $applicableSubtotal += $itemTotal;
            }
        }

        // Vérifier si le coupon s'applique à au moins un produit
        if ($applicableSubtotal <= 0) {
            $scopeMessage = $this->getScopeErrorMessage($coupon);
            return back()->with('error', $scopeMessage);
        }

        // Vérifier le montant minimum de commande
        if ($coupon->min_order_amount && $applicableSubtotal < $coupon->min_order_amount) {
            return back()->with('error', 'Le montant minimum pour ce coupon est de ' . number_format($coupon->min_order_amount, 0, ',', ' ') . ' XOF.');
        }

        // Vérifier si un coupon est déjà appliqué
        $currentCoupon = session()->get('applied_coupon');
        if ($currentCoupon && $currentCoupon['code'] === $request->coupon_code) {
            return back()->with('info', 'Ce coupon est déjà appliqué.');
        }

        // Calculer la réduction basée sur le type et le montant applicable
        $discount = 0;
        if ($coupon->type === 'percentage') {
            $discount = ($applicableSubtotal * $coupon->value) / 100;
            // Appliquer le max_discount si défini
            if ($coupon->max_discount && $discount > $coupon->max_discount) {
                $discount = $coupon->max_discount;
            }
        } elseif ($coupon->type === 'fixed') {
            $discount = min($coupon->value, $applicableSubtotal);
        }
        // Pour free_shipping, la réduction sur produits est 0, mais livraison gratuite sera appliquée

        // Sauvegarder le coupon en session
        session()->put('applied_coupon', [
            'id' => $coupon->id,
            'code' => $coupon->code,
            'type' => $coupon->type,
            'value' => $coupon->value,
            'discount' => $discount,
            'name' => $coupon->name,
            'seller_id' => $coupon->seller_id,
            'scope' => $coupon->scope,
            'includes_free_shipping' => $coupon->includes_free_shipping ?? false
        ]);

        $discountDisplay = $coupon->type === 'percentage' 
            ? $coupon->value . '%' 
            : ($coupon->type === 'free_shipping' ? 'Livraison gratuite' : number_format($coupon->value, 0, ',', ' ') . ' XOF');
        
        $scopeNote = $this->getScopeSuccessNote($coupon);

        return back()->with('success', "Coupon '{$coupon->code}' appliqué ! {$discountDisplay}{$scopeNote}.");
    }
    
    /**
     * Obtenir le message d'erreur selon le scope du coupon
     */
    private function getScopeErrorMessage(\App\Models\Coupon $coupon): string
    {
        switch ($coupon->scope) {
            case \App\Models\Coupon::SCOPE_SHOP_ONLY:
                return 'Ce coupon s\'applique uniquement aux produits de la boutique (hors investissements).';
            case \App\Models\Coupon::SCOPE_INVESTMENT_ONLY:
                return 'Ce coupon s\'applique uniquement aux produits d\'investissement.';
            case \App\Models\Coupon::SCOPE_CATEGORY:
                return 'Ce coupon s\'applique uniquement à certaines catégories de produits.';
            case \App\Models\Coupon::SCOPE_PRODUCT:
                return 'Ce coupon s\'applique uniquement à certains produits spécifiques.';
            case \App\Models\Coupon::SCOPE_SELLER:
                return 'Ce coupon s\'applique uniquement aux produits de certains vendeurs.';
            case \App\Models\Coupon::SCOPE_SELLER_OWN:
                return 'Ce coupon s\'applique uniquement aux produits du vendeur concerné.';
            default:
                return 'Ce coupon n\'est pas applicable aux produits de votre panier.';
        }
    }
    
    /**
     * Obtenir la note de succès selon le scope du coupon
     */
    private function getScopeSuccessNote(\App\Models\Coupon $coupon): string
    {
        switch ($coupon->scope) {
            case \App\Models\Coupon::SCOPE_SHOP_ONLY:
                return ' (produits boutique uniquement)';
            case \App\Models\Coupon::SCOPE_INVESTMENT_ONLY:
                return ' (produits investissement uniquement)';
            case \App\Models\Coupon::SCOPE_CATEGORY:
                return ' (catégories spécifiques)';
            case \App\Models\Coupon::SCOPE_PRODUCT:
                return ' (produits spécifiques)';
            case \App\Models\Coupon::SCOPE_SELLER:
            case \App\Models\Coupon::SCOPE_SELLER_OWN:
                return ' (produits du vendeur)';
            default:
                return '';
        }
    }

    /**
     * Retirer le coupon appliqué
     */
    public function removeCoupon()
    {
        if (!session()->has('applied_coupon')) {
            return back()->with('info', 'Aucun coupon à retirer.');
        }

        session()->forget('applied_coupon');
        return back()->with('success', 'Coupon retiré.');
    }

    /**
     * Appliquer un code promo (système Promotion)
     */
    public function applyPromo(Request $request)
    {
        $request->validate([
            'code' => 'required|string|max:50'
        ]);

        $promotionService = app(\App\Services\PromotionService::class);
        
        // Calculer le total du panier
        $cart = session()->get('cart', []);
        $cartTotal = 0;
        $cartItems = [];
        
        foreach ($cart as $productId => $item) {
            $itemTotal = floatval($item['price']) * intval($item['quantity']);
            $cartTotal += $itemTotal;
            $cartItems[] = [
                'product_id' => $productId,
                'price' => $item['price'],
                'quantity' => $item['quantity'],
                'category_id' => $item['category_id'] ?? null,
            ];
        }

        $userId = auth()->id();
        $result = $promotionService->applyPromoCode($request->code, $cartTotal, $userId, $cartItems);

        if ($request->wantsJson()) {
            return response()->json($result);
        }

        if ($result['success']) {
            // Sauvegarder la promo en session
            session()->put('applied_promotion', [
                'id' => $result['promotion']->id,
                'code' => $result['promotion']->code,
                'name' => $result['promotion']->name,
                'type' => $result['promotion']->type,
                'value' => $result['promotion']->value,
                'discount' => $result['discount'],
            ]);
            
            return back()->with('success', $result['message'] . ' Réduction: ' . number_format($result['discount'], 0, ',', ' ') . ' FCFA');
        }

        return back()->with('error', $result['message']);
    }
    
    /**
     * Vérifier si le panier contient des produits de différents vendeurs
     */
    public function checkMultiSeller(): array
    {
        $cart = session()->get('cart', []);
        $sellers = [];
        
        foreach ($cart as $productId => $item) {
            $sellerId = $item['seller_id'] ?? null;
            $sellerName = $item['seller_name'] ?? $this->getSellerInfo($sellerId);
            
            if (!isset($sellers[$sellerId ?? 'admin'])) {
                $sellers[$sellerId ?? 'admin'] = [
                    'id' => $sellerId,
                    'name' => $sellerName,
                    'products' => []
                ];
            }
            $sellers[$sellerId ?? 'admin']['products'][] = [
                'id' => $productId,
                'name' => $item['name'],
                'price' => $item['price'],
                'quantity' => $item['quantity']
            ];
        }
        
        return [
            'has_multiple_sellers' => count($sellers) > 1,
            'sellers' => array_values($sellers),
            'seller_count' => count($sellers)
        ];
    }
    
    /**
     * API pour vérifier les vendeurs multiples (appelé via AJAX)
     */
    public function checkMultiSellerApi()
    {
        $result = $this->checkMultiSeller();
        return response()->json($result);
    }
    
    public function checkout()
    {
        $cart = session()->get('cart', []);
        
        if (empty($cart)) {
            return redirect()->route('shop.index')->with('error', 'Votre panier est vide !');
        }
        
        // Vérifier les vendeurs multiples
        $multiSellerCheck = $this->checkMultiSeller();
        
        $memberCode = session()->get('member_discount_code');
        $memberDiscount = 0;
        $discountPercentage = 0;
        $member = null;
        
        // Calcul du sous-total avec conversion en float
        $subtotal = 0;
        foreach ($cart as $item) {
            $subtotal += floatval($item['price']) * intval($item['quantity']);
        }
        $subtotal = floatval($subtotal);
        
        // Si l'utilisateur est connecté et est membre, appliquer sa réduction automatiquement
        if (Auth::check() && Auth::user()->role === 'member') {
            $member = Auth::user();
            // Utiliser le paramètre global member_discount_percentage (défaut 5%)
            $discountPercentage = floatval(\App\Models\Setting::get('member_discount_percentage', 5));
            $memberDiscount = ($subtotal * $discountPercentage) / 100;
            session()->put('member_discount_code', $member->member_code);
        } 
        // Sinon, utiliser le code manuel s'il existe
        elseif ($memberCode) {
            $member = User::where('member_code', $memberCode)->first();
            if ($member && $member->role === 'member') {
                // Utiliser le paramètre global member_discount_percentage
                $discountPercentage = floatval(\App\Models\Setting::get('member_discount_percentage', 5));
                $memberDiscount = ($subtotal * $discountPercentage) / 100;
            }
        }
        
        $memberDiscount = floatval($memberDiscount);
        
        // ===== RÉCUPÉRER LE COUPON APPLIQUÉ =====
        $appliedCoupon = session()->get('applied_coupon');
        $couponDiscount = 0;
        
        if ($appliedCoupon) {
            // Recalculer la réduction du coupon basée sur le panier actuel
            $couponDiscount = $this->recalculateCouponDiscount($cart, $appliedCoupon);
            // Mettre à jour la session avec le nouveau montant
            $appliedCoupon['discount'] = $couponDiscount;
            session()->put('applied_coupon', $appliedCoupon);
        }
        
        // Total des réductions
        $discount = $memberDiscount + $couponDiscount;
        
        // Récupération des frais de livraison depuis la session
        $shippingFee = floatval(session()->get('shipping_fee', 0));
        
        // Total = Sous-total - Réduction + Frais de livraison
        $total = $subtotal - $discount + $shippingFee;
        
        // Récupération des pays disponibles pour la livraison
        $countries = ShippingFee::where('is_active', true)
            ->distinct()
            ->pluck('country')
            ->sort()
            ->values();
        
        // Récupérer le wallet si l'utilisateur est connecté
        $wallet = null;
        if (Auth::check()) {
            $walletService = app(\App\Services\WalletService::class);
            $wallet = $walletService->getOrCreateWallet(Auth::user());
        }
        
        return view('shop.checkout', compact('cart', 'subtotal', 'total', 'discount', 'discountPercentage', 'member', 'countries', 'shippingFee', 'wallet', 'multiSellerCheck', 'appliedCoupon', 'couponDiscount', 'memberDiscount'));
    }
    
    public function saveCheckout(Request $request)
    {
        // Si shipping_fee n'est pas défini, essayer de le calculer automatiquement
        $shippingFee = session('shipping_fee');

        // Si pas de shipping_fee en session, essayer de calculer basé sur les infos fournies
        if ($shippingFee === null && $request->has('country') && $request->has('city')) {
            // Calculer automatiquement les frais de livraison
            $country = $request->input('country');
            $city = $request->input('city');
            $district = $request->input('district');
            $subtotal = floatval($request->input('subtotal', 0));

            $shippingFeeRecord = \App\Models\ShippingFee::where('is_active', true)
                ->where('country', $country);

            // Recherche spécifique par quartier si fourni
            if (!empty($district)) {
                $shippingFeeRecord = $shippingFeeRecord->where('city', $city)
                    ->where('district', $district);
            } else {
                // Sinon chercher par ville
                $shippingFeeRecord = $shippingFeeRecord->where('city', $city)
                    ->whereNull('district');
            }

            $shippingFeeRecord = $shippingFeeRecord->first();

            if (!$shippingFeeRecord) {
                // Fallback à la recherche générale par pays
                $shippingFeeRecord = \App\Models\ShippingFee::where('is_active', true)
                    ->where('country', $country)
                    ->whereNull('city')
                    ->whereNull('district')
                    ->first();
            }

            if ($shippingFeeRecord) {
                $fee = floatval($shippingFeeRecord->fee);
                
                // Vérifier la livraison gratuite
                if ($shippingFeeRecord->free_shipping_minimum && $subtotal >= $shippingFeeRecord->free_shipping_minimum) {
                    $shippingFee = 0;
                } else {
                    $shippingFee = $fee;
                }

                session()->put('shipping_fee', $shippingFee);
            }
        }

        // Si toujours pas de shipping_fee, mettre à 0 (livraison locale gratuite)
        if ($shippingFee === null) {
            $shippingFee = 0;
            session()->put('shipping_fee', $shippingFee);
        }

        $request->merge([
            'shipping_fee' => $shippingFee,
        ]);

        $request->validate([
            'first_name' => 'required|string',
            'last_name' => 'required|string',
            'email' => 'required|email',
            'phone' => 'required|string',
            'address' => 'nullable|string',
            'city' => 'required|string',
            'country' => 'required|string',
            'district' => 'nullable|string',
            'notes' => 'nullable|string',
            'total' => 'required|numeric',
            'subtotal' => 'required|numeric',
            'shipping_fee' => 'required|numeric|min:0',
            'discount' => 'nullable|numeric|min:0',
            'discount_percentage' => 'nullable|numeric|min:0'
        ]);

        session([
            'checkout_data' => $request->all()
        ]);
        
        return response()->json([
            'success' => true,
            'shipping_fee' => $shippingFee
        ]);
    }
    
    public function getCountries()
    {
        $countries = ShippingFee::getAvailableCountries();
        return response()->json($countries);
    }
    
    public function getCities(Request $request)
    {
        $country = $request->query('country');
        
        if (!$country) {
            return response()->json([]);
        }
        
        // Récupérer toutes les villes actives pour ce pays
        $cities = ShippingFee::where('country', $country)
            ->where('is_active', true)
            ->whereNotNull('city')
            ->distinct()
            ->pluck('city')
            ->sort()
            ->values();
        
        return response()->json($cities);
    }
    
    public function getDistricts(Request $request)
    {
        $country = $request->query('country');
        $city = $request->query('city');
        
        if (!$country || !$city) {
            return response()->json([]);
        }
        
        // Récupérer les quartiers/communes disponibles pour cette ville
        $districts = ShippingFee::where('country', $country)
            ->where('city', $city)
            ->where('is_active', true)
            ->whereNotNull('district')
            ->where('district', '!=', '')
            ->distinct()
            ->pluck('district')
            ->sort()
            ->values();
        
        return response()->json($districts);
    }
    
    public function calculateShipping(Request $request)
    {
        $request->validate([
            'country' => 'required|string',
            'city' => 'required|string',
            'district' => 'nullable|string',
            'subtotal' => 'nullable|numeric|min:0'
        ]);
        
        $country = $request->input('country');
        $city = $request->input('city');
        $district = $request->input('district');
        $subtotal = floatval($request->input('subtotal', 0));
        
        try {
            // Utiliser la nouvelle méthode getShippingInfo
            $shippingFee = ShippingFee::getShippingInfo($country, $city, $district);
            
            if (!$shippingFee) {
                return response()->json([
                    'success' => false,
                    'message' => 'Aucun frais de livraison trouvé pour cette zone. Nous ne livrons pas encore dans cette localité.',
                    'fee' => 0
                ], 404);
            }
            
            // Récupérer le montant des frais
            $fee = floatval($shippingFee->fee);
            $isFree = false;
            
            // Vérification de la livraison gratuite - SEULEMENT si free_shipping_minimum > 0
            $freeShippingMin = floatval($shippingFee->free_shipping_minimum);
            if ($freeShippingMin > 0 && $subtotal >= $freeShippingMin) {
                $fee = 0;
                $isFree = true;
            }
            
            // Si les frais sont à 0 en base (livraison gratuite configurée par l'admin)
            if ($fee == 0 && !$isFree) {
                $isFree = true;
            }
            
            // Stocker les frais de livraison en session
            session()->put('shipping_fee', $fee);
            session()->put('shipping_country', $country);
            session()->put('shipping_city', $city);
            session()->put('shipping_district', $district);
            
            return response()->json([
                'success' => true,
                'fee' => $fee,
                'formatted_fee' => number_format($fee, 0, ',', ' ') . ' XOF',
                'is_free' => $isFree,
                'estimated_days' => $shippingFee->estimated_days,
                'message' => $isFree ? 'Livraison gratuite !' : null
            ]);
            
        } catch (\Exception $e) {
            \Illuminate\Support\Facades\Log::error('Erreur calcul frais livraison: ' . $e->getMessage());
            
            return response()->json([
                'success' => false,
                'message' => 'Erreur lors du calcul des frais de livraison',
                'fee' => 0
            ], 500);
        }
    }
}