from agentfield import Agent
from pydantic import BaseModel

app = Agent("support-system")

class TriageDecision(BaseModel):
    sentiment: str  # "frustrated", "angry", "confused", "neutral"
    priority: str  # "low", "medium", "high", "critical"
    category: str  # "technical", "billing", "account"
    needs_escalation: bool
    reasoning: str  # Why did we make this decision?

@app.reasoner()
async def triage_support_ticket(ticket: dict) -> dict:
    """
    Analyzes a support ticket and routes it autonomously.
    AI provides judgment. Code provides control.
    """

    # Step 1: AI analyzes the ticket
    analysis = await app.ai(
        system="You are a support triage expert. Analyze tickets for sentiment, priority, and category.",
        user=f"Ticket #{ticket['id']}: {ticket['message']}\nCustomer tier: {ticket['tier']}",
        schema=TriageDecision
    )

    # Step 2: Your code makes routing decisions based on AI insights
    if analysis.needs_escalation:
        # High-stakes decision: route to senior team
        queue = await escalate_to_human(ticket, analysis.reasoning)
        app.note(f"⚠️ Escalated ticket {ticket['id']} to senior team", tags=["escalation"])
    elif analysis.priority == "critical":
        # Urgent but not escalation-worthy: fast-track queue
        queue = await assign_to_senior_team(ticket)
        app.note(f"🚨 Critical priority: {analysis.reasoning}", tags=["critical"])
    else:
        # Standard routing based on category
        queue = await add_to_standard_queue(ticket, analysis.category)

    # Step 3: Update systems (deterministic operations)
    await update_ticket_metadata(ticket['id'], {
        'priority': analysis.priority,
        'category': analysis.category,
        'sentiment': analysis.sentiment,
        'ai_reasoning': analysis.reasoning,
        'assigned_queue': queue
    })

    # Step 4: Send notifications
    await notify_team(queue, ticket, analysis)

    return {
        'ticket_id': ticket['id'],
        'routed_to': queue,
        'analysis': analysis.dict()
    }

@app.skill(tags=["database", "users"])
def get_user_profile(user_id: int) -> dict:
    """Retrieves user profile from database."""
    user = db.query(User).filter_by(id=user_id).first()
    return user.to_dict() if user else None

@app.skill(tags=["calculations", "pricing"])
def calculate_discount(price: float, tier: str) -> float:
    """Calculates discount based on customer tier."""
    discount_rates = {
        "gold": 0.20,
        "silver": 0.10,
        "bronze": 0.05
    }
    return price * (1 - discount_rates.get(tier, 0))

@app.skill(tags=["notifications"])
async def send_slack_alert(channel: str, message: str) -> bool:
    """Sends alert to Slack channel."""
    response = await slack_client.post_message(channel, message)
    return response.ok

from pydantic import BaseModel, Field

class FeedbackAnalysis(BaseModel):
    sentiment: str = Field(description="positive, negative, or neutral")
    confidence: float = Field(ge=0.0, le=1.0, description="Confidence score")
    keywords: list[str] = Field(description="Key topics mentioned")
    is_feature_request: bool
    urgency: str = Field(description="low, medium, or high")
    reasoning: str = Field(description="Explanation of the analysis")

@app.reasoner()
async def analyze_customer_feedback(feedback: dict) -> dict:
    """
    Analyzes customer feedback and takes autonomous action.
    Pydantic ensures AI output is structured and reliable.
    """

    # AI provides structured analysis
    analysis = await app.ai(
        system="Analyze customer feedback for sentiment, topics, and urgency.",
        user=feedback['message'],
        schema=FeedbackAnalysis
    )

    # Your code can now reliably act on AI insights
    actions_taken = []

    if analysis.sentiment == "negative" and analysis.confidence > 0.8:
        # High-confidence negative feedback: immediate action
        await notify_customer_success_team(feedback, analysis)
        await create_follow_up_task(feedback['customer_id'], analysis.keywords)
        actions_taken.extend(["notified_cs_team", "created_follow_up"])

    if analysis.is_feature_request:
        # Route to product team
        await route_to_product_team(feedback, analysis.keywords)
        actions_taken.append("routed_to_product")

    if analysis.urgency == "high":
        # Flag for immediate review
        await flag_for_review(feedback['id'], analysis.reasoning)
        actions_taken.append("flagged_urgent")

    return {
        'feedback_id': feedback['id'],
        'analysis': analysis.dict(),
        'actions_taken': actions_taken
    }

class PricingRecommendation(BaseModel):
    recommended_price: float
    discount_tier: str
    upsell_opportunity: bool
    reasoning: str

@app.reasoner()
async def recommend_pricing(user_id: int, product_id: int) -> dict:
    """
    AI-powered pricing recommendation using skills for data.
    Pattern: Skills gather data → AI analyzes → Skills execute.
    """

    # Skills: Get deterministic data
    user = get_user_profile(user_id)  # Skill
    base_price = get_product_price(product_id)  # Skill
    purchase_history = get_purchase_history(user_id)  # Skill

    # Reasoner: AI analyzes and recommends
    recommendation = await app.ai(
        system="You are a pricing strategist. Recommend optimal pricing based on user data.",
        user=f"""
        User tier: {user['tier']}
        Purchase history: {purchase_history}
        Base price: ${base_price}
        Lifetime value: ${user['lifetime_value']}
        """,
        schema=PricingRecommendation
    )

    # Skills: Calculate final price and execute
    final_price = calculate_discount(
        recommendation.recommended_price,
        recommendation.discount_tier
    )  # Skill

    if recommendation.upsell_opportunity:
        # AI detected upsell potential: trigger marketing automation
        await trigger_upsell_campaign(user_id, product_id)  # Skill

    # Update pricing in database
    await update_user_pricing(user_id, product_id, final_price)  # Skill

    app.note(f"""
    ## Pricing Decision

    **User:** {user_id}
    **Product:** {product_id}
    **Final Price:** ${final_price}
    **Reasoning:** {recommendation.reasoning}
    """, tags=["pricing", "decision"])

    return {
        'user_id': user_id,
        'product_id': product_id,
        'final_price': final_price,
        'recommendation': recommendation.dict()
    }

@app.reasoner()
async def analyze_support_ticket(ticket: dict) -> TicketAnalysis:
    ...

@app.reasoner()
async def evaluate_loan_application(application: dict) -> dict:
    """
    Evaluates loan application with full audit trail.
    Notes create a timeline of decisions visible in Agentfield UI.
    """

    # Step 1: Risk assessment
    risk = await app.ai(
        "Evaluate loan risk based on application data",
        f"Application: {application}",
        schema=RiskAssessment
    )

    app.note(f"""
    ## Risk Assessment Complete

    **Application ID:** {application['id']}
    **Risk Score:** {risk.score}/10
    **Decision:** {risk.decision}

    **Key Factors:**
    - Credit score: {application['credit_score']}
    - Income: ${application['income']}
    - Debt ratio: {application['debt_ratio']}%

    **AI Reasoning:** {risk.reasoning}
    """, tags=["risk-assessment", "decision"])

    # Step 2: Check for high-risk scenarios
    if risk.score > 7.5:
        app.note("⚠️ High risk detected - flagging for manual review", tags=["alert", "manual-review"])
        await flag_for_manual_review(application['id'])

        # Notify risk team
        await send_slack_alert(
            channel="#risk-team",
            message=f"High-risk loan application {application['id']} requires review"
        )

        app.note("✅ Risk team notified via Slack", tags=["notification"])

    # Step 3: Final decision
    if risk.decision == "approve":
        await approve_loan(application['id'], risk.approved_amount)
        app.note(f"✅ Loan approved for ${risk.approved_amount}", tags=["approval"])
    else:
        await reject_loan(application['id'], risk.reasoning)
        app.note(f"❌ Loan rejected: {risk.reasoning}", tags=["rejection"])

    return {
        'application_id': application['id'],
        'decision': risk.decision,
        'risk_score': risk.score,
        'reasoning': risk.reasoning
    }

from agentfield.router import AgentRouter

# Create routers for different domains
users = AgentRouter(prefix="users")
billing = AgentRouter(prefix="billing")
support = AgentRouter(prefix="support")

# User operations
@users.reasoner()
async def analyze_user_behavior(user_id: str) -> BehaviorAnalysis:
    """Analyzes user behavior patterns."""
    ...

@users.skill()
def get_user_settings(user_id: str) -> dict:
    """Retrieves user settings from database."""
    ...

# Billing operations
@billing.reasoner()
async def recommend_plan(user_id: str) -> PlanRecommendation:
    """Recommends subscription plan based on usage."""
    ...

@billing.skill()
def calculate_invoice(user_id: str, period: str) -> float:
    """Calculates invoice amount for billing period."""
    ...

# Support operations
@support.reasoner()
async def triage_ticket(ticket: dict) -> TriageDecision:
    """Triages support ticket and routes appropriately."""
    ...

# Include all routers in your agent
app.include_router(users)
app.include_router(billing)
app.include_router(support)

# Without router: analyze_user_behavior becomes:
curl -X POST http://localhost:8080/api/v1/execute/user-agent.analyze_user_behavior

# With router prefix "users": analyze_user_behavior becomes:
curl -X POST http://localhost:8080/api/v1/execute/user-agent.users_analyze_user_behavior