# Multi-Platform Content Multiplication System
# Tools: Windmill + OpenAI + Buffer + Airtable + RSS

# Trigger: New blog post published or content URL submitted
const contentInput = {
  url: trigger.content_url,
  title: trigger.title,
  excerpt: trigger.excerpt,
  author: trigger.author,
  tags: trigger.tags,
  target_platforms: ["twitter", "linkedin", "instagram", "tiktok"]
};

# Step 1: Content Analysis & Strategy Generation
const contentAnalysis = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [{
    role: "user", 
    content: `Analyze this content and create platform-specific strategies:
    
    URL: ${contentInput.url}
    Title: ${contentInput.title}
    Excerpt: ${contentInput.excerpt}
    Tags: ${contentInput.tags.join(", ")}
    
    For each platform (Twitter, LinkedIn, Instagram, TikTok), provide:
    - Key hook/angle that resonates with that audience
    - Optimal content format (thread, carousel, video, etc.)
    - 3 different messaging approaches (educational, controversial, behind-scenes)
    - Hashtag strategy (platform-specific)
    - Best posting times based on content type
    
    Return as JSON with platform-specific recommendations.`
  }],
  max_tokens: 800
});

const strategy = JSON.parse(contentAnalysis.choices[0].message.content);

# Step 2: Platform-Specific Content Generation
async function generatePlatformContent(platform, approach) {
  const platformSpecs = {
    twitter: { maxLength: 280, format: "thread", tone: "conversational" },
    linkedin: { maxLength: 1300, format: "post", tone: "professional" },
    instagram: { maxLength: 2200, format: "carousel", tone: "visual-first" },
    tiktok: { maxLength: 100, format: "video-script", tone: "energetic" }
  };
  
  const spec = platformSpecs[platform];
  
  const contentGeneration = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [{
      role: "user",
      content: `Create ${approach} content for ${platform}:
      
      Source: ${contentInput.title} - ${contentInput.excerpt}
      Strategy: ${strategy[platform].angles[approach]}
      Format: ${spec.format}
      Tone: ${spec.tone}
      Max length: ${spec.maxLength} characters
      
      Requirements:
      - Hook within first 10 words
      - Include call-to-action
      - Use hashtags: ${strategy[platform].hashtags}
      - ${platform === 'twitter' ? 'Create 3-tweet thread' : ''}
      - ${platform === 'instagram' ? 'Include 5 carousel slide titles' : ''}
      - ${platform === 'tiktok' ? 'Include visual cues and timing' : ''}
      
      Return ready-to-post content.`
    }],
    max_tokens: 500
  });
  
  return {
    platform: platform,
    approach: approach,
    content: contentGeneration.choices[0].message.content,
    hashtags: strategy[platform].hashtags,
    scheduledTime: strategy[platform].optimalTimes[0],
    format: spec.format
  };
}

# Step 3: Generate All Content Variations
const allContent = [];
for (const platform of contentInput.target_platforms) {
  for (const approach of ["educational", "controversial", "behind-scenes"]) {
    const content = await generatePlatformContent(platform, approach);
    allContent.push(content);
  }
}

# Step 4: Visual Asset Generation (for Instagram/TikTok)
async function generateVisualAssets(content) {
  if (content.platform === 'instagram' && content.format === 'carousel') {
    const visualPrompts = content.content.match(/Slide \d+: (.+)/g);
    
    for (let i = 0; i < visualPrompts.length; i++) {
      const imageGeneration = await openai.images.generate({
        model: "dall-e-3",
        prompt: `Create a modern, minimalist Instagram carousel slide: ${visualPrompts[i]}
                Brand colors: #2563eb, #f3f4f6
                Include space for text overlay
                Professional but engaging style`,
        size: "1024x1024",
        quality: "standard"
      });
      
      content.images = content.images || [];
      content.images.push(imageGeneration.data[0].url);
    }
  }
  return content;
}

# Step 5: Content Approval Workflow
async function sendForApproval(contentBatch) {
  const approvalRecord = {
    "Content Batch ID": `batch_${Date.now()}`,
    "Source Content": contentInput.title,
    "Generated Pieces": contentBatch.length,
    "Status": "Pending Review",
    "Review URL": `https://app.airtable.com/review/${contentBatch[0].id}`,
    "Auto-Approve Date": new Date(Date.now() + 24*60*60*1000).toISOString(),
    "Platforms": contentBatch.map(c => c.platform).join(", ")
  };
  
  await createAirtableRecord("Content Approval", approvalRecord);
  
  await sendSlackMessage({
    channel: "#content-review",
    text: `🎨 New content batch ready for review!
    
    Source: ${contentInput.title}
    Generated: ${contentBatch.length} pieces across ${contentInput.target_platforms.length} platforms
    
    📋 Review: ${approvalRecord["Review URL"]}
    ⏰ Auto-approve in 24h if no response
    
    Preview (Twitter Educational):
    ${contentBatch.find(c => c.platform === 'twitter' && c.approach === 'educational').content.substring(0, 200)}...`
  });
}

# Step 6: Smart Scheduling Algorithm
async function scheduleContent(approvedContent) {
  const scheduleStrategy = {
    twitter: [9, 13, 17], // 9am, 1pm, 5pm
    linkedin: [8, 12, 16], // 8am, 12pm, 4pm  
    instagram: [11, 15, 19], // 11am, 3pm, 7pm
    tiktok: [18, 20, 22] // 6pm, 8pm, 10pm
  };
  
  for (const content of approvedContent) {
    const platform = content.platform;
    const times = scheduleStrategy[platform];
    const scheduleTime = getNextOptimalTime(times);
    
    await bufferAPI.posts.create({
      profiles: [getPlatformProfileId(platform)],
      text: content.content,
      media: content.images || [],
      scheduled_at: scheduleTime,
      metadata: {
        source_url: contentInput.url,
        approach: content.approach,
        batch_id: content.batchId
      }
    });
  }
}

# Step 7: Performance Tracking Setup
async function setupTracking(scheduledContent) {
  for (const content of scheduledContent) {
    const trackingRecord = {
      "Content ID": content.id,
      "Platform": content.platform,
      "Approach": content.approach,
      "Scheduled Time": content.scheduledTime,
      "Source URL": contentInput.url,
      "Engagement Goal": getEngagementBenchmark(content.platform),
      "Status": "Scheduled"
    };
    
    await createAirtableRecord("Content Performance", trackingRecord);
  }
  
  // Schedule performance check in 48 hours
  await scheduleWorkflow("content-performance-check", {
    batchId: scheduledContent[0].batchId,
    runAt: new Date(Date.now() + 48*60*60*1000)
  });
}

# Main Execution Flow
const generatedContent = await Promise.all(
  allContent.map(c => generateVisualAssets(c))
);

await sendForApproval(generatedContent);

// Auto-approve and schedule after 24h if no manual review
setTimeout(async () => {
  const pendingContent = await getAirtableRecords("Content Approval", {
    filter: `AND({Status} = "Pending Review", {Auto-Approve Date} < NOW())`
  });
  
  for (const batch of pendingContent) {
    await scheduleContent(batch.content);
    await setupTracking(batch.content);
  }
}, 24 * 60 * 60 * 1000);