llm.py

"""
LLM Service for generating marketing content using OpenAI or Azure OpenAI.

This module handles all interactions with the OpenAI/Azure OpenAI API to generate
channel-specific marketing content for events.
"""

import json
import logging
from typing import Dict, Any

from openai import OpenAI, AzureOpenAI
from app.core.config import settings

logger = logging.getLogger(__name__)


def _get_client():
    """Initialize and return the appropriate OpenAI client based on settings."""
    if settings.LLM_PROVIDER == "azure":
        logger.info("Using Azure OpenAI (AI Foundry) client")
        return AzureOpenAI(
            azure_endpoint=settings.AZURE_OPENAI_ENDPOINT,
            api_key=settings.AZURE_OPENAI_API_KEY,
            api_version=settings.AZURE_OPENAI_API_VERSION,
        )
    else:
        logger.info("Using OpenAI client")
        return OpenAI(api_key=settings.OPENAI_API_KEY)


def _get_model():
    """Get the model/deployment name based on provider."""
    if settings.LLM_PROVIDER == "azure":
        return settings.AZURE_OPENAI_DEPLOYMENT
    return "gpt-4o-mini"


client = _get_client()


def generate_marketing_content(
    event_data: Dict[str, Any],
    feedback: str = None,
    previous_content: Dict[str, str] = None,
) -> Dict[str, str]:
    """
    Generate channel-specific marketing content for an event.

    This function takes event details and uses OpenAI's GPT model to generate
    tailored marketing copy for different platforms (Instagram, WhatsApp, Email, etc.)

    Args:
        event_data: Dictionary containing event details:
            - title: Event name
            - description: Event description
            - location: Where the event takes place
            - starts_at: Date/time of the event
            - tone: Desired tone (casual, professional, hype)
            - perks: Any perks/benefits (optional)
            - audience: Target audience (optional)
            - rsvp_link: Registration link (optional)
        feedback: Optional user feedback for regeneration (e.g., "Make it more casual")
        previous_content: Optional previously generated content to refine

    Returns:
        Dictionary with generated content for each channel:
            - instagram: Caption with emojis and hashtags
            - whatsapp: Conversational message
            - email_subject: Email subject line
            - email_body: Email body content
            - engage: Campus engagement platform description
    """

    # Extract event details with defaults for optional fields
    title = event_data.get("title", "")
    description = event_data.get("description", "")
    location = event_data.get("location", "")
    starts_at = event_data.get("starts_at", "")
    tone = event_data.get("tone", "casual")
    perks = event_data.get("perks", "")
    audience = event_data.get("audience", "")
    rsvp_link = event_data.get("rsvp_link", "")

    # Build the prompt for OpenAI
    prompt = f"""You are a marketing copywriter helping a student organization promote their event. Generate channel-specific marketing content that is engaging, concise, and appropriate for each platform.

Event Details:
- Title: {title}
- Description: {description}
- Location: {location}
- Date/Time: {starts_at}
- Tone: {tone}
{f"- Perks: {perks}" if perks else ""}
{f"- Target Audience: {audience}" if audience else ""}
{f"- RSVP Link: {rsvp_link}" if rsvp_link else ""}

Generate content for these channels. Return your response as a valid JSON object with these exact keys:

{{
  "instagram": "Instagram caption with emojis and hashtags (max 300 chars)",
  "whatsapp": "WhatsApp message - conversational and concise (max 200 chars)",
  "email_subject": "Email subject line (max 60 chars)",
  "email_body": "Email body - professional but friendly (max 400 chars)",
  "engage": "Campus engagement platform description - structured and informative (max 300 chars)"
}}

Guidelines:
- Instagram: Use relevant emojis, 3-5 hashtags, engaging hook
- WhatsApp: Casual, conversational, include key details
- Email Subject: Compelling, clear, action-oriented
- Email Body: Structured with greeting, details, and CTA
- Engage: Professional, all key info (what, when, where, why)
- Tone: Adapt to "{tone}" style
- Include RSVP link naturally if provided

Return ONLY the JSON object, no other text."""

    # Add regeneration context if feedback and previous content are provided
    if previous_content and feedback:
        regeneration_context = f"""

---
REGENERATION REQUEST:

Previously Generated Content:
- Instagram: {previous_content.get('instagram', 'N/A')}
- WhatsApp: {previous_content.get('whatsapp', 'N/A')}
- Email Subject: {previous_content.get('email_subject', 'N/A')}
- Email Body: {previous_content.get('email_body', 'N/A')}
- Engage: {previous_content.get('engage', 'N/A')}

User Feedback: {feedback}

Please regenerate ALL content incorporating this feedback. Keep what worked well from the previous version while addressing the user's concerns. Return the complete JSON with all channels updated."""
        prompt += regeneration_context

    try:
        # Call OpenAI/Azure OpenAI API
        response = client.chat.completions.create(
            model=_get_model(),
            messages=[
                {
                    "role": "system",
                    "content": "You are a helpful marketing copywriter. Always respond with valid JSON only.",
                },
                {"role": "user", "content": prompt},
            ],
            max_tokens=1500,
            temperature=0.7,  # Balance creativity and consistency
        )

        # Extract the response text
        response_text = response.choices[0].message.content

        # Parse JSON response
        content = json.loads(response_text)

        return content

    except json.JSONDecodeError as e:
        # If JSON parsing fails, return fallback content
        logger.warning(f"Failed to parse JSON response: {e}")
        logger.debug(f"Response was: {response_text}")
        return {
            "instagram": f"🎉 {title} - {location} - Don't miss out! #event #campus",
            "whatsapp": f"Hey! {title} is happening at {location}. See you there!",
            "email_subject": f"You're Invited: {title}",
            "email_body": f"Join us for {title} at {location}. {description}",
            "engage": f"{title} - {location} - {description}",
        }

    except Exception as e:
        logger.error(f"Error generating content: {e}")
        raise