const { Zapserp } = require('zapserp')

class SEOContentGapAnalyzer {
  constructor(apiKey) {
    this.zapserp = new Zapserp({ apiKey })
    this.competitorData = new Map()
    this.gapOpportunities = []
    this.keywordDifficulty = new Map()
  }

  async analyzeContentGaps(yourDomain, competitors, niche) {
    console.log(`🔍 Starting content gap analysis for ${yourDomain}`)
    
    const analysis = {
      domain: yourDomain,
      competitors,
      niche,
      timestamp: new Date().toISOString(),
      gaps: [],
      opportunities: [],
      recommendations: [],
      summary: {}
    }

    // Analyze your current content footprint
    const yourContent = await this.analyzeDomainContent(yourDomain, niche)
    
    // Analyze each competitor
    for (const competitor of competitors) {
      try {
        const competitorContent = await this.analyzeDomainContent(competitor, niche)
        this.competitorData.set(competitor, competitorContent)
        
        // Find gaps between your content and competitor content
        const gaps = this.findContentGaps(yourContent, competitorContent, competitor)
        analysis.gaps.push(...gaps)
        
        // Brief delay between competitor analyses
        await this.delay(2000)
        
      } catch (error) {
        console.error(`Failed to analyze competitor ${competitor}:`, error)
      }
    }

    // Process and prioritize opportunities
    analysis.opportunities = this.prioritizeOpportunities(analysis.gaps)
    analysis.recommendations = this.generateRecommendations(analysis.opportunities)
    analysis.summary = this.generateSummary(analysis)

    console.log(`✅ Found ${analysis.opportunities.length} content gap opportunities`)
    return analysis
  }

  async analyzeDomainContent(domain, niche) {
    const searchQueries = this.generateDomainQueries(domain, niche)
    const contentData = {
      domain,
      topics: new Set(),
      keywords: new Set(),
      contentTypes: new Map(),
      rankingPages: [],
      topicalCoverage: new Map()
    }

    for (const query of searchQueries) {
      try {
        const searchResults = await this.zapserp.search({
          query: `site:${domain} ${query}`,
          engines: ['google'],
          limit: 10,
          country: 'us'
        })

        // Process results to extract content insights
        searchResults.results.forEach(result => {
          if (result.url.includes(domain)) {
            this.extractContentInsights(result, contentData, query)
          }
        })

      } catch (error) {
        console.error(`Domain analysis failed for query: ${query}`, error)
      }
    }

    // Also analyze what this domain ranks for in the niche
    await this.analyzeRankingQueries(domain, niche, contentData)

    return contentData
  }

  generateDomainQueries(domain, niche) {
    const commonContentTypes = [
      'guide', 'tutorial', 'tips', 'best practices', 'how to',
      'review', 'comparison', 'list', 'examples', 'tools'
    ]

    const queries = []
    
    // Generate niche-specific queries
    commonContentTypes.forEach(type => {
      queries.push(`${niche} ${type}`)
    })

    // Add broader topic queries
    queries.push(
      niche,
      `${niche} resources`,
      `${niche} tools`,
      `${niche} software`,
      `${niche} solutions`
    )

    return queries.slice(0, 12) // Limit to avoid rate limits
  }

  async analyzeRankingQueries(domain, niche, contentData) {
    // Discover what queries this domain actually ranks for
    const rankingQueries = [
      `${niche} ${domain}`,
      `site:${domain} ${niche}`,
      `"${domain}" ${niche} ranking`
    ]

    for (const query of rankingQueries) {
      try {
        const results = await this.zapserp.search({
          query,
          engines: ['google'],
          limit: 15
        })

        results.results.forEach(result => {
          if (result.url.includes(domain)) {
            contentData.rankingPages.push({
              url: result.url,
              title: result.title,
              snippet: result.snippet,
              query,
              estimatedPosition: result.position || 'unknown'
            })
          }
        })

      } catch (error) {
        console.error(`Ranking analysis failed for ${domain}:`, error)
      }
    }
  }

  extractContentInsights(result, contentData, query) {
    const title = result.title.toLowerCase()
    const snippet = result.snippet.toLowerCase()
    const fullText = `${title} ${snippet}`

    // Extract topics and keywords
    const words = fullText.match(/\b\w{3,}\b/g) || []
    words.forEach(word => {
      if (word.length > 3 && !this.isStopWord(word)) {
        contentData.keywords.add(word)
      }
    })

    // Identify content types
    const contentTypeIndicators = {
      guide: ['guide', 'tutorial', 'how to', 'step by step'],
      list: ['best', 'top', 'list', 'ways', 'methods'],
      review: ['review', 'comparison', 'vs', 'versus'],
      resource: ['tools', 'resources', 'software', 'platforms'],
      news: ['news', 'update', 'latest', 'new', 'announced']
    }

    Object.entries(contentTypeIndicators).forEach(([type, indicators]) => {
      if (indicators.some(indicator => fullText.includes(indicator))) {
        const count = contentData.contentTypes.get(type) || 0
        contentData.contentTypes.set(type, count + 1)
      }
    })

    // Extract main topics
    this.extractTopics(fullText, contentData.topics)
  }

  extractTopics(text, topicsSet) {
    // Simple topic extraction based on noun phrases
    const topicPatterns = [
      /\b[a-z]+(?:\s+[a-z]+){1,2}\b/g, // 2-3 word phrases
    ]

    topicPatterns.forEach(pattern => {
      const matches = text.match(pattern) || []
      matches.forEach(match => {
        if (match.length > 5 && !this.isStopPhrase(match)) {
          topicsSet.add(match.trim())
        }
      })
    })
  }

  isStopWord(word) {
    const stopWords = ['the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can', 'had', 'her', 'was', 'one', 'our', 'out', 'day', 'get', 'has', 'him', 'his', 'how', 'its', 'may', 'new', 'now', 'old', 'see', 'two', 'who', 'boy', 'did', 'man', 'way']
    return stopWords.includes(word.toLowerCase())
  }

  isStopPhrase(phrase) {
    const stopPhrases = ['the best', 'how to', 'you can', 'this is', 'that are']
    return stopPhrases.some(stop => phrase.includes(stop))
  }

  findContentGaps(yourContent, competitorContent, competitorDomain) {
    const gaps = []

    // Find topics competitor covers that you don't
    competitorContent.topics.forEach(topic => {
      if (!yourContent.topics.has(topic)) {
        gaps.push({
          type: 'topic_gap',
          competitor: competitorDomain,
          opportunity: topic,
          description: `Competitor covers "${topic}" which you don't`,
          priority: this.calculateTopicPriority(topic, competitorContent)
        })
      }
    })

    // Find content types competitor uses that you don't
    competitorContent.contentTypes.forEach((count, type) => {
      const yourCount = yourContent.contentTypes.get(type) || 0
      if (count > yourCount * 2) { // Competitor has significantly more
        gaps.push({
          type: 'content_type_gap',
          competitor: competitorDomain,
          opportunity: type,
          description: `Competitor has ${count} ${type} pieces vs your ${yourCount}`,
          priority: this.calculateContentTypePriority(type, count, yourCount)
        })
      }
    })

    // Find keyword gaps
    competitorContent.keywords.forEach(keyword => {
      if (!yourContent.keywords.has(keyword) && this.isValuableKeyword(keyword)) {
        gaps.push({
          type: 'keyword_gap',
          competitor: competitorDomain,
          opportunity: keyword,
          description: `Competitor ranks for "${keyword}" keyword`,
          priority: this.calculateKeywordPriority(keyword)
        })
      }
    })

    return gaps
  }

  calculateTopicPriority(topic, competitorContent) {
    // Higher priority for topics that appear frequently
    let score = 0
    
    // Check frequency in competitor's content
    const topicFrequency = Array.from(competitorContent.topics).filter(t => 
      t.includes(topic) || topic.includes(t)
    ).length
    
    score += Math.min(topicFrequency * 0.2, 1)
    
    // Bonus for business-relevant topics
    const businessKeywords = ['marketing', 'sales', 'growth', 'strategy', 'optimization']
    if (businessKeywords.some(kw => topic.includes(kw))) {
      score += 0.3
    }
    
    return Math.min(score, 1)
  }

  calculateContentTypePriority(type, competitorCount, yourCount) {
    const gap = competitorCount - yourCount
    let priority = Math.min(gap * 0.1, 1)
    
    // Boost priority for high-value content types
    const highValueTypes = ['guide', 'tutorial', 'review', 'comparison']
    if (highValueTypes.includes(type)) {
      priority += 0.2
    }
    
    return Math.min(priority, 1)
  }

  calculateKeywordPriority(keyword) {
    let priority = 0.5 // Base priority
    
    // Higher priority for longer, more specific keywords
    if (keyword.length > 8) priority += 0.2
    if (keyword.includes(' ')) priority += 0.1
    
    // Commercial intent keywords get higher priority
    const commercialIndicators = ['buy', 'price', 'cost', 'review', 'best', 'vs', 'compare']
    if (commercialIndicators.some(indicator => keyword.includes(indicator))) {
      priority += 0.3
    }
    
    return Math.min(priority, 1)
  }

  isValuableKeyword(keyword) {
    // Filter out low-value keywords
    if (keyword.length < 4) return false
    if (/^\d+$/.test(keyword)) return false // Pure numbers
    if (this.isStopWord(keyword)) return false
    
    return true
  }

  prioritizeOpportunities(gaps) {
    return gaps
      .sort((a, b) => b.priority - a.priority)
      .slice(0, 20) // Top 20 opportunities
      .map((gap, index) => ({
        ...gap,
        rank: index + 1,
        urgency: this.calculateUrgency(gap),
        estimatedEffort: this.estimateEffort(gap)
      }))
  }

  calculateUrgency(gap) {
    if (gap.priority > 0.8) return 'high'
    if (gap.priority > 0.5) return 'medium'
    return 'low'
  }

  estimateEffort(gap) {
    const effortMap = {
      topic_gap: 'high', // Requires new content creation
      content_type_gap: 'medium', // May need content reformatting
      keyword_gap: 'low' // Can optimize existing content
    }
    
    return effortMap[gap.type] || 'medium'
  }

  generateRecommendations(opportunities) {
    const recommendations = []
    
    // Group by type for strategic recommendations
    const groupedOps = {}
    opportunities.forEach(op => {
      if (!groupedOps[op.type]) groupedOps[op.type] = []
      groupedOps[op.type].push(op)
    })

    Object.entries(groupedOps).forEach(([type, ops]) => {
      const typeRecommendations = this.getTypeSpecificRecommendations(type, ops)
      recommendations.push(...typeRecommendations)
    })

    return recommendations.slice(0, 10) // Top 10 recommendations
  }

  getTypeSpecificRecommendations(type, opportunities) {
    const recommendations = []
    
    switch (type) {
      case 'topic_gap':
        const topTopics = opportunities.slice(0, 5)
        recommendations.push({
          title: `Create content for ${topTopics.length} high-priority topics`,
          description: `Focus on: ${topTopics.map(t => t.opportunity).join(', ')}`,
          impact: 'high',
          effort: 'high',
          timeline: '2-3 months'
        })
        break
        
      case 'keyword_gap':
        const topKeywords = opportunities.slice(0, 8)
        recommendations.push({
          title: `Optimize for ${topKeywords.length} competitor keywords`,
          description: `Target keywords: ${topKeywords.map(k => k.opportunity).join(', ')}`,
          impact: 'medium',
          effort: 'low',
          timeline: '2-4 weeks'
        })
        break
        
      case 'content_type_gap':
        const contentTypes = [...new Set(opportunities.map(o => o.opportunity))]
        recommendations.push({
          title: `Expand content types: ${contentTypes.join(', ')}`,
          description: `Competitors are winning with these content formats`,
          impact: 'medium',
          effort: 'medium',
          timeline: '1-2 months'
        })
        break
    }
    
    return recommendations
  }

  generateSummary(analysis) {
    const totalGaps = analysis.gaps.length
    const highPriorityOps = analysis.opportunities.filter(op => op.urgency === 'high').length
    const competitorCount = analysis.competitors.length
    
    const gapsByType = {}
    analysis.gaps.forEach(gap => {
      gapsByType[gap.type] = (gapsByType[gap.type] || 0) + 1
    })

    return {
      totalOpportunities: analysis.opportunities.length,
      highPriorityCount: highPriorityOps,
      competitorsAnalyzed: competitorCount,
      gapBreakdown: gapsByType,
      topCompetitor: this.findTopCompetitor(analysis.gaps),
      quickWins: analysis.opportunities.filter(op => 
        op.urgency === 'high' && op.estimatedEffort === 'low'
      ).length
    }
  }

  findTopCompetitor(gaps) {
    const competitorCounts = {}
    gaps.forEach(gap => {
      competitorCounts[gap.competitor] = (competitorCounts[gap.competitor] || 0) + 1
    })
    
    return Object.entries(competitorCounts)
      .sort(([,a], [,b]) => b - a)[0]?.[0] || 'Unknown'
  }

  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms))
  }
}

module.exports = SEOContentGapAnalyzer

const analyzer = new SEOContentGapAnalyzer('your-zapserp-api-key')

// Analyze content gaps in your niche
const analysis = await analyzer.analyzeContentGaps(
  'yourdomain.com',
  ['competitor1.com', 'competitor2.com', 'competitor3.com'],
  'digital marketing'
)

console.log(`📊 SEO Content Gap Analysis Results:`)
console.log(`Total opportunities: ${analysis.summary.totalOpportunities}`)
console.log(`High priority: ${analysis.summary.highPriorityCount}`)
console.log(`Quick wins: ${analysis.summary.quickWins}`)

// Show top opportunities
analysis.opportunities.slice(0, 5).forEach(op => {
  console.log(`\n${op.rank}. ${op.type.toUpperCase()}: ${op.opportunity}`)
  console.log(`   Priority: ${op.urgency} | Effort: ${op.estimatedEffort}`)
  console.log(`   From: ${op.competitor}`)
})

// Focus specifically on keyword gaps
const keywordGaps = analysis.opportunities.filter(op => op.type === 'keyword_gap')

console.log('\n🔑 TOP KEYWORD OPPORTUNITIES:')
keywordGaps.slice(0, 10).forEach((gap, index) => {
  console.log(`${index + 1}. "${gap.opportunity}" (from ${gap.competitor})`)
})

// Generate keyword targeting plan
const keywordPlan = {
  immediate: keywordGaps.filter(k => k.urgency === 'high').slice(0, 5),
  shortTerm: keywordGaps.filter(k => k.urgency === 'medium').slice(0, 8),
  longTerm: keywordGaps.filter(k => k.urgency === 'low').slice(0, 10)
}

console.log(`\nKeyword Targeting Plan:`)
console.log(`Immediate (this month): ${keywordPlan.immediate.length} keywords`)
console.log(`Short-term (next 3 months): ${keywordPlan.shortTerm.length} keywords`)
console.log(`Long-term (6+ months): ${keywordPlan.longTerm.length} keywords`)

// Get actionable content recommendations
console.log('\n📝 CONTENT STRATEGY RECOMMENDATIONS:')
analysis.recommendations.forEach((rec, index) => {
  console.log(`\n${index + 1}. ${rec.title}`)
  console.log(`   Impact: ${rec.impact} | Effort: ${rec.effort}`)
  console.log(`   Timeline: ${rec.timeline}`)
  console.log(`   Details: ${rec.description}`)
})

// Export content calendar
const contentCalendar = analysis.opportunities
  .filter(op => op.type === 'topic_gap')
  .slice(0, 12)
  .map((gap, index) => ({
    month: index + 1,
    topic: gap.opportunity,
    competitor: gap.competitor,
    priority: gap.urgency,
    contentType: 'pillar page'
  }))

console.log('\n📅 12-MONTH CONTENT CALENDAR:')
contentCalendar.forEach(item => {
  console.log(`Month ${item.month}: ${item.topic} (${item.priority} priority)`)
})

// Compare gaps across multiple competitors
const competitorInsights = {}

analysis.gaps.forEach(gap => {
  if (!competitorInsights[gap.competitor]) {
    competitorInsights[gap.competitor] = {
      total: 0,
      topicGaps: 0,
      keywordGaps: 0,
      contentTypeGaps: 0,
      avgPriority: 0
    }
  }
  
  const insights = competitorInsights[gap.competitor]
  insights.total++
  insights[gap.type.replace('_gap', 'Gaps')]++
  insights.avgPriority += gap.priority
})

// Calculate averages
Object.values(competitorInsights).forEach(insights => {
  insights.avgPriority = (insights.avgPriority / insights.total).toFixed(2)
})

console.log('\n🏆 COMPETITOR THREAT ANALYSIS:')
Object.entries(competitorInsights)
  .sort(([,a], [,b]) => b.total - a.total)
  .forEach(([competitor, insights]) => {
    console.log(`\n${competitor}:`)
    console.log(`  Total gaps: ${insights.total}`)
    console.log(`  Average priority: ${insights.avgPriority}`)
    console.log(`  Strongest in: ${insights.topicGaps > insights.keywordGaps ? 'topics' : 'keywords'}`)
  })

// Estimate potential traffic impact
const trafficEstimation = analysis.opportunities.map(op => {
  const baseTraffic = {
    topic_gap: 500,  // New topic could bring 500+ monthly visits
    keyword_gap: 200, // Keyword optimization could bring 200+ visits
    content_type_gap: 300 // New content type could bring 300+ visits
  }
  
  const priorityMultiplier = {
    high: 1.5,
    medium: 1.0,
    low: 0.6
  }
  
  return {
    opportunity: op.opportunity,
    estimatedMonthlyTraffic: Math.round(
      baseTraffic[op.type] * priorityMultiplier[op.urgency]
    ),
    priority: op.urgency,
    effort: op.estimatedEffort
  }
})

const totalPotentialTraffic = trafficEstimation
  .reduce((sum, item) => sum + item.estimatedMonthlyTraffic, 0)

console.log(`\n💰 TRAFFIC POTENTIAL:`)
console.log(`Total estimated monthly traffic: ${totalPotentialTraffic.toLocaleString()} visits`)

const quickWins = trafficEstimation
  .filter(item => item.effort === 'low' && item.priority === 'high')
  .slice(0, 5)

console.log(`\nQuick wins (low effort, high impact):`)
quickWins.forEach(item => {
  console.log(`  ${item.opportunity}: +${item.estimatedMonthlyTraffic} monthly visits`)
})

// Set up monthly content gap monitoring
setInterval(async () => {
  try {
    const monthlyAnalysis = await analyzer.analyzeContentGaps(
      'yourdomain.com',
      ['competitor1.com', 'competitor2.com'],
      'your-niche'
    )
    
    // Alert on new high-priority opportunities
    const newHighPriority = monthlyAnalysis.opportunities
      .filter(op => op.urgency === 'high')
      .slice(0, 3)
    
    if (newHighPriority.length > 0) {
      console.log(`🚨 NEW HIGH-PRIORITY OPPORTUNITIES:`)
      newHighPriority.forEach(op => {
        console.log(`  ${op.type}: ${op.opportunity} (from ${op.competitor})`)
      })
      
      // Here you would send alerts via email, Slack, etc.
    }
    
  } catch (error) {
    console.error('❌ Monthly SEO analysis failed:', error)
  }
}, 30 * 24 * 60 * 60 * 1000) // 30 days