Corporate vs Consumer Email Overview

// Production-ready domain analysis system for corporate vs consumer email classification
interface DomainAnalysisResult {
  email: string
  domain: string
  classification: 'corporate' | 'consumer' | 'education' | 'government' | 'nonprofit' | 'unknown'
  confidence: number // 0-100
  indicators: {
    domainAuthority: {
      score: number
      factors: string[]
    }
    corporateKeywords: {
      found: string[]
      score: number
    }
    tldClassification: {
      tld: string
      category: 'commercial' | 'organization' | 'educational' | 'government' | 'country' | 'generic'
    }
    mxRecords: {
      corporate: boolean
      personal: boolean
      education: boolean
    }
    websiteAnalysis: {
      hasCorporateContent: boolean
      hasPersonalContent: boolean
      industry: string | null
    }
  }
  riskScore: number
  metadata: {
    analysisTimestamp: number
    dataSources: string[]
    processingTime: number
  }
}

interface CorporateDomainIndicators {
  keywords: string[]
  patterns: RegExp[]
  tldMappings: Record<string, string>
  mxIndicators: string[]
  websitePatterns: RegExp[]
}

class CorporateEmailAnalyzer {
  private corporateIndicators: CorporateDomainIndicators
  private analysisCache: Map<string, DomainAnalysisResult> = new Map()
  private domainDatabase: Map<string, any> = new Map()

  constructor() {
    this.initializeCorporateIndicators()
    this.loadDomainDatabase()
  }

  async analyzeEmail(email: string): Promise<DomainAnalysisResult> {
    const startTime = Date.now()

    // Validate email format
    if (!this.isValidEmail(email)) {
      throw new Error('Invalid email format')
    }

    const domain = email.split('@')[1].toLowerCase()

    // Check cache first
    const cached = this.analysisCache.get(domain)
    if (cached && Date.now() - cached.metadata.analysisTimestamp < 24 * 60 * 60 * 1000) {
      return cached
    }

    try {
      // Perform comprehensive domain analysis
      const [domainAuthority, corporateKeywords, tldClassification, mxAnalysis, websiteAnalysis] = await Promise.all([
        this.analyzeDomainAuthority(domain),
        this.analyzeCorporateKeywords(domain),
        this.analyzeTLD(domain),
        this.analyzeMXRecords(domain),
        this.analyzeWebsite(domain)
      ])

      // Calculate final classification
      const classification = this.determineClassification({
        domainAuthority,
        corporateKeywords,
        tldClassification,
        mxAnalysis,
        websiteAnalysis
      })

      // Calculate confidence score
      const confidence = this.calculateConfidence({
        domainAuthority,
        corporateKeywords,
        tldClassification,
        mxAnalysis,
        websiteAnalysis
      })

      // Calculate risk score
      const riskScore = this.calculateRiskScore(classification, confidence, {
        domainAuthority,
        corporateKeywords,
        tldClassification,
        mxAnalysis,
        websiteAnalysis
      })

      const result: DomainAnalysisResult = {
        email,
        domain,
        classification,
        confidence,
        indicators: {
          domainAuthority,
          corporateKeywords,
          tldClassification,
          mxRecords: mxAnalysis,
          websiteAnalysis
        },
        riskScore,
        metadata: {
          analysisTimestamp: Date.now(),
          dataSources: ['Domain Authority', 'Keywords', 'TLD', 'MX Records', 'Website Analysis'],
          processingTime: Date.now() - startTime
        }
      }

      // Cache result
      this.analysisCache.set(domain, result)

      return result

    } catch (error) {
      console.error(`Email analysis failed for ${email}:`, error)

      // Return default classification
      return {
        email,
        domain,
        classification: 'unknown',
        confidence: 0,
        indicators: {
          domainAuthority: { score: 0, factors: [] },
          corporateKeywords: { found: [], score: 0 },
          tldClassification: { tld: domain.split('.').pop() || 'unknown', category: 'generic' },
          mxRecords: { corporate: false, personal: false, education: false },
          websiteAnalysis: { hasCorporateContent: false, hasPersonalContent: false, industry: null }
        },
        riskScore: 50,
        metadata: {
          analysisTimestamp: Date.now(),
          dataSources: [],
          processingTime: Date.now() - startTime
        }
      }
    }
  }

  private isValidEmail(email: string): boolean {
    const emailRegex = /^[^s@]+@[^s@]+.[^s@]+$/
    return emailRegex.test(email)
  }

  private async analyzeDomainAuthority(domain: string): Promise<DomainAnalysisResult['indicators']['domainAuthority']> {
    let score = 0
    const factors: string[] = []

    // Check domain age (simulated)
    if (this.isEstablishedDomain(domain)) {
      score += 30
      factors.push('Established domain')
    }

    // Check domain popularity (simulated)
    if (this.isPopularDomain(domain)) {
      score += 25
      factors.push('Popular domain')
    }

    // Check domain registration info (simulated)
    if (this.hasCorporateRegistration(domain)) {
      score += 35
      factors.push('Corporate registration')
    }

    // Check SSL certificate (simulated)
    if (this.hasCorporateSSL(domain)) {
      score += 10
      factors.push('Corporate SSL certificate')
    }

    return { score: Math.min(100, score), factors }
  }

  private async analyzeCorporateKeywords(domain: string): Promise<DomainAnalysisResult['indicators']['corporateKeywords']> {
    const foundKeywords: string[] = []
    let score = 0

    for (const keyword of this.corporateIndicators.keywords) {
      if (domain.includes(keyword)) {
        foundKeywords.push(keyword)
        score += 20
      }
    }

    for (const pattern of this.corporateIndicators.patterns) {
      if (pattern.test(domain)) {
        foundKeywords.push(pattern.source)
        score += 15
      }
    }

    return { found: foundKeywords, score: Math.min(100, score) }
  }

  private async analyzeTLD(domain: string): Promise<DomainAnalysisResult['indicators']['tldClassification']> {
    const tld = domain.split('.').pop() || 'unknown'
    const category = this.corporateIndicators.tldMappings[tld] || 'generic'

    return { tld, category: category as any }
  }

  private async analyzeMXRecords(domain: string): Promise<DomainAnalysisResult['indicators']['mxRecords']> {
    // In production, query MX records
    // For demo, simulate MX analysis

    const corporateMX = ['mail.corporate.com', 'smtp.company.org', 'mx.enterprise.net']
    const personalMX = ['mail.personal.com', 'smtp.home.org', 'mx.consumer.net']
    const educationMX = ['mail.university.edu', 'smtp.school.org', 'mx.academy.net']

    const mxRecords = [domain] // Simulated MX records

    return {
      corporate: mxRecords.some(record => corporateMX.some(mx => record.includes(mx))),
      personal: mxRecords.some(record => personalMX.some(mx => record.includes(mx))),
      education: mxRecords.some(record => educationMX.some(mx => record.includes(mx)))
    }
  }

  private async analyzeWebsite(domain: string): Promise<DomainAnalysisResult['indicators']['websiteAnalysis']> {
    // In production, analyze website content
    // For demo, simulate website analysis

    const corporateContent = ['about-us', 'contact', 'services', 'company', 'business']
    const personalContent = ['blog', 'personal', 'home', 'family', 'photos']

    const mockContent = this.getMockWebsiteContent(domain)

    return {
      hasCorporateContent: corporateContent.some(keyword => mockContent.includes(keyword)),
      hasPersonalContent: personalContent.some(keyword => mockContent.includes(keyword)),
      industry: this.detectIndustry(mockContent)
    }
  }

  private determineClassification(indicators: any): DomainAnalysisResult['classification'] {
    const { domainAuthority, corporateKeywords, tldClassification, mxAnalysis, websiteAnalysis } = indicators

    // Primary classification based on indicators
    if (corporateKeywords.score > 60 && domainAuthority.score > 50) {
      return 'corporate'
    }

    if (tldClassification.category === 'educational') {
      return 'education'
    }

    if (tldClassification.category === 'government') {
      return 'government'
    }

    if (tldClassification.category === 'organization') {
      return 'nonprofit'
    }

    if (websiteAnalysis.hasPersonalContent && !websiteAnalysis.hasCorporateContent) {
      return 'consumer'
    }

    if (mxAnalysis.corporate || websiteAnalysis.hasCorporateContent) {
      return 'corporate'
    }

    return 'unknown'
  }

  private calculateConfidence(indicators: any): number {
    const { domainAuthority, corporateKeywords, tldClassification, mxAnalysis, websiteAnalysis } = indicators

    let confidence = 0

    // Domain authority contributes to confidence
    confidence += domainAuthority.score * 0.3

    // Corporate keywords contribute significantly
    confidence += corporateKeywords.score * 0.25

    // MX record analysis
    if (mxAnalysis.corporate) confidence += 20
    if (mxAnalysis.personal) confidence += 15
    if (mxAnalysis.education) confidence += 15

    // Website analysis
    if (websiteAnalysis.hasCorporateContent) confidence += 15
    if (websiteAnalysis.hasPersonalContent) confidence += 10

    // TLD classification
    if (['commercial', 'organization'].includes(tldClassification.category)) {
      confidence += 10
    }

    return Math.min(100, confidence)
  }

  private calculateRiskScore(classification: string, confidence: number, indicators: any): number {
    let riskScore = 50 // Base risk

    // High confidence reduces risk
    if (confidence > 80) riskScore -= 20
    else if (confidence > 60) riskScore -= 10

    // Corporate emails generally lower risk
    if (classification === 'corporate') riskScore -= 15
    if (classification === 'education') riskScore -= 10
    if (classification === 'government') riskScore -= 10

    // Consumer emails higher risk
    if (classification === 'consumer') riskScore += 10

    // Unknown classification increases risk
    if (classification === 'unknown') riskScore += 20

    // MX record indicators
    if (indicators.mxRecords.corporate) riskScore -= 5
    if (indicators.mxRecords.personal) riskScore += 10

    return Math.max(0, Math.min(100, riskScore))
  }

  private initializeCorporateIndicators(): void {
    this.corporateIndicators = {
      keywords: [
        'corp', 'company', 'enterprise', 'business', 'office', 'inc', 'ltd', 'llc',
        'corporation', 'corporate', 'solutions', 'services', 'group', 'holdings',
        'international', 'global', 'systems', 'technology', 'tech', 'software'
      ],
      patterns: [
        /^.*corp./i,
        /^.*company./i,
        /^.*enterprise./i,
        /^.*business./i,
        /^.*solutions./i
      ],
      tldMappings: {
        'com': 'commercial',
        'org': 'organization',
        'edu': 'educational',
        'gov': 'government',
        'net': 'generic',
        'co': 'commercial',
        'uk': 'country',
        'de': 'country',
        'fr': 'country',
        'ca': 'country'
      },
      mxIndicators: [
        'corporate', 'company', 'business', 'enterprise', 'mail', 'smtp'
      ],
      websitePatterns: [
        /company|corporate|business|enterprise/i,
        /about.*us|contact|services|solutions/i,
        /privacy.*policy|terms.*service/i
      ]
    }
  }

  private loadDomainDatabase(): void {
    // In production, load domain classification database
    // For demo, populate with sample data

    console.log('Domain database loaded')
  }

  private isEstablishedDomain(domain: string): boolean {
    // Simulate domain age check
    const establishedDomains = ['google.com', 'microsoft.com', 'apple.com', 'amazon.com']
    return establishedDomains.some(d => domain.includes(d.split('.')[0]))
  }

  private isPopularDomain(domain: string): boolean {
    // Simulate popularity check
    const popularDomains = ['gmail.com', 'yahoo.com', 'hotmail.com', 'outlook.com']
    return popularDomains.includes(domain)
  }

  private hasCorporateRegistration(domain: string): boolean {
    // Simulate WHOIS check
    const corporateDomains = ['company.com', 'business.org', 'enterprise.net']
    return corporateDomains.some(d => domain.includes(d.split('.')[0]))
  }

  private hasCorporateSSL(domain: string): boolean {
    // Simulate SSL certificate check
    return domain.includes('corporate') || domain.includes('company')
  }

  private getMockWebsiteContent(domain: string): string {
    // Simulate website content analysis
    const contentMap: Record<string, string> = {
      'google.com': 'company corporate business enterprise search technology',
      'gmail.com': 'personal email consumer free service',
      'university.edu': 'education academic research students',
      'company.org': 'nonprofit organization charity foundation'
    }

    return contentMap[domain] || 'generic content'
  }

  private detectIndustry(content: string): string | null {
    const industryKeywords: Record<string, string[]> = {
      'technology': ['software', 'tech', 'digital', 'innovation'],
      'finance': ['bank', 'financial', 'investment', 'insurance'],
      'healthcare': ['medical', 'health', 'hospital', 'clinic'],
      'education': ['university', 'school', 'academic', 'education'],
      'retail': ['shop', 'store', 'retail', 'ecommerce']
    }

    for (const [industry, keywords] of Object.entries(industryKeywords)) {
      if (keywords.some(keyword => content.includes(keyword))) {
        return industry
      }
    }

    return null
  }

  // Batch analysis for multiple emails
  async analyzeEmailBatch(emails: string[]): Promise<Map<string, DomainAnalysisResult>> {
    const results = new Map<string, DomainAnalysisResult>()

    // Process in parallel with rate limiting
    const batchSize = 20
    for (let i = 0; i < emails.length; i += batchSize) {
      const batch = emails.slice(i, i + batchSize)

      const batchPromises = batch.map(async (email) => {
        try {
          const result = await this.analyzeEmail(email)
          return { email, result }
        } catch (error) {
          console.error(`Batch analysis failed for ${email}:`, error)
          return { email, result: null }
        }
      })

      const batchResults = await Promise.all(batchPromises)

      batchResults.forEach(({ email, result }) => {
        if (result) {
          results.set(email, result)
        }
      })

      // Small delay between batches
      if (i + batchSize < emails.length) {
        await new Promise(resolve => setTimeout(resolve, 100))
      }
    }

    return results
  }

  getAnalysisStats(): {
    totalAnalyses: number
    corporatePercentage: number
    consumerPercentage: number
    averageConfidence: number
    topCorporateDomains: Array<{ domain: string; count: number }>
  } {
    const analyses = Array.from(this.analysisCache.values())
    const total = analyses.length

    if (total === 0) {
      return {
        totalAnalyses: 0,
        corporatePercentage: 0,
        consumerPercentage: 0,
        averageConfidence: 0,
        topCorporateDomains: []
      }
    }

    const corporate = analyses.filter(a => a.classification === 'corporate').length
    const consumer = analyses.filter(a => a.classification === 'consumer').length
    const averageConfidence = analyses.reduce((sum, a) => sum + a.confidence, 0) / total

    // Count domain occurrences
    const domainCounts = new Map<string, number>()
    analyses.forEach(analysis => {
      const count = domainCounts.get(analysis.domain) || 0
      domainCounts.set(analysis.domain, count + 1)
    })

    const topCorporateDomains = Array.from(domainCounts.entries())
      .filter(([, count]) => count > 1)
      .sort(([, a], [, b]) => b - a)
      .slice(0, 10)
      .map(([domain, count]) => ({ domain, count }))

    return {
      totalAnalyses: total,
      corporatePercentage: (corporate / total) * 100,
      consumerPercentage: (consumer / total) * 100,
      averageConfidence,
      topCorporateDomains
    }
  }
}

// Corporate vs Consumer Email Classifier
class CorporateConsumerClassifier {
  private emailAnalyzer: CorporateEmailAnalyzer
  private classificationCache: Map<string, {
    result: DomainAnalysisResult
    expires: number
  }> = new Map()

  constructor() {
    this.emailAnalyzer = new CorporateEmailAnalyzer()
  }

  async classifyEmail(email: string): Promise<{
    isCorporate: boolean
    confidence: number
    analysis: DomainAnalysisResult
    recommendation: string
  }> {
    // Check cache first
    const cached = this.getCachedClassification(email)
    if (cached) {
      return {
        isCorporate: cached.result.classification === 'corporate',
        confidence: cached.result.confidence,
        analysis: cached.result,
        recommendation: this.generateRecommendation(cached.result)
      }
    }

    // Perform fresh analysis
    const analysis = await this.emailAnalyzer.analyzeEmail(email)

    // Cache result for 24 hours
    this.cacheClassification(email, analysis)

    return {
      isCorporate: analysis.classification === 'corporate',
      confidence: analysis.confidence,
      analysis,
      recommendation: this.generateRecommendation(analysis)
    }
  }

  private getCachedClassification(email: string): DomainAnalysisResult | null {
    const cached = this.classificationCache.get(email)
    if (cached && cached.expires > Date.now()) {
      return cached.result
    }

    if (cached) {
      this.classificationCache.delete(email)
    }

    return null
  }

  private cacheClassification(email: string, result: DomainAnalysisResult): void {
    this.classificationCache.set(email, {
      result,
      expires: Date.now() + 24 * 60 * 60 * 1000 // 24 hours
    })
  }

  private generateRecommendation(analysis: DomainAnalysisResult): string {
    if (analysis.classification === 'corporate' && analysis.confidence > 80) {
      return 'High confidence corporate email - suitable for B2B communications'
    }

    if (analysis.classification === 'consumer' && analysis.confidence > 80) {
      return 'High confidence consumer email - suitable for B2C marketing'
    }

    if (analysis.confidence < 60) {
      return 'Low confidence classification - manual review recommended'
    }

    return 'Medium confidence classification - verify with additional context'
  }

  // Batch classification
  async classifyEmailBatch(emails: string[]): Promise<Map<string, DomainAnalysisResult>> {
    return this.emailAnalyzer.analyzeEmailBatch(emails)
  }

  getClassificationStats(): {
    totalAnalyses: number
    corporatePercentage: number
    consumerPercentage: number
    averageConfidence: number
  } {
    return this.emailAnalyzer.getAnalysisStats()
  }
}

// Initialize classification service
const emailAnalyzer = new CorporateEmailAnalyzer()
const corporateConsumerClassifier = new CorporateConsumerClassifier()

// Corporate vs Consumer email detection endpoints
app.post('/api/detect-corporate-consumer-email', async (req, res) => {
  try {
    const { email } = req.body

    if (!email) {
      return res.status(400).json({ error: 'Email address required' })
    }

    const classification = await corporateConsumerClassifier.classifyEmail(email)

    res.json({
      classification,
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Corporate vs Consumer email detection error:', error)
    res.status(500).json({ error: 'Detection failed' })
  }
})

// Batch email classification
app.post('/api/detect-corporate-consumer-emails-batch', async (req, res) => {
  try {
    const { emails } = req.body

    if (!Array.isArray(emails)) {
      return res.status(400).json({ error: 'Emails array required' })
    }

    const results = await corporateConsumerClassifier.classifyEmailBatch(emails)

    res.json({
      results: Object.fromEntries(results.entries()),
      count: results.size,
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Batch email classification error:', error)
    res.status(500).json({ error: 'Batch classification failed' })
  }
})

// Email classification statistics
app.get('/api/corporate-consumer-email-stats', (req, res) => {
  const stats = corporateConsumerClassifier.getClassificationStats()

  res.json({
    stats,
    timestamp: new Date().toISOString()
  })
})

console.log('Corporate vs Consumer email detection system initialized')

// Advanced ML-based corporate vs consumer email classification
interface EmailClassificationFeatures {
  email: string
  domain: string
  localPart: string
  domainLength: number
  hasNumbers: boolean
  hasSpecialChars: boolean
  tld: string
  tldCategory: string
  domainAuthority: number
  keywordScore: number
  mxCorporate: boolean
  mxPersonal: boolean
  websiteCorporate: boolean
  websitePersonal: boolean
  industry: string | null
  domainAge: number
  popularityScore: number
}

interface MLClassificationResult {
  email: string
  predictedClass: 'corporate' | 'consumer' | 'education' | 'government' | 'nonprofit' | 'unknown'
  confidence: number
  probabilities: Record<string, number>
  featureImportance: Record<string, number>
  modelVersion: string
  processingTime: number
}

class MLEmailClassifier {
  private model: any = null
  private featureExtractor: EmailFeatureExtractor
  private modelVersion: string = '1.0.0'
  private predictionCache: Map<string, MLClassificationResult> = new Map()

  constructor() {
    this.featureExtractor = new EmailFeatureExtractor()
    this.initializeModel()
  }

  async classifyEmailWithML(email: string, features: EmailClassificationFeatures): Promise<MLClassificationResult> {
    const startTime = Date.now()

    // Check cache first
    const cacheKey = this.generateCacheKey(email, features)
    const cached = this.getCachedPrediction(cacheKey)
    if (cached) {
      return { ...cached, processingTime: Date.now() - startTime }
    }

    try {
      // Extract numerical features for ML model
      const numericalFeatures = await this.featureExtractor.extractNumericalFeatures(features)

      // Run ML prediction
      const prediction = await this.runModelPrediction(numericalFeatures)

      // Calculate feature importance
      const featureImportance = this.calculateFeatureImportance(numericalFeatures)

      const result: MLClassificationResult = {
        email,
        predictedClass: prediction.class,
        confidence: prediction.confidence,
        probabilities: prediction.probabilities,
        featureImportance,
        modelVersion: this.modelVersion,
        processingTime: Date.now() - startTime
      }

      // Cache prediction for 12 hours
      this.cachePrediction(cacheKey, result)

      return result

    } catch (error) {
      console.error('ML classification failed:', error)

      // Fallback to rule-based classification
      return this.fallbackClassification(email, features, Date.now() - startTime)
    }
  }

  private async initializeModel(): Promise<void> {
    // In production, load pre-trained TensorFlow.js model
    // For demo, simulate model initialization

    console.log('Initializing ML email classification model...')

    await new Promise(resolve => setTimeout(resolve, 1000))

    this.model = {
      predict: async (features: number[]) => {
        // Simplified prediction logic for demo
        const classProbabilities = this.calculateClassProbabilities(features)

        const maxProb = Math.max(...Object.values(classProbabilities))
        const predictedClass = Object.keys(classProbabilities).find(
          key => classProbabilities[key] === maxProb
        ) as any

        return {
          class: predictedClass,
          confidence: maxProb,
          probabilities: classProbabilities
        }
      }
    }

    console.log('ML model initialized successfully')
  }

  private calculateClassProbabilities(features: number[]): Record<string, number> {
    // Simplified probability calculation for demo
    const probabilities: Record<string, number> = {
      corporate: 0.2,
      consumer: 0.2,
      education: 0.2,
      government: 0.2,
      nonprofit: 0.1,
      unknown: 0.1
    }

    // Adjust probabilities based on features
    if (features[0] > 0.7) probabilities.corporate += 0.3 // High domain authority
    if (features[1] > 0.8) probabilities.consumer += 0.3 // High consumer indicators
    if (features[2] > 0.6) probabilities.education += 0.2 // High education indicators

    // Normalize probabilities
    const total = Object.values(probabilities).reduce((a, b) => a + b, 0)
    for (const key in probabilities) {
      probabilities[key] /= total
    }

    return probabilities
  }

  private calculateFeatureImportance(features: number[]): Record<string, number> {
    // Simplified feature importance calculation
    return {
      domain_authority: features[0] * 0.3,
      keyword_score: features[1] * 0.25,
      tld_category: features[2] * 0.2,
      mx_records: features[3] * 0.15,
      website_analysis: features[4] * 0.1
    }
  }

  private fallbackClassification(
    email: string,
    features: EmailClassificationFeatures,
    processingTime: number
  ): MLClassificationResult {
    // Rule-based fallback classification
    let predictedClass: MLClassificationResult['predictedClass'] = 'unknown'
    let confidence = 50

    // Simple rule-based logic
    if (features.domainAuthority > 0.8 && features.keywordScore > 0.7) {
      predictedClass = 'corporate'
      confidence = 85
    } else if (features.tldCategory === 'generic' && features.websitePersonal) {
      predictedClass = 'consumer'
      confidence = 75
    } else if (features.tld === 'edu') {
      predictedClass = 'education'
      confidence = 90
    }

    return {
      email,
      predictedClass,
      confidence,
      probabilities: {
        corporate: predictedClass === 'corporate' ? confidence / 100 : 0.2,
        consumer: predictedClass === 'consumer' ? confidence / 100 : 0.2,
        education: predictedClass === 'education' ? 0.9 : 0.2,
        government: 0.2,
        nonprofit: 0.1,
        unknown: predictedClass === 'unknown' ? 0.8 : 0.1
      },
      featureImportance: {},
      modelVersion: 'fallback-1.0',
      processingTime
    }
  }

  private generateCacheKey(email: string, features: EmailClassificationFeatures): string {
    const keyData = `${email}-${features.domain}-${features.domainAuthority}-${features.keywordScore}`
    return Buffer.from(keyData).toString('base64').slice(0, 32)
  }

  private getCachedPrediction(key: string): MLClassificationResult | null {
    const cached = this.predictionCache.get(key)
    if (cached && Date.now() - 12 * 60 * 60 * 1000 < cached.processingTime) { // 12 hours cache
      return cached
    }

    if (cached) {
      this.predictionCache.delete(key)
    }

    return null
  }

  private cachePrediction(key: string, result: MLClassificationResult): void {
    this.predictionCache.set(key, result)

    // Maintain cache size (keep only 10000 entries)
    if (this.predictionCache.size > 10000) {
      const entries = Array.from(this.predictionCache.entries())
      const oldestKey = entries.sort(([, a], [, b]) => a.processingTime - b.processingTime)[0][0]
      this.predictionCache.delete(oldestKey)
    }
  }

  private async runModelPrediction(features: number[]): Promise<any> {
    if (!this.model) {
      throw new Error('Model not initialized')
    }

    return await this.model.predict(features)
  }
}

class EmailFeatureExtractor {
  async extractNumericalFeatures(features: EmailClassificationFeatures): Promise<number[]> {
    return [
      features.domainAuthority,
      features.keywordScore,
      this.normalizeTLDCategory(features.tldCategory),
      this.normalizeMXScore(features.mxCorporate, features.mxPersonal),
      this.normalizeWebsiteScore(features.websiteCorporate, features.websitePersonal),
      this.normalizeIndustryScore(features.industry)
    ]
  }

  private normalizeTLDCategory(category: string): number {
    const categoryScores: Record<string, number> = {
      'commercial': 0.9,
      'organization': 0.7,
      'educational': 0.8,
      'government': 0.8,
      'country': 0.5,
      'generic': 0.3
    }

    return categoryScores[category] || 0.1
  }

  private normalizeMXScore(mxCorporate: boolean, mxPersonal: boolean): number {
    if (mxCorporate) return 0.9
    if (mxPersonal) return 0.2
    return 0.5
  }

  private normalizeWebsiteScore(websiteCorporate: boolean, websitePersonal: boolean): number {
    if (websiteCorporate && !websitePersonal) return 0.9
    if (websitePersonal && !websiteCorporate) return 0.2
    if (websiteCorporate && websitePersonal) return 0.5
    return 0.3
  }

  private normalizeIndustryScore(industry: string | null): number {
    if (!industry) return 0.5

    const industryScores: Record<string, number> = {
      'technology': 0.8,
      'finance': 0.9,
      'healthcare': 0.8,
      'education': 0.9,
      'retail': 0.7
    }

    return industryScores[industry] || 0.6
  }
}

// Enhanced email classification with ML
class EnhancedEmailClassifier {
  private emailAnalyzer: CorporateEmailAnalyzer
  private mlClassifier: MLEmailClassifier
  private corporateConsumerClassifier: CorporateConsumerClassifier

  constructor() {
    this.emailAnalyzer = new CorporateEmailAnalyzer()
    this.mlClassifier = new MLEmailClassifier()
    this.corporateConsumerClassifier = new CorporateConsumerClassifier()
  }

  async classifyEmailEnhanced(email: string): Promise<{
    ruleBasedClassification: DomainAnalysisResult
    mlClassification: MLClassificationResult
    finalDecision: {
      isCorporate: boolean
      confidence: number
      method: 'rule_based' | 'ml' | 'consensus'
    }
    recommendation: string
  }> {
    // Get rule-based analysis
    const ruleBasedAnalysis = await this.emailAnalyzer.analyzeEmail(email)

    // Extract features for ML
    const features: EmailClassificationFeatures = {
      email,
      domain: ruleBasedAnalysis.domain,
      localPart: email.split('@')[0],
      domainLength: ruleBasedAnalysis.domain.length,
      hasNumbers: /d/.test(ruleBasedAnalysis.domain),
      hasSpecialChars: /[^a-zA-Z0-9]/.test(ruleBasedAnalysis.domain),
      tld: ruleBasedAnalysis.indicators.tldClassification.tld,
      tldCategory: ruleBasedAnalysis.indicators.tldClassification.category,
      domainAuthority: ruleBasedAnalysis.indicators.domainAuthority.score / 100,
      keywordScore: ruleBasedAnalysis.indicators.corporateKeywords.score / 100,
      mxCorporate: ruleBasedAnalysis.indicators.mxRecords.corporate,
      mxPersonal: ruleBasedAnalysis.indicators.mxRecords.personal,
      websiteCorporate: ruleBasedAnalysis.indicators.websiteAnalysis.hasCorporateContent,
      websitePersonal: ruleBasedAnalysis.indicators.websiteAnalysis.hasPersonalContent,
      industry: ruleBasedAnalysis.indicators.websiteAnalysis.industry,
      domainAge: 5, // Simulated
      popularityScore: 0.5 // Simulated
    }

    // Get ML classification
    const mlClassification = await this.mlClassifier.classifyEmailWithML(email, features)

    // Combine results
    const finalDecision = this.combineClassifications(ruleBasedAnalysis, mlClassification)

    return {
      ruleBasedClassification: ruleBasedAnalysis,
      mlClassification,
      finalDecision,
      recommendation: this.generateEnhancedRecommendation(finalDecision, ruleBasedAnalysis, mlClassification)
    }
  }

  private combineClassifications(
    ruleBased: DomainAnalysisResult,
    ml: MLClassificationResult
  ): { isCorporate: boolean; confidence: number; method: string } {
    // Weighted combination of rule-based and ML results
    const ruleBasedScore = ruleBased.classification === 'corporate' ? ruleBased.confidence / 100 : 0.2
    const mlScore = ml.probabilities.corporate || 0

    // Weight ML higher if confidence is good
    const mlWeight = ml.confidence > 70 ? 0.7 : 0.3
    const ruleBasedWeight = 1 - mlWeight

    const combinedScore = (ruleBasedScore * ruleBasedWeight) + (mlScore * mlWeight)
    const isCorporate = combinedScore > 0.6

    let method = 'consensus'
    if (ml.confidence > 80 && ruleBased.confidence < 60) method = 'ml'
    if (ruleBased.confidence > 80 && ml.confidence < 60) method = 'rule_based'

    return {
      isCorporate,
      confidence: combinedScore * 100,
      method
    }
  }

  private generateEnhancedRecommendation(
    finalDecision: any,
    ruleBased: DomainAnalysisResult,
    ml: MLClassificationResult
  ): string {
    if (finalDecision.confidence > 85) {
      return `High confidence ${finalDecision.isCorporate ? 'corporate' : 'consumer'} email (${finalDecision.method})`
    }

    if (finalDecision.confidence < 60) {
      return 'Low confidence classification - consider manual review or additional data sources'
    }

    return `Medium confidence ${finalDecision.isCorporate ? 'corporate' : 'consumer'} email - verify with business context`
  }
}

// Initialize enhanced classifier
const enhancedEmailClassifier = new EnhancedEmailClassifier()

// Enhanced email classification endpoint
app.post('/api/classify-email-enhanced', async (req, res) => {
  try {
    const { email } = req.body

    if (!email) {
      return res.status(400).json({ error: 'Email address required' })
    }

    const result = await enhancedEmailClassifier.classifyEmailEnhanced(email)

    res.json({
      classification: result,
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Enhanced email classification error:', error)
    res.status(500).json({ error: 'Enhanced classification failed' })
  }
})

console.log('Enhanced email classification with ML initialized')

// Email classification integration patterns for enterprise applications
interface EmailValidationConfig {
  enableCorporateDetection: boolean
  enableConsumerDetection: boolean
  minConfidenceThreshold: number
  enableMLClassification: boolean
  enableBehavioralAnalysis: boolean
  cacheResults: boolean
  cacheDuration: number
  batchSize: number
}

interface EmailValidationResult {
  email: string
  isValid: boolean
  isCorporate: boolean
  isConsumer: boolean
  confidence: number
  riskScore: number
  validationErrors: string[]
  recommendations: string[]
  processingTime: number
}

class EmailClassificationService {
  private config: EmailValidationConfig
  private corporateConsumerClassifier: CorporateConsumerClassifier
  private enhancedEmailClassifier: EnhancedEmailClassifier
  private validationCache: Map<string, EmailValidationResult> = new Map()

  constructor(config: EmailValidationConfig) {
    this.config = config
    this.corporateConsumerClassifier = new CorporateConsumerClassifier()
    this.enhancedEmailClassifier = new EnhancedEmailClassifier()
  }

  async validateAndClassifyEmail(email: string): Promise<EmailValidationResult> {
    const startTime = Date.now()

    // Check cache first
    if (this.config.cacheResults) {
      const cached = this.getCachedResult(email)
      if (cached) {
        return { ...cached, processingTime: Date.now() - startTime }
      }
    }

    const validationErrors: string[] = []
    const recommendations: string[] = []

    try {
      // Basic email validation
      if (!this.isValidEmailFormat(email)) {
        validationErrors.push('Invalid email format')
      }

      if (validationErrors.length > 0) {
        return {
          email,
          isValid: false,
          isCorporate: false,
          isConsumer: false,
          confidence: 0,
          riskScore: 100,
          validationErrors,
          recommendations: ['Fix email format'],
          processingTime: Date.now() - startTime
        }
      }

      // Corporate/Consumer classification
      let classification: any = null
      let isCorporate = false
      let isConsumer = false
      let confidence = 0
      let riskScore = 50

      if (this.config.enableCorporateDetection || this.config.enableConsumerDetection) {
        if (this.config.enableMLClassification) {
          classification = await this.enhancedEmailClassifier.classifyEmailEnhanced(email)
          isCorporate = classification.finalDecision.isCorporate
          confidence = classification.finalDecision.confidence
        } else {
          classification = await this.corporateConsumerClassifier.classifyEmail(email)
          isCorporate = classification.isCorporate
          confidence = classification.confidence
        }

        isConsumer = !isCorporate
        riskScore = classification.analysis?.riskScore || 50
      }

      // Generate recommendations based on classification
      if (isCorporate && confidence > this.config.minConfidenceThreshold) {
        recommendations.push('Corporate email - suitable for B2B communications')
      } else if (isConsumer && confidence > this.config.minConfidenceThreshold) {
        recommendations.push('Consumer email - suitable for B2C marketing')
      } else if (confidence < this.config.minConfidenceThreshold) {
        recommendations.push('Low confidence classification - manual review recommended')
      }

      const result: EmailValidationResult = {
        email,
        isValid: validationErrors.length === 0,
        isCorporate,
        isConsumer,
        confidence,
        riskScore,
        validationErrors,
        recommendations,
        processingTime: Date.now() - startTime
      }

      // Cache result if enabled
      if (this.config.cacheResults) {
        this.cacheResult(email, result)
      }

      return result

    } catch (error) {
      console.error('Email validation and classification failed:', error)

      return {
        email,
        isValid: false,
        isCorporate: false,
        isConsumer: false,
        confidence: 0,
        riskScore: 100,
        validationErrors: ['Validation failed'],
        recommendations: ['Retry validation or manual review'],
        processingTime: Date.now() - startTime
      }
    }
  }

  private isValidEmailFormat(email: string): boolean {
    const emailRegex = /^[^s@]+@[^s@]+.[^s@]+$/
    return emailRegex.test(email)
  }

  private getCachedResult(email: string): EmailValidationResult | null {
    const cached = this.validationCache.get(email)
    if (cached && Date.now() - this.config.cacheDuration < cached.processingTime) {
      return cached
    }

    if (cached) {
      this.validationCache.delete(email)
    }

    return null
  }

  private cacheResult(email: string, result: EmailValidationResult): void {
    this.validationCache.set(email, result)

    // Maintain cache size
    if (this.validationCache.size > 50000) {
      const entries = Array.from(this.validationCache.entries())
      const oldestKey = entries.sort(([, a], [, b]) => a.processingTime - b.processingTime)[0][0]
      this.validationCache.delete(oldestKey)
    }
  }

  // Batch validation and classification
  async validateAndClassifyEmailBatch(emails: string[]): Promise<Map<string, EmailValidationResult>> {
    const results = new Map<string, EmailValidationResult>()

    // Process in batches
    for (let i = 0; i < emails.length; i += this.config.batchSize) {
      const batch = emails.slice(i, i + this.config.batchSize)

      const batchPromises = batch.map(async (email) => {
        try {
          const result = await this.validateAndClassifyEmail(email)
          return { email, result }
        } catch (error) {
          console.error(`Batch validation failed for ${email}:`, error)
          return { email, result: null }
        }
      })

      const batchResults = await Promise.all(batchPromises)

      batchResults.forEach(({ email, result }) => {
        if (result) {
          results.set(email, result)
        }
      })

      // Small delay between batches
      if (i + this.config.batchSize < emails.length) {
        await new Promise(resolve => setTimeout(resolve, 50))
      }
    }

    return results
  }

  // Get validation statistics
  getValidationStats(): {
    totalValidations: number
    validEmails: number
    corporateEmails: number
    consumerEmails: number
    averageConfidence: number
    averageProcessingTime: number
  } {
    const results = Array.from(this.validationCache.values())
    const total = results.length

    if (total === 0) {
      return {
        totalValidations: 0,
        validEmails: 0,
        corporateEmails: 0,
        consumerEmails: 0,
        averageConfidence: 0,
        averageProcessingTime: 0
      }
    }

    const validEmails = results.filter(r => r.isValid).length
    const corporateEmails = results.filter(r => r.isCorporate).length
    const consumerEmails = results.filter(r => r.isConsumer).length
    const averageConfidence = results.reduce((sum, r) => sum + r.confidence, 0) / total
    const averageProcessingTime = results.reduce((sum, r) => sum + r.processingTime, 0) / total

    return {
      totalValidations: total,
      validEmails,
      corporateEmails,
      consumerEmails,
      averageConfidence,
      averageProcessingTime
    }
  }

  // Update configuration
  updateConfig(newConfig: Partial<EmailValidationConfig>): void {
    this.config = { ...this.config, ...newConfig }
    console.log('Email validation configuration updated')
  }
}

// Default configuration
const defaultConfig: EmailValidationConfig = {
  enableCorporateDetection: true,
  enableConsumerDetection: true,
  minConfidenceThreshold: 70,
  enableMLClassification: true,
  enableBehavioralAnalysis: false,
  cacheResults: true,
  cacheDuration: 24 * 60 * 60 * 1000, // 24 hours
  batchSize: 50
}

// Initialize email classification service
const emailClassificationService = new EmailClassificationService(defaultConfig)

// Email validation and classification endpoints
app.post('/api/validate-email', async (req, res) => {
  try {
    const { email } = req.body

    if (!email) {
      return res.status(400).json({ error: 'Email address required' })
    }

    const result = await emailClassificationService.validateAndClassifyEmail(email)

    res.json({
      validation: result,
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Email validation error:', error)
    res.status(500).json({ error: 'Validation failed' })
  }
})

// Batch email validation
app.post('/api/validate-emails-batch', async (req, res) => {
  try {
    const { emails } = req.body

    if (!Array.isArray(emails)) {
      return res.status(400).json({ error: 'Emails array required' })
    }

    const results = await emailClassificationService.validateAndClassifyEmailBatch(emails)

    res.json({
      results: Object.fromEntries(results.entries()),
      count: results.size,
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Batch email validation error:', error)
    res.status(500).json({ error: 'Batch validation failed' })
  }
})

// Get validation statistics
app.get('/api/email-validation-stats', (req, res) => {
  const stats = emailClassificationService.getValidationStats()

  res.json({
    stats,
    timestamp: new Date().toISOString()
  })
})

// Update validation configuration
app.post('/api/email-validation-config', (req, res) => {
  try {
    const config = req.body

    if (!config || typeof config !== 'object') {
      return res.status(400).json({ error: 'Configuration object required' })
    }

    emailClassificationService.updateConfig(config)

    res.json({
      message: 'Configuration updated successfully',
      config: emailClassificationService['config'],
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Configuration update error:', error)
    res.status(500).json({ error: 'Configuration update failed' })
  }
})

console.log('Email classification service initialized')

Corporate vs Consumer Email Architecture

class EmailClassificationCache {
  private domainCache: Map<string, { isCorporate: boolean; confidence: number; expiry: number }> = new Map()
  
  getCached(domain: string): { isCorporate: boolean; confidence: number } | null {
    const cached = this.domainCache.get(domain)
    if (!cached || Date.now() > cached.expiry) return null
    return { isCorporate: cached.isCorporate, confidence: cached.confidence }
  }
  
  setCached(domain: string, result: { isCorporate: boolean; confidence: number }): void {
    this.domainCache.set(domain, {
      ...result,
      expiry: Date.now() + 86400000 // 24 hour TTL for domains
    })
  }
}