enhanced_rag.py

import json
import logging
from datetime import datetime

import numpy as np
import re
from collections import Counter
from typing import Dict, List, Tuple, Optional
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
from openai import OpenAI
import pprint

# Import our similarity matrix manager
from similarity_matrix_manager import SimilarityMatrixManager


class EnhancedCompactAeropressRAG:
    def __init__(self, recipe_database_path, similarity_matrices_path=None,
                 model_name="gpt-4.1", embedding_model="all-mpnet-base-v2"):
        # Set up logging
        self.logger = logging.getLogger("EnhancedCompactAeropressRAG")
        self.logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        handler.setFormatter(formatter)
        self.logger.addHandler(handler)

        self.logger.info("Initializing Enhanced Compact Aeropress RAG")

        self.recipes_db = self._load_recipe_database(recipe_database_path)
        self.embedding_model = SentenceTransformer(embedding_model)
        self.model_name = model_name
        self.llm_client = OpenAI()

        # Create flat embeddings (sufficient for 51 recipes)
        self.recipe_embeddings = self._create_recipe_embeddings()
        self.logger.info(f"Created recipe embeddings of shape {self.recipe_embeddings.shape}")

        # Create specialized coffee attribute embeddings
        self.coffee_embeddings = self._create_attribute_embeddings()
        self.logger.info(f"Created coffee attribute embeddings of shape {self.coffee_embeddings.shape}")

        # Create method embeddings
        self.method_embeddings = self._create_method_embeddings()
        self.logger.info(f"Created method embeddings of shape {self.method_embeddings.shape}")

        # Pre-calculate indices for fast lookup
        self.processing_index = self._build_processing_index()
        self.origin_index = self._build_origin_index()
        self.country_index = self._build_country_index()

        # Initialize similarity matrix manager if available
        if similarity_matrices_path:
            try:
                self.similarity_matrix_manager = SimilarityMatrixManager(similarity_matrices_path)
                self.logger.info("Initialized similarity matrix manager")
            except Exception as e:
                self.logger.error(f"Failed to initialize similarity matrix manager: {str(e)}")
                self.similarity_matrix_manager = None
        else:
            self.similarity_matrix_manager = None
            self.logger.warning("No similarity matrices path provided, similarity enhancement disabled")

        # WAC competition rules
        self.wac_rules = {
            "max_coffee_dose": 18.0,  # Maximum 18g coffee dose
            "min_brew_output": 150.0,  # Minimum 150ml/g output
            "max_time": 300,  # 5-minute (300 seconds) time limit
            "allowed_ingredients": ["coffee", "water"],  # Only coffee and water
            "allowed_positions": ["standard", "inverted"],  # Standard or inverted
            "allowed_brewers": ["AeroPress Original", "AeroPress Clear"]  # Allowed brewer types
        }

        self.logger.info("Enhanced CompactAeropressRAG initialized successfully")

    def _load_recipe_database(self, path):
        """Load recipe database from JSON file"""
        with open(path, 'r') as f:
            return json.load(f)

    def retrieve_similar_recipes(self, coffee_attributes, k=5, weights=None):
        """Retrieve similar recipes with boosting for exact matches and semantic similarity"""
        if weights is None:
            weights = {'attributes': 0.7, 'method': 0.1, 'recipe': 0.2}

        # Original retrieval code (unchanged)
        # Get query about coffee characteristics
        query = f"""
        Origin: {coffee_attributes.get('origin', 'Unknown')}
        Country: {coffee_attributes.get('country', 'Unknown')}
        Processing: {coffee_attributes.get('processing', 'Unknown')}
        """

        # Calculate similarity for coffee attributes
        query_attribute_embedding = self.embedding_model.encode([query])[0]
        attribute_similarities = cosine_similarity(
            [query_attribute_embedding],
            self.coffee_embeddings
        )[0]

        # Calculate similarity for overall recipe
        query_recipe_embedding = self.embedding_model.encode(
            [self._query_to_full_text(coffee_attributes)]
        )[0]
        recipe_similarities = cosine_similarity(
            [query_recipe_embedding],
            self.recipe_embeddings
        )[0]

        # Get method preference if provided
        method_similarities = np.zeros(len(self.recipes_db))
        if coffee_attributes.get('preferred_method'):
            query_method_embedding = self.embedding_model.encode(
                [f"Position: {coffee_attributes.get('preferred_position', '')}. "
                 f"Method: {coffee_attributes.get('preferred_method', '')}"]
            )[0]
            method_similarities = cosine_similarity(
                [query_method_embedding],
                self.method_embeddings
            )[0]

        # Combine scores with weights
        combined_scores = (
                weights['attributes'] * attribute_similarities +
                weights['method'] * method_similarities +
                weights['recipe'] * recipe_similarities
        )

        # Apply exact match boosts using the existing indices
        query_processing = coffee_attributes.get('processing', '').lower()
        query_origin = coffee_attributes.get('origin', '').lower()
        query_country = coffee_attributes.get('country', '').lower()

        origin_matches = []
        if query_origin and query_origin in self.origin_index:
            origin_matches.extend(self.origin_index[query_origin])
            self.logger.info(f"Found exact origin matches for '{query_origin}'")
        elif query_country and query_country in self.country_index:
            origin_matches.extend(self.country_index[query_country])
            self.logger.info(f"Found exact country matches for '{query_country}'")

        # Apply 50% boost for exact processing method match
        if query_processing and query_processing in self.processing_index:
            for idx in self.processing_index[query_processing]:
                combined_scores[idx] *= 1.5
                self.logger.info(f"Applied processing method boost for '{query_processing}'")

        # Apply 30% boost for exact origin match
        if query_origin and query_origin in self.origin_index:
            for idx in self.origin_index[query_origin]:
                combined_scores[idx] *= 2.5
                self.logger.info(f"Applied origin boost for '{query_origin}'")

        # Apply 20% boost for exact country match if origin not matched
        if not query_origin and query_country and query_country in self.country_index:
            for idx in self.country_index[query_country]:
                combined_scores[idx] *= 1.2
                self.logger.info(f"Applied country boost for '{query_country}'")

        # Apply WAC compliance boost: favor recipes with doses <= 18g
        for idx, recipe in enumerate(self.recipes_db):
            recipe_origin = recipe.get('coffee', {}).get('origin', '')
            recipe_processing = recipe.get('coffee', {}).get('processing', '')
            recipe_dose = recipe.get('recipe', {}).get('dose', 0)
            if 0 < recipe_dose <= self.wac_rules["max_coffee_dose"]:
                combined_scores[idx] *= 1.05  # 5% boost for WAC-compliant doses
            if recipe_origin and recipe_processing:
                if (recipe_origin.lower() == query_origin and
                        recipe_processing.lower() == query_processing):
                    combined_scores[idx] *= 3.0  # Substantial boost for matching both

        # Get top k indices
        top_indices = combined_scores.argsort()[-k:][::-1]

        # Create similar recipes list
        similar_recipes = []
        for idx in top_indices:
            similar_recipes.append({
                'recipe': self.recipes_db[idx],
                'similarity': combined_scores[idx]
            })

        # Apply similarity matrix enhancement if available
        if self.similarity_matrix_manager:
            self.logger.info("Enhancing retrieval with similarity matrices")
            similar_recipes = self._enhance_retrieval_with_similarity_matrices(
                coffee_attributes, similar_recipes)

        return similar_recipes

    # Include the _enhance_retrieval_with_similarity_matrices method here
    def _enhance_retrieval_with_similarity_matrices(self, coffee_attributes, similar_recipes):
        """
        Enhance recipe retrieval using similarity matrices when exact matches aren't available

        Args:
            coffee_attributes: User's requested coffee attributes
            similar_recipes: Current list of similar recipes from embedding search

        Returns:
            Enhanced list of similar recipes with adjusted similarity scores
        """
        if not hasattr(self, 'similarity_matrix_manager') or self.similarity_matrix_manager is None:
            self.logger.warning("Similarity matrix manager not initialized, skipping enhancement")
            return similar_recipes

        # Extract key attributes from the query
        query_origin = coffee_attributes.get('origin', '').lower()
        query_processing = coffee_attributes.get('processing', '').lower()
        query_variety = coffee_attributes.get('variety', '').lower()

        # Check if we have direct matches for these attributes in our similar_recipes
        has_origin_match = any(recipe['recipe'].get('coffee', {}).get('origin', '').lower() == query_origin
                               for recipe in similar_recipes)
        has_processing_match = any(recipe['recipe'].get('coffee', {}).get('processing', '').lower() == query_processing
                                   for recipe in similar_recipes)

        # Only apply similarity-based enhancement if we're missing direct matches
        enhanced_recipes = similar_recipes.copy()

        # For each similar recipe, adjust similarity score based on attribute similarity
        for i, recipe_data in enumerate(enhanced_recipes):
            recipe = recipe_data['recipe']
            coffee = recipe.get('coffee', {})

            recipe_origin = coffee.get('origin', '')
            recipe_processing = coffee.get('processing', '')
            recipe_variety = coffee.get('variety', '')

            boost_factor = 1.0

            # Apply origin similarity if no direct match
            if query_origin and recipe_origin and not has_origin_match:
                origin_similarity = self.similarity_matrix_manager.get_similarity_score(
                    query_origin, recipe_origin, 'origin')
                if origin_similarity > 0.7:  # Only boost for high similarity
                    boost_factor *= (1.0 + origin_similarity * 0.5)  # Up to 50% boost
                    self.logger.info(
                        f"Boosting recipe due to origin similarity: {query_origin} -> {recipe_origin} = {origin_similarity}")

            # Apply processing similarity if no direct match
            if query_processing and recipe_processing and not has_processing_match:
                process_similarity = self.similarity_matrix_manager.get_similarity_score(
                    query_processing, recipe_processing, 'process')
                if process_similarity > 0.7:  # Only boost for high similarity
                    boost_factor *= (1.0 + process_similarity * 0.5)  # Up to 50% boost
                    self.logger.info(
                        f"Boosting recipe due to processing similarity: {query_processing} -> {recipe_processing} = {process_similarity}")

            # Apply variety similarity if available
            if query_variety and recipe_variety:
                variety_similarity = self.similarity_matrix_manager.get_similarity_score(
                    query_variety, recipe_variety, 'variety')
                if variety_similarity > 0.7:
                    boost_factor *= (1.0 + variety_similarity * 0.3)  # Up to 30% boost
                    self.logger.info(
                        f"Boosting recipe due to variety similarity: {query_variety} -> {recipe_variety} = {variety_similarity}")

            # Apply the boost to the similarity score
            if boost_factor > 1.0:
                enhanced_recipes[i]['similarity'] *= boost_factor

        # Resort the recipes based on enhanced similarity scores
        enhanced_recipes.sort(key=lambda x: x['similarity'], reverse=True)

        return enhanced_recipes

    def _suggest_similar_attributes(self, coffee_attributes):
        """
        Suggest similar coffee attributes when exact matches aren't available

        Args:
            coffee_attributes: User's requested coffee attributes

        Returns:
            Dictionary with suggested similar attributes
        """
        if not hasattr(self, 'similarity_matrix_manager') or self.similarity_matrix_manager is None:
            return {}

        suggestions = {}

        # Check origin
        query_origin = coffee_attributes.get('origin', '')
        if query_origin and query_origin.lower() not in self.origin_index:
            # Try to find similar origins
            closest_origin = self.similarity_matrix_manager.find_closest_term(query_origin, 'origin')
            if closest_origin:
                suggestions['origin'] = closest_origin
                self.logger.info(
                    f"Suggesting similar origin: {query_origin} -> {closest_origin['term']} (similarity: {closest_origin['similarity']:.2f})")

                # Get additional similar origins
                similar_origins = self.similarity_matrix_manager.get_similar_terms(closest_origin['term'], 'origin')
                if similar_origins:
                    suggestions['similar_origins'] = similar_origins[:3]  # Top 3 similar origins

        # Check processing method
        query_processing = coffee_attributes.get('processing', '')
        if query_processing and query_processing.lower() not in self.processing_index:
            # Try to find similar processing methods
            closest_processing = self.similarity_matrix_manager.find_closest_term(query_processing, 'process')
            if closest_processing:
                suggestions['processing'] = closest_processing
                self.logger.info(
                    f"Suggesting similar processing: {query_processing} -> {closest_processing['term']} (similarity: {closest_processing['similarity']:.2f})")

                # Get additional similar processing methods
                similar_processes = self.similarity_matrix_manager.get_similar_terms(closest_processing['term'],
                                                                                     'process')
                if similar_processes:
                    suggestions['similar_processes'] = similar_processes[:3]  # Top 3 similar processes

        # Check variety
        query_variety = coffee_attributes.get('variety', '')
        if query_variety:
            closest_variety = self.similarity_matrix_manager.find_closest_term(query_variety, 'variety')
            if closest_variety:
                suggestions['variety'] = closest_variety
                self.logger.info(
                    f"Suggesting similar variety: {query_variety} -> {closest_variety['term']} (similarity: {closest_variety['similarity']:.2f})")

                # Get additional similar varieties
                similar_varieties = self.similarity_matrix_manager.get_similar_terms(closest_variety['term'], 'variety')
                if similar_varieties:
                    suggestions['similar_varieties'] = similar_varieties[:3]  # Top 3 similar varieties

        return suggestions

    def generate_recipe(self, coffee_attributes, user_preferences=None):
        """Main method to generate WAC-compliant recipe for given coffee attributes"""
        self.logger.info(f"Generating recipe for coffee attributes: {coffee_attributes}")

        # Check if we need to suggest similar attributes
        suggested_attributes = self._suggest_similar_attributes(coffee_attributes)

        # If we have suggested attributes, add them to the explanation
        if suggested_attributes:
            self.logger.info(f"Found suggested attributes: {suggested_attributes}")

            # Enhance coffee attributes with suggested replacements if there's no direct match
            enhanced_attributes = coffee_attributes.copy()
            if 'origin' in suggested_attributes and coffee_attributes.get('origin',
                                                                          '').lower() not in self.origin_index:
                suggested_origin = suggested_attributes['origin']['term']
                self.logger.info(f"Using suggested origin: {suggested_origin}")
                enhanced_attributes['origin'] = suggested_origin

            if 'processing' in suggested_attributes and coffee_attributes.get('processing',
                                                                              '').lower() not in self.processing_index:
                suggested_processing = suggested_attributes['processing']['term']
                self.logger.info(f"Using suggested processing: {suggested_processing}")
                enhanced_attributes['processing'] = suggested_processing

            # 1. Retrieve similar recipes with enhanced attributes
            similar_recipes = self.retrieve_similar_recipes(enhanced_attributes)
        else:
            # 1. Retrieve similar recipes with original attributes
            similar_recipes = self.retrieve_similar_recipes(coffee_attributes)

        # 2. Calculate confidence metrics
        confidence_data = self.calculate_confidence(similar_recipes, coffee_attributes)

        # 3. Synthesize recipe parameters with WAC compliance
        recipe = self.synthesize_recipe(similar_recipes, coffee_attributes, user_preferences)

        # 4. Generate detailed explanation
        explanation = self.generate_explanation(recipe, similar_recipes,
                                                confidence_data, coffee_attributes, suggested_attributes)

        # 5. Evaluate recipe accuracy
        accuracy = self.evaluate_recipe_accuracy(recipe, similar_recipes, coffee_attributes)

        return {
            "recipe": recipe,
            "explanation": explanation,
            "confidence": confidence_data,
            "accuracy": accuracy,
            "similar_recipes": similar_recipes[:3],
            "suggested_attributes": suggested_attributes,
            "wac_compliant": True
        }

    # Rest of the CompactAeropressRAG methods would be included here...
    def _create_recipe_embeddings(self):
        """Create comprehensive recipe embeddings"""
        texts = []
        for recipe in self.recipes_db:
            text = self._recipe_to_text(recipe)
            texts.append(text)
        return self.embedding_model.encode(texts)

    def _create_attribute_embeddings(self):
        """Create coffee attribute-focused embeddings"""
        texts = []
        for recipe in self.recipes_db:
            coffee = recipe.get('coffee', {})
            text = f"""
            Origin: {coffee.get('origin', 'Unknown')}
            Country: {coffee.get('country', 'Unknown')}
            Region: {coffee.get('region', 'Unknown')}
            Processing: {coffee.get('processing', 'Unknown')}
            Variety: {coffee.get('variety', 'Unknown')}
            """
            texts.append(text)
        return self.embedding_model.encode(texts)

    def _create_method_embeddings(self):
        """Create method-focused embeddings"""
        texts = []
        for recipe in self.recipes_db:
            recipe_data = recipe.get('recipe', {})
            method = ' '.join(recipe_data.get('method', []))
            position = recipe_data.get('position', 'Unknown')
            text = f"Position: {position}. Method: {method}"
            texts.append(text)
        return self.embedding_model.encode(texts)

    def _recipe_to_text(self, recipe):
        """Convert recipe to comprehensive text for embedding"""
        recipe_data = recipe.get('recipe', {})
        coffee = recipe.get('coffee', {})

        return f"""
        Competitor: {recipe.get('competitor_name', 'Unknown')} 
        Year: {recipe.get('year', 'Unknown')}
        Placement: {recipe.get('placement', 'Unknown')}

        Coffee Origin: {coffee.get('origin', 'Unknown')}
        Coffee Country: {coffee.get('country', 'Unknown')}
        Coffee Region: {coffee.get('region', 'Unknown')}
        Coffee Processing: {coffee.get('processing', 'Unknown')}
        Coffee Variety: {coffee.get('variety', 'Unknown')}

        Brewing Position: {recipe_data.get('position', 'Unknown')}
        Dose: {recipe_data.get('dose', 'Unknown')}g
        Water Temperature: {recipe_data.get('water', {}).get('temperature', 'Unknown')}°C
        Water Amount: {recipe_data.get('water', {}).get('amount', 'Unknown')}ml
        Brew Time: {recipe_data.get('brew_time', 'Unknown')} seconds

        Method: {' '.join(recipe_data.get('method', []))}
        """

    def _build_processing_index(self):
        """Build index for processing method lookups"""
        index = {}
        for i, recipe in enumerate(self.recipes_db):
            processing = recipe.get('coffee', {}).get('processing', '')
            if processing:
                if processing not in index:
                    index[processing.lower()] = []
                index[processing.lower()].append(i)
        return index

    def _build_origin_index(self):
        """Build index for origin lookups"""
        index = {}
        for i, recipe in enumerate(self.recipes_db):
            origin = recipe.get('coffee', {}).get('origin', '')
            if origin:
                if origin not in index:
                    index[origin.lower()] = []
                index[origin.lower()].append(i)
        return index

    def _build_country_index(self):
        """Build index for country lookups"""
        index = {}
        for i, recipe in enumerate(self.recipes_db):
            country = recipe.get('coffee', {}).get('country', '')
            if country:
                if country not in index:
                    index[country.lower()] = []
                index[country.lower()].append(i)
        return index

    def retrieve_similar_recipes(self, coffee_attributes, k=5, weights=None):
        """Retrieve similar recipes with boosting for exact matches"""
        if weights is None:
            weights = {'attributes': 0.7, 'method': 0.1, 'recipe': 0.2}

        # Get query about coffee characteristics
        query = f"""
        Origin: {coffee_attributes.get('origin', 'Unknown')}
        Country: {coffee_attributes.get('country', 'Unknown')}
        Processing: {coffee_attributes.get('processing', 'Unknown')}
        """

        # Calculate similarity for coffee attributes
        query_attribute_embedding = self.embedding_model.encode([query])[0]
        attribute_similarities = cosine_similarity(
            [query_attribute_embedding],
            self.coffee_embeddings
        )[0]

        # Calculate similarity for overall recipe
        query_recipe_embedding = self.embedding_model.encode(
            [self._query_to_full_text(coffee_attributes)]
        )[0]
        recipe_similarities = cosine_similarity(
            [query_recipe_embedding],
            self.recipe_embeddings
        )[0]

        # Get method preference if provided
        method_similarities = np.zeros(len(self.recipes_db))
        if coffee_attributes.get('preferred_method'):
            query_method_embedding = self.embedding_model.encode(
                [f"Position: {coffee_attributes.get('preferred_position', '')}. "
                 f"Method: {coffee_attributes.get('preferred_method', '')}"]
            )[0]
            method_similarities = cosine_similarity(
                [query_method_embedding],
                self.method_embeddings
            )[0]

        # Combine scores with weights
        combined_scores = (
                weights['attributes'] * attribute_similarities +
                weights['method'] * method_similarities +
                weights['recipe'] * recipe_similarities
        )

        # Apply exact match boosts
        query_processing = coffee_attributes.get('processing', '').lower()
        query_origin = coffee_attributes.get('origin', '').lower()
        query_country = coffee_attributes.get('country', '').lower()

        origin_matches = []
        if query_origin and query_origin in self.origin_index:
            origin_matches.extend(self.origin_index[query_origin])
        elif query_country and query_country in self.country_index:
            origin_matches.extend(self.country_index[query_country])

        # Apply 50% boost for exact processing method match
        if query_processing and query_processing in self.processing_index:
            for idx in self.processing_index[query_processing]:
                combined_scores[idx] *= 1.5

        # Apply 30% boost for exact origin match
        if query_origin and query_origin in self.origin_index:
            for idx in self.origin_index[query_origin]:
                combined_scores[idx] *= 2.5

        # Apply 20% boost for exact country match if origin not matched
        if not query_origin and query_country and query_country in self.country_index:
            for idx in self.country_index[query_country]:
                combined_scores[idx] *= 1.2

        # Apply WAC compliance boost: favor recipes with doses <= 18g
        for idx, recipe in enumerate(self.recipes_db):
            recipe_origin = recipe.get('coffee', {}).get('origin', '')
            recipe_processing = recipe.get('coffee', {}).get('processing', '')
            recipe_dose = recipe.get('recipe', {}).get('dose', 0)
            if 0 < recipe_dose <= self.wac_rules["max_coffee_dose"]:
                combined_scores[idx] *= 1.05  # 5% boost for WAC-compliant doses
            if recipe_origin and recipe_processing:
                if (recipe_origin == query_origin and
                        recipe_processing == query_processing):
                    combined_scores[idx] *= 3.0  # Substantial boost for matching both

        # Get top k indices
        top_indices = combined_scores.argsort()[-k:][::-1]

        similar_recipes = []
        for idx in top_indices:
            similar_recipes.append({
                'recipe': self.recipes_db[idx],
                'similarity': combined_scores[idx]
            })

        return similar_recipes

    def _query_to_full_text(self, coffee_attributes):
        """Convert query attributes to text for full embedding comparison"""
        return f"""
        Looking for a recipe for coffee with:
        Origin: {coffee_attributes.get('origin', 'Unknown')}
        Country: {coffee_attributes.get('country', 'Unknown')}
        Region: {coffee_attributes.get('region', 'Unknown')}
        Processing: {coffee_attributes.get('processing', 'Unknown')}
        Variety: {coffee_attributes.get('variety', 'Unknown')}
        Preferred brewing position: {coffee_attributes.get('preferred_position', 'any')}
        """

    def calculate_confidence(self, similar_recipes, coffee_attributes):
        """Calculate confidence with small dataset optimizations"""
        if not similar_recipes:
            return {"overall": 0.0, "parameters": {}, "reason": "No similar recipes found"}

        # 1. Max similarity value instead of average (better for smaller datasets)
        max_similarity = max([recipe['similarity'] for recipe in similar_recipes[:3]])

        # 2. Processing method exact match (critical with small datasets)
        processing_match = 0.0
        query_processing = coffee_attributes.get('processing', '').lower()

        if query_processing:
            for recipe_data in similar_recipes[:3]:
                recipe = recipe_data['recipe']
                if processing := recipe.get('coffee', {}).get('processing', ''):
                    if processing and processing.lower() == query_processing:
                        processing_match += 0.25  # Up to 0.75 for 3 matches

        # 3. Placement weighting (championships matter more in small datasets)
        placement_boost = 0.0
        for recipe_data in similar_recipes[:3]:
            recipe = recipe_data['recipe']
            if recipe.get('placement') == '1st':
                placement_boost += 0.15
            elif recipe.get('placement') == '2nd':
                placement_boost += 0.10
            elif recipe.get('placement') == '3rd':
                placement_boost += 0.05

        # 4. Parameter consistency (use normalized range instead of variance)
        parameter_confidence = {}

        # Calculate parameter consistency for key attributes
        for param_name, extractor in [
            ('dose', lambda r: r.get('recipe', {}).get('dose')),
            ('temperature', lambda r: r.get('recipe', {}).get('water', {}).get('temperature')),
            ('brew_time', lambda r: r.get('recipe', {}).get('brew_time'))
        ]:
            values = [extractor(r['recipe']) for r in similar_recipes[:3] if extractor(r['recipe'])]

            if values:
                # Use range normalization instead of standard deviation
                value_range = max(values) - min(values)
                if max(values) == 0:
                    range_confidence = 0.0
                else:
                    range_confidence = 1.0 - min(1.0, value_range / max(values))

                parameter_confidence[param_name] = {
                    'confidence': range_confidence,
                    'value': sum(values) / len(values),
                    'min': min(values),
                    'max': max(values),
                    'range': value_range
                }

        # Calculate position confidence
        positions = [r['recipe'].get('recipe', {}).get('position')
                     for r in similar_recipes[:3]
                     if r['recipe'].get('recipe', {}).get('position')]

        if positions:
            most_common = Counter(positions).most_common(1)[0]
            position_confidence = most_common[1] / len(positions)
            parameter_confidence['position'] = {
                'confidence': position_confidence,
                'value': most_common[0],
                'count': f"{most_common[1]}/{len(positions)}"
            }

        # Calculate overall confidence (weighted more toward processing match)
        overall_confidence = (
                0.3 * max_similarity +
                0.4 * processing_match +  # Higher weight for processing match
                0.2 * placement_boost +
                0.1 * np.mean([conf.get('confidence', 0) for conf in parameter_confidence.values()])
        )

        return {
            "overall": min(1.0, overall_confidence),
            "similarity": max_similarity,
            "processing_match": processing_match,
            "placement_boost": placement_boost,
            "parameters": parameter_confidence
        }

    def synthesize_recipe(self, similar_recipes, coffee_attributes, user_preferences=None):
        """Generate WAC-compliant recipe with high emphasis on championship recipes"""
        recipe = {
            "position": "inverted",
            "dose": 18.0,  # Enforce WAC maximum
            "water": {},
            "grind": {},
            "filter": {},
            "brewer": "AeroPress Original"  # Specify WAC-compliant brewer
        }

        # With only 51 recipes, we should heavily favor the top matching recipe
        top_recipe = similar_recipes[0]['recipe'].get('recipe', {})

        # 1. Direct parameter copying with WAC compliance enforcement
        recipe['position'] = top_recipe.get('position', 'inverted')
        if recipe['position'] not in self.wac_rules["allowed_positions"]:
            recipe['position'] = 'inverted'  # Default to inverted if invalid

        # 2. For dose, use the most similar recipe's value but cap at 18g
        original_dose = top_recipe.get('dose', 18.0)
        recipe['dose'] = min(original_dose, self.wac_rules["max_coffee_dose"])

        # 3. For temperature, adjust based on processing method
        base_temp = top_recipe.get('water', {}).get('temperature', 90)
        if coffee_attributes.get('processing', '').lower() == 'washed':
            # Slight increase for washed coffee to highlight acidity
            recipe['water']['temperature'] = min(94, base_temp + 2)
        elif coffee_attributes.get('processing', '').lower() == 'natural':
            # Slight decrease for naturals to avoid over-extraction
            recipe['water']['temperature'] = max(85, base_temp - 2)
        else:
            recipe['water']['temperature'] = base_temp

        # 4. Grind settings - mostly use top recipe's setting
        recipe['grind'] = top_recipe.get('grind', {'grinder': 'Comandante', 'setting': '25 clicks'})

        # 5. Water amount - ensure minimum 150g output for WAC rules
        ratio = 13  # Default ratio
        if user_preferences and user_preferences.get('strength') == 'strong':
            ratio = 11
        elif user_preferences and user_preferences.get('strength') == 'light':
            ratio = 15

        water_amount = recipe['dose'] * ratio

        # Ensure we meet minimum output requirement, use bypass if necessary
        recipe['water']['amount'] = water_amount

        # Add bypass water if needed to meet minimum output
        if water_amount < self.wac_rules["min_brew_output"]:
            recipe['bypass'] = {
                'amount': max(0, self.wac_rules["min_brew_output"] - water_amount),
                'temperature': 'room temperature'
            }

        # 6. Filter - copy from top recipe
        recipe['filter'] = top_recipe.get('filter', {
            'type': 'Paper',
            'count': 1,
            'preparation': 'rinsed with hot water'
        })

        # 7. Brew time - copy from top recipe or calculate based on method
        # Ensure it's under the 5-minute limit
        recipe['brew_time'] = min(top_recipe.get('brew_time', 90), self.wac_rules["max_time"])

        # 8. Method - take steps from top recipe but adjust for coffee attributes and WAC rules
        recipe["method"] = self._generate_method_steps_with_llm(recipe, coffee_attributes, similar_recipes[:3])

        # 9. Total time - maximum 5 minutes for WAC rules
        recipe['total_time'] = min(recipe['brew_time'] + 30, self.wac_rules["max_time"])  # Add 30s for setup

        return recipe

    def _generate_method_steps_with_llm(self, recipe_params, coffee_attributes, similar_recipes):
        """Use LLM to generate coherent method steps based on recipe parameters"""

        # Create a detailed prompt for the LLM
        prompt = f"""Generate a logical, step-by-step AeroPress brewing method for a WAC-compliant recipe with the following parameters:

    Recipe Parameters:
    - Position: {recipe_params['position']}
    - Dose: {recipe_params['dose']}g coffee (WAC maximum: 18g)
    - Water Temperature: {recipe_params['water']['temperature']}°C
    - Total Water Amount: {recipe_params['water']['amount']}g
    - Brew Time: {recipe_params['brew_time']} seconds
    - Grinder: {recipe_params.get('grind', {}).get('grinder', 'standard')}
    - Grind Setting: {recipe_params.get('grind', {}).get('setting', 'medium')}
    - Filter: {recipe_params.get('filter', {}).get('type', 'Paper')} ({recipe_params.get('filter', {}).get('count', 1)})

    Similar Recipes:
    """

        # Add information about similar recipes for the LLM to draw inspiration from
        for i, similar in enumerate(similar_recipes):
            recipe_data = similar['recipe']
            method_steps = recipe_data.get('recipe', {}).get('method', [])
            prompt += f"\nRecipe {i + 1} Method Steps:\n"
            for j, step in enumerate(method_steps):
                prompt += f"{j + 1}. {step}\n"

        # Add specific instructions for logical step generation
        prompt += f"""
    Coffee Type: {coffee_attributes.get('processing', 'Unknown')} {coffee_attributes.get('origin', 'Unknown')}

    Please generate 6-8 logical, sequential steps for brewing with this recipe. The steps should:
    1. Include all necessary actions (heating water, adding coffee, blooming if appropriate, etc.)
    2. Distribute the water logically (if using bloom, specify bloom water amount and remaining water)
    3. Include specific timings that add up to the total brew time ({recipe_params['brew_time']} seconds)
    4. Ensure the steps follow a logical sequence for the {recipe_params['position']} position
    5. Be clear and concise
    6. Be compliant with WAC rules (5-minute time limit, only coffee and water as ingredients)

    Return ONLY the numbered steps, one per line.
    """

        try:
            # Make the LLM call
            response = self.llm_client.chat.completions.create(
                model=self.model_name,
                messages=[
                    {"role": "system",
                     "content": "You are an expert AeroPress barista with deep knowledge of competition recipes."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.4,  # Lower temperature for more consistent results
                max_tokens=500
            )

            # Process the response
            method_text = response.choices[0].message.content.strip()

            # Extract numbered steps
            method_steps = []
            for line in method_text.split('\n'):
                # Remove leading numbers and periods
                cleaned_line = re.sub(r'^\d+\.\s*', '', line.strip())
                if cleaned_line:
                    method_steps.append(cleaned_line)

            # Add WAC compliance reminder if not already included
            if not any('5-minute' in step or 'time limit' in step for step in method_steps):
                method_steps.append("Complete all steps within the 5-minute competition time limit.")

            return method_steps

        except Exception as e:
            # Fallback to basic method if LLM call fails
            return self._generate_default_method(recipe_params, coffee_attributes)

    def _adapt_method_steps(self, original_steps, recipe_params, coffee_attributes):
        """Adapt method steps to match the new recipe parameters and WAC rules"""
        if not original_steps:
            return self._generate_default_method(recipe_params, coffee_attributes)

        # Copy steps but update any numbers/parameters
        adapted_steps = []
        for step in original_steps:
            # Replace dose mentions
            step = re.sub(r'(\d+(?:\.\d+)?)\s*g(?:rams)? (?:of )?coffee',
                          f"{recipe_params['dose']}g coffee", step)

            # Replace temperature mentions
            step = re.sub(r'(\d+(?:\.\d+)?)\s*°C',
                          f"{recipe_params['water']['temperature']}°C", step)

            # Replace water amount mentions
            step = re.sub(r'(\d+(?:\.\d+)?)\s*(?:g|ml|grams|milliliters) (?:of )?water',
                          f"{recipe_params['water']['amount']}g water", step)

            adapted_steps.append(step)

        # Add bypass water step if needed for WAC compliance
        if 'bypass' in recipe_params and recipe_params['bypass']['amount'] > 0:
            adapted_steps.append(
                f"Add {recipe_params['bypass']['amount']}g of {recipe_params['bypass']['temperature']} "
                f"water to reach the required {self.wac_rules['min_brew_output']}g output."
            )

        # Ensure total steps don't exceed 5-minute limit
        if len(adapted_steps) > 10:  # If too many steps, might exceed time limit
            adapted_steps = adapted_steps[:8]
            if 'bypass' in recipe_params and recipe_params['bypass']['amount'] > 0:
                adapted_steps.append(
                    f"Add {recipe_params['bypass']['amount']}g of {recipe_params['bypass']['temperature']} water."
                )

        # Add timing note for WAC compliance
        adapted_steps.append(f"Complete all steps within the 5-minute competition time limit.")

        return adapted_steps

    def _generate_default_method(self, recipe_params, coffee_attributes):
        """Generate default WAC-compliant method steps if original steps not available"""
        if recipe_params['position'] == 'inverted':
            steps = [
                f"Place the AeroPress in inverted position and add {recipe_params['dose']}g coffee",
                f"Add {recipe_params['dose'] * 3}g water at {recipe_params['water']['temperature']}°C and stir gently",
                f"Wait 30 seconds for blooming",
                f"Add remaining water to reach {recipe_params['water']['amount']}g total",
                f"Attach filter cap with rinsed filter",
                f"At 1:00, flip AeroPress and press gently for 30 seconds",
            ]
        else:
            steps = [
                f"Place filter in cap, rinse with hot water, and attach to AeroPress",
                f"Add {recipe_params['dose']}g coffee to AeroPress",
                f"Add {recipe_params['dose'] * 2}g water at {recipe_params['water']['temperature']}°C",
                f"Stir gently 5 times and wait 30 seconds",
                f"Add remaining water to reach {recipe_params['water']['amount']}g total",
                f"Insert plunger, wait until 1:00, then press gently for 30 seconds",
            ]

        # Add bypass water step if needed for WAC compliance
        if 'bypass' in recipe_params and recipe_params['bypass']['amount'] > 0:
            steps.append(
                f"Add {recipe_params['bypass']['amount']}g of {recipe_params['bypass']['temperature']} "
                f"water to reach the required {self.wac_rules['min_brew_output']}g output"
            )

        steps.append(
            f"Enjoy your {coffee_attributes.get('origin', '')} {coffee_attributes.get('processing', '')} coffee!")
        steps.append(f"Complete all steps within the 5-minute competition time limit.")

        return steps

    def generate_explanation(self, recipe, similar_recipes, confidence_data, coffee_attributes, suggested_attributes):
        """Generate detailed explanation using LLM"""
        prompt = self._create_explanation_prompt(recipe, similar_recipes,
                                                 confidence_data, coffee_attributes, suggested_attributes)

        try:
            response = self.llm_client.chat.completions.create(
                model=self.model_name,
                messages=[
                    {"role": "system", "content": self._get_system_prompt()},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.7,
                max_tokens=1200
            )

            return response.choices[0].message.content
        except Exception as e:
            # Fallback explanation if API fails
            return self._generate_fallback_explanation(
                recipe, similar_recipes, confidence_data, coffee_attributes)

    def _create_explanation_prompt(self, recipe, similar_recipes, confidence_data, coffee_attributes,
                                   suggested_attributes=None):
        """Create detailed prompt for explanation generation with WAC rules emphasis, similarity insights, and confidence data"""
        original_origin = coffee_attributes.get('origin', '')
        original_processing = coffee_attributes.get('processing', '')

        # Determine if we're using original or suggested attributes for clarity
        using_origin = original_origin
        using_processing = original_processing

        # Build similarity explanations if applicable
        similarity_text = ""
        if suggested_attributes:
            similarity_text = "\n\nSimilarity Insights:\n"

            # Explain origin similarity
            if 'origin' in suggested_attributes:
                suggested_origin = suggested_attributes['origin']['term']
                similarity_score = suggested_attributes['origin']['similarity']
                using_origin = suggested_origin

                similarity_text += f"- Original origin '{original_origin}' was matched to '{suggested_origin}' (similarity: {similarity_score:.2f})\n"

                if 'similar_origins' in suggested_attributes:
                    similarity_text += "  Other similar origins include: "
                    similarity_text += ", ".join([f"{o['term']} ({o['similarity']:.2f})"
                                                  for o in suggested_attributes['similar_origins']])
                    similarity_text += "\n"

            # Explain processing similarity
            if 'processing' in suggested_attributes:
                suggested_processing = suggested_attributes['processing']['term']
                similarity_score = suggested_attributes['processing']['similarity']
                using_processing = suggested_processing

                similarity_text += f"- Original processing '{original_processing}' was matched to '{suggested_processing}' (similarity: {similarity_score:.2f})\n"

                if 'similar_processes' in suggested_attributes:
                    similarity_text += "  Other similar processing methods include: "
                    similarity_text += ", ".join([f"{p['term']} ({p['similarity']:.2f})"
                                                  for p in suggested_attributes['similar_processes']])
                    similarity_text += "\n"

            # Explain variety similarity if present
            if 'variety' in suggested_attributes:
                original_variety = coffee_attributes.get('variety', '')
                suggested_variety = suggested_attributes['variety']['term']
                similarity_score = suggested_attributes['variety']['similarity']

                similarity_text += f"- Original variety '{original_variety}' was matched to '{suggested_variety}' (similarity: {similarity_score:.2f})\n"

                if 'similar_varieties' in suggested_attributes:
                    similarity_text += "  Other similar varieties include: "
                    similarity_text += ", ".join([f"{v['term']} ({v['similarity']:.2f})"
                                                  for v in suggested_attributes['similar_varieties']])
                    similarity_text += "\n"

        # Build confidence data explanation
        confidence_text = "\n\nConfidence Metrics:\n"
        confidence_text += f"- Overall Confidence: {confidence_data['overall']:.2f}\n"

        if 'similarity' in confidence_data:
            confidence_text += f"- Similarity Score: {confidence_data['similarity']:.2f}\n"

        if 'processing_match' in confidence_data:
            confidence_text += f"- Processing Match Confidence: {confidence_data['processing_match']:.2f}\n"

        if 'placement_boost' in confidence_data:
            confidence_text += f"- Championship Placement Boost: {confidence_data['placement_boost']:.2f}\n"

        # Add parameter-specific confidence information
        if 'parameters' in confidence_data:
            confidence_text += "- Parameter-specific confidence:\n"
            for param, param_data in confidence_data['parameters'].items():
                if 'confidence' in param_data:
                    confidence_text += f"  * {param.capitalize()}: {param_data['confidence']:.2f}"

                    if 'value' in param_data:
                        confidence_text += f" (value: {param_data['value']})"

                    if 'min' in param_data and 'max' in param_data:
                        confidence_text += f" (range: {param_data['min']} - {param_data['max']})"

                    confidence_text += "\n"

        prompt = f"""Generate an expert explanation for this WAC-compliant AeroPress recipe for {using_origin} 
    {using_processing} coffee.

    This recipe is based on a carefully curated dataset of 51 World AeroPress Championship recipes from 
    champions and finalists. These are proven, competition-winning recipes from the best AeroPress brewers 
    in the world. The recipe is fully compliant with World AeroPress Championship rules, which limit coffee dose 
    to 18g maximum and require a minimum of 150g output.

    Recipe Parameters:
    - Position: {recipe['position']}
    - Dose: {recipe['dose']}g (WAC maximum: 18g)
    - Water Temperature: {recipe['water']['temperature']}°C
    - Water Amount: {recipe['water']['amount']}ml
    - Total Output: {recipe['water']['amount'] + recipe.get('bypass', {}).get('amount', 0)}ml (WAC minimum: 150ml)
    - Brew Time: {recipe['brew_time']} seconds (Under WAC 5-minute limit)
    - Filter: {recipe['filter']['type']} ({recipe['filter']['count']}, {recipe['filter']['preparation']})

    Top 3 Similar Championship Recipes:
    """

        for i, similar in enumerate(similar_recipes[:3], 1):
            recipe_data = similar['recipe']
            params = recipe_data.get('recipe', {})
            coffee = recipe_data.get('coffee', {})

            prompt += f"""
    Recipe {i}: {recipe_data.get('competitor_name')} ({recipe_data.get('year')}, {recipe_data.get('placement')})
    - Coffee: {coffee.get('origin', 'Unknown')}, {coffee.get('processing', 'Unknown')}
    - Position: {params.get('position', 'Unknown')}
    - Dose: {params.get('dose', 'Unknown')}g
    - Temperature: {params.get('water', {}).get('temperature', 'Unknown')}°C
    - Water: {params.get('water', {}).get('amount', 'Unknown')}ml
    - Brew Time: {params.get('brew_time', 'Unknown')} seconds
    - Similarity Score: {similar.get('similarity', 0):.2f}
    """

        # Add confidence information
        prompt += confidence_text

        # Add similarity information if available
        if similarity_text:
            prompt += similarity_text
            prompt += """
    The recipe was generated using similarity-based matching since direct matches weren't available in the championship database. 
    Please explain how the recipe takes into account both the original coffee attributes and the championship-proven 
    techniques for similar coffee types.
    """

        prompt += f"""
    Please explain in detail:
    1. Why this recipe is well-suited for {original_processing} {original_origin} coffee
    2. Which championship techniques were incorporated and why
    3. How each parameter specifically enhances this coffee's characteristics
    4. What flavor profile this recipe aims to highlight
    5. How the recipe complies with WAC competition rules
    6. Any special techniques that improve extraction quality
    7. How the confidence data influenced the parameter choices
    """

        # If we used similarity-based matching, add extra instruction
        if similarity_text:
            prompt += f"""
    8. How the similarities between {original_origin}/{using_origin} and {original_processing}/{using_processing} 
       influenced the recipe choices
    9. Which aspects of the recipe would be the same regardless of the specific origin/processing, and which 
       were specifically adapted based on the similarity analysis
    """

        prompt += """
    The explanation should emphasize the championship pedigree of the recipe and how it's been optimized
    for this specific coffee type while maintaining full WAC competition compliance. Be sure to reference 
    the confidence metrics when explaining why certain parameters were chosen.
    """
        return prompt

    def _generate_fallback_explanation(self, recipe, similar_recipes, confidence_data, coffee_attributes,
                                       suggested_attributes=None):
        """Generate a fallback explanation if LLM fails, incorporating similarity insights and confidence data"""
        top_recipe = similar_recipes[0]['recipe'] if similar_recipes else {}
        top_champion = top_recipe.get('competitor_name', 'a World AeroPress Champion')
        top_year = top_recipe.get('year', '')

        # Determine which attributes we're using (original or suggested)
        using_origin = coffee_attributes.get('origin', '')
        using_processing = coffee_attributes.get('processing', '')

        # Add information about similarity matches if applicable
        similarity_note = ""
        if suggested_attributes:
            if 'origin' in suggested_attributes:
                original_origin = coffee_attributes.get('origin', '')
                using_origin = suggested_attributes['origin']['term']
                similarity = suggested_attributes['origin']['similarity']
                similarity_note += f"\n\nYour {original_origin} coffee was matched with championship recipes for {using_origin} based on flavor profile similarities (similarity score: {similarity:.2f})."

            if 'processing' in suggested_attributes:
                original_processing = coffee_attributes.get('processing', '')
                using_processing = suggested_attributes['processing']['term']
                similarity = suggested_attributes['processing']['similarity']
                similarity_note += f"\n\nYour {original_processing} processing was matched with championship recipes for {using_processing} processed coffees based on extraction characteristic similarities (similarity score: {similarity:.2f})."

        # Add confidence information
        confidence_note = ""
        if confidence_data:
            confidence_note = f"\n\n## Confidence Analysis\n\nThis recipe achieves an overall confidence score of {confidence_data['overall']:.2f}, indicating a strong match with championship recipes."

            # Add more detailed confidence information
            if 'processing_match' in confidence_data and confidence_data['processing_match'] > 0.6:
                confidence_note += f"\n\nThe processing method match was particularly strong ({confidence_data['processing_match']:.2f}), indicating that this recipe is well-aligned with champion recipes for {using_processing} coffees."

            if 'parameters' in confidence_data:
                high_confidence_params = [k for k, v in confidence_data.get('parameters', {}).items()
                                          if v.get('confidence', 0) > 0.7]
                if high_confidence_params:
                    confidence_note += f"\n\nParameters with high confidence: {', '.join(high_confidence_params)}."

        explanation = f"""# Expert WAC-Compliant AeroPress Recipe for {coffee_attributes.get('origin', '')} {coffee_attributes.get('processing', '')} Coffee

    This recipe is optimized for your {coffee_attributes.get('processing', '')} {coffee_attributes.get('origin', '')} coffee, 
    drawing inspiration from {top_champion}'s {top_year} championship technique, while ensuring full 
    compliance with World AeroPress Championship rules.{similarity_note}

    ## WAC Compliance Features

    This recipe uses exactly {recipe['dose']}g of coffee (within the WAC 18g maximum) and produces 
    {recipe['water']['amount'] + recipe.get('bypass', {}).get('amount', 0)}ml of brewed coffee 
    (above the WAC 150ml minimum requirement). All steps can be completed within the 5-minute time limit.

    ## Why These Parameters Work Well

    The {recipe['position']} position provides optimal extraction control for {coffee_attributes.get('processing', '')} coffees. 
    The {recipe['water']['temperature']}°C water temperature is specifically calibrated to highlight the classic 
    characteristics of {coffee_attributes.get('origin', '')} coffees.

    A {recipe['dose']}g dose with {recipe['water']['amount']}ml of water creates an ideal brewing ratio that 
    balances extraction and strength.{confidence_note}

    Follow the method steps precisely for best results and competition success."""

        return explanation

    def _get_system_prompt(self):
        """System prompt for the LLM with WAC rules emphasis"""
        return """You are an expert AeroPress barista and coffee consultant with extensive knowledge 
        of competition brewing techniques. You excel at explaining why specific brewing parameters 
        are chosen for different coffees based on their characteristics. Focus on the relationships 
        between brewing parameters and coffee attributes like processing method, origin, and variety. 
        Your explanations should be detailed, educational, and highlight the championship pedigree 
        of the brewing techniques used.

        You have deep knowledge of the World AeroPress Championship (WAC) rules, which include:
        - Maximum 18g coffee dose
        - Minimum 150g brewed coffee output
        - 5-minute time limit
        - Only water and coffee as ingredients (no additives)
        - Only genuine AeroPress Original or AeroPress Clear can be used

        Highlight how recipes comply with these rules while maximizing flavor extraction."""

    def _generate_fallback_explanation(self, recipe, similar_recipes, confidence_data, coffee_attributes,
                                       suggested_attributes=None):
        """Generate a fallback explanation if LLM fails, incorporating similarity insights"""
        top_recipe = similar_recipes[0]['recipe'] if similar_recipes else {}
        top_champion = top_recipe.get('competitor_name', 'a World AeroPress Champion')
        top_year = top_recipe.get('year', '')

        # Determine which attributes we're using (original or suggested)
        using_origin = coffee_attributes.get('origin', '')
        using_processing = coffee_attributes.get('processing', '')

        # Add information about similarity matches if applicable
        similarity_note = ""
        if suggested_attributes:
            if 'origin' in suggested_attributes:
                original_origin = coffee_attributes.get('origin', '')
                using_origin = suggested_attributes['origin']['term']
                similarity_note += f"\n\nYour {original_origin} coffee was matched with championship recipes for {using_origin} based on flavor profile similarities."

            if 'processing' in suggested_attributes:
                original_processing = coffee_attributes.get('processing', '')
                using_processing = suggested_attributes['processing']['term']
                similarity_note += f"\n\nYour {original_processing} processing was matched with championship recipes for {using_processing} processed coffees based on extraction characteristic similarities."

        explanation = f"""# Expert WAC-Compliant AeroPress Recipe for {coffee_attributes.get('origin', '')} {coffee_attributes.get('processing', '')} Coffee

    This recipe is optimized for your {coffee_attributes.get('processing', '')} {coffee_attributes.get('origin', '')} coffee, 
    drawing inspiration from {top_champion}'s {top_year} championship technique, while ensuring full 
    compliance with World AeroPress Championship rules.{similarity_note}

    ## WAC Compliance Features

    This recipe uses exactly {recipe['dose']}g of coffee (within the WAC 18g maximum) and produces 
    {recipe['water']['amount'] + recipe.get('bypass', {}).get('amount', 0)}ml of brewed coffee 
    (above the WAC 150ml minimum requirement). All steps can be completed within the 5-minute time limit.

    ## Why These Parameters Work Well

    The {recipe['position']} position provides optimal extraction control for {coffee_attributes.get('processing', '')} coffees. 
    The {recipe['water']['temperature']}°C water temperature is specifically calibrated to highlight the classic 
    characteristics of {coffee_attributes.get('origin', '')} coffees.

    A {recipe['dose']}g dose with {recipe['water']['amount']}ml of water creates an ideal brewing ratio that 
    balances extraction and strength.

    This recipe achieves a confidence score of {confidence_data['overall']:.2f}, with particularly 
    strong confidence in the {', '.join([k for k, v in confidence_data.get('parameters', {}).items()
                                         if v.get('confidence', 0) > 0.7])} parameters.

    Follow the method steps precisely for best results and competition success."""

        return explanation

    def evaluate_recipe_accuracy(self, recipe, similar_recipes, coffee_attributes):
        """Evaluate accuracy with emphasis on processing method match and WAC compliance"""
        # 1. Processing method match (most important in small datasets)
        processing_match = 0.0
        query_processing = coffee_attributes.get('processing', '').lower()

        if query_processing:
            for recipe_data in similar_recipes[:3]:
                recipe_similar = recipe_data['recipe']
                if processing := recipe_similar.get('coffee', {}).get('processing', ''):
                    if processing.lower() == query_processing:
                        processing_match += 0.25

        # 2. Origin match
        origin_match = 0.0
        query_origin = coffee_attributes.get('origin', '')

        if query_origin:
            for recipe_data in similar_recipes[:3]:
                recipe_similar = recipe_data['recipe']
                if similar_recipe_origin := recipe_similar.get('coffee', {}).get('origin', ''):
                    if similar_recipe_origin.lower() == query_origin.lower():
                        origin_match += 0.25

        # 3. Parameter transfer accuracy
        param_accuracy = 0.0
        top_recipe = similar_recipes[0]['recipe'].get('recipe', {})

        # Compare key parameters with the most similar recipe
        if abs(recipe['dose'] - top_recipe.get('dose', 18)) / top_recipe.get('dose', 18) < 0.1:
            param_accuracy += 0.1

        if abs(recipe['water']['temperature'] - top_recipe.get('water', {}).get('temperature', 90)) < 3:
            param_accuracy += 0.1

        if recipe['position'] == top_recipe.get('position', 'inverted'):
            param_accuracy += 0.1

        # 4. Championship influence
        championship_influence = 0.0
        for i, recipe_data in enumerate(similar_recipes[:3]):
            placement = recipe_data['recipe'].get('placement', '')
            if placement == '1st':
                championship_influence += 0.25 / (i + 1)
            elif placement == '2nd':
                championship_influence += 0.15 / (i + 1)
            elif placement == '3rd':
                championship_influence += 0.10 / (i + 1)

        # 5. WAC compliance rating
        wac_compliance = 0.0

        # Check dose compliance (most important)
        if recipe['dose'] <= self.wac_rules["max_coffee_dose"]:
            wac_compliance += 0.4

        # Check output amount
        total_output = recipe['water']['amount'] + recipe.get('bypass', {}).get('amount', 0)
        if total_output >= self.wac_rules["min_brew_output"]:
            wac_compliance += 0.3

        # Check time compliance
        if recipe['total_time'] <= self.wac_rules["max_time"]:
            wac_compliance += 0.2

        # Check ingredients compliance
        ingredients_compliant = True
        for step in recipe['method']:
            for ingredient in ["milk", "sugar", "syrup", "flavoring"]:
                if ingredient in step.lower():
                    ingredients_compliant = False
                    break

        if ingredients_compliant:
            wac_compliance += 0.1

        # Calculate overall accuracy with WAC compliance
        overall_accuracy = (
                0.25 * processing_match +  # Processing match
                0.15 * origin_match +
                0.15 * param_accuracy +
                0.15 * championship_influence +
                0.30 * wac_compliance  # WAC compliance now weighs heavily
        )

        return {
            "overall": min(1.0, overall_accuracy),
            "processing_match": processing_match,
            "origin_match": origin_match,
            "parameter_accuracy": param_accuracy,
            "championship_influence": championship_influence,
            "wac_compliance": wac_compliance
        }

if __name__ == "__main__":
    rag = CompactAeropressRAG(recipe_database_path="dataset.json")
    origin = "Kenya"
    process = "washed"
    recipe = rag.generate_recipe({
        "origin": origin,
        "processing": process
    })
    with open(f"{origin}_{process}_recipe_{datetime.now().strftime('%d_%m_%y_%H_%M')}.json", "w") as f:
        json.dump(recipe, f, indent=4)