Get Inbox Replies

def check_daily_inbox():
    """Get all unread replies from today"""
    today_start = datetime.now().replace(hour=0, minute=0, second=0).isoformat() + 'Z'
    now = datetime.now().isoformat() + 'Z'
    
    payload = {
        "filters": {
            "emailStatus": "Replied",
            "replyTimeBetween": [today_start, now]
        },
        "sortBy": "REPLY_TIME_DESC",
        "limit": 20
    }
    
    response = get_inbox_replies(payload, fetch_history=False)
    
    unread = [msg for msg in response['messages'] if not msg['is_read']]
    print(f"{len(unread)} unread replies today")
    
    return unread

def get_hot_leads():
    """Get interested leads that replied recently"""
    three_days_ago = (datetime.now() - timedelta(days=3)).isoformat() + 'Z'
    
    payload = {
        "filters": {
            "leadCategories": {
                "categoryIdsIn": [1, 2]  # Interested, Meeting Request
            },
            "replyTimeBetween": [three_days_ago, datetime.now().isoformat() + 'Z']
        },
        "sortBy": "REPLY_TIME_DESC"
    }
    
    return get_inbox_replies(payload)

def get_team_workload(team_member_ids):
    """Check reply counts for each team member"""
    workload = {}
    
    for member_id in team_member_ids:
        payload = {
            "filters": {
                "campaignTeamMemberId": member_id,
                "emailStatus": "Replied"
            },
            "limit": 1  # Just need count
        }
        
        response = get_inbox_replies(payload)
        workload[member_id] = response.get('total_count', 0)
    
    return workload

def monitor_campaign_replies(campaign_ids, start_date, end_date):
    """Track reply metrics across campaigns"""
    payload = {
        "filters": {
            "campaignId": campaign_ids[:5],  # Max 5
            "replyTimeBetween": [start_date, end_date]
        },
        "limit": 20
    }
    
    response = get_inbox_replies(payload)
    messages = response.get('messages', [])
    
    # Calculate metrics
    metrics = {
        'total_replies': len(messages),
        'interested': len([m for m in messages 
                          if m.get('category', {}).get('id') == 1]),
        'by_campaign': {}
    }
    
    for msg in messages:
        campaign_id = msg['campaign']['id']
        if campaign_id not in metrics['by_campaign']:
            metrics['by_campaign'][campaign_id] = 0
        metrics['by_campaign'][campaign_id] += 1
    
    return metrics

# Fast list view
list_view_response = get_inbox_replies(
    payload,
    fetch_history=False  # Fast
)

# Then fetch details only when user clicks
def view_conversation(message_id):
    detailed_response = get_inbox_replies(
        {"filters": {"messageId": message_id}},
        fetch_history=True  # Full context
    )
    return detailed_response

# ✅ GOOD: Within limits
filters = {
    "campaignId": [12345, 12346, 12347],  # Max 5 OK
    "emailAccountId": [1, 2, 3, ..., 20],  # Max 20 OK
    "campaignTeamMemberId": [10, 11, 12]  # Max 10 OK
}

# ❌ BAD: Exceeds limits
filters = {
    "campaignId": [1, 2, 3, 4, 5, 6, 7],  # ERROR: Max 5
}

# Get engaged leads, exclude uninterested
filters = {
    "leadCategories": {
        "isAssigned": True,  # Has a category
        "categoryIdsNotIn": [3, 4]  # Exclude "Not Interested", "Do Not Contact"
    }
}

# Rolling windows for consistent monitoring
def get_recent_replies(days=7):
    end = datetime.now()
    start = end - timedelta(days=days)
    
    return {
        "replyTimeBetween": [
            start.isoformat() + 'Z',
            end.isoformat() + 'Z'
        ]
    }

# Start broad, narrow down based on results
def find_replies_progressive():
    # Step 1: Get all replies
    payload1 = {"filters": {"emailStatus": "Replied"}}
    result1 = get_inbox_replies(payload1)
    
    if result1['total_count'] > 100:
        # Step 2: Add time filter
        payload2 = {
            "filters": {
                "emailStatus": "Replied",
                "replyTimeBetween": get_recent_replies(7)
            }
        }
        result2 = get_inbox_replies(payload2)
        
        if result2['total_count'] > 50:
            # Step 3: Add category filter
            payload3 = payload2.copy()
            payload3["filters"]["leadCategories"] = {"categoryIdsIn": [1]}
            return get_inbox_replies(payload3)
        
        return result2
    
    return result1

def safe_get_inbox_replies(payload, fetch_history=False):
    """Get inbox replies with error handling"""
    try:
        response = requests.post(
            "https://server.smartlead.ai/api/v1/master-inbox/inbox-replies",
            params={
                "api_key": API_KEY,
                "fetch_message_history": fetch_history
            },
            json=payload,
            timeout=30  # 30 second timeout
        )
        
        response.raise_for_status()
        return response.json()
        
    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 422:
            print(f"Validation error: {e.response.json()}")
            # Adjust payload and retry
        elif e.response.status_code == 429:
            print("Rate limited - waiting 60 seconds")
            time.sleep(60)
            return safe_get_inbox_replies(payload, fetch_history)
        else:
            print(f"HTTP error: {e}")
            
    except requests.exceptions.Timeout:
        print("Request timed out - try with smaller limit or disable message history")
        
    except Exception as e:
        print(f"Unexpected error: {e}")
    
    return None