app.py

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
from datetime import timedelta
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", "ebx2h0aCL2wCEPcZAA2h5wOq")  # 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():
    # Fetch user details from URL parameters
    user_email = request.args.get("email")
    user_name = request.args.get("name")
    table_number = request.args.get("table")  # Capture table number

    if user_email and user_name:
        session["user_email"] = user_email
        session["user_name"] = user_name
        session["table_number"] = table_number  # Store table number in session
        print(f"User logged in: {user_email} - {user_name} - Table: {table_number}")

        # Ensure session is saved before redirecting
        session.modified = True
        return redirect(url_for("menu"))  # Redirect to menu directly

    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))
@app.route("/generate_custom_dish", methods=["POST"])
def generate_custom_dish():
    try:
        data = request.form
        dish_name = data.get("name")
        description = data.get("description")
        item_image_url = "https://huggingface.co/spaces/nagasurendra/BiryaniHubflask30/resolve/main/static/customized.jpg"
        item_image_url2 = "https://huggingface.co/spaces/nagasurendra/BiryaniHubflask30/resolve/main/static/customized1.jpg"

        if not dish_name or not description:
            return jsonify({"success": False, "error": "Both fields are required"}), 400

        # Generate a random price for the custom dish
        price = random.randint(10, 30)  # Example logic for price setting

        # Determine Veg/Non-Veg
        veg_keywords = ["paneer", "vegetable", "mushroom", "cheese"]
        non_veg_keywords = ["chicken", "mutton", "fish", "egg"]
        
        category = "Veg" if any(word in description.lower() for word in veg_keywords) else \
                   "Non veg" if any(word in description.lower() for word in non_veg_keywords) else \
                   "both"

        # Query to check if the dish already exists in Salesforce (Custom_Dish__c object)
        existing_dish_query = f"SELECT Id, Name, Price__c, Image1__c, Image2__c, Description__c, Veg_NonVeg__c FROM Custom_Dish__c WHERE Name = '{dish_name}'"
        existing_dish_result = sf.query(existing_dish_query)

        if existing_dish_result['totalSize'] > 0:
            # If the dish exists, use the existing details
            existing_dish = existing_dish_result['records'][0]
            price = existing_dish['Price__c']
            item_image_url = existing_dish['Image1__c']
            item_image_url2 = existing_dish['Image2__c']
            category = existing_dish['Veg_NonVeg__c']
        else:
            # If the dish does not exist, create a new custom dish
            custom_dish = {
                'Name': dish_name,
                'Price__c': price,
                'Image1__c': item_image_url,
                'Image2__c': item_image_url2,
                'Description__c': description,
                'Veg_NonVeg__c': category,
                'Section__c': 'Customized dish',
                'Total_Ordered__c': 0
            }

            # Insert the custom dish into Salesforce (Custom_Dish__c object)
            result = sf.Custom_Dish__c.create(custom_dish)

            if not result.get('success'):
                return jsonify({"success": False, "error": "Failed to create custom dish in Salesforce"}), 500

        # After ensuring the dish exists, check if it's already in the Cart_Item__c
        email = session.get('user_email')  # Assuming you have the user's email in session
        
        # Query to check if the custom dish already exists in the cart for the logged-in user
        cart_item_query = f"SELECT Id, Quantity__c, Price__c, Base_Price__c FROM Cart_Item__c WHERE Customer_Email__c = '{email}' AND Name = '{dish_name}'"
        cart_item_result = sf.query(cart_item_query)

        if cart_item_result['totalSize'] > 0:
            # If the custom dish is already in the cart, update the quantity and price
            cart_item = cart_item_result['records'][0]
            new_quantity = cart_item['Quantity__c'] + 1  # Increase quantity by 1
            new_price = price * new_quantity  # Update price based on new quantity
            
            # Update the cart item in Salesforce
            updated_cart_item = {
                'Quantity__c': new_quantity,
                'Price__c': new_price
            }
            
            cart_item_update = sf.Cart_Item__c.update(cart_item['Id'], updated_cart_item)

        else:
            # If the custom dish is not in the cart, create a new cart item
            cart_item = {
                'Name': dish_name,
                'Price__c': price,
                'Base_Price__c': price,
                'Image1__c': item_image_url,
                'Quantity__c': 1,  # Default quantity is 1
                'Add_Ons__c': '',  # Set Add_ons__c to empty
                'Add_Ons_Price__c': 0,  # Set Add_ons_Price__c to 0
                'Customer_Email__c': email  # Associate the custom dish with the logged-in user
            }

            # Insert the custom dish as a Cart_Item__c record in Salesforce
            cart_result = sf.Cart_Item__c.create(cart_item)

        # Redirect to the cart page after successfully adding or updating the cart item
        return redirect(url_for("cart"))

    except Exception as e:
        return jsonify({"success": False, "error": str(e)}), 500

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

    try:
        # Fetch customer details from Salesforce based on the email
        customer_record = sf.query(f"""
            SELECT Id, Name, Email__c, Phone_Number__c, Referral__c, Reward_Points__c
            FROM Customer_Login__c
            WHERE Email__c = '{email}'
            LIMIT 1
        """)

        if not customer_record.get("records"):
            flash("Customer not found", "danger")
            return redirect(url_for("login"))

        customer = customer_record["records"][0]

        # Prepare the data to return to the frontend
        customer_data = {
            "name": customer.get("Name", ""),
            "email": customer.get("Email__c", ""),
            "phone": customer.get("Phone_Number__c", ""),
            "referral_code": customer.get("Referral__c", ""),
            "reward_points": customer.get("Reward_Points__c", 0)
        }

        return render_template("customer_details.html", customer=customer_data)

    except Exception as e:
        flash(f"Error fetching customer details: {str(e)}", "danger")
        return redirect(url_for("login"))

@app.route("/update_profile", methods=["POST"])
def update_profile():
    email = session.get('user_email')  # Get logged-in user's email
    if not email:
        return jsonify({'status': 'error', 'message': 'User not logged in'})

    try:
        # Fetch user details from Salesforce
        result = sf.query(f"""
            SELECT Id, Name, Email__c, Phone_Number__c, Referral__c, Reward_Points__c
            FROM Customer_Login__c
            WHERE Email__c = '{email}'
        """)

        if not result['records']:
            return jsonify({'status': 'error', 'message': 'User not found'})

        user = result['records'][0]
        user_id = user.get("Id")

        # Get updated profile data from the form
        new_name = request.form.get('customerName')
        new_email = request.form.get('email')
        new_phone = request.form.get('phone')
        new_referral_code = request.form.get('referralCode')
        new_reward_points = request.form.get('rewardPoints')

        # Prepare data for Salesforce update
        update_data = {
            'Name': new_name,
            'Email__c': new_email,
            'Phone_Number__c': new_phone,
            'Referral__c': new_referral_code,
            'Reward_Points__c': new_reward_points
        }

        # Update Salesforce record
        sf.Customer_Login__c.update(user_id, update_data)

        return jsonify({
            'status': 'success',
            'message': 'Profile updated successfully!',
            'data': update_data
        })

    except Exception as e:
        return jsonify({'status': 'error', 'message': str(e)})



from datetime import datetime
import pytz  # Library to handle timezone conversions

@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
        """)

        print(f"Salesforce query result: {result}")  # Debugging line

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

        if not orders:
            print("No orders found for this email.")  # Debugging line

        # Format the order details for better readability
        for order in orders:
            order_details = order.get("Order_Details__c", "")
            items = order_details.split("\n")  # Assuming each item is separated by a new line
            formatted_items = []

            # Loop through the items and format them as "item name * quantity"
            for item in items:
                item_details = item.split(" | ")
                if len(item_details) > 1:
                    name = item_details[0].strip()
                    quantity = item_details[1].strip()
                    formatted_items.append(f"{name} * {quantity}")

            # Join the formatted items into a single string
            order['formatted_items'] = ", ".join(formatted_items)

            # Get the order date and time from CreatedDate
            created_date = order.get("CreatedDate", "")
            if created_date:
                # Convert CreatedDate to datetime object in UTC
                utc_datetime = datetime.strptime(created_date, '%Y-%m-%dT%H:%M:%S.000+0000')
                utc_datetime = utc_datetime.replace(tzinfo=pytz.UTC)
            
                # Convert UTC datetime to the desired timezone (e.g., IST)
                local_timezone = pytz.timezone('Asia/Kolkata')  # Replace with your timezone
                local_datetime = utc_datetime.astimezone(local_timezone)

                # Format the date and time in the desired format
                order['formatted_date'] = local_datetime.strftime('%B %d, %I:%M %p')

            order_status = order.get("Order_Status__c", "N/A")  # Default to "N/A" if no status
            order['order_status'] = order_status


        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.permanent_session_lifetime = timedelta(minutes=5)
@app.before_request
def check_session_timeout():
    if "last_activity" in session:
        last_activity_time = session["last_activity"]
        now = datetime.now().timestamp()
        
        # Check if inactivity time has exceeded 5 minutes (300 seconds)
        if now - last_activity_time > 300:
            session.clear()  # Clear session
            return redirect(url_for("logout"))
    
    # Update last activity timestamp on every request
    session["last_activity"] = datetime.now().timestamp()

@app.route("/dashboard")
def dashboard():
    return render_template("dashboard.html") 
@app.route("/logout")
def logout():
    # Retrieve table number before clearing session
    table_number = session.get('table_number', '')

    # Clear session variables
    session.pop('name', None)
    session.pop('email', None)
    session.pop('rewardPoints', None)
    session.pop('coupon', None)

    # Pass table number to redirect page
    return render_template("redirect_page.html", table_number=table_number)

@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 from Salesforce
            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']

                # ✅ Always store or update session email
                if 'user_email' not in session or session['user_email'] != email:
                    session['user_email'] = email
                    session['user_name'] = user.get("Name", "")
                    print(f"✅ Session email updated: {session['user_email']}")

                reward_points = user.get("Reward_Points__c") or 0

                # Coupon generation logic (if reward points >= 500)
                if reward_points >= 500:
                    new_coupon_code = generate_coupon_code()
                    coupon_query = sf.query(f"SELECT Id, Coupon_Code__c FROM Referral_Coupon__c WHERE Referral_Email__c = '{email}'")

                    if coupon_query["records"]:
                        coupon_record = coupon_query["records"][0]
                        referral_coupon_id = coupon_record["Id"]
                        existing_coupons = coupon_record.get("Coupon_Code__c", "")

                        updated_coupons = f"{existing_coupons}\n{new_coupon_code}".strip()
                        sf.Referral_Coupon__c.update(referral_coupon_id, {"Coupon_Code__c": updated_coupons})
                    else:
                        sf.Referral_Coupon__c.create({
                            "Referral_Email__c": email,
                            "Name": user.get("Name", ""),
                            "Coupon_Code__c": new_coupon_code
                        })

                    new_reward_points = reward_points - 500
                    sf.Customer_Login__c.update(user['Id'], {"Reward_Points__c": 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_email = session.get('user_email')

    if not user_email:
        user_email = request.args.get("email")
        user_name = request.args.get("name")

        if user_email:
            session['user_email'] = user_email
            session['user_name'] = user_name  # Store name in session
        else:
            return redirect(url_for("login"))
    else:
        user_name = session.get('user_name')  # Get name from session if it's already stored

    # Get the first letter of the user's name (make it uppercase for consistency)
    first_letter = user_name[0].upper() if user_name else "A"

    try:
        # Fetch user referral and reward points
        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']:
            return redirect(url_for('login'))

        referral_code = user_result['records'][0].get('Referral__c', 'N/A')
        reward_points = user_result['records'][0].get('Reward_Points__c', 0)

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

        # Ensure Total_Ordered__c has a valid value
        for item in food_items:
            if 'Total_Ordered__c' not in item or item['Total_Ordered__c'] is None:
                item['Total_Ordered__c'] = 0  # Default value

        # Query to fetch Custom_Dish__c records created within the last 7 days with Total_Ordered__c > 10
        custom_dish_query = """
            SELECT Name, Price__c, Description__c, Image1__c, Image2__c, Veg_NonVeg__c, Section__c, Total_Ordered__c 
            FROM Custom_Dish__c
            WHERE CreatedDate >= LAST_N_DAYS:7
        """
        custom_dish_result = sf.query(custom_dish_query)
        custom_dishes = custom_dish_result['records'] if 'records' in custom_dish_result else []

        # Merge both Menu_Item__c and Custom_Dish__c records into the ordered menu
        all_items = food_items + custom_dishes

        # Define the order of sections, adding "Best Sellers" at the top
        section_order = ["Best Sellers", "Starters", "Biryanis", "Curries", "Breads", "Customized dish", "Apetizer", "Desserts", "Soft Drinks"]
        ordered_menu = {section: [] for section in section_order}

        # Sort items by Total_Ordered__c in descending order and pick top 4 as best sellers
        best_sellers = sorted(all_items, key=lambda x: x.get("Total_Ordered__c", 0), reverse=True)

        if selected_category == "Veg":
            best_sellers = [item for item in best_sellers if item.get("Veg_NonVeg__c") in ["Veg", "both"]]
        elif selected_category == "Non veg":
            best_sellers = [item for item in best_sellers if item.get("Veg_NonVeg__c") in ["Non veg", "both"]]

        # Take only the top 4 best sellers after filtering
        best_sellers = best_sellers[:4]

        # Ensure "Best Sellers" is added only if there are items after filtering
        if best_sellers:
            ordered_menu["Best Sellers"] = best_sellers

        # Create a set to track item names already added to prevent duplicates
        added_item_names = set()

        # Filter and organize menu items based on category and section (to avoid duplicates)
        for item in all_items:
            section = item.get("Section__c", "Others")  # Default to "Others" if missing
            if section not in ordered_menu:
                ordered_menu[section] = []

            # Skip item if it's already been added to avoid duplicates
            if item['Name'] in added_item_names:
                continue

            # Apply category filters
            if selected_category == "Veg" and item.get("Veg_NonVeg__c") not in ["Veg", "both"]:
                continue
            if selected_category == "Non veg" and item.get("Veg_NonVeg__c") not in ["Non veg", "both"]:
                continue

            ordered_menu[section].append(item)
            added_item_names.add(item['Name'])  # Add item to the set of added items
            print(f"Added item to {section}: {item['Name']}")  # Debugging

        # Remove empty sections
        ordered_menu = {section: items for section, items in ordered_menu.items() if items}
        print(f"Final ordered menu: {ordered_menu.keys()}")  # Debugging

        categories = ["All", "Veg", "Non veg"]

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

    # Pass the user's first letter (first_letter) to the template
    return render_template(
        "menu.html",
        ordered_menu=ordered_menu,
        categories=categories,
        selected_category=selected_category,
        referral_code=referral_code,
        reward_points=reward_points,
        user_name=user_name,  # Pass name to the template
        first_letter=first_letter  # Pass first letter to the template
    )


@app.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=[])


@app.route("/cart/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)})


@app.route('/cart/add', methods=['POST'])
def add_to_cart():
    try:
        # Get data from request
        data = request.json
        item_name = data.get('itemName', '').strip()
        item_price = data.get('itemPrice')
        item_image = data.get('itemImage')
        addons = data.get('addons', [])
        instructions = data.get('instructions', '')
        category = data.get('category')
        section = data.get('section')
        quantity = data.get('quantity', 1)  # Get the quantity field from the request
        customer_email = session.get('user_email')

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

        if not customer_email:
            return jsonify({"success": False, "error": "User email is required."}), 400

        # Query to check if the item is already in the 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", [])

        # Calculate the total price for the addons
        addons_price = sum(addon['price'] for addon in addons)
        new_addons = "; ".join([f"{addon['name']} (${addon['price']})" for addon in addons])

        # If the item is already in the cart, update it
        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 the new addons with the existing ones
            combined_addons = existing_addons if existing_addons != "None" else ""
            if new_addons:
                combined_addons = f"{combined_addons}; {new_addons}".strip("; ")

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

            # Calculate total addons 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 cart item in Salesforce (updating quantity)
            sf.Cart_Item__c.update(cart_item_id, {
                "Quantity__c": existing_quantity + quantity,  # Add the selected quantity
                "Add_Ons__c": combined_addons,
                "Add_Ons_Price__c": combined_addons_price,
                "Instructions__c": combined_instructions,
                "Price__c": (existing_quantity + quantity) * item_price + combined_addons_price,
                "Category__c": category,
                "Section__c": section
            })
        else:
            # If the item is not already in the cart, create a new entry
            addons_string = "None"
            if addons:
                addons_string = new_addons

            total_price = item_price * quantity + addons_price  # Multiply by the quantity

            # Create new cart item in Salesforce
            sf.Cart_Item__c.create({
                "Name": item_name,
                "Price__c": total_price,
                "Base_Price__c": item_price,
                "Quantity__c": quantity,  # Use the selected quantity
                "Add_Ons_Price__c": addons_price,
                "Add_Ons__c": addons_string,
                "Image1__c": item_image,
                "Customer_Email__c": customer_email,
                "Instructions__c": instructions,
                "Category__c": category,
                "Section__c": section
            })

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

    except KeyError as e:
        # Handle missing expected keys in request data
        return jsonify({"success": False, "error": f"Missing required field: {str(e)}"}), 400

    except Exception as e:
        # Log the error for debugging and return a general error message
        print(f"Error adding item to cart: {str(e)}")
        return jsonify({"success": False, "error": "An error occurred while adding the item to the cart."}), 500


@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

@app.route('/api/addons', methods=['GET'])
def get_addons():
    item_name = request.args.get('item_name')  
    item_section = request.args.get('item_section')  

    # Check if both item_name and item_section are provided
    if not item_name or not item_section:
        return jsonify({"success": False, "error": "Item name and section are required."}), 400

    try:
        # Fetch customization options from Salesforce based on the section
        query = f"""
            SELECT Name, Customization_Type__c, Options__c, Max_Selections__c, Extra_Charge__c, Extra_Charge_Amount__c
            FROM Customization_Options__c
            WHERE Section__c = '{item_section}'
        """
        result = sf.query(query)
        addons = result.get('records', [])

        # Check if we found any addons
        if not addons:
            return jsonify({"success": False, "error": "No customization options found for the given section."}), 404

        # Format data for frontend
        formatted_addons = []
        for addon in addons:
            # Ensure 'Options__c' exists and is not None
            options = addon.get("Options__c", "")
            if options:  # If options are available, split them
                options = options.split(", ")  # Convert comma-separated options into a list
            else:
                options = []  # If no options, default to an empty list

            formatted_addons.append({
                "name": addon["Name"],
                "type": addon["Customization_Type__c"],
                "options": options,
                "max_selections": addon.get("Max_Selections__c", 1),
                "extra_charge": addon.get("Extra_Charge__c", False),
                "extra_charge_amount": addon.get("Extra_Charge_Amount__c", 0)
            })

        return jsonify({"success": True, "addons": formatted_addons})

    except Exception as e:
        # Log the exception for debugging
        app.logger.error(f"Error fetching addons: {str(e)}")
        return jsonify({"success": False, "error": "An error occurred while fetching customization options."}), 500


@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_name')
    table_number = session.get('table_number')  # Retrieve table number

    print(f"Session Email: {email}, User ID: {user_id}, Table Number: {table_number}")  # Debugging session data

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

    try:
        # Fetch the selected coupon (if any)
        data = request.json
        selected_coupon = data.get("selectedCoupon", "").strip() if data.get("selectedCoupon") else None
        # Now selected_coupon will be None if it's not provided or empty, or a valid string otherwise
        print(f"Selected Coupon: {selected_coupon}")  # Debugging selected coupon

        # Fetch cart items for the current user
        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}'
        """)
        
        # Log the cart items to see if they are fetched correctly
        cart_items = result.get("records", [])
        print(f"Cart Items Retrieved: {cart_items}")  # Debugging log

        if not cart_items:
            print("Cart is empty")
            return jsonify({"success": False, "message": "Cart is empty"})

        total_price = sum(item['Price__c'] for item in cart_items)
        print(f"Total Price: {total_price}")  # Debugging total price calculation

        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}'
        """)
        print(f"Coupon Query Results: {coupon_query}")  # Debugging coupon query results

        has_coupons = bool(coupon_query["records"])
        print(f"Has Coupons: {has_coupons}")  # Debugging coupon presence check

        if selected_coupon:
            # Apply 10% discount if a valid coupon is selected
            discount = total_price * 0.10  # Example: 10% discount
            print(f"Discount Applied: {discount}")  # Debugging discount calculation
            
            referral_coupon_id = coupon_query["records"][0]["Id"]
            print(f"Referral Coupon ID: {referral_coupon_id}")  # Debugging referral coupon ID

            existing_coupons = coupon_query["records"][0]["Coupon_Code__c"].split("\n")
            print(f"Existing Coupons Before Removal: {existing_coupons}")  # Debugging existing coupons

            # Remove the selected coupon from the list of existing coupons
            updated_coupons = [coupon for coupon in existing_coupons if coupon.strip() != selected_coupon]
            updated_coupons_str = "\n".join(updated_coupons).strip()

            print(f"Updated Coupons After Removal: {updated_coupons}")  # Debugging updated coupons

            # If no coupons remain, set the field to None (not empty string)
            if not updated_coupons:
                updated_coupons_str = None  # Set to None if no coupons are left
                print("No Coupons Remaining. Setting to None")  # Debugging no coupons left

            # Update the Referral_Coupon__c record
            print(f"Updating Referral Coupon: {updated_coupons_str}")  # Debugging update to Salesforce
            sf.Referral_Coupon__c.update(referral_coupon_id, {
                "Coupon_Code__c": updated_coupons_str
            })
        else:
            # If no coupon is selected, add reward points
            reward_points_to_add = total_price * 0.10  # Example: 10% reward points
            print(f"Reward Points to Add: {reward_points_to_add}")  # Debugging reward points

            # Fetch current reward points
            customer_record = sf.query(f"""
                SELECT Id, Reward_Points__c FROM Customer_Login__c
                WHERE Email__c = '{email}'
            """)
            print(f"Customer Reward Points Query: {customer_record}")  # Debugging customer reward points query
            
            customer = customer_record.get("records", [])[0] if customer_record else None
            if customer:
                current_reward_points = customer.get("Reward_Points__c") or 0
                print(f"Current Reward Points: {current_reward_points}")  # Debugging current reward points
                new_reward_points = current_reward_points + reward_points_to_add
                print(f"New Reward Points: {new_reward_points}")  # Debugging new reward points calculation

                # Update reward points
                sf.Customer_Login__c.update(customer["Id"], {
                    "Reward_Points__c": new_reward_points
                })

        # Final total bill calculation
        total_bill = total_price - discount
        print(f"Total Bill After Discount: {total_bill}")  # Debugging final total bill

        # Store all order details (before deleting cart items)
        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
        )
        print(f"Order Details: {order_details}")  # Debugging order details

        # Fetch Customer ID from Customer_Login__c
        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
        print(f"Customer ID: {customer_id}")  # Debugging customer ID retrieval

        if not customer_id:
            print("Customer record not found")
            return jsonify({"success": False, "message": "Customer record not found in Salesforce"})

        # Store order data
        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  # Store table number
        }
        print(f"Order Data: {order_data}")  # Debugging order data

        # Create the order in Salesforce
        order_response = sf.Order__c.create(order_data)
        print(f"Order Response: {order_response}")  # Debugging order creation response

        # Ensure the order was created successfully before deleting cart items
        if order_response:
            # Only delete cart items after the order is created
            for item in cart_items:
                print(f"Deleting Cart Item: {item['Id']}")  # Debugging cart item deletion
                sf.Cart_Item__c.delete(item["Id"])

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

    except Exception as e:
        print(f"Error during checkout: {str(e)}")  # Debugging error message
        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))
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText




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