lambda_function.py

#!/usr/bin/env python3
"""
AWS Lambda function for email automation with SES, S3, and Backend API.
Processes incoming emails, performs lead qualification, and sends automated replies.
This version uses the backend API instead of direct MongoDB connections.
"""

import json
import os
import base64
import boto3
import email
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from typing import Dict, List, Literal, Optional, Any, Union, Tuple
from datetime import datetime, timezone
from dataclasses import dataclass
import re

# Third-party imports
from pydantic import BaseModel, Field
from enum import Enum
from agents import Agent, Runner

# API client
from api_client import (
    APIClient,
    create_api_client,
    convert_lead_to_api_format,
    convert_message_to_api_format,
    convert_deal_to_api_format,
)
from database.models.user import User, UserPreferences, PartnershipPreferences
from database.models.lead import (
    LeadQualificationData,
    LeadStatus,
    LeadDealState,
    ConversationState,
)
from database.models.deal import (
    Deal,
    DealStatus,
    DealType,
    DueDateType,
    Deliverable,
    Contact,
    Brief,
)

# Environment variables
S3_BUCKET = os.environ.get(
    "S3_BUCKET"
)
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
SES_REGION = os.environ.get("SES_REGION", "us-east-2")

# AWS clients
s3_client = boto3.client("s3")
ses_client = boto3.client("ses", region_name=SES_REGION)


# =============================
# Deal/Conversation FSM Helpers
# =============================

def _next_conversation_state_after_parse(lead: LeadQualificationData) -> ConversationState:
    """Decide which conversation state to move to based on lead completeness."""
    missing = set(lead.get_missing_fields())
    # Prioritize by most critical blockers
    if "Budget" in missing:
        return ConversationState.AWAITING_BUDGET
    if "Deliverables" in missing:
        return ConversationState.AWAITING_DELIVERABLES
    if {"Brand Name", "Brand Website", "Brand Category", "Brand Contact Name", "Brand Contact Email"} & missing:
        return ConversationState.AWAITING_DETAILS
    # No critical blockers -> proceed to negotiation/finalization decision later
    return ConversationState.NEGOTIATING_TERMS


async def run_deal_conversation_fsm(
    api_client: APIClient,
    user: User,
    conversation_history: str,
    sender_email: str,
    thread_id: str,
) -> "QAPolisherResponse" | str | None:
    """Compact FSM controlling deal + conversation states per lead/thread.

    Returns either a polished response (QAPolisherResponse), a plain string response,
    or None (no reply to send).
    """

    # 1) Ensure or create lead for this thread (classification gates this below)
    existing_lead = await get_lead_by_thread_id(api_client, thread_id)

    # If no existing lead, classify first to decide if we should even create a lead
    if not existing_lead:
        filter_input = f"""
CONVERSATION HISTORY:
{conversation_history}

Classify this email conversation into one of the three categories and provide the appropriate subcategory.
"""
        filter_result = await Runner.run(deal_filter_agent, filter_input)
        filter_response = filter_result.final_output_as(DealFilterResponse)

        if filter_response.classification != "Sponsorship" or filter_response.confidence < 0.75:
            # Non-sponsorship → standard response
            return (
                "Thank you for reaching out! This message appears to be outside the scope of business partnership inquiries that I can assist with. If you have a collaboration or partnership proposal, please feel free to send those details and I'll be happy to help connect you with the right person."
            )

        # Create initial lead with default FSM states
        created_lead = await create_lead(api_client, sender_email, thread_id, user.uuid)
        if not created_lead:
            return "I apologize, but there was an issue processing your request. Please try again."
        existing_lead = created_lead

    # Normalize into model
    lead_model = LeadQualificationData.model_validate(existing_lead)

    # 2) Conversation state selection and agent invocation
    # For NEW_INQUIRY/INITIAL_OUTREACH, parse and gather info first
    if lead_model.deal_state in {LeadDealState.NEW_INQUIRY, LeadDealState.INFO_GATHERING}:
        parser_input = f"""
EXISTING LEAD INFORMATION, ANY FIELD THAT IS RELATED TO LEAD QUALIFICATION AND IS NULL IS UNKNOWN:
{existing_lead}

CONVERSATION HISTORY:
{conversation_history}

Extract and update comprehensive structured deal information from this sponsorship opportunity conversation.
Build upon existing information and extract ALL possible fields mentioned or implied.
"""
        parser_result = await Runner.run(deal_parser_agent, parser_input)
        parser_response = parser_result.final_output_as(LeadQualificationData)

        # Update lead with parsed information
        updated_lead_dict = await update_lead(api_client, existing_lead.get("_id"), thread_id, parser_response)
        if not updated_lead_dict:
            return "I apologize, but there was an issue processing your request. Please try again."

        lead_model = LeadQualificationData.model_validate(updated_lead_dict)
        # Transition conversation state based on missing fields
        next_conv = _next_conversation_state_after_parse(lead_model)
        new_deal_state = LeadDealState.INFO_GATHERING if next_conv in {
            ConversationState.AWAITING_DETAILS,
            ConversationState.AWAITING_BUDGET,
            ConversationState.AWAITING_DELIVERABLES,
        } else LeadDealState.EVALUATING

        # Persist FSM states
        lead_model.conversation_state = next_conv
        lead_model.deal_state = new_deal_state
        await update_lead(api_client, existing_lead.get("_id"), thread_id, lead_model)

        # Prepare targeted prompt asking for missing info (if needed)
        if new_deal_state == LeadDealState.INFO_GATHERING:
            missing = ", ".join(lead_model.get_missing_fields())
            draft = (
                f"Thanks for reaching out! To move forward, could you please share: {missing}? This will help us confirm scope and next steps."
            )
            polisher_input = f"""
DRAFT RESPONSE TO POLISH:
{draft}

CONTEXT: 
- Recommendation: CONTINUE
- Tone: professional
- Key Messages: requesting missing details

REQUIREMENTS:
- Keep under 125 words
- Maintain the professional tone
- Ensure professional talent agent voice
- No email signature at the end of the response
"""
            polished = await Runner.run(qa_polisher_agent, polisher_input)
            return polished.final_output_as(QAPolisherResponse)

    # 3) Evaluation / Negotiation phase
    if lead_model.deal_state in {LeadDealState.EVALUATING, LeadDealState.NEGOTIATING}:
        # Build preference evaluation input
        creator_name = user.profile.name or "our creator"
        prefs = user.preferences
        platform_context = ""
        if user.platforms:
            primary_platforms = [
                p.platformType.value.title() for p in user.platforms[:3] if p.isActive
            ]
            if primary_platforms:
                platform_context = f"Primary Platforms: {', '.join(primary_platforms)}"

        preference_input = f"""
COMPREHENSIVE LEAD INFORMATION:
{lead_model.model_dump_json(indent=2)}

MISSING FIELDS:
{', '.join(lead_model.get_missing_fields())}

CREATOR PREFERENCES:
- Name: {creator_name}
- Minimum Rate: ${prefs.absoluteMinimumRate}
- Auto-Reject Categories: {', '.join(prefs.autoRejectCategories)}
- Partnership Types: Flat Rate: {prefs.partnershipTypes.flatRate}, Affiliate: {prefs.partnershipTypes.affiliate}, Performance Hybrid: {prefs.partnershipTypes.performanceHybrid}
- {platform_context}

CONVERSATION HISTORY:
{conversation_history}
"""
        pref_result = await Runner.run(comprehensive_preference_agent, preference_input)
        pref = pref_result.final_output_as(PreferenceEvaluationDraftResponse)

        # Map recommendation to deal state and actions
        if pref.recommendation == "REJECT":
            lead_model.deal_state = LeadDealState.REJECTED
            lead_model.conversation_state = ConversationState.CLOSED
            await update_lead(api_client, existing_lead.get("_id"), thread_id, lead_model)
            # Send polite decline
            polisher_input = f"""
DRAFT RESPONSE TO POLISH:
{pref.draft_response}

CONTEXT: 
- Recommendation: REJECT
- Tone: {pref.communication_tone}
- Key Messages: {', '.join(pref.key_messages)}
"""
            polished = await Runner.run(qa_polisher_agent, polisher_input)
            return polished.final_output_as(QAPolisherResponse)

        if pref.recommendation == "NEGOTIATE":
            lead_model.deal_state = LeadDealState.NEGOTIATING
            lead_model.conversation_state = ConversationState.NEGOTIATING_TERMS
            await update_lead(api_client, existing_lead.get("_id"), thread_id, lead_model)
            polisher_input = f"""
DRAFT RESPONSE TO POLISH:
{pref.draft_response}

CONTEXT: 
- Recommendation: NEGOTIATE
- Tone: {pref.communication_tone}
- Key Messages: {', '.join(pref.key_messages)}
"""
            polished = await Runner.run(qa_polisher_agent, polisher_input)
            return polished.final_output_as(QAPolisherResponse)

        # CONTINUE → if qualifies, create deal and finalize; else ask for missing info
        qualified = check_qualification_criteria(lead_model, user.preferences)
        if qualified:
            deal_id = await create_deal_from_qualified_lead(api_client, lead_model)
            if deal_id:
                # Ensure conversation exists for this deal and thread
                try:
                    await api_client.create_conversation_for_deal(deal_id, thread_id)
                except Exception:
                    pass
                lead_model.deal_state = LeadDealState.ACCEPTED
                lead_model.conversation_state = ConversationState.FINALIZING
                await update_lead(api_client, existing_lead.get("_id"), thread_id, lead_model)
                return "Thanks for working with Repflow! We'll get back to you soon."
        # Not yet qualified → request missing info
        missing = ", ".join(lead_model.get_missing_fields())
        draft = (
            f"Appreciate the details so far. To keep things moving, could you confirm: {missing}? This will let us lock scope and next steps."
        )
        polisher_input = f"""
DRAFT RESPONSE TO POLISH:
{draft}

CONTEXT: 
- Recommendation: CONTINUE
- Tone: professional
- Key Messages: requesting missing details
"""
        polished = await Runner.run(qa_polisher_agent, polisher_input)
        return polished.final_output_as(QAPolisherResponse)

    # Default: no action
    return None

# Models and Enums (same as original)
class DealFilterResponse(BaseModel):
    """Response from the Deal Filter Agent."""

    classification: str = Field(
        ..., description="Sponsorship | Non-Sponsorship | Other"
    )
    subcategory: str = Field(
        ...,
        description="Specific subcategory like flat, affiliate, hybrid, gifting, ugc, event, press, recruiting, spam, etc.",
    )
    confidence: float = Field(
        ..., description="Confidence score for the classification (0-1)"
    )


class PreferenceEvaluationDraftResponse(BaseModel):
    """Expansive response from the Preference Evaluation Agent."""

    # Preference evaluation
    recommendation: Literal[
        "CONTINUE",
        "NEGOTIATE",
        "REJECT",
    ] = Field(..., description="CONTINUE, NEGOTIATE, REJECT")

    # Communication strategy
    communication_tone: str = Field(
        default="professional",
        description="Recommended tone: professional, warm, firm, etc.",
    )
    key_messages: List[str] = Field(
        default=[], description="Key messages to convey in response"
    )
    draft_response: str = Field(
        ..., description="Complete draft response based on recommendation"
    )


class QAPolisherResponse(BaseModel):
    """Response from the QA/Talent Agent Polisher."""

    polished_reply: str = Field(
        ..., description="Final polished email text under 125 words"
    )
    should_send: bool = Field(
        default=True, description="Whether the email should be sent"
    )


@dataclass
class EmailEvent:
    """Parsed email event from SES."""

    message_id: str
    thread_id: str
    sender_email: str
    recipient_email: str
    subject: str
    content: str
    timestamp: datetime
    s3_bucket: str
    s3_key: str


# Database Operations via API
async def get_lead_by_thread_id(api_client, thread_id: str) -> Optional[Dict]:
    """Get lead qualification data by thread ID."""
    try:
        lead = await api_client.get_lead_by_thread_id(thread_id)
        if lead:
            print(f"Retrieved lead with ID: {lead.get('_id')}")
        return lead
    except Exception as e:
        print(f"Error fetching lead by thread_id {thread_id}: {e}")
        return None


async def create_lead(
    api_client: APIClient, email: str, thread_id: str, userId: str
) -> Optional[Dict]:
    """Create a new lead qualification record."""
    try:
        now = datetime.now(timezone.utc)
        lead_data = {
            "email": email,
            "thread_id": thread_id,
            "userId": userId,
            "status": "new",
            # FSM initial states
            "deal_state": LeadDealState.NEW_INQUIRY.value,
            "conversation_state": ConversationState.INITIAL_OUTREACH.value,
            "created_at": now,
            "updated_at": now,
        }

        lead_data = convert_lead_to_api_format(lead_data)
        lead = await api_client.create_lead(lead_data)
        print(f"Created lead with ID: {lead.get('_id')}")
        return lead
    except Exception as e:
        print(f"Error creating lead: {e}")
        return None


async def update_lead(
    api_client: APIClient, leadID: str, thread_id: str, leadData: LeadQualificationData
) -> dict | None:
    """Update lead qualification data."""
    try:
        lead_id = leadID
        if not lead_id:
            print("ERROR: Lead missing ID field")
            return None

        print(f"Updating lead {lead_id}")

        leadData.thread_id = thread_id

        # Convert datetime fields
        update_data = convert_lead_to_api_format(leadData.model_dump())
        updated_lead = await api_client.update_lead(lead_id, update_data)

        return updated_lead

    except Exception as e:
        print(f"Error updating lead: {e}")
        return None


async def mark_lead_qualified(api_client, thread_id: str) -> bool:
    """Mark a lead as qualified."""
    try:
        lead = await api_client.mark_lead_qualified(thread_id)
        if lead:
            print(f"Marked lead as qualified for thread {thread_id}")
            return True
        return False
    except Exception as e:
        print(f"Error marking lead qualified: {e}")
        return False


def check_qualification_criteria(
    lead: LeadQualificationData, preferences: UserPreferences
) -> bool:
    """
    Check if the lead passes qualification criteria for deal creation.

    Validates:
    1. Required fields for deal creation (brand_name, brand_category, budget, deliverables)
    2. Budget meets minimum rate requirement
    3. Brand category not in auto-reject list
    4. Partnership type compatibility with user preferences
    5. Contact information availability
    6. Field quality validation (minimum lengths, etc.)

    Args:
        lead: Dictionary containing lead information
        preferences: User preferences for filtering leads

    Returns:
        bool: True if lead passes all qualification criteria, False otherwise
    """
    try:
        # 1. Check required fields for deal creation
        missing_fields = lead.get_missing_fields()
        if len(missing_fields) > 0:
            print(f"QUALIFICATION FAILED: Lead is incomplete: {missing_fields}")
            return False

        # 2. Check budget meets minimum rate requirement
        if lead.budget:
            budget_value = extract_budget_value(lead.budget)
            if budget_value < preferences.absoluteMinimumRate:
                print(
                    f"QUALIFICATION FAILED: Budget ${budget_value} below minimum rate ${preferences.absoluteMinimumRate}"
                )
                return False
        else:
            print("QUALIFICATION FAILED: No budget information provided")
            return False

        # 3. Check against auto-reject categories
        brand_category = (lead.brand_category or "").lower()
        for reject_category in preferences.autoRejectCategories:
            if reject_category.lower() in brand_category:
                print(
                    f"QUALIFICATION FAILED: Brand category '{brand_category}' is in auto-reject list"
                )
                return False

        # 4. Check partnership type compatibility
        deal_type = determine_deal_type_from_budget(lead.budget or "")
        if not is_partnership_type_accepted(deal_type, preferences.partnershipTypes):
            print(
                f"QUALIFICATION FAILED: Deal type '{deal_type}' not accepted in partnership preferences"
            )
            return False

        # 5. Validate contact information (at least one contact method required)
        has_contact_info = (
            lead.brand_contact_name
            or lead.brand_contact_email
            or lead.email  # fallback to lead email
        )
        if not has_contact_info:
            print("QUALIFICATION FAILED: No contact information available")
            return False

        # 6. Additional validation for critical fields
        if lead.brand_name and len(lead.brand_name.strip()) < 2:
            print("QUALIFICATION FAILED: Brand name too short")
            return False

        if lead.deliverables:
            for deliverable in lead.deliverables:
                if len(deliverable.strip()) < 5:
                    print("QUALIFICATION FAILED: Deliverables description too short")
                    return False

        print(f"QUALIFICATION PASSED: Lead for {lead.brand_name} meets all criteria")
        return True

    except Exception as e:
        print(f"QUALIFICATION ERROR: Exception during qualification check: {e}")
        return False


def extract_budget_value(budget_str: str) -> float:
    """Extract numeric budget value from budget string."""
    if not budget_str:
        return 0.0

    try:
        # Remove common currency symbols and formatting
        clean_budget = (
            budget_str.replace("$", "").replace(",", "").replace("USD", "").strip()
        )

        # Find all numeric values in the string
        budget_numbers = re.findall(r"\d+(?:\.\d{2})?", clean_budget)

        if budget_numbers:
            # Take the first (usually largest or most prominent) number
            return float(budget_numbers[0])
        else:
            # Look for ranges (e.g., "1000-5000")
            range_match = re.search(
                r"(\d+(?:\.\d{2})?)\s*[-–]\s*(\d+(?:\.\d{2})?)", clean_budget
            )
            if range_match:
                # Return the lower bound of the range
                return float(range_match.group(1))
    except (ValueError, AttributeError):
        pass

    return 0.0


def determine_deal_type_from_budget(budget_str: str) -> str:
    """Determine deal type based on budget description."""
    if not budget_str:
        return "FLAT_RATE"

    budget_lower = budget_str.lower()

    if any(term in budget_lower for term in ["affiliate", "commission", "%"]):
        return "AFFILIATE"
    elif "ugc" in budget_lower:
        return "UGC"
    elif "sponsored" in budget_lower:
        return "SPONSORED_POST"
    elif "partnership" in budget_lower:
        return "BRAND_PARTNERSHIP"
    elif any(term in budget_lower for term in ["revenue", "share"]):
        return "REVENUE_SHARE"
    elif any(term in budget_lower for term in ["performance", "hybrid"]):
        return "PERFORMANCE_HYBRID"
    else:
        return "FLAT_RATE"


def is_partnership_type_accepted(
    deal_type: str, partnership_prefs: PartnershipPreferences
) -> bool:
    """Check if the deal type is accepted based on partnership preferences."""
    deal_type_mapping = {
        "FLAT_RATE": partnership_prefs.flatRate,
        "AFFILIATE": partnership_prefs.affiliate,
        "UGC": partnership_prefs.flatRate,  # UGC typically falls under flat rate
        "SPONSORED_POST": partnership_prefs.flatRate,  # Sponsored posts typically flat rate
        "BRAND_PARTNERSHIP": partnership_prefs.custom,  # Brand partnerships often custom
        "REVENUE_SHARE": partnership_prefs.performanceHybrid,  # Revenue share is performance-based
        "PERFORMANCE_HYBRID": partnership_prefs.performanceHybrid,
    }

    return deal_type_mapping.get(
        deal_type, partnership_prefs.custom
    )  # Default to custom if unknown


async def create_deal_from_qualified_lead(
    api_client, lead: LeadQualificationData
) -> Optional[str]:
    """Create a Deal object from a qualified lead via API."""
    try:
        # Parse budget to extract numeric value using our helper function
        budget_value = extract_budget_value(lead.budget or "")
        if budget_value == 0.0:
            budget_value = 1000.0  # Default value if no budget found

        # Determine deal type based on budget description using our helper function
        deal_type_str = determine_deal_type_from_budget(lead.budget or "")

        # Convert string to DealType enum
        deal_type_mapping = {
            "FLAT_RATE": DealType.FLAT_RATE,
            "AFFILIATE": DealType.AFFILIATE,
            "UGC": DealType.UGC,
            "SPONSORED_POST": DealType.SPONSORED_POST,
            "BRAND_PARTNERSHIP": DealType.BRAND_PARTNERSHIP,
            "REVENUE_SHARE": DealType.REVENUE_SHARE,
        }
        deal_type = deal_type_mapping.get(deal_type_str, DealType.FLAT_RATE)

        # Parse deliverables into structured format
        deliverables = []
        if lead.deliverables:
            for deliverable in lead.deliverables:
                deliverable = Deliverable(
                    contentType="mixed",
                    text=deliverable,
                    draftLink=None,
                    invoiceLink=None,
                )
                deliverables.append(deliverable)

        # Create contact from lead information
        contacts = []
        if lead.brand_contact_name or lead.brand_contact_email:
            # Determine contact type based on lead data
            contact_type = lead.contact_type or "Brand Direct"
            role = f"Primary Contact ({contact_type})"

            contact = Contact(
                name=lead.brand_contact_name or "Unknown",
                role=role,
                email=lead.brand_contact_email,
                avatar=None,
                phone=None,
            )
            contacts.append(contact)

        # Create brief object (required field)
        brief = Brief(
            link="https://placeholder.com/brief",
            promoCode="PENDING",
        )

        # Parse deadline
        due_date = None
        if lead.deadline:
            due_date = lead.deadline.date()

        # Build comprehensive comments including all lead information
        comments_parts = []
        if lead.brand_comment:
            comments_parts.append(f"Brand Comment: {lead.brand_comment}")

        # Add all required lead fields as structured data
        lead_info = [
            f"Brand: {lead.brand_name or 'Unknown'}",
            f"Website: {lead.brand_website or 'Not provided'}",
            f"Category: {lead.brand_category or 'Unknown'}",
            f"Contact: {lead.brand_contact_name or 'Unknown'} ({lead.brand_contact_email or 'No email'})",
            f"Contact Type: {lead.contact_type or 'Unknown'}",
            f"Budget: {lead.budget or 'Not specified'}",
            f"Deadline: {lead.deadline or 'TBD'}",
            f"Deliverables: {lead.deliverables or 'Not specified'}",
        ]
        comments_parts.append("Lead Details: " + " | ".join(lead_info))
        comments_parts.append("Source: Email automation")

        final_comments = " | ".join(comments_parts)

        # Create the Deal object using Pydantic model
        deal = Deal(
            company=lead.brand_name or "Unknown Company",
            title=f"Partnership with {lead.brand_name or 'Unknown Company'}",
            status=DealStatus.NEW_OFFER,
            dealType=deal_type,
            value=budget_value,
            valueCurrency="USD",
            dueDate=due_date,
            dueDateType=DueDateType.REMINDER,
            reminderDays=3,
            isPriority=False,
            isHighValue=budget_value >= 5000,
            isAiPaused=False,
            dateReceived=datetime.now(timezone.utc).date(),
            comments=final_comments,
            brief=brief,
            deliverables=deliverables,
            communicationHistory=[],
            keyContacts=contacts,
            timeInStage=0,
            userId=None,
            createdBy="email_automation",
            updatedBy="email_automation",
        )

        # Convert Deal object to dict using model_dump
        deal_data = deal.model_dump()

        # Create the deal via API
        created_deal = await api_client.create_deal(deal_data)

        if created_deal:
            deal_id = created_deal.get("id")
            print(
                f"Successfully created deal with ID: {deal_id} for company: {deal.company}"
            )
            return deal_id

        return None

    except Exception as e:
        print(f"Error creating deal from qualified lead: {e}")
        return None


async def was_email_processed(api_client, message_id: str) -> bool:
    """Check if email was already processed."""
    try:
        return await api_client.check_email_processed(message_id)
    except Exception as e:
        print(f"Error checking processed email: {e}")
        return False


async def mark_email_processed(api_client, message_id: str, thread_id: str) -> bool:
    """Mark email as processed."""
    try:
        result = await api_client.mark_email_processed(message_id, thread_id)
        return result is not None
    except Exception as e:
        print(f"Error marking email processed: {e}")
        return False


async def is_blacklisted(api_client, email: str) -> bool:
    """Check if an email address is blacklisted."""
    try:
        return await api_client.check_email_blacklisted(email.lower())
    except Exception as e:
        print(f"Error checking blacklist: {e}")
        return False


async def store_message(api_client, message_data: Dict) -> bool:
    """Store a message via API."""
    try:
        message_data = convert_message_to_api_format(message_data)
        result = await api_client.create_simple_message(message_data)
        if result:
            print(f"Stored message {message_data['message_id']} via API")
            return True
        return False
    except Exception as e:
        print(f"Error storing message: {e}")
        return False


async def get_conversation_history(
    api_client, thread_id: str, limit: int = 50
) -> List[Dict]:
    """Get conversation history for a thread ID, ordered by timestamp."""
    try:
        messages = await api_client.get_conversation_history(thread_id, limit)
        return messages or []
    except Exception as e:
        print(f"Error fetching conversation history: {e}")
        return []


def format_conversation_history(messages: List[Dict]) -> str:
    """Format conversation history for AI context."""
    if not messages:
        return ""

    formatted_history = "CONVERSATION HISTORY:\n"

    for i, message in enumerate(messages, 1):
        is_current = i == len(messages)
        marker = "[CURRENT MESSAGE]" if is_current else f"[MESSAGE {i}]"

        formatted_history += f"""
--- {marker} ---
From: {message.get('sender_email')}
To: {message.get('recipient_email')}
Subject: {message.get('subject')}
Date: {message.get('timestamp')}
Direction: {message.get('direction', '').upper()}

{message.get('content')}
"""

    return formatted_history


# Email Processing Functions (same as original)
def extract_email_address(from_header: str) -> str:
    """Extract clean email address from 'From' header."""
    email_match = re.search(r"<([^>]+)>|([^\s<>]+@[^\s<>]+)", from_header)
    if email_match:
        return email_match.group(1) or email_match.group(2)
    return from_header.strip()


def normalize_subject_for_thread(subject: str) -> str:
    """Normalize email subject for thread_id generation by removing 'Re:' prefixes."""
    if not subject:
        return ""

    # Remove common reply prefixes (case insensitive)
    normalized = re.sub(r"^(re:|fwd:|fw:)\s*", "", subject, flags=re.IGNORECASE).strip()

    # Remove extra whitespace and normalize
    normalized = " ".join(normalized.split())

    return normalized


def generate_thread_id(sender_email: str, recipient_email: str, subject: str) -> str:
    """
    Generate a consistent thread_id based on sender email, recipient email, and normalized subject.
    This ensures that emails in the same conversation thread have the same thread_id.
    """
    # Normalize emails to lowercase
    sender_clean = sender_email.lower().strip()
    recipient_clean = recipient_email.lower().strip()

    # Normalize subject by removing reply prefixes
    subject_normalized = normalize_subject_for_thread(subject)

    # Create a consistent thread_id by concatenating the components
    # We sort sender and recipient to ensure consistency regardless of direction
    emails_sorted = sorted([sender_clean, recipient_clean])
    thread_components = emails_sorted + [subject_normalized]

    # Join components and create a hash for consistent length
    thread_string = "|".join(thread_components)

    # Create a hash to ensure consistent length and avoid special characters
    import hashlib

    thread_hash = hashlib.sha256(thread_string.encode("utf-8")).hexdigest()[:16]

    # Return a readable format: hash-first_few_chars_of_subject
    subject_prefix = "".join(c for c in subject_normalized[:10] if c.isalnum()).lower()
    if subject_prefix:
        return f"{thread_hash}-{subject_prefix}"
    else:
        return thread_hash


def parse_ses_event(event: Dict[str, Any]) -> EmailEvent:
    """Parse SES email event to extract relevant information."""
    try:
        # Extract SES mail object
        ses_record = event["Records"][0]["ses"]
        mail = ses_record["mail"]
        receipt = ses_record["receipt"]

        # Extract basic info
        message_id = mail["messageId"]
        timestamp = datetime.fromisoformat(mail["timestamp"].replace("Z", "+00:00"))

        # Extract sender and recipient
        sender_email = extract_email_address(mail["commonHeaders"]["from"][0])
        recipient_email = mail["commonHeaders"]["to"][0]
        subject = mail["commonHeaders"]["subject"]

        # Generate consistent thread_id based on sender, recipient, and normalized subject
        thread_id = generate_thread_id(sender_email, recipient_email, subject)
        print(
            f"Generated thread_id: {thread_id} for email from {sender_email} to {recipient_email} with subject: {subject}"
        )

        # S3 location
        s3_bucket = S3_BUCKET
        s3_key = "emails/" + message_id

        return EmailEvent(
            message_id=message_id,
            thread_id=thread_id,
            sender_email=sender_email,
            recipient_email=recipient_email,
            subject=subject,
            content="",  # Will be filled from S3
            timestamp=timestamp,
            s3_bucket=s3_bucket,
            s3_key=s3_key,
        )
    except Exception as e:
        print(f"Error parsing SES event: {e}")
        raise


def fetch_email_from_s3(bucket: str, key: str) -> str:
    """Fetch email content from S3."""
    try:
        response = s3_client.get_object(Bucket=bucket, Key=key)
        email_content = response["Body"].read().decode("utf-8")

        # Parse email to extract text content
        msg = email.message_from_string(email_content)

        # Extract plain text content
        text_content = ""
        if msg.is_multipart():
            for part in msg.walk():
                if part.get_content_type() == "text/plain":
                    payload = part.get_payload(decode=True)
                    if isinstance(payload, bytes):
                        text_content += payload.decode("utf-8")
                    elif isinstance(payload, str):
                        text_content += payload
        else:
            if msg.get_content_type() == "text/plain":
                payload = msg.get_payload(decode=True)
                if isinstance(payload, bytes):
                    text_content = payload.decode("utf-8")
                elif isinstance(payload, str):
                    text_content = payload

        # If no plain text, try to get any text content
        if not text_content.strip():
            if msg.is_multipart():
                for part in msg.walk():
                    if part.get_content_type().startswith("text/"):
                        payload = part.get_payload(decode=True)
                        if isinstance(payload, bytes):
                            text_content += payload.decode("utf-8", errors="ignore")
                        elif isinstance(payload, str):
                            text_content += payload
            else:
                payload = msg.get_payload(decode=True)
                if isinstance(payload, bytes):
                    text_content = payload.decode("utf-8", errors="ignore")
                elif isinstance(payload, str):
                    text_content = payload

        return text_content.strip()

    except Exception as e:
        print(f"Error fetching email from S3: {e}")
        return ""


def send_ses_reply(
    to_email: str,
    from_email: str,
    subject: str,
    body: str,
    user: User,
    in_reply_to_id: Optional[str] = None,
) -> bool:
    """Send reply email using SES."""
    try:
        # Add signature to body if not already present
        signature = f"\n\nBest regards,\n{user.profile.name}"
        body_with_signature = body + signature

        # Prepare email
        message = {
            "Subject": {"Data": subject, "Charset": "UTF-8"},
            "Body": {"Text": {"Data": body_with_signature, "Charset": "UTF-8"}},
        }

        # Send email
        response = ses_client.send_email(
            Source=from_email, Destination={"ToAddresses": [to_email]}, Message=message
        )

        print(f"Email sent successfully. Message ID: {response['MessageId']}")
        return True

    except Exception as e:
        print(f"Error sending SES reply: {e}")
        return False


# AI Agents (same as original)
deal_filter_agent = Agent(
    name="Deal Filter Agent",
    instructions="""
You are an Email Deal Filter for a content creator's inbox.
Your job is to classify each email into one of three categories:

1. Sponsorship / Revenue Opportunity
   - Paid Sponsorship (flat rate)
   - Affiliate Offer
   - Performance / Hybrid (MG + performance, CPA, CPC, CPM)
   - Product Seeding / Gifting
   - UGC / Freelance Content Request (content for brand-owned channels)

2. Non-Sponsorship / Business
   - Events/Press invites, equity partnerships, collaboration with another creator, casting/appearance request, speaking opportunities

3. Other (ignore)
   - Fan mail, donations, platform notices, agencies recruiting, feedback, spam, newsletters, cold irrelevant outreach, system alerts, job offers, recruiting.

Rules:
- If any budget/payment language is present, prefer category (1).
- If gifting/product only, choose sponsorship → Gifting.
- If multiple apply, pick the highest ID category in Sponsorship (flat > affiliate > hybrid > gifting > ugc).
- If no clear business opportunity, classify as Other.

Output JSON only:
{
  "classification": "<Sponsorship | Non-Sponsorship | Other>",
  "subcategory": "<flat | affiliate | hybrid | gifting | ugc | event | press | recruiting | spam | etc.>",
  "confidence": <0..1>
}
""",
    output_type=DealFilterResponse,
    tools=[],
)

deal_parser_agent = Agent(
    name="Deal Parser Agent",
    instructions="""
You are an Email Deal Parser focused on extracting essential information for deal creation.
You receive:
1) A conversation history (multiple emails in a thread)
2) Existing lead information from previous emails (if any)
3) Current email content

Your job is to extract and UPDATE essential deal information needed to create a Deal record.

Extract/update these ESSENTIAL fields when available:

COMPANY INFORMATION:
- brand_name: Brand/company name (required for deal creation)
- brand_website: Company website URL
- brand_category: Brand category or industry

FINANCIAL TERMS:
- budget: Budget/compensation offered (flat fee, affiliate %, hybrid terms, gifting value)

DELIVERABLES:
- deliverables: Specific content requested (e.g., "1x YouTube video", "3x TikTok posts", "Instagram story series")

TIMELINE:
- deadline: Project deadline, campaign launch date, or content due date

CONTACT INFORMATION:
- brand_contact_name: Primary contact name (from signature, sender, or signoff)
- brand_contact_email: Primary contact email (from metadata or signature)  
- contact_type: Contact title/role (Marketing Manager, Brand Manager, etc.)

ADDITIONAL CONTEXT:
- brand_comment: Any additional context, campaign goals, special requirements, or notes that would be useful for deal management

Rules:
- MERGE new information with existing data - don't overwrite good data with null
- Only update fields when you find NEW or BETTER information
- If existing data conflicts with new data, prefer the more recent/specific information
- Do not invent details; only extract what exists in the conversation
- Normalize to clean values (remove filler words, standardize formats)
- If unknown or unchanged, set null (existing data will be preserved)
- Focus on information that directly helps create and manage the deal
- Be concise but thorough - capture the essential business details

Output JSON with only the essential fields needed for deal creation.
""",
    output_type=LeadQualificationData,
    tools=[],
)


qa_polisher_agent = Agent(
    name="QA Polisher Agent",
    instructions="""
You are a Quality Assurance Agent specializing in sponsorship negotiations.
Your job: polish draft emails so they read as if sent by a top-tier digital talent agent representing the creator.

Rules:
- Maintain professionalism, warmth, and confidence.
- Avoid jargon, filler, or desperate tone.
- Keep the word count of the email draft under 125 words
- Structure emails clearly: greeting → concise value → clear ask/next step.
- Emphasize the creator's professionalism, past sponsor success, and readiness to deliver.
- If countering, anchor confidently with the creator's rate and highlight ROI.
- Do not include any signature or sign-off in your response.
- If there is a signature in the draft response, remove it.

Output the final polished email text only.
""",
    output_type=QAPolisherResponse,
    tools=[],
)


comprehensive_preference_agent = Agent(
    name="Comprehensive Preference Evaluation Agent",
    instructions="""
You are an Advanced Creator Preference Evaluation and Response Strategy Agent.
Your job is to comprehensively evaluate leads, determine action plans, and draft appropriate responses.

You receive:
1) Complete lead information (all extracted fields)
2) Creator preferences (minimum rates, categories, partnership types)
3) Creator's platform focus and audience
4) Conversation history

Your responsibilities:
A) EVALUATE the lead against creator preferences
B) DETERMINE the appropriate action (CONTINUE/NEGOTIATE/REJECT  )
C) DRAFT a complete response based on your recommendation
D) PROVIDE comprehensive analysis and strategy

EVALUATION CRITERIA:
- Budget meets minimum requirements
- Category aligns with creator's brand
- Partnership type is acceptable
- Deliverables match creator's capabilities
- Timeline is feasible

Comprehensively evaluate this lead, determine the appropriate action, and draft a complete response. Your response should be in the following format:
{{
  "recommendation": "<CONTINUE | NEGOTIATE | REJECT>",
  "draft_response": "<response text>"
}}

Rules:
- If more information is needed, set recommendation to CONTINUE
- If the lead matches most preferences, and the fields not matching are not the auto-reject categories, set recommendation to NEGOTIATE
- If the lead matches most preferences, and the fields not matching are the auto-reject categories, set recommendation to REJECT
- If negotiation has been attempted but failed, set recommendation to REJECT

MISSING INFORMATION HANDLING:
If any information is missing, set recommendation to CONTINUE and identify:
- What specific information is needed
- Why it's important for evaluation
- How to ask for it professionally

RESPONSE DRAFTING GUIDELINES:
- Match tone to recommendation (warm for CONTINUE, firm for NEGOTIATE, polite for REJECT)
- Be specific about what you need (for REQUEST_MORE_INFO)
- Include creator's value proposition when negotiating
- Keep professional but approachable
- Include relevant creator stats/portfolio when beneficial
- Address specific concerns or highlight opportunities
- Set clear expectations for next steps

BUSINESS INTELLIGENCE:
- Assess market value of the opportunity
- Identify strategic benefits beyond payment
- Flag potential risks or red flags
- Consider long-term relationship value

Rules:
- Be thorough in evaluation - consider all aspects
- Provide actionable insights and specific recommendations
- Draft responses that sound like a professional talent agent
- Include creator's portfolio/stats when relevant
- Be honest about fit but maintain professionalism
- Consider creator's growth stage and goals
- Maximum 125 words for draft responses
- Do not include an email signature in draft responses

Output comprehensive JSON with all analysis, recommendations, and draft response.
""",
    output_type=PreferenceEvaluationDraftResponse,
    tools=[],
)


async def process_multi_agent_qualification(
    api_client: APIClient,
    user: User,
    conversation_history: str,
    sender_email: str,
    thread_id: str,
) -> Union[str, QAPolisherResponse]:
    """4-agent pipeline for progressive lead qualification.

    New Flow:
    1. Deal Filter Agent - classify the email
    2. Deal Parser Agent - extract comprehensive information
    3. Comprehensive Preference Agent - evaluate, decide action, and draft response
    4. QA/Polisher Agent - polish the final response
    """

    try:
        # Step 1: Deal Filter Agent - classify the email
        print(f"Step 1: Filtering deal type for thread {thread_id}")

        filter_input = f"""
CONVERSATION HISTORY:
{conversation_history}

Classify this email conversation into one of the three categories and provide the appropriate subcategory.
"""

        filter_result = await Runner.run(deal_filter_agent, filter_input)
        filter_response = filter_result.final_output_as(DealFilterResponse)

        print(
            f"Deal filter: classification={filter_response.classification}, subcategory={filter_response.subcategory}, confidence={filter_response.confidence}"
        )

        # If not a sponsorship opportunity, return standard response
        if (
            filter_response.classification != "Sponsorship"
            or filter_response.confidence < 0.75
        ):
            standard_response = "Thank you for reaching out! This message appears to be outside the scope of business partnership inquiries that I can assist with. If you have a collaboration or partnership proposal, please feel free to send those details and I'll be happy to help connect you with the right person."
            print("Email classified as non-sponsorship, returning standard response")
            return standard_response

        # Step 2: Deal Parser Agent - extract comprehensive information
        print("Step 2: Parsing with comprehensive field extraction")
        existing_lead = await get_lead_by_thread_id(api_client, thread_id)

        # If no existing lead, create a new one
        if not existing_lead:
            new_lead = await create_lead(api_client, sender_email, thread_id, user.uuid)

            if not new_lead:
                print("ERROR: Could not create lead")
                return "I apologize, but there was an issue processing your request. Please try again."

            existing_lead = new_lead

        lead_id = existing_lead.get("_id")

        if not lead_id:
            print("ERROR: Could not get lead ID")
            return "I apologize, but there was an issue processing your request. Please try again."

        # Format existing lead data for parser context
        existing_lead_context = ""
        if existing_lead:
            existing_lead_context = f"""
EXISTING LEAD INFORMATION, ANY FIELD THAT IS RELATED TO LEAD QUALIFICATION AND IS NULL IS UNKNOWN:
{existing_lead}
"""
        else:
            existing_lead_context = (
                "\nEXISTING LEAD INFORMATION: None (new conversation)"
            )

        parser_input = f"""
{existing_lead_context}

CONVERSATION HISTORY:
{conversation_history}

Extract and update comprehensive structured deal information from this sponsorship opportunity conversation.
Build upon existing information and extract ALL possible fields mentioned or implied.
"""

        parser_result = await Runner.run(deal_parser_agent, parser_input)
        parser_response = parser_result.final_output_as(LeadQualificationData)

        print(
            f"Parsing: company={parser_response.brand_name}, budget={parser_response.budget}"
        )

        # Update lead with parsed information
        current_lead_dict = await update_lead(
            api_client, lead_id, thread_id, parser_response
        )

        if not current_lead_dict:
            print("ERROR: Could not update lead")
            return "I apologize, but there was an issue processing your request. Please try again."

        # Convert dict to LeadQualificationData object
        current_lead = LeadQualificationData.model_validate(current_lead_dict)

        # Step 3: Comprehensive Preference Agent - evaluate and determine action
        print("Step 3: Comprehensive preference evaluation and response strategy")

        # Format user preferences for evaluation
        creator_name = user.profile.name or "our creator"
        prefs = user.preferences

        # Build platform context
        platform_context = ""
        if user.platforms:
            primary_platforms = [
                platform.platformType.value.title()
                for platform in user.platforms[:3]
                if platform.isActive
            ]
            if primary_platforms:
                platform_context = f"Primary Platforms: {', '.join(primary_platforms)}"

        # Build comprehensive lead context from parsing
        comprehensive_lead_context = f"""
COMPREHENSIVE LEAD INFORMATION:
{current_lead.model_dump_json(indent=2)}

MISSING FIELDS:
{', '.join(current_lead.get_missing_fields())}
"""

        preference_input = f"""
{comprehensive_lead_context}

CREATOR PREFERENCES:
- Name: {creator_name}
- Minimum Rate: ${prefs.absoluteMinimumRate}
- Auto-Reject Categories: {', '.join(prefs.autoRejectCategories)}
- Partnership Types: Flat Rate: {prefs.partnershipTypes.flatRate}, Affiliate: {prefs.partnershipTypes.affiliate}, Performance Hybrid: {prefs.partnershipTypes.performanceHybrid}
- {platform_context}

CONVERSATION HISTORY:
{conversation_history}

"""

        preference_result = await Runner.run(
            comprehensive_preference_agent, preference_input
        )
        preference_response = preference_result.final_output_as(
            PreferenceEvaluationDraftResponse
        )

        print(
            f"Comprehensive evaluation: recommendation={preference_response.recommendation}"
        )

        # if the recommendation is CONTINUE, then check if the lead is qualified
        if preference_response.recommendation == "CONTINUE":
            print("Step 3b: Checking if the lead is qualified")

            qualified = check_qualification_criteria(current_lead, prefs)
            if qualified:
                print("Step 3b: Lead is qualified - creating deal")
                deal_id = await create_deal_from_qualified_lead(
                    api_client, current_lead
                )
                if deal_id:
                    print(f"✅ Created deal {deal_id} from qualified lead")

                    # Create or get conversation for this deal with threadId
                    try:
                        conversation = await api_client.create_conversation_for_deal(
                            deal_id, thread_id
                        )
                        print(
                            f"✅ Conversation {conversation.get('uuid')} ready for deal {deal_id} with threadId {thread_id}"
                        )
                    except Exception as e:
                        print(f"⚠️ Failed to create/get conversation: {e}")

                    # Return response completing the entire flow
                    return (
                        "Thanks for working with Repflow! We'll get back to you soon."
                    )
        elif preference_response.recommendation == "REJECT":
            print("Step 3b: Lead is not qualified - returning standard response")
            return f"I apologize, but the lead does not meet the qualification criteria. Please email {user.profile.email} for assistance."

        # Step 4: QA/Polisher Agent - polish the final response
        print("Step 4: Polishing final response")

        polisher_input = f"""
DRAFT RESPONSE TO POLISH:
{preference_response.draft_response}

CONTEXT: 
- Recommendation: {preference_response.recommendation}
- Tone: {preference_response.communication_tone}
- Key Messages: {', '.join(preference_response.key_messages)}

REQUIREMENTS:
- Keep under 125 words
- Maintain the {preference_response.communication_tone} tone
- Ensure professional talent agent voice
- No email signature at the end of the response

Polish this response to perfection while maintaining all key points and context.
"""

        polisher_result = await Runner.run(qa_polisher_agent, polisher_input)
        polisher_response = polisher_result.final_output_as(QAPolisherResponse)

        print("Step 4: Response polished successfully")
        return polisher_response

    except Exception as e:
        print(f"Error in multi-agent qualification: {e}")
        raise e


async def async_lambda_handler(event, context):
    """Main Lambda handler function using API calls."""
    api_client = None
    try:
        print(f"Received event: {json.dumps(event)}")

        # Create API client
        api_client = create_api_client()

        async with api_client:
            # Parse the SES event
            email_event = parse_ses_event(event)
            print(f"Processing email from {email_event.sender_email}")

            # Get the repflow username from the recipient email address (the user's email)
            repflow_username = email_event.recipient_email.split("@")[0]

            # Check there is a user with the email address
            user = await api_client.get_user_by_repflow_username(repflow_username)
            if not user:
                print(f"User {repflow_username} not found, skipping")
                return {"statusCode": 200, "body": "User not found"}

            # Check if already processed
            if await was_email_processed(api_client, email_event.message_id):
                print(f"Email {email_event.message_id} already processed, skipping")
                return {"statusCode": 200, "body": "Email already processed"}

            # Check blacklist
            clean_email = extract_email_address(email_event.sender_email)
            if await is_blacklisted(api_client, clean_email):
                print(f"Email from {clean_email} is blacklisted, skipping")
                await mark_email_processed(
                    api_client, email_event.message_id, email_event.thread_id
                )
                return {"statusCode": 200, "body": "Email blacklisted"}

            # Check for no-reply patterns
            no_reply_regex = r"no-reply|noreply|no-response"
            if re.search(no_reply_regex, clean_email, re.IGNORECASE):
                print(f"Skipping no-reply email: {clean_email}")
                await mark_email_processed(
                    api_client, email_event.message_id, email_event.thread_id
                )
                return {"statusCode": 200, "body": "No-reply email skipped"}

            # Fetch email content from S3
            email_content = fetch_email_from_s3(
                email_event.s3_bucket, email_event.s3_key
            )

            print("Email content: ", email_content)

            # Check if this thread already has a qualified lead with a conversation
            existing_lead = await get_lead_by_thread_id(
                api_client, email_event.thread_id
            )

            if existing_lead and existing_lead.get("status") == "qualified":
                print(
                    f"Thread {email_event.thread_id} already has a qualified lead, checking for conversation"
                )

                # Try to find the conversation for this thread
                conversation = await api_client.get_conversation_by_thread_id(
                    email_event.thread_id
                )

                if conversation:
                    print(
                        f"Found conversation {conversation.get('uuid')} for thread {email_event.thread_id}"
                    )

                    # Create a proper Message in the Conversation (not SimpleMessage)
                    message_data = {
                        "messageType": "email",
                        "content": email_content,
                        "status": "received",
                        "conversationId": conversation.get("uuid"),
                        "dealId": conversation.get("dealId"),
                        "userId": user.uuid,
                        "senderName": existing_lead.get("brand_contact_name")
                        or email_event.sender_email,
                        "senderEmail": email_event.sender_email,
                        "senderId": email_event.sender_email,
                        "threadPosition": 0,  # Will be auto-calculated by backend
                        "isInternal": False,
                        "isAutomated": False,
                        "priority": 0,
                        "tags": [],
                        "emailData": {
                            "subject": email_event.subject,
                            "toEmails": [email_event.recipient_email],
                            "emailId": email_event.message_id,
                        },
                        "sentAt": (
                            email_event.timestamp.isoformat()
                            if isinstance(email_event.timestamp, datetime)
                            else email_event.timestamp
                        ),
                        "receivedAt": datetime.now(timezone.utc).isoformat(),
                    }

                    try:
                        await api_client.create_message_for_conversation(message_data)
                        print(
                            f"✅ Added message to conversation {conversation.get('uuid')}"
                        )
                    except Exception as e:
                        print(f"❌ Failed to create message in conversation: {e}")
                        # Fallback to SimpleMessage
                        incoming_message = {
                            "message_id": email_event.message_id,
                            "thread_id": email_event.thread_id,
                            "sender_email": email_event.sender_email,
                            "recipient_email": email_event.recipient_email,
                            "subject": email_event.subject,
                            "content": email_content,
                            "direction": "inbound",
                            "timestamp": email_event.timestamp,
                        }
                        await store_message(api_client, incoming_message)
                else:
                    print(
                        f"⚠️ No conversation found for qualified thread {email_event.thread_id}, storing as SimpleMessage"
                    )
                    # Store as SimpleMessage
                    incoming_message = {
                        "message_id": email_event.message_id,
                        "thread_id": email_event.thread_id,
                        "sender_email": email_event.sender_email,
                        "recipient_email": email_event.recipient_email,
                        "subject": email_event.subject,
                        "content": email_content,
                        "direction": "inbound",
                        "timestamp": email_event.timestamp,
                    }
                    await store_message(api_client, incoming_message)

                # Mark as processed
                await mark_email_processed(
                    api_client, email_event.message_id, email_event.thread_id
                )

                return {
                    "statusCode": 200,
                    "body": json.dumps(
                        {
                            "message": "Email added to existing conversation",
                            "message_id": email_event.message_id,
                            "sender": email_event.sender_email,
                            "thread_id": email_event.thread_id,
                            "reply_sent": False,
                            "agent_type": "existing-conversation-bypass",
                        }
                    ),
                }

            # Thread ID is already consistently generated in parse_ses_event, no need to update it

            # Store the incoming message
            incoming_message = {
                "message_id": email_event.message_id,
                "thread_id": email_event.thread_id,
                "sender_email": email_event.sender_email,
                "recipient_email": email_event.recipient_email,
                "subject": email_event.subject,
                "content": email_content,
                "direction": "inbound",
                "timestamp": email_event.timestamp,
            }
            await store_message(api_client, incoming_message)

            # Get full conversation history
            conversation_messages = await get_conversation_history(
                api_client, email_event.thread_id
            )
            conversation_history = format_conversation_history(conversation_messages)

            print(
                f"Processing multi-agent qualification for thread: {email_event.thread_id}"
            )
            # Run compact FSM for deal + conversation management
            qualification_response = await run_deal_conversation_fsm(
                api_client,
                user,
                conversation_history,
                email_event.sender_email,
                email_event.thread_id,
            )

            print(f"Qualification completed successfully")

            # Determine reply content and whether to send
            should_send_reply = False
            reply_content = ""

            if isinstance(qualification_response, str):
                # Non-sponsorship email or standard response
                should_send_reply = True
                reply_content = qualification_response
            elif isinstance(qualification_response, QAPolisherResponse):
                # Polished response from new 4-agent flow
                should_send_reply = qualification_response.should_send
                reply_content = qualification_response.polished_reply
            else:
                # This should not happen with the new 4-agent flow
                print(f"Unexpected response type: {type(qualification_response)}")
                should_send_reply = False
                reply_content = ""

            # Send reply if conditions are met
            if should_send_reply and reply_content:
                # Prepare reply subject
                reply_subject = email_event.subject
                if not reply_subject.lower().startswith("re:"):
                    reply_subject = f"Re: {reply_subject}"

                # Send reply via SES
                success = send_ses_reply(
                    email_event.sender_email,
                    email_event.recipient_email,
                    reply_subject,
                    reply_content,
                    user,
                    email_event.message_id,
                )

                if success:
                    print(f"✅ Sent reply to {email_event.sender_email}")

                    # Store the outbound reply
                    reply_message = {
                        "message_id": f"reply-{email_event.message_id}-{int(datetime.now(timezone.utc).timestamp())}",
                        "thread_id": email_event.thread_id,
                        "sender_email": email_event.recipient_email,  # Our email address
                        "recipient_email": email_event.sender_email,
                        "subject": reply_subject,
                        "content": reply_content,
                        "direction": "outbound",
                        "timestamp": datetime.now(timezone.utc),
                    }
                    await store_message(api_client, reply_message)

                else:
                    print(f"❌ Failed to send reply to {email_event.sender_email}")

            # Mark as processed
            await mark_email_processed(
                api_client, email_event.message_id, email_event.thread_id
            )

            return {
                "statusCode": 200,
                "body": json.dumps(
                    {
                        "message": "Email processed successfully",
                        "message_id": email_event.message_id,
                        "sender": email_event.sender_email,
                        "reply_sent": should_send_reply,
                        "agent_type": "4-agent-pipeline-api",
                    }
                ),
            }

    except Exception as e:
        import traceback

        traceback.print_exc()
        print(f"Error in Lambda handler: {e}")
        return {"statusCode": 500, "body": json.dumps({"error": str(e)})}


def lambda_handler(event, context):
    import asyncio

    return asyncio.run(async_lambda_handler(event, context))