Marketing Campaigns with Deep Linking: From Click to Conversion

app.post('/api/create-campaign-link', async (req, res) => {
  try {
    const { 
      campaignName, 
      targetUrl, 
      source, 
      medium, 
      content, 
      term,
      metadata = {} 
    } = req.body;
    
    // 1. Generate unique campaign slug
    const campaignSlug = generateCampaignSlug(campaignName);
    
    // 2. Create campaign link with UTM parameters
    const campaignLink = await createCampaignLink({
      slug: campaignSlug,
      target: targetUrl,
      metadata: {
        campaign: campaignName,
        source: source,
        medium: medium,
        content: content,
        term: term,
        ...metadata
      }
    });
    
    // 3. Store campaign in database
    await storeCampaign({
      name: campaignName,
      slug: campaignSlug,
      link: campaignLink,
      source: source,
      medium: medium,
      status: 'active',
      created_at: new Date()
    });
    
    res.json({
      success: true,
      campaignLink: campaignLink,
      campaignId: campaignSlug,
      trackingUrl: `${campaignLink}?utm_source=${source}&utm_medium=${medium}&utm_campaign=${campaignName}`
    });
    
  } catch (error) {
    console.error('Campaign creation error:', error);
    res.status(500).json({ error: 'Failed to create campaign' });
  }
});

async function createCampaignLink({ slug, target, metadata }) {
  try {
    const response = await redirectly.post('/links', {
      slug: slug,
      target: target,
      metadata: metadata
    });
    
    return response.data.url;
  } catch (error) {
    console.error('Failed to create campaign link:', error);
    throw new Error('Failed to create campaign link');
  }
}

function generateCampaignSlug(campaignName) {
  const timestamp = Date.now();
  const cleanName = campaignName.toLowerCase()
    .replace(/[^a-z0-9]/g, '-')
    .replace(/-+/g, '-')
    .replace(/^-|-$/g, '');
  
  return `${cleanName}-${timestamp}`;
}

class CampaignTrackingService {
  static final FlutterRedirectly _redirectly = FlutterRedirectly();
  
  static Future<void> initialize() async {
    await _redirectly.initialize(RedirectlyConfig(
      apiKey: 'YOUR_API_KEY',
      baseUrl: 'https://redirectly.app',
      enableDebugLogging: true,
    ));
    
    // Listen for campaign link clicks
    _redirectly.onLinkClick.listen(_handleCampaignClick);
    
    // Listen for app installs from campaigns
    _redirectly.onAppInstalled.listen(_handleCampaignInstall);
  }
  
  static void _handleCampaignClick(LinkClickEvent event) {
    if (event.error != null) return;
    
    final uri = Uri.parse(event.originalUrl);
    final campaignData = _extractCampaignData(uri);
    
    if (campaignData != null) {
      // Store campaign attribution
      _storeCampaignAttribution(campaignData);
      
      // Track campaign click
      _trackCampaignEvent('click', campaignData);
    }
  }
  
  static void _handleCampaignInstall(AppInstallEvent event) {
    if (event.matched && event.link != null) {
      final campaignData = _extractCampaignDataFromLink(event.link!);
      
      if (campaignData != null) {
        // Track successful campaign conversion
        _trackCampaignEvent('install', campaignData);
        
        // Show campaign-specific onboarding
        _showCampaignOnboarding(campaignData);
      }
    }
  }
  
  static Map<String, String>? _extractCampaignData(Uri uri) {
    final utmSource = uri.queryParameters['utm_source'];
    final utmMedium = uri.queryParameters['utm_medium'];
    final utmCampaign = uri.queryParameters['utm_campaign'];
    final utmContent = uri.queryParameters['utm_content'];
    final utmTerm = uri.queryParameters['utm_term'];
    
    if (utmSource != null && utmMedium != null && utmCampaign != null) {
      return {
        'source': utmSource,
        'medium': utmMedium,
        'campaign': utmCampaign,
        'content': utmContent ?? '',
        'term': utmTerm ?? '',
        'timestamp': DateTime.now().toIso8601String(),
      };
    }
    
    return null;
  }
  
  static Future<void> _trackCampaignEvent(String eventType, Map<String, String> campaignData) async {
    try {
      await http.post(
        Uri.parse('${ApiConfig.baseUrl}/api/track-campaign-event'),
        headers: {'Content-Type': 'application/json'},
        body: jsonEncode({
          'eventType': eventType,
          'campaignData': campaignData,
          'deviceInfo': await _getDeviceInfo(),
        }),
      );
    } catch (e) {
      print('Campaign tracking error: $e');
    }
  }
  
  static void _showCampaignOnboarding(Map<String, String> campaignData) {
    // Show campaign-specific welcome message
    final campaignName = campaignData['campaign'] ?? 'Unknown Campaign';
    
    Get.snackbar(
      'Welcome!',
      'Thanks for joining from our $campaignName campaign!',
      backgroundColor: Colors.blue,
      colorText: Colors.white,
      duration: Duration(seconds: 5),
    );
    
    // Navigate to campaign-specific onboarding flow
    Get.toNamed('/onboarding', arguments: {
      'campaign': campaignData,
      'source': 'campaign'
    });
  }
}

app.get('/api/campaign-analytics', async (req, res) => {
  try {
    const { 
      campaignId, 
      timeRange = '30d', 
      source, 
      medium 
    } = req.query;
    
    const analytics = await getCampaignAnalytics({
      campaignId,
      timeRange,
      source,
      medium
    });
    
    res.json({
      success: true,
      analytics: {
        overview: analytics.overview,
        performance: analytics.performance,
        sources: analytics.sources,
        devices: analytics.devices,
        geographic: analytics.geographic,
        trends: analytics.trends
      }
    });
    
  } catch (error) {
    console.error('Campaign analytics error:', error);
    res.status(500).json({ error: 'Failed to fetch analytics' });
  }
});

async function getCampaignAnalytics({ campaignId, timeRange, source, medium }) {
  const startDate = getStartDate(timeRange);
  const filters = buildFilters({ campaignId, source, medium, startDate });
  
  const [
    clicks,
    installs,
    conversions,
    revenue,
    sources,
    devices,
    geographic
  ] = await Promise.all([
    getCampaignClicks(filters),
    getCampaignInstalls(filters),
    getCampaignConversions(filters),
    getCampaignRevenue(filters),
    getSourceBreakdown(filters),
    getDeviceBreakdown(filters),
    getGeographicBreakdown(filters)
  ]);
  
  return {
    overview: {
      totalClicks: clicks.total,
      totalInstalls: installs.total,
      conversionRate: clicks.total > 0 ? (installs.total / clicks.total) * 100 : 0,
      totalRevenue: revenue.total,
      roas: revenue.total / (clicks.total * 0.5), // Assuming $0.50 per click
      cpa: installs.total > 0 ? (clicks.total * 0.5) / installs.total : 0
    },
    performance: {
      dailyClicks: clicks.daily,
      dailyInstalls: installs.daily,
      dailyRevenue: revenue.daily
    },
    sources: sources,
    devices: devices,
    geographic: geographic,
    trends: {
      clickTrend: calculateTrend(clicks.daily),
      installTrend: calculateTrend(installs.daily),
      revenueTrend: calculateTrend(revenue.daily)
    }
  };
}