// Sort by AI recommendation score
const topCreators = searchResults.items
  .sort((a, b) => b.ai_recommendation.score - a.ai_recommendation.score)
  .slice(0, 10);

// Filter by minimum AI score threshold
const qualifiedCreators = searchResults.items.filter(
  creator => creator.ai_recommendation.score >= 0.85
);

console.log(`Top candidates: ${topCreators.length}`);
console.log(`Qualified creators: ${qualifiedCreators.length}`);

// Get recent posts for each creator
async function analyzeCreatorContent(creatorId) {
  const posts = await fetch(
    `https://api.influship.com/v1/posts/by-creator?creator_id=${creatorId}&limit=20`,
    {
      headers: { 'X-API-Key': process.env.INFLUSHIP_API_KEY }
    }
  ).then(r => r.json());

  // Calculate content metrics
  const avgEngagement = posts.items.reduce((sum, post) => 
    sum + post.engagement_rate, 0) / posts.items.length;
  
  const contentTypes = posts.items.reduce((types, post) => {
    types[post.type] = (types[post.type] || 0) + 1;
    return types;
  }, {});

  return {
    creator_id: creatorId,
    avg_engagement: avgEngagement,
    content_types: contentTypes,
    post_count: posts.items.length
  };
}

// Analyze all finalists
const contentAnalysis = await Promise.all(
  safeCreators.map(c => analyzeCreatorContent(c.creator_id))
);

function scoreCreator(creator, safetyResult, matchResult, contentAnalysis) {
  return {
    id: creator.id,
    name: creator.name,
    platform: creator.profiles[0].platform,
    username: creator.profiles[0].username,
    
    // Metrics
    followers: creator.profiles[0].follower_count,
    engagement_rate: creator.profiles[0].engagement_rate,
    
    // Scores
    ai_relevance: creator.ai_recommendation.score,
    match_score: matchResult.match_score,
    brand_safety: 1 - safetyResult.risk_score,
    
    // Content
    posts_per_week: creator.profiles[0].posts_per_week,
    avg_engagement: contentAnalysis.avg_engagement,
    
    // Composite score (weighted)
    overall_score: (
      creator.ai_recommendation.score * 0.3 +
      matchResult.match_score * 0.3 +
      (1 - safetyResult.risk_score) * 0.2 +
      (creator.profiles[0].engagement_rate / 100) * 0.2
    )
  };
}

// Generate final rankings
const finalRankings = rankedCreators.map(matchResult => {
  const creator = topCreators.find(c => c.id === matchResult.creator_id);
  const safety = safetyAnalysis.results.find(s => s.creator_id === matchResult.creator_id);
  const content = contentAnalysis.find(c => c.creator_id === matchResult.creator_id);
  
  return scoreCreator(creator, safety, matchResult, content);
}).sort((a, b) => b.overall_score - a.overall_score);

console.log('Top 10 Creators for Campaign:', finalRankings.slice(0, 10));

async function discoverCreatorsForCampaign(campaignQuery, filters) {
  const API_KEY = process.env.INFLUSHIP_API_KEY;
  
  // Step 1: Search for creators
  console.log('🔍 Searching for creators...');
  const search = await fetch('https://api.influship.com/v1/search', {
    method: 'POST',
    headers: { 'X-API-Key': API_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify({ query: campaignQuery, filters, limit: 25 })
  }).then(r => r.json());
  
  console.log(`✅ Found ${search.items.length} creators`);
  
  // Step 2: Find lookalikes using top 3 creators
  console.log('👥 Finding similar creators...');
  const topSeeds = search.items
    .sort((a, b) => b.ai_recommendation.score - a.ai_recommendation.score)
    .slice(0, 3);
  
  const lookalikes = await fetch('https://api.influship.com/v1/lookalike', {
    method: 'POST',
    headers: { 'X-API-Key': API_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify({
      seeds: topSeeds.map(c => ({ id: c.id, weight: 1.0 })),
      limit: 30
    })
  }).then(r => r.json());
  
  console.log(`✅ Found ${lookalikes.items.length} similar creators`);
  
  // Step 3: Combine and deduplicate
  const allCreators = [...search.items, ...lookalikes.items];
  const uniqueCreators = [...new Map(
    allCreators.map(c => [c.id, c])
  ).values()];
  
  // Step 4: Brand safety check
  console.log('🛡️ Analyzing brand safety...');
  const safety = await fetch('https://api.influship.com/v1/brand-safety/creators', {
    method: 'POST',
    headers: { 'X-API-Key': API_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify({ creator_ids: uniqueCreators.map(c => c.id) })
  }).then(r => r.json());
  
  const safeCreators = safety.results.filter(r => r.risk_level !== 'high');
  console.log(`✅ ${safeCreators.length} creators passed safety check`);
  
  // Step 5: Match and score
  console.log('🎯 Scoring creators for campaign...');
  const matches = await fetch('https://api.influship.com/v1/match', {
    method: 'POST',
    headers: { 'X-API-Key': API_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify({
      creators: safeCreators.map(s => ({ id: s.creator_id })),
      search_intent: { query: campaignQuery }
    })
  }).then(r => r.json());
  
  // Step 6: Final rankings
  const rankings = matches.results
    .map(match => {
      const creator = uniqueCreators.find(c => c.id === match.creator_id);
      const safetyScore = safety.results.find(s => s.creator_id === match.creator_id);
      
      return {
        ...creator,
        match_score: match.match_score,
        safety_score: 1 - safetyScore.risk_score,
        overall_score: (match.match_score + creator.ai_recommendation.score) / 2
      };
    })
    .sort((a, b) => b.overall_score - a.overall_score);
  
  console.log(`✅ Campaign discovery complete! Top ${rankings.length} creators ranked.`);
  
  return rankings;
}

// Usage
const results = await discoverCreatorsForCampaign(
  'sustainable fashion influencers with engaged millennial audiences',
  {
    platform_filters: [{
      platform: 'instagram',
      min_followers: 10000,
      max_followers: 500000,
      min_engagement_rate: 3.0
    }]
  }
);

console.log('Top 10 Creators:', results.slice(0, 10));