from flask import Blueprint, render_template, request, session, jsonify  # Added jsonify import
from salesforce import get_salesforce_connection
sf = get_salesforce_connection()

cart_blueprint = Blueprint('cart', __name__)
@cart_blueprint.route("/cart", methods=["GET"])
def cart():
    email = session.get('user_email')
    if not email:
        return redirect(url_for("login"))

    try:
        # Fetch cart items with Category and Section
        result = sf.query(f"""
            SELECT Name, Price__c, Quantity__c, Add_Ons__c, Add_Ons_Price__c, Image1__c, Instructions__c, Category__c, Section__c
            FROM Cart_Item__c
            WHERE Customer_Email__c = '{email}'
        """)
        cart_items = result.get("records", [])

        subtotal = sum(item['Price__c'] for item in cart_items)

        # Fetch reward points
        customer_result = sf.query(f"""
            SELECT Reward_Points__c 
            FROM Customer_Login__c
            WHERE Email__c = '{email}'
        """)
        reward_points = customer_result['records'][0].get('Reward_Points__c', 0) if customer_result['records'] else 0

        # Fetch coupons for the user
        coupon_result = sf.query(f"""
            SELECT Coupon_Code__c FROM Referral_Coupon__c WHERE Referral_Email__c = '{email}'
        """)
        if coupon_result["records"]:
            raw_coupons = coupon_result["records"][0].get("Coupon_Code__c", "")
            coupons = raw_coupons.split("\n") if raw_coupons else []
        else:
            coupons = []

        # Initialize suggestions as an empty list
        suggestions = []

        # If there are items in the cart, fetch suggestions
        if cart_items:
            # Get the category and section of the first item in the cart (You can choose which item you want to base suggestions on)
            first_item = cart_items[0]
            item_category = first_item.get('Category__c', 'All')  # Default to 'All' if not found
            item_section = first_item.get('Section__c', 'Biryanis')  # Default to 'Biryanis' if not found

            # Define section-to-complementary section mapping
            complementary_sections = {
                'Breads': ['Curries', 'Biryanis', 'Starters'],
                'Biryanis': ['Curries', 'Starters', 'Desserts'],
                'Curries': ['Biryanis', 'Breads', 'Starters'],
                'Starters': ['Biryanis', 'Curries', 'Desserts'],
                'Desserts': ['Biryanis', 'Curries', 'Soft Drinks'],
                'Soft Drinks': ['Starters', 'Biryanis', 'Curries']
            }

            # Get the complementary sections for the selected section
            suggested_sections = complementary_sections.get(item_section, [])

            # Fetch suggestions from the complementary sections
            try:
                for suggested_section in suggested_sections:
                    if item_category == "All":
                        query = f"""
                            SELECT Name, Price__c, Image1__c
                            FROM Menu_Item__c
                            WHERE Section__c = '{suggested_section}' 
                            AND (Veg_NonVeg__c = 'Veg' OR Veg_NonVeg__c = 'Non veg')
                            LIMIT 4
                        """
                    else:
                        query = f"""
                            SELECT Name, Price__c, Image1__c
                            FROM Menu_Item__c
                            WHERE Section__c = '{suggested_section}' 
                            AND Veg_NonVeg__c = '{item_category}'
                            LIMIT 4
                        """
                    suggestion_result = sf.query(query)
                    suggestions.extend(suggestion_result.get("records", []))  # Add suggestions from each section

                # Limit the number of suggestions to 4
                if len(suggestions) > 4:
                    suggestions = suggestions[:4]

            except Exception as e:
                print(f"Error fetching suggestions: {e}")

        return render_template(
            "cart.html",
            cart_items=cart_items,
            subtotal=subtotal,
            reward_points=reward_points,
            customer_email=email,
            coupons=coupons,
            suggestions=suggestions
        )

    except Exception as e:
        print(f"Error fetching cart items: {e}")
        return render_template("cart.html", cart_items=[], subtotal=0, reward_points=0, coupons=[], suggestions=[])

@cart_blueprint.route("/add_suggestion_to_cart", methods=["POST"])
def add_suggestion_to_cart():
    try:
        # Get data from the request
        data = request.get_json()
        item_name = data.get('item_name').strip()
        item_price = data.get('item_price')
        item_image = data.get('item_image')
        item_id = data.get('item_id')
        customer_email = data.get('customer_email')
        addons = data.get('addons', [])
        instructions = data.get('instructions', "")

        # Default values if addons and instructions are not provided
        addons_price = 0
        addons_string = "None"

        # Check if the customer already has this item in their cart
        query = f"""
            SELECT Id, Quantity__c, Add_Ons__c, Add_Ons_Price__c, Instructions__c 
            FROM Cart_Item__c
            WHERE Customer_Email__c = '{customer_email}' AND Name = '{item_name}'
        """
        result = sf.query(query)
        cart_items = result.get("records", [])

        # If item already exists in the cart, update its quantity and other details
        if cart_items:
            cart_item_id = cart_items[0]['Id']
            existing_quantity = cart_items[0]['Quantity__c']
            existing_addons = cart_items[0].get('Add_Ons__c', "None")
            existing_addons_price = cart_items[0].get('Add_Ons_Price__c', 0)
            existing_instructions = cart_items[0].get('Instructions__c', "")

            # Combine existing and new addons
            combined_addons = existing_addons if existing_addons != "None" else ""
            if addons:
                combined_addons = f"{combined_addons}; {addons}".strip("; ")

            combined_instructions = existing_instructions
            if instructions:
                combined_instructions = f"{combined_instructions} | {instructions}".strip(" | ")

            combined_addons_list = combined_addons.split("; ")
            combined_addons_price = sum(
                float(addon.split("($")[1][:-1]) for addon in combined_addons_list if "($" in addon
            )

            # Update the cart item
            sf.Cart_Item__c.update(cart_item_id, {
                "Quantity__c": existing_quantity + 1,
                "Add_Ons__c": combined_addons,
                "Add_Ons_Price__c": combined_addons_price,
                "Instructions__c": combined_instructions,
                "Price__c": (existing_quantity + 1) * float(item_price) + combined_addons_price
            })
        else:
            # If item doesn't exist in cart, create a new cart item
            total_price = float(item_price) + addons_price

            # Create a new cart item in Salesforce
            sf.Cart_Item__c.create({
                "Name": item_name,
                "Price__c": total_price,
                "Base_Price__c": item_price,
                "Quantity__c": 1,
                "Add_Ons_Price__c": addons_price,
                "Add_Ons__c": addons_string,
                "Image1__c": item_image,
                "Customer_Email__c": customer_email,
                "Instructions__c": instructions
            })

        return jsonify({"success": True, "message": "Item added to cart successfully."})

    except Exception as e:
        print(f"Error adding item to cart: {str(e)}")
        return jsonify({"success": False, "error": str(e)})
@cart_blueprint.route('/remove/<item_name>', methods=['POST'])
def remove_cart_item(item_name):
    try:
        customer_email = session.get('user_email')
        if not customer_email:
            return jsonify({'success': False, 'message': 'User email not found. Please log in again.'}), 400
        
        query = f"""
            SELECT Id FROM Cart_Item__c 
            WHERE Customer_Email__c = '{customer_email}' AND Name = '{item_name}'
        """
        result = sf.query(query)
        
        if result['totalSize'] == 0:
            return jsonify({'success': False, 'message': 'Item not found in cart.'}), 400
        
        # If item exists, delete it
        cart_item_id = result['records'][0]['Id']
        sf.Cart_Item__c.delete(cart_item_id)
        return jsonify({'success': True, 'message': f"'{item_name}' removed successfully!"}), 200
    except Exception as e:
        print(f"Error: {str(e)}")
        return jsonify({'success': False, 'message': f"An error occurred: {str(e)}"}), 500

@cart_blueprint.route("/update_quantity", methods=["POST"])
def update_quantity():
    print("Handling update_quantity request...")
    data = request.json  # Extract JSON data from the request
    email = data.get('email')
    item_name = data.get('item_name')

    try:
        # Convert quantity to an integer
        quantity = int(data.get('quantity'))
    except (ValueError, TypeError):
        return jsonify({"success": False, "error": "Invalid quantity provided."}), 400

    # Validate inputs
    if not email or not item_name or quantity is None:
        return jsonify({"success": False, "error": "Email, item name, and quantity are required."}), 400

    try:
        # Query the cart item in Salesforce
        cart_items = sf.query(
            f"SELECT Id, Quantity__c, Price__c, Base_Price__c, Add_Ons_Price__c FROM Cart_Item__c "
            f"WHERE Customer_Email__c = '{email}' AND Name = '{item_name}'"
        )['records']

        if not cart_items:
            return jsonify({"success": False, "error": "Cart item not found."}), 404

        # Retrieve the first matching record
        cart_item_id = cart_items[0]['Id']
        base_price = cart_items[0]['Base_Price__c']
        addons_price = cart_items[0].get('Add_Ons_Price__c', 0)

        # Calculate the new item price
        new_item_price = (base_price * quantity) + addons_price

        # Update the record in Salesforce
        sf.Cart_Item__c.update(cart_item_id, {
            "Quantity__c": quantity,
            "Price__c": new_item_price,  # Update base price
        })

        # Recalculate the subtotal for all items in the cart
        cart_items = sf.query(f"""
            SELECT Price__c, Add_Ons_Price__c 
            FROM Cart_Item__c 
            WHERE Customer_Email__c = '{email}'
        """)['records']
        new_subtotal = sum(item['Price__c'] for item in cart_items) 

        # Return updated item price and subtotal
        return jsonify({"success": True, "new_item_price": new_item_price, "subtotal": new_subtotal})

    except Exception as e:
        print(f"Error updating quantity: {str(e)}")
        return jsonify({"success": False, "error": str(e)}), 500


@cart_blueprint.route("/checkout", methods=["POST"])
def checkout():
    email = session.get('user_email')
    user_id = session.get('user_name')
    table_number = session.get('table_number')

    if not email or not user_id:
        return jsonify({"success": False, "message": "User not logged in"})

    try:
        data = request.json
        selected_coupon = data.get("selectedCoupon", "").strip() if data.get("selectedCoupon") else None

        # Fetch cart items
        result = sf.query(f"""
            SELECT Id, Name, Price__c, Add_Ons_Price__c, Quantity__c, Add_Ons__c, Instructions__c, Image1__c
            FROM Cart_Item__c
            WHERE Customer_Email__c = '{email}'
        """)
        cart_items = result.get("records", [])
        if not cart_items:
            return jsonify({"success": False, "message": "Cart is empty"})

        total_price = sum(item['Price__c'] for item in cart_items)
        discount = 0

        # Coupon handling (existing logic)
        coupon_query = sf.query(f"""
            SELECT Id, Coupon_Code__c FROM Referral_Coupon__c WHERE Referral_Email__c = '{email}'
        """)
        if selected_coupon and coupon_query["records"]:
            discount = total_price * 0.10
            referral_coupon_id = coupon_query["records"][0]["Id"]
            existing_coupons = coupon_query["records"][0]["Coupon_Code__c"].split("\n")
            updated_coupons = [coupon for coupon in existing_coupons if coupon.strip() != selected_coupon]
            updated_coupons_str = "\n".join(updated_coupons).strip() or None
            sf.Referral_Coupon__c.update(referral_coupon_id, {"Coupon_Code__c": updated_coupons_str})
        else:
            # Add reward points (existing logic)
            reward_points_to_add = total_price * 0.10
            customer_record = sf.query(f"""
                SELECT Id, Reward_Points__c, Total_Orders__c, Total_Spent__c
                FROM Customer_Login__c WHERE Email__c = '{email}'
            """)
            customer = customer_record.get("records", [])[0] if customer_record else None
            if customer:
                current_reward_points = customer.get("Reward_Points__c", 0)
                new_reward_points = current_reward_points + reward_points_to_add
                total_orders = (customer.get("Total_Orders__c", 0) or 0) + 1
                total_spent = (customer.get("Total_Spent__c", 0) or 0) + total_price

                # Determine badge
                badge = "Newbie"
                if total_orders >= 10:
                    badge = "VIP"
                elif total_orders >= 5:
                    badge = "Regular"
                if total_spent > 500:
                    badge = "Gold Member"

                # Update customer record
                sf.Customer_Login__c.update(customer["Id"], {
                    "Reward_Points__c": new_reward_points,
                    "Total_Orders__c": total_orders,
                    "Total_Spent__c": total_spent,
                    "Badge__c": badge
                })

        total_bill = total_price - discount

        # Store order (existing logic)
        customer_query = sf.query(f"SELECT Id FROM Customer_Login__c WHERE Email__c = '{email}'")
        customer_id = customer_query["records"][0]["Id"] if customer_query["records"] else None
        if not customer_id:
            return jsonify({"success": False, "message": "Customer record not found"})

        order_details = "\n".join(
            f"{item['Name']} x{item['Quantity__c']} | Add-Ons: {item.get('Add_Ons__c', 'None')} | "
            f"Instructions: {item.get('Instructions__c', 'None')} | Price: ${item['Price__c']}"
            for item in cart_items
        )
        table_number = table_number if table_number != 'null' else None
        order_data = {
            "Customer_Name__c": user_id,
            "Customer_Email__c": email,
            "Total_Amount__c": total_price,
            "Discount__c": discount,
            "Total_Bill__c": total_bill,
            "Order_Status__c": "Pending",
            "Customer2__c": customer_id,
            "Order_Details__c": order_details,
            "Table_Number__c": table_number
        }
        order_response = sf.Order__c.create(order_data)

        if order_response:
            for item in cart_items:
                sf.Cart_Item__c.delete(item["Id"])

        return jsonify({
            "success": True,
            "message": "Order placed successfully!",
            "discount": discount,
            "totalBill": total_bill
        })

    except Exception as e:
        return jsonify({"success": False, "error": str(e)})
@cart_blueprint.route("/loyalty", methods=["GET"])
def get_loyalty_data():
    email = session.get('user_email')
    if not email:
        return redirect(url_for('login'))

    try:
        customer_record = sf.query(f"""
            SELECT Reward_Points__c, Total_Orders__c, Total_Spent__c, Badge__c
            FROM Customer_Login__c WHERE Email__c = '{email}'
        """)
        customer = customer_record.get("records", [])[0] if customer_record["records"] else None
        if not customer:
            return "Customer not found", 404

        # Clean up data
        reward_points = round(customer.get("Reward_Points__c", 0) or 0, 2)  # Round to 2 decimals
        total_orders = customer.get("Total_Orders__c", 0) or 0
        total_spent = customer.get("Total_Spent__c", 0) or 0
        badge = customer.get("Badge__c") or "Newbie"  # Default to "Newbie" if None

        # Define rewards with image URLs (you can store these in Salesforce or locally)
        rewards = [
            {"name": "$5 Off", "points": 50, "description": "Get $5 off your next order", "image": "/static/images/reward_discount.png"},
            {"name": "Free Drink", "points": 100, "description": "Redeem for a free drink", "image": "/static/images/reward_drink.png"},
            {"name": "20% Off", "points": 200, "description": "20% off your next order", "image": "/static/images/reward_percentage.png"}
        ]

        # Badge images (map badge names to image paths)
        badge_images = {
            "Newbie": "/static/images/badge_bronze.png",
            "Regular": "/static/images/badge_silver.png",
            "VIP": "/static/images/badge_gold.png",
            "Gold Member": "/static/images/badge_platinum.png"
        }

        loyalty_data = {
            "reward_points": reward_points,
            "total_orders": total_orders,
            "total_spent": total_spent,
            "badge": badge,
            "badge_image": badge_images.get(badge, "/static/images/badge_bronze.png"),  # Default to bronze
            "available_rewards": rewards
        }
        return render_template("loyalty.html", loyalty_data=loyalty_data)

    except Exception as e:
        return f"Error: {str(e)}", 500
@cart_blueprint.route("/fetch_previous_order", methods=["GET"])
def fetch_previous_order():
    # Assuming `email` is the unique identifier for the user
    email = session.get('user_email')
    
    if not email:
        return jsonify({"success": False, "message": "User not logged in"})

    try:
        # Fetch the most recent order (or any other logic to get the previous order)
        previous_order_query = f"""
            SELECT Order_Details__c 
            FROM Order__c 
            WHERE Customer_Email__c = '{email}' AND Order_Status__c = 'Completed' 
            ORDER BY CreatedDate DESC LIMIT 1
        """
        previous_order_result = sf.query(previous_order_query)
        previous_order = previous_order_result["records"][0] if previous_order_result["records"] else None
        
        if not previous_order:
            return jsonify({"success": False, "message": "No previous order found."})

        # Parse the order details to extract the items and add-ons
        order_details = previous_order["Order_Details__c"]
        
        # Assuming the order details are stored as JSON (you can use JSON.parse() in JavaScript to handle this)
        # You might need to adjust the parsing based on how the data is structured (whether it's JSON or string-based)
        order_items = json.loads(order_details)["items"]
        
        return jsonify({"success": True, "previousOrder": order_items})

    except Exception as e:
        print(f"Error fetching previous order: {e}")
        return jsonify({"success": False, "message": "Error fetching previous order."})