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

@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")
        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
            # Check if a referral code is entered
            if referral_code:
                # Query Salesforce to check if the referral code exists
                referral_query = f"SELECT Id, Reward_Points__c FROM Customer_Login__c WHERE Referral__c = '{referral_code}'"
                referral_result = sf.query(referral_query)
                ref=50

                if not referral_result['records']:
                    # If referral code does not exist, show an error message
                    return render_template("signup.html", error="Invalid referral code!")

                # If referral exists, get the first matching record
                referrer = referral_result['records'][0]
                referrer_id = referrer['Id']
                # Fetch the existing reward points, defaulting to 0 if None
                existing_reward_points = referrer.get('Reward_Points__c') or 0  # Default to 0 if the field is None
                updated_reward_points = existing_reward_points + 100
                # Update the referrer's Reward_Points__c field in Salesforce
                sf.Customer_Login__c.update(referrer_id, {
                    "Reward_Points__c": updated_reward_points
                })
            
            # Create the new customer record in Salesforce
            sf.Customer_Login__c.create({
                "Name": name,
                "Phone_Number__c": phone,
                "Email__c": email,
                "Password__c": password,
                "Reward_Points__c": ref,
                "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:
            query = f"SELECT Id, Name, Email__c FROM Customer_Login__c WHERE Email__c='{email}' AND Password__c='{password}'"
            result = sf.query(query)

            if result["records"]:
                session['user_id'] = result["records"][0]['Id']
                session['user_email'] = email
                print(f"Session variables set: user_id={session['user_id']}, user_email={session['user_email']}")
                #print(f"Session cookie: {request.cookies.get(app.session_cookie_name)}")  # Check session cookie
                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')
    print(f"Cookies on /menu: {request.cookies}")
    print(f"Session check in /menu: user_id={user_id}")
    
    # Get the selected category from the query parameter, default is "All"
    selected_category = request.args.get("category", "All")
    print(f"Selected category: {selected_category}")
    if not user_id:
        print("Session missing, redirecting to login.")
        return redirect(url_for('login'))
    

    try:
        query = """
            SELECT Name, Price__c, Description__c, Image1__c, Image2__c, Veg_NonVeg__c, Section__c 
            FROM Menu_Item__c
        """
        # Query to fetch menu items
        result = sf.query(query)

        # Fetch all food items from the query result
        food_items = result['records'] if 'records' in result else []

        # Dynamically determine categories based on the fetched data
        categories = {item.get("Veg_NonVeg__c").capitalize() for item in food_items if item.get("Veg_NonVeg__c")}
        categories = {"Veg", "Non-Veg"}  # Explicitly overwrite to 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

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

    )
@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)
        customer_result = sf.query(f"""
            SELECT Reward_Points__c 
            FROM Customer_Login__c
            WHERE Email__c = '{email}'
        """)
        
        # Extract the reward points (default to 0 if not found)
        reward_points = customer_result['records'][0].get('Reward_Points__c', 0) if customer_result['records'] else 0
        return render_template("cart.html", cart_items=cart_items, subtotal=subtotal, reward_points=reward_points, customer_email=email)

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


@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

@app.route('/api/addons', methods=['GET'])
def get_addons():
    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')
    
    # Check if the user is logged in
    if not email or not user_id:
        return jsonify({"success": False, "message": "User not logged in"})

    try:
        # Fetch cart items for the user
        result = sf.query(f"""
            SELECT Id, Name, Price__c, Add_Ons_Price__c, Quantity__c, Add_Ons__c, Instructions__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"})

        # Calculate the total price of the order
        total_price = sum(item['Price__c'] for item in cart_items)

        # Format order details including instructions
        order_details = []
        for item in cart_items:
            details = f"{item['Name']} (Qty: {item['Quantity__c']}, Add-Ons: {item['Add_Ons__c'] or 'None'}, Price: ${item['Price__c']})"
            if item.get('Instructions__c'):  # Include instructions if available
                details += f", Instructions: {item['Instructions__c']}"
            order_details.append(details)


        # Fetch the current Reward_Points__c for the user
        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:
            # Get the checkbox status from the frontend
            use_reward_points = request.json.get("useRewardPoints", False)

            if use_reward_points:
                # Subtract 500 points if checkbox is selected
                if customer['Reward_Points__c'] >= 500:
                    new_reward_points = customer['Reward_Points__c'] - 500
                    discount=total_price * 0.10
                    total_bill=total_price-discount
                    
                else:
                    return jsonify({"success": False, "message": "Insufficient reward points to apply."})
            else:
                # Add 10% of the subtotal if checkbox is not selected
                reward_points_to_add = total_price * 0.10
                new_reward_points = customer['Reward_Points__c'] + reward_points_to_add
                discount=0
                total_bill=total_price
            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": "\n".join(order_details)  # Store all item details
            }

            # Create the order record in Salesforce
            order_result = sf.Order__c.create(order_data)

            # Update the Reward_Points__c field in Salesforce
            try:
                sf.Customer_Login__c.update(customer['Id'], {
                    "Reward_Points__c": new_reward_points
                })
            except Exception as update_error:
                return jsonify({"success": False, "message": f"Error updating reward points: {str(update_error)}"})

        # Clear the cart after placing the order
        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=False, host="0.0.0.0", port=7860)