from flask import Flask, render_template, request, jsonify, redirect, url_for, session
from flask_session import Session  # Import the Session class
from flask.sessions import SecureCookieSessionInterface  # Import the class
from salesforce import get_salesforce_connection
import os

# Initialize Flask app and Salesforce connection
print("Starting app...")
app = Flask(__name__)
print("Flask app initialized.")

# Add debug logs in Salesforce connection setup
sf = get_salesforce_connection()
print("Salesforce connection established.")

# Set the secret key to handle sessions securely
app.secret_key = os.getenv("SECRET_KEY", "sSSjyhInIsUohKpG8sHzty2q")  # Replace with a secure key

# Configure the session type
app.config["SESSION_TYPE"] = "filesystem"  # Use filesystem for session storage
#app.config["SESSION_COOKIE_NAME"] = "my_session"  # Optional: Change session cookie name
app.config["SESSION_COOKIE_SECURE"] = True  # Ensure cookies are sent over HTTPS
app.config["SESSION_COOKIE_SAMESITE"] = "None"  # Allow cross-site cookies

# Initialize the session
Session(app)  # Correctly initialize the Session object
print("Session interface configured.")

# Ensure secure session handling for environments like Hugging Face
app.session_interface = SecureCookieSessionInterface()
print("Session interface configured.")
import random
import string

def generate_referral_code(length=8):
    # Generates a random referral code with uppercase, lowercase letters, and digits
    characters = string.ascii_letters + string.digits  # A-Z, a-z, 0-9
    referral_code = ''.join(random.choice(characters) for _ in range(length))
    return referral_code

@app.route("/")
def home():
    return render_template("index.html")

from datetime import datetime

def generate_coupon_code(length=10):
    """Generates a random alphanumeric coupon code"""
    characters = string.ascii_uppercase + string.digits  # A-Z, 0-9
    return ''.join(random.choice(characters) for _ in range(length))


import re

import re

@app.route("/order-history", methods=["GET"])
def order_history():
    email = session.get('user_email')  # Get logged-in user's email
    if not email:
        return redirect(url_for("login"))

    try:
        # Fetch past orders for the user
        result = sf.query(f"""
            SELECT Id, Customer_Name__c, Customer_Email__c, Total_Amount__c, 
                   Order_Details__c, Order_Status__c, Discount__c, Total_Bill__c, CreatedDate
            FROM Order__c
            WHERE Customer_Email__c = '{email}'
            ORDER BY CreatedDate DESC
        """)

        orders = result.get("records", [])  # Fetch all orders

        # Strip image URLs from order details and split remaining data by new lines
        for order in orders:
            order_details = order.get("Order_Details__c", "")
            # Remove image URLs using regex
            cleaned_details = re.sub(r'http[s]?://\S+', '', order_details)
            
            # Now split the cleaned details by lines and join them with <br> to create line breaks
            cleaned_details = cleaned_details.replace("\n", "<br>")

            # Update the order details with the cleaned and formatted details
            order['Order_Details__c'] = cleaned_details

        return render_template("order_history.html", orders=orders)

    except Exception as e:
        print(f"Error fetching order history: {str(e)}")
        return render_template("order_history.html", orders=[], error=str(e))
@app.route("/logout")
def logout():
    session.clear()  # Clear the session
    return redirect(url_for("login"))  # Redirect to the login page

@app.route("/signup", methods=["GET", "POST"])
def signup():
    if request.method == "POST":
        name = request.form.get("name")
        phone = request.form.get("phone")
        email = request.form.get("email").strip()  # Trim spaces
        password = request.form.get("password")
        referral_code = request.form.get("referral")  # Fetch referral code from the form
        generated_referral_code = generate_referral_code()

        try:
            ref = 0  # Default reward points for new user

            # **Fix: Fetch all emails and compare in Python (Case-Insensitive)**
            email_query = "SELECT Id, Email__c FROM Customer_Login__c"
            email_result = sf.query(email_query)

            # Convert all stored emails to lowercase and compare with user input
            existing_emails = {record["Email__c"].lower() for record in email_result["records"]}
            if email.lower() in existing_emails:
                return render_template("signup.html", error="Email already in use! Please use a different email.")

            # Check if a referral code is entered
            if referral_code:
                referral_query = f"SELECT Id, Email__c, Name FROM Customer_Login__c WHERE Referral__c = '{referral_code}'"
                referral_result = sf.query(referral_query)

                if not referral_result['records']:
                    return render_template("signup.html", error="Invalid referral code!")

                # Get referrer's details
                referrer = referral_result['records'][0]
                referrer_email = referrer.get('Email__c')
                referrer_name = referrer.get('Name')

                # Generate a new unique coupon code
                new_coupon_code = generate_coupon_code()

                # Check if referrer already has a record in Referral_Coupon__c
                existing_coupon_query = f"SELECT Id, Coupon_Code__c FROM Referral_Coupon__c WHERE Referral_Email__c = '{referrer_email}'"
                existing_coupon_result = sf.query(existing_coupon_query)

                if existing_coupon_result['records']:
                    referral_record = existing_coupon_result['records'][0]
                    referral_id = referral_record['Id']
                    existing_coupons = referral_record.get('Coupon_Code__c', '')

                    updated_coupons = f"{existing_coupons}\n{new_coupon_code}".strip()

                    # Update the existing record with the new coupon
                    sf.Referral_Coupon__c.update(referral_id, {
                        "Coupon_Code__c": updated_coupons
                    })
                else:
                    # If no record exists, create a new one
                    sf.Referral_Coupon__c.create({
                        "Name": referrer_name,
                        "Referral_Email__c": referrer_email,
                        "Coupon_Code__c": new_coupon_code
                    })

            # **Fix: Ensure Salesforce enforces unique email constraint**
            sf.Customer_Login__c.create({
                "Name": name,
                "Phone_Number__c": phone,
                "Email__c": email,
                "Password__c": password,
                "Reward_Points__c": ref,  # No points added, only coupon is created
                "Referral__c": generated_referral_code
            })

            return redirect(url_for("login"))

        except Exception as e:
            return render_template("signup.html", error=f"Error: {str(e)}")

    return render_template("signup.html")




@app.route("/login", methods=["GET", "POST"])
def login():
    if request.method == "POST":
        email = request.form.get("email")
        password = request.form.get("password")
        print(f"Login attempt with email: {email}")  # Debug log

        try:
            # Fetch user details, including Name and Reward_Points__c
            query = f"SELECT Id, Name, Email__c, Reward_Points__c FROM Customer_Login__c WHERE Email__c='{email}' AND Password__c='{password}'"
            result = sf.query(query)

            if result["records"]:
                user = result["records"][0]
                session['user_id'] = user['Id']
                session['user_email'] = email
                print(f"Session variables set: user_id={session['user_id']}, user_email={session['user_email']}")

                user_name = user.get("Name", "")  # Get the user's name
                reward_points = user.get("Reward_Points__c") or 0  # Ensures reward_points is always an integer



                if reward_points >= 500:
                    print(f"User {email} has {reward_points} reward points. Generating coupon...")

                    # Generate a new coupon code
                    new_coupon_code = generate_coupon_code()

                    # Check if user already has a record in Referral_Coupon__c
                    coupon_query = sf.query(f"""
                        SELECT Id, Coupon_Code__c FROM Referral_Coupon__c WHERE Referral_Email__c = '{email}'
                    """)

                    if coupon_query["records"]:
                        # If record exists, append the new coupon
                        coupon_record = coupon_query["records"][0]
                        referral_coupon_id = coupon_record["Id"]
                        existing_coupons = coupon_record.get("Coupon_Code__c", "")

                        # Append the new coupon on the next line
                        updated_coupons = f"{existing_coupons}\n{new_coupon_code}".strip()

                        # Update the Referral_Coupon__c record
                        sf.Referral_Coupon__c.update(referral_coupon_id, {
                            "Coupon_Code__c": updated_coupons
                        })
                        print(f"Updated existing coupon record for {email}. New Coupon: {new_coupon_code}")
                    else:
                        # If no record exists, create a new one with Referral_Name__c
                        sf.Referral_Coupon__c.create({
                            "Referral_Email__c": email,
                            "Name": user_name,  # Store user's name in Referral_Coupon__c
                            "Coupon_Code__c": new_coupon_code
                        })
                        print(f"Created new coupon record for {email} with name {user_name}. Coupon: {new_coupon_code}")

                    # Subtract 500 reward points from user's account
                    new_reward_points = reward_points - 500
                    sf.Customer_Login__c.update(user['Id'], {
                        "Reward_Points__c": new_reward_points
                    })
                    print(f"Coupon {new_coupon_code} generated and 500 points deducted. New balance: {new_reward_points}")

                return redirect(url_for("menu"))

            else:
                print("Invalid credentials!")
                return render_template("login.html", error="Invalid credentials!")

        except Exception as e:
            print(f"Error during login: {str(e)}")
            return render_template("login.html", error=f"Error: {str(e)}")

    return render_template("login.html")


@app.route("/menu", methods=["GET", "POST"])
def menu():
    selected_category = request.args.get("category", "All")
    user_id = session.get('user_id')
    user_email = session.get('user_email')  # Fetch the user's email
    print(f"Session check in /menu: user_id={user_id}, user_email={user_email}")
    
    if not user_id:
        print("Session missing, redirecting to login.")
        return redirect(url_for('login'))
    
    try:
        # Fetch the user's Referral__c and Reward_Points__c
        user_query = f"SELECT Referral__c, Reward_Points__c FROM Customer_Login__c WHERE Email__c = '{user_email}'"
        user_result = sf.query(user_query)

        if not user_result['records']:
            print("User not found!")
            return redirect(url_for('login'))

        referral_code = user_result['records'][0].get('Referral__c', 'N/A')  # Default to 'N/A' if empty
        reward_points = user_result['records'][0].get('Reward_Points__c', 0)  # Default to 0 if empty

        # Query to fetch menu items
        menu_query = """
            SELECT Name, Price__c, Description__c, Image1__c, Image2__c, Veg_NonVeg__c, Section__c 
            FROM Menu_Item__c
        """
        result = sf.query(menu_query)
        food_items = result['records'] if 'records' in result else []

        # Filter categories dynamically
        categories = {item.get("Veg_NonVeg__c").capitalize() for item in food_items if item.get("Veg_NonVeg__c")}
        categories = {"Veg", "Non-Veg"}  # Ensure valid categories only

        # Filter food items based on the selected category
        if selected_category == "Veg":
            food_items = [item for item in food_items if item.get("Veg_NonVeg__c") in ["Veg", "both"]]
        elif selected_category == "Non-Veg":
            food_items = [item for item in food_items if item.get("Veg_NonVeg__c") in ["Non veg", "both"]]

    except Exception as e:
        print(f"Error fetching menu data: {str(e)}")
        food_items = []
        categories = {"All", "Veg", "Non-Veg"}  # Default categories on error
        referral_code = 'N/A'
        reward_points = 0

    # Render the menu page with the fetched data
    return render_template(
        "menu.html",
        food_items=food_items,
        categories=sorted(categories),  # Sort categories alphabetically if needed
        selected_category=selected_category,
        referral_code=referral_code,
        reward_points=reward_points
    )

@app.route("/cart", methods=["GET"])
def cart():
    email = session.get('user_email')  # Get logged-in user's email
    if not email:
        return redirect(url_for("login"))

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

        # Subtotal should be the sum of all item prices in the cart
        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}'
        """)

        # Extract and split coupons into a list
        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 = []

        return render_template(
            "cart.html",
            cart_items=cart_items,
            subtotal=subtotal,
            reward_points=reward_points,
            customer_email=email,
            coupons=coupons  # Send coupons to template
        )

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



@app.route('/cart/add', methods=['POST'])
def add_to_cart():
    data = request.json  # Extract JSON payload from frontend
    item_name = data.get('itemName').strip()  # Item name
    item_price = data.get('itemPrice')  # Base price of the item
    item_image = data.get('itemImage')  # Item image
    addons = data.get('addons', [])  # Add-ons array
    instructions = data.get('instructions', '')  # Special instructions
    customer_email = session.get('user_email')  # Get logged-in user's email

    if not item_name or not item_price:
        return jsonify({"success": False, "error": "Item name and price are required."})

    try:
        # Query the cart to check if the item already exists
        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", [])

        # Calculate the price of the new add-ons
        addons_price = sum(addon['price'] for addon in addons)  # New add-ons price
        new_addons = "; ".join([f"{addon['name']} (${addon['price']})" for addon in addons])  # Format new add-ons

        if cart_items:
            # If the item already exists in the cart, update it
            cart_item_id = cart_items[0]['Id']
            existing_quantity = cart_items[0]['Quantity__c']
            existing_addons = cart_items[0].get('Add_Ons__c', "None")  # Previous add-ons
            existing_addons_price = cart_items[0].get('Add_Ons_Price__c', 0)  # Previous add-ons price
            existing_instructions = cart_items[0].get('Instructions__c', "")  # Previous instructions

            # Combine the existing and new add-ons
            combined_addons = existing_addons if existing_addons != "None" else ""
            if new_addons:
                combined_addons = f"{combined_addons}; {new_addons}".strip("; ")

            # Combine the existing and new instructions
            combined_instructions = existing_instructions
            if instructions:
                combined_instructions = f"{combined_instructions} | {instructions}".strip(" | ")

            # Recalculate the total add-ons price
            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 item in the cart
            sf.Cart_Item__c.update(cart_item_id, {
                "Quantity__c": existing_quantity + 1,  # Increase quantity by 1
                "Add_Ons__c": combined_addons,  # Update add-ons list
                "Add_Ons_Price__c": combined_addons_price,  # Update add-ons price
                "Instructions__c": combined_instructions,  # Update instructions
                "Price__c": (existing_quantity + 1) * item_price + combined_addons_price,  # Update total price
            })
        else:
            # If the item does not exist in the cart, create a new one
            addons_string = "None"
            if addons:
                addons_string = new_addons  # Use the formatted add-ons string

            total_price = item_price + addons_price  # Base price + add-ons price

            # Create a new cart item
            sf.Cart_Item__c.create({
                "Name": item_name,  # Item name
                "Price__c": total_price,  # Total price (item + add-ons)
                "Base_Price__c": item_price,  # Base price without add-ons
                "Quantity__c": 1,  # Default quantity is 1
                "Add_Ons_Price__c": addons_price,  # Total add-ons price
                "Add_Ons__c": addons_string,  # Add-ons with names and prices
                "Image1__c": item_image,  # Item image URL
                "Customer_Email__c": customer_email,  # Associated customer's email
                "Instructions__c": instructions  # Save 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)})



@app.route("/cart/add_item", methods=["POST"])
def add_item_to_cart():
    data = request.json  # Extract JSON data from the request
    email = data.get('email')  # Customer email
    item_name = data.get('item_name')  # Item name
    quantity = data.get('quantity', 1)  # Quantity to add (default is 1)
    addons = data.get('addons', [])  # Add-ons for the item (optional)

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

    try:
        # Add a new item to the cart with the provided details
        sf.Cart_Item__c.create({
            "Customer_Email__c": email,  # Associate the cart item with the customer's email
            "Item_Name__c": item_name,  # Item name
            "Quantity__c": quantity,  # Quantity to add
            "Add_Ons__c": addons_string
        })

        return jsonify({"success": True, "message": "Item added to cart successfully."})
    except Exception as e:
        print(f"Error adding item to cart: {str(e)}")  # Log the error for debugging
        return jsonify({"success": False, "error": str(e)}), 500



@app.route('/cart/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
        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

import logging

# Set up logging to the console
logging.basicConfig(level=logging.DEBUG)  # You can change the level to INFO, WARNING, ERROR as needed

@app.route('/api/addons', methods=['GET'])
def get_addons():
    # Fetch the requested item name, category, and section
    item_name = request.args.get('item_name')  
    category = request.args.get('category')    
    section = request.args.get('section')      

    # Log the incoming parameters for debugging
    logging.debug(f"Item Name: {item_name}, Category: {category}, Section: {section}")

    item_name = request.args.get('item_name')  # Fetch the requested item name
    if not item_name:
        return jsonify({"success": False, "error": "Item name is required."})

    try:
        # Fetch add-ons related to the item (update query as needed)
        query = f"""
            SELECT Name, Price__c 
            FROM Add_Ons__c 
        """
        addons = sf.query(query)['records']
        return jsonify({"success": True, "addons": addons})
    except Exception as e:
        print(f"Error fetching add-ons: {e}")
        return jsonify({"success": False, "error": "Unable to fetch add-ons. Please try again later."})
@app.route("/cart/update_quantity", methods=["POST"])
def update_quantity():
    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})
        print(f"New item price: {new_item_price}, New subtotal: {new_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
@app.route("/checkout", methods=["POST"])
def checkout():
    email = session.get('user_email')
    user_id = session.get('user_id')

    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()

        # 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
        # Fetch the user's existing coupons
        coupon_query = sf.query(f"""
            SELECT Id, Coupon_Code__c FROM Referral_Coupon__c WHERE Referral_Email__c = '{email}'
        """)

        has_coupons = bool(coupon_query["records"])  # Check if user has any coupons

        if selected_coupon:
            # Case 3: User selected a valid coupon → Apply discount & remove coupon
            discount = total_price * 0.10  # 10% discount
            referral_coupon_id = coupon_query["records"][0]["Id"]
            existing_coupons = coupon_query["records"][0]["Coupon_Code__c"].split("\n")

            # Remove only the selected coupon
            updated_coupons = [coupon for coupon in existing_coupons if coupon.strip() != selected_coupon]

            # Convert list back to a string with newlines
            updated_coupons_str = "\n".join(updated_coupons).strip()

            # Update the Referral_Coupon__c record with the remaining coupons
            sf.Referral_Coupon__c.update(referral_coupon_id, {
                "Coupon_Code__c": updated_coupons_str
            })
        else:
            # Case 1 & Case 2: User has no coupons or has coupons but didn’t select one → Add 10% to reward points
            reward_points_to_add = total_price * 0.10

            # Fetch current reward points
            customer_record = sf.query(f"""
                SELECT Id, Reward_Points__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") or 0
                new_reward_points = current_reward_points + reward_points_to_add

                print(f"Updating reward points: Current = {current_reward_points}, Adding = {reward_points_to_add}, New = {new_reward_points}")

                # Update reward points in Salesforce
                sf.Customer_Login__c.update(customer["Id"], {
                    "Reward_Points__c": new_reward_points
                })
                print(f"Successfully updated reward points for {email}")

        

        total_bill = total_price - discount

        # ✅ Store **all details** including Add-Ons, Instructions, Price, and Image
        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')} | "
            f"Price: ${item['Price__c']} | Image: {item['Image1__c']}"
            for item in cart_items
        )

        # Store the order details in Order__c
        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",
            "Order_Details__c": order_details  # ✅ Now includes **all details**
        }

        sf.Order__c.create(order_data)

        # ✅ Delete cart items after order is placed
        for item in cart_items:
            sf.Cart_Item__c.delete(item["Id"])

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

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

@app.route("/order", methods=["GET"])
def order_summary():
    email = session.get('user_email')  # Fetch logged-in user's email
    if not email:
        return redirect(url_for("login"))

    try:
        # Fetch the most recent order for the user
        result = sf.query(f"""
            SELECT Id, Customer_Name__c, Customer_Email__c, Total_Amount__c, Order_Details__c, Order_Status__c, Discount__c, Total_Bill__c
            FROM Order__c
            WHERE Customer_Email__c = '{email}'
            ORDER BY CreatedDate DESC
            LIMIT 1
        """)
        order = result.get("records", [])[0] if result.get("records") else None

        if not order:
            return render_template("order.html", order=None)

        return render_template("order.html", order=order)
    except Exception as e:
        print(f"Error fetching order details: {str(e)}")
        return render_template("order.html", order=None, error=str(e))

if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=7860)