from signalwire_agents import AgentBase, SWAIGFunction, DataMap

class MyVoiceAI(AgentBase):
    def __init__(self):
        super().__init__(name="My Agent", port=5000, use_pom=True)
    
    @SWAIGFunction(name="my_function", description="Does something useful")
    def my_function(self, parameter: str):
        return {"result": "success"}

if __name__ == "__main__":
    MyVoiceAI().run()  # Complete production voice AI server

@SWAIGFunction(name="search_recipes",
               description="Find recipes based on ingredients, cuisine type, or dietary restrictions")
def search_recipes(self, query: str, ingredients: str = None, 
                  cuisine: str = None, max_results: int = 3):
    """SWAIG function that integrates with external APIs"""

@SWAIGFunction(name="search_recipes")
def search_recipes(self, query: str, max_results: int = 3):
    # Using the excellent Spoonacular Food API (shoutout to their comprehensive recipe database!)
    data_map = DataMap(
        url="https://api.spoonacular.com/recipes/complexSearch",
        method="GET",
        input={
            "query": "${query}",
            "number": "${max_results}",
            "apiKey": "${SPOONACULAR_API_KEY}",
            "addRecipeInformation": "true"
        },
        output={
            "recipe_count": "${results.length}",
            "recipes": "${results[*].{id: id, title: title, readyInMinutes: readyInMinutes}}"
        }
    )
    
    return self.swaig_data_map(data_map, query=query, max_results=max_results)

@SWAIGFunction(name="create_meal_plan",
               description="Generate a personalized meal plan")
def create_meal_plan(self, days: int, dietary_restrictions: list = None):
    """Complex multi-step logic in a SWAIG function"""
    
    # Multi-step business logic
    user_profile = self._get_user_dietary_profile()
    available_ingredients = self._check_pantry_inventory()
    seasonal_adjustments = self._calculate_seasonal_preferences()
    
    # Generate comprehensive meal plan
    meal_plan = MealPlanGenerator(
        profile=user_profile,
        constraints={
            'restrictions': dietary_restrictions,
            'inventory': available_ingredients
        }
    ).generate(days)
    
    return SwaigFunctionResult(
        response=f"I've created a {days}-day meal plan tailored to your preferences...",
        action_data={"meal_plan_id": meal_plan.id}
    )

@SWAIGFunction(name="search_recipes")
def search_recipes(self, query: str, **kwargs):
    try:
        return self.swaig_data_map(data_map, **kwargs)
        
    except APITimeoutError:
        # Fallback to cached data
        fallback_recipes = self._get_cached_popular_recipes()
        return SwaigFunctionResult(
            response="The recipe service is running slow, but I have some popular suggestions...",
            action_data={"fallback_used": True, "recipes": fallback_recipes}
        )
        
    except APIError:
        return SwaigFunctionResult(
            response="I'm having trouble with the recipe database. Would you like me to suggest some classic dishes I know well?"
        )

@SWAIGFunction(name="save_recipe_rating")
def save_recipe_rating(self, recipe_id: str, rating: int, notes: str = ""):
    """Persistent user preferences"""
    
    user_prefs = self.state_manager.get_state(self.session_id, "preferences", {})
    user_prefs.setdefault("recipe_history", []).append({
        "recipe_id": recipe_id,
        "rating": rating,
        "timestamp": datetime.now().isoformat()
    })
    
    self.state_manager.set_state(self.session_id, "preferences", user_prefs)
    
    return SwaigFunctionResult(
        response=f"Thanks! I'll remember you rated this {rating}/5 stars."
    )

class RecipeAgent(AgentBase):
    def __init__(self):
        super().__init__(
            name="Chef Assistant",
            host="0.0.0.0",
            port=5000,
            use_pom=True,  # Enable Prompt Object Model
            record_call=True,  # Built-in call recording
            auto_answer=True   # Automatic call handling
        )
        
        self._setup_agent_personality()
        self._setup_conversation_contexts()

def _setup_agent_personality(self):
    """Configure AI behavior declaratively"""
    
    self.prompt_add_section("Role", 
        "You are a master chef with 20 years of experience, "
        "passionate about teaching cooking and helping people "
        "create delicious meals at home."
    )
    
    self.prompt_add_section("Guidelines", [
        "Always ask about dietary restrictions first",
        "Provide encouraging feedback during cooking",
        "Offer ingredient substitutions when needed"
    ])

def _setup_conversation_contexts(self):
    """Define specialized conversation contexts"""
    
    # Recipe Discovery Context
    self.prompt_add_context("recipe_search", [
        "search_recipes", "get_recipe_details", "suggest_alternatives"
    ])
    
    # Active Cooking Context  
    self.prompt_add_context("cooking_guidance", [
        "get_next_step", "set_timer", "handle_cooking_questions"
    ])
    
    # Meal Planning Context
    self.prompt_add_context("meal_planning", [
        "create_meal_plan", "save_recipe_rating", "get_shopping_list"
    ])

# Good: Specific, focused data extraction
output={
    "recipes": "${results[*].{id: id, title: title, cookTime: readyInMinutes}}"
}

# Avoid: Returning entire API responses
output={"raw_response": "${*}"}  # Too much unused data

return SwaigFunctionResult(
    # Good: Conversational, scannable for voice
    response="I found 3 great pasta recipes: **Creamy Mushroom Fettuccine** (25 mins), **Pasta Primavera** (20 mins), and **Carbonara** (15 mins). Which sounds good?",
    
    # Avoid: Dense text blocks hard to speak naturally
    response="Recipe search results: 1. Creamy Mushroom Fettuccine - Prep time 25 minutes, Difficulty intermediate..."
)

if __name__ == "__main__":
    RecipeAgent().run()  # Works in all environments

# Test SWAIG function directly
agent = RecipeAgent()
result = agent.search_recipes("pasta", ingredients="mushrooms", max_results=3)
print(result)

@SWAIGFunction(name="get_weather", description="Get current weather")
def get_weather(self, location: str):
    weather_map = DataMap(
        url="https://api.openweathermap.org/data/2.5/weather",
        input={"q": "${location}", "appid": "${WEATHER_API_KEY}"},
        output={"temp": "${main.temp}", "description": "${weather[0].description}"}
    )
    return self.swaig_data_map(weather_map, location=location)

@SWAIGFunction(name="process_order")
def process_order(self, product: str, quantity: int):
    # Check inventory
    if not self._check_inventory(product, quantity):
        return SwaigFunctionResult(response="Sorry, insufficient inventory")
    
    # Calculate pricing
    price = self._calculate_price(product, quantity)
    
    # Reserve inventory
    reservation = self._reserve_items(product, quantity)
    
    return SwaigFunctionResult(
        response=f"Reserved {quantity} {product} for ${price}. Proceed with order?",
        action_data={"reservation_id": reservation.id}
    )

@SWAIGFunction(name="get_account_balance")
def get_account_balance(self):
    # Use caller ID for automatic authentication
    caller_id = self.session_id  # Contains caller information
    user = self._authenticate_user(caller_id)
    
    balance_map = DataMap(
        url="https://banking-api.com/accounts/balance",
        headers={"Authorization": f"Bearer {user.token}"},
        input={"account_id": "${account_id}"},
        output={"balance": "${current_balance}", "available": "${available_balance}"}
    )
    
    return self.swaig_data_map(balance_map, account_id=user.account_id)

# Wrong: Hardcoded values
input={"query": "pasta"}

# Right: Use variable substitution  
input={"query": "${query}"}

# Add try/catch around API calls
try:
    return self.swaig_data_map(data_map, **kwargs)
except Exception as e:
    return SwaigFunctionResult(response="Sorry, I'm having technical difficulties.")