The Rise of AI in Content Creation: Transforming Communications, Media, and Information Services

import openai
import requests
from datetime import datetime
from typing import Dict, List, Optional
import json

class AIContentCreator:
    def __init__(self, api_key: str, model: str = "gpt-4"):
        self.client = openai.OpenAI(api_key=api_key)
        self.model = model
        self.brand_voice = {}
        self.content_templates = {}
        
    def set_brand_voice(self, tone: str, style: str, keywords: List[str]):
        """Configure brand voice parameters for consistent content creation"""
        self.brand_voice = {
            'tone': tone,
            'style': style,
            'keywords': keywords,
            'voice_description': f"Content should be {tone} in tone, {style} in style, and include keywords: {', '.join(keywords)}"
        }
        
    def generate_article(self, topic: str, word_count: int = 800, target_audience: str = "general") -> Dict:
        """Generate a complete article with AI assistance"""
        
        # Create comprehensive prompt
        prompt = f"""
        Write a {word_count}-word article about {topic} for {target_audience} audience.
        
        Brand Voice Guidelines:
        {self.brand_voice.get('voice_description', 'Professional and engaging')}
        
        Article Structure:
        1. Compelling headline
        2. Engaging introduction (100-150 words)
        3. Main content with 3-4 key sections
        4. Conclusion with call-to-action
        
        Include:
        - Data-backed insights where relevant
        - Actionable takeaways
        - SEO-friendly subheadings
        - Natural keyword integration
        
        Format as JSON with: headline, introduction, sections, conclusion, meta_description, suggested_tags
        """
        
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": "You are an expert content creator and journalist with deep knowledge across industries."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.7,
                max_tokens=2000
            )
            
            # Parse the response
            content = json.loads(response.choices[0].message.content)
            
            # Add metadata
            content['generated_at'] = datetime.now().isoformat()
            content['word_count'] = word_count
            content['target_audience'] = target_audience
            content['ai_confidence'] = self._calculate_confidence_score(content)
            
            return content
            
        except Exception as e:
            return {'error': f'Content generation failed: {str(e)}'}
    
    def create_social_media_content(self, base_content: str, platforms: List[str]) -> Dict:
        """Adapt content for different social media platforms"""
        
        platform_specs = {
            'twitter': {'max_length': 280, 'style': 'concise and engaging'},
            'linkedin': {'max_length': 3000, 'style': 'professional and insightful'},
            'instagram': {'max_length': 2200, 'style': 'visual-friendly with hashtags'},
            'facebook': {'max_length': 500, 'style': 'conversational and shareable'},
            'youtube': {'max_length': 5000, 'style': 'descriptive for video content'}
        }
        
        social_content = {}
        
        for platform in platforms:
            if platform not in platform_specs:
                continue
                
            specs = platform_specs[platform]
            
            prompt = f"""
            Adapt this content for {platform}:
            
            Original Content: {base_content[:1000]}...
            
            Platform Requirements:
            - Maximum length: {specs['max_length']} characters
            - Style: {specs['style']}
            - Brand voice: {self.brand_voice.get('tone', 'professional')}
            
            Create engaging {platform} post that:
            1. Captures attention in first few words
            2. Includes relevant hashtags (if appropriate)
            3. Has clear call-to-action
            4. Optimizes for {platform} algorithm
            
            Return as JSON with: post_text, hashtags, call_to_action, estimated_engagement
            """
            
            try:
                response = self.client.chat.completions.create(
                    model=self.model,
                    messages=[
                        {"role": "system", "content": f"You are a social media expert specializing in {platform} content optimization."},
                        {"role": "user", "content": prompt}
                    ],
                    temperature=0.8,
                    max_tokens=800
                )
                
                platform_content = json.loads(response.choices[0].message.content)
                platform_content['platform'] = platform
                platform_content['character_count'] = len(platform_content.get('post_text', ''))
                
                social_content[platform] = platform_content
                
            except Exception as e:
                social_content[platform] = {'error': f'Failed to generate {platform} content: {str(e)}'}
        
        return social_content
    
    def generate_video_script(self, topic: str, duration_minutes: int = 5, video_type: str = "educational") -> Dict:
        """Generate video script with timing and visual cues"""
        
        prompt = f"""
        Create a {duration_minutes}-minute {video_type} video script about {topic}.
        
        Script Requirements:
        - Engaging hook in first 15 seconds
        - Clear structure with smooth transitions
        - Visual cues for production team
        - Audience retention techniques
        - Strong call-to-action
        
        Brand Voice: {self.brand_voice.get('voice_description', 'Professional and engaging')}
        
        Format as JSON with:
        - title
        - hook (0-15 seconds)
        - introduction (15-45 seconds)
        - main_sections (with timing and visual_cues)
        - conclusion (last 30 seconds)
        - total_estimated_words
        - production_notes
        """
        
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": "You are a professional video script writer with expertise in audience engagement and retention."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.7,
                max_tokens=1500
            )
            
            script = json.loads(response.choices[0].message.content)
            script['duration_minutes'] = duration_minutes
            script['video_type'] = video_type
            script['generated_at'] = datetime.now().isoformat()
            
            return script
            
        except Exception as e:
            return {'error': f'Script generation failed: {str(e)}'}
    
    def optimize_content_seo(self, content: str, target_keywords: List[str], search_intent: str = "informational") -> Dict:
        """Optimize content for search engines while maintaining readability"""
        
        prompt = f"""
        Optimize this content for SEO:
        
        Content: {content[:1500]}...
        Target Keywords: {', '.join(target_keywords)}
        Search Intent: {search_intent}
        
        Optimization Requirements:
        1. Natural keyword integration (2-3% density)
        2. SEO-friendly headings (H1, H2, H3)
        3. Meta description (150-160 characters)
        4. Internal linking opportunities
        5. Featured snippet optimization
        6. Readability improvements
        
        Return JSON with:
        - optimized_content
        - meta_description
        - title_suggestions (3 options)
        - heading_structure
        - keyword_density_analysis
        - seo_score (1-100)
        - improvement_recommendations
        """
        
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": "You are an SEO expert with deep knowledge of search algorithm optimization and content marketing."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.6,
                max_tokens=2000
            )
            
            seo_optimization = json.loads(response.choices[0].message.content)
            seo_optimization['target_keywords'] = target_keywords
            seo_optimization['search_intent'] = search_intent
            seo_optimization['optimized_at'] = datetime.now().isoformat()
            
            return seo_optimization
            
        except Exception as e:
            return {'error': f'SEO optimization failed: {str(e)}'}
    
    def analyze_content_performance(self, content: str, engagement_metrics: Dict) -> Dict:
        """Analyze content performance and suggest improvements"""
        
        prompt = f"""
        Analyze this content's performance and suggest improvements:
        
        Content Sample: {content[:800]}...
        
        Engagement Metrics:
        - Views: {engagement_metrics.get('views', 0)}
        - Likes: {engagement_metrics.get('likes', 0)}
        - Shares: {engagement_metrics.get('shares', 0)}
        - Comments: {engagement_metrics.get('comments', 0)}
        - Time on Page: {engagement_metrics.get('time_on_page', 0)} seconds
        - Bounce Rate: {engagement_metrics.get('bounce_rate', 0)}%
        
        Provide analysis as JSON:
        - performance_score (1-100)
        - strength_areas
        - improvement_opportunities
        - content_optimization_suggestions
        - audience_engagement_insights
        - next_content_recommendations
        """
        
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": "You are a content analytics expert specializing in performance optimization and audience engagement."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.5,
                max_tokens=1200
            )
            
            analysis = json.loads(response.choices[0].message.content)
            analysis['analyzed_at'] = datetime.now().isoformat()
            analysis['input_metrics'] = engagement_metrics
            
            return analysis
            
        except Exception as e:
            return {'error': f'Performance analysis failed: {str(e)}'}
    
    def _calculate_confidence_score(self, content: Dict) -> float:
        """Calculate AI confidence score based on content completeness and structure"""
        score = 0.0
        
        # Check for required fields
        required_fields = ['headline', 'introduction', 'sections', 'conclusion']
        for field in required_fields:
            if field in content and content[field]:
                score += 25.0
        
        # Bonus for additional quality indicators
        if 'meta_description' in content:
            score += 5.0
        if 'suggested_tags' in content:
            score += 5.0
            
        return min(100.0, score)
    
    def get_content_calendar(self, themes: List[str], days: int = 30) -> Dict:
        """Generate content calendar with AI-suggested topics and scheduling"""
        
        prompt = f"""
        Create a {days}-day content calendar for these themes: {', '.join(themes)}
        
        Calendar Requirements:
        1. Diverse content types (articles, social posts, videos)
        2. Optimal posting times for engagement
        3. Seasonal relevance and trending topics
        4. Brand voice consistency: {self.brand_voice.get('tone', 'professional')}
        5. Cross-platform content repurposing opportunities
        
        Return JSON with daily entries including:
        - date
        - content_type
        - topic
        - platform
        - estimated_reach
        - production_time_hours
        - priority_level
        """
        
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": "You are a content strategist expert in editorial calendars and audience engagement optimization."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.7,
                max_tokens=2000
            )
            
            calendar = json.loads(response.choices[0].message.content)
            calendar['themes'] = themes
            calendar['duration_days'] = days
            calendar['generated_at'] = datetime.now().isoformat()
            
            return calendar
            
        except Exception as e:
            return {'error': f'Content calendar generation failed: {str(e)}'}

# Example usage:
# creator = AIContentCreator(api_key="your-openai-key")
# creator.set_brand_voice("professional", "informative", ["innovation", "technology"])
# 
# # Generate article
# article = creator.generate_article("The Future of AI in Media", 1200, "media professionals")
# 
# # Create social content
# social = creator.create_social_media_content(article['introduction'], ["twitter", "linkedin"])
# 
# # Generate video script
# script = creator.generate_video_script("AI Content Creation Tips", 7, "tutorial")

class AIContentManagementSystem {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.contentQueue = [];
    this.publishingSchedule = new Map();
    this.performanceMetrics = new Map();
    this.brandGuidelines = {};
  }

  // Set brand voice and guidelines for consistent AI generation
  setBrandGuidelines(guidelines) {
    this.brandGuidelines = {
      tone: guidelines.tone || 'professional',
      style: guidelines.style || 'informative',
      keywords: guidelines.keywords || [],
      avoidWords: guidelines.avoidWords || [],
      targetAudience: guidelines.targetAudience || 'general',
      brandValues: guidelines.brandValues || [],
      voiceDescription: this.createVoiceDescription(guidelines)
    };
  }

  createVoiceDescription(guidelines) {
    return `Create content that is ${guidelines.tone} in tone, ${guidelines.style} in style. ` +
           `Target audience: ${guidelines.targetAudience}. ` +
           `Include these keywords naturally: ${guidelines.keywords?.join(', ')}. ` +
           `Avoid these words: ${guidelines.avoidWords?.join(', ')}. ` +
           `Align with brand values: ${guidelines.brandValues?.join(', ')}.`;
  }

  // Generate content ideas based on trending topics and brand alignment
  async generateContentIdeas(topic, contentType, count = 5) {
    const prompt = {
      system: "You are a creative content strategist with expertise in viral content and audience engagement.",
      user: `Generate ${count} creative content ideas about ${topic} for ${contentType}. 
             
             Brand Guidelines: ${this.brandGuidelines.voiceDescription}
             
             For each idea, provide:
             - catchy_title
             - brief_description
             - target_audience_segment
             - estimated_engagement_potential (high/medium/low)
             - content_pillars_alignment
             - suggested_format (video/article/infographic/social_post)
             - trending_elements
             
             Return as JSON array.`
    };

    try {
      const response = await this.callAIAPI(prompt);
      const ideas = JSON.parse(response.content);
      
      // Score and rank ideas
      const rankedIdeas = ideas.map(idea => ({
        ...idea,
        aiScore: this.calculateContentScore(idea),
        generatedAt: new Date().toISOString()
      })).sort((a, b) => b.aiScore - a.aiScore);

      return rankedIdeas;
    } catch (error) {
      console.error('Content idea generation failed:', error);
      return [];
    }
  }

  // Auto-generate content based on approved ideas
  async generateContent(contentIdea, specifications) {
    const contentSpecs = {
      wordCount: specifications.wordCount || 800,
      format: specifications.format || 'article',
      platform: specifications.platform || 'blog',
      seoKeywords: specifications.seoKeywords || [],
      callToAction: specifications.callToAction || 'engage',
      includeImages: specifications.includeImages || false
    };

    const prompt = {
      system: `You are an expert content creator specializing in ${contentSpecs.format} creation for ${contentSpecs.platform}.`,
      user: `Create ${contentSpecs.format} content based on this idea:
             
             Title: ${contentIdea.catchy_title}
             Description: ${contentIdea.brief_description}
             Target Audience: ${contentIdea.target_audience_segment}
             
             Specifications:
             - Word count: ${contentSpecs.wordCount}
             - Platform: ${contentSpecs.platform}
             - SEO Keywords: ${contentSpecs.seoKeywords.join(', ')}
             - Call to action: ${contentSpecs.callToAction}
             
             Brand Voice: ${this.brandGuidelines.voiceDescription}
             
             Create comprehensive content with:
             - engaging_headline
             - hook_introduction
             - structured_body_content
             - compelling_conclusion
             - meta_description
             - suggested_hashtags
             - image_suggestions (if requested)
             
             Return as JSON object.`
    };

    try {
      const response = await this.callAIAPI(prompt);
      const content = JSON.parse(response.content);
      
      // Add metadata and quality checks
      const processedContent = {
        ...content,
        id: this.generateContentId(),
        originalIdea: contentIdea,
        specifications: contentSpecs,
        createdAt: new Date().toISOString(),
        status: 'draft',
        qualityScore: await this.assessContentQuality(content),
        seoScore: this.calculateSEOScore(content, contentSpecs.seoKeywords),
        brandAlignmentScore: this.checkBrandAlignment(content)
      };

      // Auto-queue for review if quality meets threshold
      if (processedContent.qualityScore > 80) {
        this.addToQueue(processedContent);
      }

      return processedContent;
    } catch (error) {
      console.error('Content generation failed:', error);
      return null;
    }
  }

  // Optimize content for multiple platforms
  async adaptContentForPlatforms(baseContent, targetPlatforms) {
    const platformSpecs = {
      facebook: { maxLength: 500, style: 'conversational', includeHashtags: false },
      twitter: { maxLength: 280, style: 'concise', includeHashtags: true },
      linkedin: { maxLength: 3000, style: 'professional', includeHashtags: false },
      instagram: { maxLength: 2200, style: 'visual-first', includeHashtags: true },
      youtube: { maxLength: 5000, style: 'descriptive', includeHashtags: true },
      tiktok: { maxLength: 150, style: 'trendy', includeHashtags: true }
    };

    const adaptedContent = {};

    for (const platform of targetPlatforms) {
      if (!platformSpecs[platform]) continue;

      const specs = platformSpecs[platform];
      const prompt = {
        system: `You are a ${platform} content optimization expert.`,
        user: `Adapt this content for ${platform}:
               
               Original Content: ${baseContent.structured_body_content?.substring(0, 1000)}...
               Original Title: ${baseContent.engaging_headline}
               
               Platform Requirements:
               - Max length: ${specs.maxLength} characters
               - Style: ${specs.style}
               - Include hashtags: ${specs.includeHashtags}
               
               Brand Voice: ${this.brandGuidelines.voiceDescription}
               
               Create optimized ${platform} content with:
               - platform_optimized_text
               - relevant_hashtags (if applicable)
               - call_to_action
               - engagement_hooks
               - posting_time_recommendation
               
               Return as JSON object.`
      };

      try {
        const response = await this.callAIAPI(prompt);
        const platformContent = JSON.parse(response.content);
        
        adaptedContent[platform] = {
          ...platformContent,
          platform: platform,
          originalContentId: baseContent.id,
          characterCount: platformContent.platform_optimized_text?.length || 0,
          adaptedAt: new Date().toISOString(),
          estimatedReach: this.estimateReach(platform, platformContent)
        };
      } catch (error) {
        console.error(`Failed to adapt content for ${platform}:`, error);
        adaptedContent[platform] = { error: `Adaptation failed: ${error.message}` };
      }
    }

    return adaptedContent;
  }

  // Smart content scheduling based on audience analytics
  scheduleContent(content, targetPlatforms, publishingStrategy = 'optimal') {
    const schedules = {};
    
    targetPlatforms.forEach(platform => {
      const optimalTimes = this.getOptimalPostingTimes(platform);
      const contentCalendar = this.getContentCalendar(platform);
      
      let scheduledTime;
      
      switch (publishingStrategy) {
        case 'immediate':
          scheduledTime = new Date();
          break;
        case 'optimal':
          scheduledTime = this.findNextOptimalSlot(platform, optimalTimes, contentCalendar);
          break;
        case 'coordinated':
          scheduledTime = this.coordinateAcrossPlatforms(platform, targetPlatforms);
          break;
        default:
          scheduledTime = this.findNextOptimalSlot(platform, optimalTimes, contentCalendar);
      }
      
      schedules[platform] = {
        scheduledTime: scheduledTime.toISOString(),
        platform: platform,
        contentId: content.id,
        estimatedReach: this.estimateReach(platform, content),
        competitorAnalysis: this.analyzeCompetitorActivity(platform, scheduledTime)
      };
      
      // Add to publishing queue
      this.publishingSchedule.set(`${platform}_${content.id}`, schedules[platform]);
    });
    
    return schedules;
  }

  // Monitor content performance and suggest optimizations
  async analyzePerformance(contentId, platformMetrics) {
    const content = this.getContentById(contentId);
    if (!content) return null;

    const prompt = {
      system: "You are a content performance analyst with expertise in engagement optimization.",
      user: `Analyze this content's performance across platforms:
             
             Content Title: ${content.engaging_headline}
             Content Type: ${content.specifications?.format}
             
             Performance Metrics:
             ${Object.entries(platformMetrics).map(([platform, metrics]) => 
               `${platform}: Views: ${metrics.views}, Engagement: ${metrics.engagement_rate}%, Shares: ${metrics.shares}`
             ).join('\n')}
             
             Provide analysis with:
             - overall_performance_score (1-100)
             - best_performing_platform
             - engagement_insights
             - optimization_recommendations
             - content_improvement_suggestions
             - next_content_strategy
             
             Return as JSON object.`
    };

    try {
      const response = await this.callAIAPI(prompt);
      const analysis = JSON.parse(response.content);
      
      // Store performance data for future optimization
      this.performanceMetrics.set(contentId, {
        ...analysis,
        platformMetrics: platformMetrics,
        analyzedAt: new Date().toISOString(),
        contentType: content.specifications?.format,
        brandAlignment: content.brandAlignmentScore
      });
      
      return analysis;
    } catch (error) {
      console.error('Performance analysis failed:', error);
      return null;
    }
  }

  // Utility methods
  calculateContentScore(idea) {
    let score = 0;
    if (idea.estimated_engagement_potential === 'high') score += 40;
    else if (idea.estimated_engagement_potential === 'medium') score += 25;
    else score += 10;
    
    if (idea.trending_elements?.length > 0) score += 20;
    if (idea.content_pillars_alignment) score += 20;
    if (idea.target_audience_segment === this.brandGuidelines.targetAudience) score += 20;
    
    return Math.min(100, score);
  }

  async assessContentQuality(content) {
    // Simplified quality assessment
    let score = 0;
    
    if (content.engaging_headline?.length > 10) score += 20;
    if (content.hook_introduction?.length > 50) score += 20;
    if (content.structured_body_content?.length > 200) score += 30;
    if (content.compelling_conclusion?.length > 50) score += 20;
    if (content.meta_description?.length > 120 && content.meta_description?.length < 160) score += 10;
    
    return Math.min(100, score);
  }

  calculateSEOScore(content, keywords) {
    if (!keywords.length) return 50;
    
    const fullText = `${content.engaging_headline} ${content.structured_body_content} ${content.meta_description}`;
    const keywordDensity = keywords.reduce((acc, keyword) => {
      const regex = new RegExp(keyword, 'gi');
      const matches = (fullText.match(regex) || []).length;
      return acc + matches;
    }, 0);
    
    return Math.min(100, (keywordDensity / keywords.length) * 20);
  }

  checkBrandAlignment(content) {
    const fullText = `${content.engaging_headline} ${content.structured_body_content}`.toLowerCase();
    let score = 50; // Base score
    
    // Check for brand keywords
    this.brandGuidelines.keywords?.forEach(keyword => {
      if (fullText.includes(keyword.toLowerCase())) score += 10;
    });
    
    // Check for avoided words
    this.brandGuidelines.avoidWords?.forEach(word => {
      if (fullText.includes(word.toLowerCase())) score -= 15;
    });
    
    return Math.max(0, Math.min(100, score));
  }

  async callAIAPI(prompt) {
    // Simulate API call - replace with actual OpenAI API call
    return new Promise((resolve) => {
      setTimeout(() => {
        resolve({
          content: JSON.stringify({
            message: "AI-generated content based on prompt",
            timestamp: new Date().toISOString()
          })
        });
      }, 1000);
    });
  }

  generateContentId() {
    return 'content_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
  }

  addToQueue(content) {
    this.contentQueue.push(content);
    console.log(`Content "${content.engaging_headline}" added to queue`);
  }

  getOptimalPostingTimes(platform) {
    // Platform-specific optimal posting times
    const times = {
      facebook: ['09:00', '13:00', '15:00'],
      twitter: ['08:00', '12:00', '17:00', '19:00'],
      linkedin: ['08:00', '10:00', '12:00', '14:00', '17:00'],
      instagram: ['11:00', '13:00', '17:00', '19:00'],
      youtube: ['14:00', '16:00', '18:00', '20:00'],
      tiktok: ['06:00', '10:00', '19:00', '21:00']
    };
    
    return times[platform] || ['12:00'];
  }

  findNextOptimalSlot(platform, optimalTimes, contentCalendar) {
    // Find next available optimal time slot
    const now = new Date();
    const tomorrow = new Date(now.getTime() + 24 * 60 * 60 * 1000);
    
    // Simplified scheduling - use first optimal time tomorrow
    const timeSlot = optimalTimes[0];
    const [hours, minutes] = timeSlot.split(':').map(Number);
    
    tomorrow.setHours(hours, minutes, 0, 0);
    return tomorrow;
  }

  estimateReach(platform, content) {
    // Simplified reach estimation based on platform and content quality
    const baseReach = {
      facebook: 1000,
      twitter: 500,
      linkedin: 300,
      instagram: 800,
      youtube: 2000,
      tiktok: 1500
    };
    
    const qualityMultiplier = (content.qualityScore || 70) / 100;
    return Math.round((baseReach[platform] || 500) * qualityMultiplier);
  }
}

// Example usage:
// const cms = new AIContentManagementSystem('your-api-key');
// cms.setBrandGuidelines({
//   tone: 'professional',
//   style: 'informative',
//   keywords: ['AI', 'technology', 'innovation'],
//   targetAudience: 'tech professionals'
// });
// 
// const ideas = await cms.generateContentIdeas('AI in content creation', 'article', 3);
// const content = await cms.generateContent(ideas[0], { wordCount: 1200, platform: 'blog' });
// const adaptedContent = await cms.adaptContentForPlatforms(content, ['twitter', 'linkedin']);