🔍 Data & Analytics¶

class ContactManager {
  constructor(linkedInAPI, zeroBounceAPI, databaseManager) {
    this.linkedInAPI = linkedInAPI;
    this.zeroBounceAPI = zeroBounceAPI;
    this.databaseManager = databaseManager;
  }

  async scrapeLinkedInContacts(searchCriteria) {
    const {
      keywords,
      location,
      industry,
      companySize,
      limit = 1000
    } = searchCriteria;

    try {
      // 1. Search LinkedIn profiles
      const profiles = await this.linkedInAPI.searchProfiles({
        keywords,
        location,
        industry,
        companySize,
        limit
      });

      // 2. Extract contact information
      const contacts = await this.extractContactInfo(profiles);

      // 3. Validate emails
      const validatedContacts = await this.validateEmails(contacts);

      // 4. Store in database
      await this.databaseManager.storeContacts(validatedContacts);

      return {
        total: contacts.length,
        valid: validatedContacts.length,
        invalid: contacts.length - validatedContacts.length
      };

    } catch (error) {
      console.error('LinkedIn scraping failed:', error);
      throw error;
    }
  }

  async validateEmails(contacts) {
    const emails = contacts.map(contact => contact.email);
    const validationResults = await this.zeroBounceAPI.validateBatch(emails);

    return contacts.filter(contact => {
      const result = validationResults.find(r => r.email === contact.email);
      return result && result.status === 'valid';
    });
  }

  async enrichContactData(contact) {
    const enrichmentData = await this.linkedInAPI.getProfileDetails(contact.linkedinUrl);

    return {
      ...contact,
      company: enrichmentData.company,
      position: enrichmentData.position,
      experience: enrichmentData.experience,
      education: enrichmentData.education,
      skills: enrichmentData.skills,
      connections: enrichmentData.connections
    };
  }
}

class AnalyticsEngine {
  constructor(databaseManager, reportingSystem) {
    this.db = databaseManager;
    this.reporting = reportingSystem;
  }

  async calculateCampaignMetrics(campaignId) {
    const campaign = await this.db.getCampaign(campaignId);
    const activities = await this.db.getCampaignActivities(campaignId);

    const metrics = {
      delivery: this.calculateDeliveryMetrics(activities),
      engagement: this.calculateEngagementMetrics(activities),
      performance: this.calculatePerformanceMetrics(activities),
      trends: await this.calculateTrends(campaignId)
    };

    return metrics;
  }

  calculateDeliveryMetrics(activities) {
    const total = activities.length;
    const delivered = activities.filter(a => a.status === 'delivered').length;
    const bounced = activities.filter(a => a.status === 'bounced').length;
    const failed = activities.filter(a => a.status === 'failed').length;

    return {
      total,
      delivered,
      bounced,
      failed,
      deliveryRate: (delivered / total) * 100,
      bounceRate: (bounced / total) * 100,
      failureRate: (failed / total) * 100
    };
  }

  calculateEngagementMetrics(activities) {
    const delivered = activities.filter(a => a.status === 'delivered');
    const opened = delivered.filter(a => a.opened).length;
    const clicked = delivered.filter(a => a.clicked).length;
    const unsubscribed = delivered.filter(a => a.unsubscribed).length;

    return {
      openRate: (opened / delivered.length) * 100,
      clickRate: (clicked / delivered.length) * 100,
      unsubscribeRate: (unsubscribed / delivered.length) * 100,
      clickToOpenRate: (clicked / opened) * 100
    };
  }

  async calculateTrends(campaignId) {
    const historicalData = await this.db.getHistoricalCampaignData(campaignId);

    return {
      deliveryTrend: this.calculateTrend(historicalData, 'deliveryRate'),
      openTrend: this.calculateTrend(historicalData, 'openRate'),
      clickTrend: this.calculateTrend(historicalData, 'clickRate'),
      bounceTrend: this.calculateTrend(historicalData, 'bounceRate')
    };
  }

  calculateTrend(data, metric) {
    if (data.length < 2) return 'insufficient_data';

    const recent = data.slice(-7); // Last 7 days
    const previous = data.slice(-14, -7); // Previous 7 days

    const recentAvg = recent.reduce((sum, d) => sum + d[metric], 0) / recent.length;
    const previousAvg = previous.reduce((sum, d) => sum + d[metric], 0) / previous.length;

    const change = ((recentAvg - previousAvg) / previousAvg) * 100;

    if (change > 5) return 'increasing';
    if (change < -5) return 'decreasing';
    return 'stable';
  }
}

class DatabaseManager {
  constructor(pool, redis) {
    this.pool = pool;
    this.redis = redis;
  }

  async storeContacts(contacts) {
    const client = await this.pool.connect();

    try {
      await client.query('BEGIN');

      for (const contact of contacts) {
        await client.query(`
          INSERT INTO contacts (
            email, first_name, last_name, company, position,
            linkedin_url, phone, location, industry, source,
            created_at, updated_at
          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, NOW(), NOW())
          ON CONFLICT (email) DO UPDATE SET
            first_name = EXCLUDED.first_name,
            last_name = EXCLUDED.last_name,
            company = EXCLUDED.company,
            position = EXCLUDED.position,
            updated_at = NOW()
        `, [
          contact.email,
          contact.firstName,
          contact.lastName,
          contact.company,
          contact.position,
          contact.linkedinUrl,
          contact.phone,
          contact.location,
          contact.industry,
          'linkedin'
        ]);
      }

      await client.query('COMMIT');

      // Update cache
      await this.redis.del('contacts:count');

    } catch (error) {
      await client.query('ROLLBACK');
      throw error;
    } finally {
      client.release();
    }
  }

  async getCampaignMetrics(campaignId, dateRange) {
    const cacheKey = `campaign:${campaignId}:metrics:${dateRange.start}:${dateRange.end}`;

    // Check cache first
    const cached = await this.redis.get(cacheKey);
    if (cached) {
      return JSON.parse(cached);
    }

    const query = `
      SELECT 
        COUNT(*) as total_sent,
        COUNT(CASE WHEN status = 'delivered' THEN 1 END) as delivered,
        COUNT(CASE WHEN status = 'bounced' THEN 1 END) as bounced,
        COUNT(CASE WHEN status = 'failed' THEN 1 END) as failed,
        COUNT(CASE WHEN opened = true THEN 1 END) as opened,
        COUNT(CASE WHEN clicked = true THEN 1 END) as clicked,
        COUNT(CASE WHEN unsubscribed = true THEN 1 END) as unsubscribed,
        AVG(response_time) as avg_response_time
      FROM campaign_activities 
      WHERE campaign_id = $1 
        AND created_at BETWEEN $2 AND $3
    `;

    const result = await this.pool.query(query, [
      campaignId,
      dateRange.start,
      dateRange.end
    ]);

    const metrics = result.rows[0];

    // Cache for 5 minutes
    await this.redis.setex(cacheKey, 300, JSON.stringify(metrics));

    return metrics;
  }

  async getAgentPerformance(agentId, dateRange) {
    const query = `
      SELECT 
        COUNT(*) as total_sessions,
        AVG(session_duration) as avg_session_duration,
        AVG(actions_performed) as avg_actions,
        AVG(typing_speed_wpm) as avg_typing_speed,
        AVG(error_rate) as avg_error_rate,
        COUNT(CASE WHEN session_completed = true THEN 1 END) as completed_sessions
      FROM activity_sessions 
      WHERE agent_id = $1 
        AND session_start BETWEEN $2 AND $3
    `;

    const result = await this.pool.query(query, [
      agentId,
      dateRange.start,
      dateRange.end
    ]);

    return result.rows[0];
  }
}

class ReportingSystem {
  constructor(databaseManager, analyticsEngine) {
    this.db = databaseManager;
    this.analytics = analyticsEngine;
  }

  async generateCampaignReport(campaignId, options = {}) {
    const {
      format = 'pdf',
      includeCharts = true,
      dateRange = null
    } = options;

    // 1. Get campaign data
    const campaign = await this.db.getCampaign(campaignId);
    const metrics = await this.analytics.calculateCampaignMetrics(campaignId);

    // 2. Generate report data
    const reportData = {
      campaign: campaign,
      metrics: metrics,
      dateRange: dateRange || {
        start: campaign.created_at,
        end: new Date()
      },
      generatedAt: new Date()
    };

    // 3. Generate report based on format
    switch (format) {
      case 'pdf':
        return await this.generatePDFReport(reportData, includeCharts);
      case 'excel':
        return await this.generateExcelReport(reportData);
      case 'csv':
        return await this.generateCSVReport(reportData);
      default:
        throw new Error(`Unsupported format: ${format}`);
    }
  }

  async generatePDFReport(data, includeCharts) {
    const pdf = new PDFDocument();
    const stream = new PassThrough();

    pdf.pipe(stream);

    // Header
    pdf.fontSize(20).text('Campaign Report', 50, 50);
    pdf.fontSize(12).text(`Campaign: ${data.campaign.name}`, 50, 80);
    pdf.text(`Generated: ${data.generatedAt.toLocaleDateString()}`, 50, 100);

    // Metrics section
    pdf.fontSize(16).text('Performance Metrics', 50, 130);

    const metrics = data.metrics;
    let y = 160;

    pdf.fontSize(12);
    pdf.text(`Total Sent: ${metrics.delivery.total}`, 50, y);
    y += 20;
    pdf.text(`Delivery Rate: ${metrics.delivery.deliveryRate.toFixed(2)}%`, 50, y);
    y += 20;
    pdf.text(`Open Rate: ${metrics.engagement.openRate.toFixed(2)}%`, 50, y);
    y += 20;
    pdf.text(`Click Rate: ${metrics.engagement.clickRate.toFixed(2)}%`, 50, y);
    y += 20;
    pdf.text(`Bounce Rate: ${metrics.delivery.bounceRate.toFixed(2)}%`, 50, y);

    // Charts (if requested)
    if (includeCharts) {
      y += 40;
      pdf.text('Performance Charts', 50, y);
      // Add chart generation logic here
    }

    pdf.end();

    return stream;
  }

  async generateExcelReport(data) {
    const workbook = new ExcelJS.Workbook();
    const worksheet = workbook.addWorksheet('Campaign Report');

    // Add headers
    worksheet.addRow(['Metric', 'Value']);

    // Add metrics
    const metrics = data.metrics;
    worksheet.addRow(['Total Sent', metrics.delivery.total]);
    worksheet.addRow(['Delivery Rate', `${metrics.delivery.deliveryRate.toFixed(2)}%`]);
    worksheet.addRow(['Open Rate', `${metrics.engagement.openRate.toFixed(2)}%`]);
    worksheet.addRow(['Click Rate', `${metrics.engagement.clickRate.toFixed(2)}%`]);
    worksheet.addRow(['Bounce Rate', `${metrics.delivery.bounceRate.toFixed(2)}%`]);

    // Add charts
    const chart = worksheet.addChart({
      type: 'column',
      name: 'Campaign Metrics',
      categories: ['Delivery Rate', 'Open Rate', 'Click Rate'],
      values: [
        metrics.delivery.deliveryRate,
        metrics.engagement.openRate,
        metrics.engagement.clickRate
      ]
    });

    chart.setPosition('E2', 'H15');

    return workbook;
  }

  async scheduleReport(reportConfig) {
    const {
      campaignId,
      frequency,
      format,
      recipients,
      time
    } = reportConfig;

    const schedule = {
      id: generateId(),
      campaignId,
      frequency,
      format,
      recipients,
      time,
      nextRun: this.calculateNextRun(frequency, time),
      createdAt: new Date()
    };

    await this.db.storeScheduledReport(schedule);

    // Schedule in job queue
    await this.scheduleJob(schedule);

    return schedule;
  }
}