from flask import Blueprint, render_template, request, session, jsonify  # Added jsonify import
from salesforce import get_salesforce_connection

menu_blueprint = Blueprint('menu', __name__)

# Initialize Salesforce connection
sf = get_salesforce_connection()

import re  # Importing regular expression module
@menu_blueprint.route("/menu", methods=["GET", "POST"])
def menu():
    selected_category = request.args.get("category", "All")
    is_veg_only = request.args.get("veg") == 'on'

    # Priority to Customized Dish only if it's selected
    if request.args.get("category") == "Customized Dish":
        selected_category = "Customized Dish"
    else:
        selected_category = "Veg" if is_veg_only else "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 the category is "Veg", filter for Veg items
        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

        # Remove empty sections
        ordered_menu = {section: items for section, items in ordered_menu.items() if items}

        # Fetch the most selected add-ons and instructions based on the user's previous orders
        past_orders_query = f"""
            SELECT Order_Details__c FROM Order__c
            WHERE Customer_Email__c = '{user_email}'
        """
        past_orders_result = sf.query(past_orders_query)
        past_orders = past_orders_result.get('records', [])

        # Frequency analysis for add-ons and instructions
        addon_counts = {}
        instruction_counts = {}

        for order in past_orders:
            order_details = order.get('Order_Details__c', '').split('\n')

            for line in order_details:
                item_parts = line.split('|')
                if len(item_parts) >= 5:
                    # Extract Add-Ons and Instructions from the order details string
                    addons = item_parts[1].strip().replace('Add-Ons:', '').split(', ')
                    instructions = item_parts[2].strip().replace('Instructions:', '').split(', ')

                    # Clean the add-on names by removing any price information
                    cleaned_addons = [re.sub(r"\s?\(\$\d+(\.\d{2})?\)", "", addon) for addon in addons]
                    # Split add-ons by semicolon and process separately
                    for addon in cleaned_addons:
                        # If the add-on contains a semicolon, split it into multiple add-ons
                        individual_addons = addon.split(';')  # Split add-ons separated by semicolons
                        for individual_addon in individual_addons:
                            individual_addon = individual_addon.strip()  # Remove extra spaces
                            if individual_addon:
                                addon_counts[individual_addon] = addon_counts.get(individual_addon, 0) + 1


                    for instruction in instructions:
                        if instruction:
                            instruction_counts[instruction] = instruction_counts.get(instruction, 0) + 1

        # Print the cleaned add-ons and instructions to check what we're fetching
        print(f"Add-ons fetched (cleaned): {addon_counts}")
        

        # Get the most frequent add-ons and instructions
        most_common_addons = sorted(addon_counts, key=addon_counts.get, reverse=True)  # Top 3 most frequent addons
        most_common_instructions = sorted(instruction_counts, key=instruction_counts.get, reverse=True)[:3]  # Top 3 most frequent instructions

        # Print to check the final most common add-ons and instructions
        print(f"Most common add-ons (cleaned): {most_common_addons}")

        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 most common add-ons and instructions 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
        most_common_addons=[addon.strip() for addon in most_common_addons],  # Pass most common addons
        most_common_instructions=most_common_instructions  # Pass most common instructions
    )

@menu_blueprint.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

@menu_blueprint.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