-- Confronto tra dati GA4 e ordini reali dal CRM
WITH ga4_conversions AS (
  SELECT
    DATE(event_timestamp) AS data,
    COUNT(DISTINCT transaction_id) AS transazioni_ga4,
    SUM(purchase_revenue) AS revenue_ga4
  FROM ga4_events
  WHERE event_name = 'purchase'
    AND event_timestamp >= TIMESTAMP '2026-01-01'
  GROUP BY 1
),

ordini_reali AS (
  SELECT
    DATE(order_date) AS data,
    COUNT(DISTINCT order_id) AS transazioni_reali,
    SUM(revenue) AS revenue_reale
  FROM orders
  WHERE order_date >= '2026-01-01'
  GROUP BY 1
)

SELECT
  r.data,
  r.transazioni_reali,
  COALESCE(g.transazioni_ga4, 0) AS transazioni_ga4,
  r.revenue_reale,
  COALESCE(g.revenue_ga4, 0) AS revenue_ga4,
  ROUND(
    (1 - COALESCE(g.transazioni_ga4, 0) * 1.0 / NULLIF(r.transazioni_reali, 0)) * 100,
  1) AS gap_transazioni_pct,
  ROUND(
    (1 - COALESCE(g.revenue_ga4, 0) / NULLIF(r.revenue_reale, 0)) * 100,
  1) AS gap_revenue_pct
FROM ordini_reali r
LEFT JOIN ga4_conversions g USING (data)
ORDER BY data DESC;

ARCHITETTURA TRADIZIONALE (client-side):
Browser utente -> JavaScript GA4 tag   -> server Google Analytics
              -> JavaScript Meta Pixel -> server Meta
              -> JavaScript TikTok tag -> server TikTok
   Problema: ogni tag può essere bloccato separatamente

ARCHITETTURA SERVER-SIDE:
Browser utente -> un solo script leggero -> tuo server GTM -> Google Analytics
                                                            -> Meta CAPI
                                                            -> TikTok Events API
                                                            -> Braze CDP
   Vantaggio: un solo punto di raccolta dati, su dominio tuo, difficile da bloccare

# main.py — Flask endpoint per il server-side GTM
from flask import Flask, request, jsonify
import hashlib
import json
from google.analytics.admin_v1 import AnalyticsAdminServiceClient
from google.cloud import secretmanager
import hmac

app = Flask(__name__)

# Carica le credenziali dal Secret Manager
def get_secret(secret_id, version_id="latest"):
    client = secretmanager.SecretManagerServiceClient()
    secret = client.access_secret_version(
        request={"name": f"projects/your-project/secrets/{secret_id}/versions/{version_id}"}
    )
    return secret.payload.data.decode('UTF-8')

GA_MEASUREMENT_ID = get_secret("ga_measurement_id")
GA_API_SECRET = get_secret("ga_api_secret")
META_ACCESS_TOKEN = get_secret("meta_access_token")

@app.route('/collect', methods=['POST'])
def collect_event():
    """
    Endpoint per raccogliere eventi dal browser e mandarli a GA4 e Meta
    """
    try:
        payload = request.get_json()

        # Estrai i dati dell'evento
        event_name = payload.get('event_name')
        user_data = payload.get('user_data', {})
        custom_data = payload.get('custom_data', {})
        event_id = payload.get('event_id')

        # Hash dell'email per GDPR compliance
        user_email = user_data.get('email', '')
        if user_email:
            email_hash = hashlib.sha256(user_email.encode()).hexdigest()
        else:
            email_hash = None

        # Crea l'evento per GA4 (Measurement Protocol v2)
        ga4_payload = {
            'measurement_id': GA_MEASUREMENT_ID,
            'api_secret': GA_API_SECRET,
            'events': [{
                'name': event_name,
                'params': {
                    'engagement_time_msec': 100,
                    **custom_data,
                    'event_id': event_id
                }
            }]
        }

        # Se è un evento di conversione, aggiungi user data
        if event_name == 'purchase' and email_hash:
            ga4_payload['user_id'] = user_data.get('external_id')
            ga4_payload['events'][0]['params']['user_id'] = user_data.get('external_id')

        # Invia a GA4
        import requests
        ga4_response = requests.post(
            f'https://www.google-analytics.com/mp/collect?measurement_id={GA_MEASUREMENT_ID}&api_secret={GA_API_SECRET}',
            json=ga4_payload
        )

        # Crea l'evento per Meta CAPI (Conversions API)
        if event_name == 'purchase':
            meta_payload = {
                'data': [{
                    'event_name': 'Purchase',
                    'event_time': int(payload.get('timestamp', 0) / 1000),
                    'user_data': {
                        'em': [email_hash] if email_hash else [],
                        'external_id': [user_data.get('external_id')],
                        'client_ip_address': request.remote_addr,
                        'client_user_agent': request.headers.get('User-Agent', '')
                    },
                    'custom_data': {
                        'value': custom_data.get('value'),
                        'currency': custom_data.get('currency', 'EUR'),
                        'content_name': custom_data.get('content_name'),
                        'content_type': 'product',
                        'content_ids': custom_data.get('content_ids', [])
                    },
                    'event_id': event_id
                }]
            }

            meta_response = requests.post(
                f'https://graph.facebook.com/v18.0/YOUR_PIXEL_ID/events?access_token={META_ACCESS_TOKEN}',
                json=meta_payload
            )

        return jsonify({
            'success': True,
            'event_id': event_id,
            'ga4_status': ga4_response.status_code,
            'meta_status': meta_response.status_code if event_name == 'purchase' else None
        }), 200

    except Exception as e:
        print(f"Errore: {str(e)}")
        return jsonify({'error': str(e)}), 400

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

// Questo codice gira nel browser dell'utente
// Invece di chiamare GA4, Meta e TikTok separatamente,
// chiama un solo endpoint sul tuo server

async function sendEvent(eventName, customData = {}) {
  // Genera un event ID unico per deduplicazione
  const eventId = crypto.randomUUID();

  // Hash l'email se presente (GDPR-safe)
  let emailHash = null;
  if (window.userData && window.userData.email) {
    const msgUint8 = new TextEncoder().encode(window.userData.email);
    const hashBuffer = await crypto.subtle.digest('SHA-256', msgUint8);
    const hashArray = Array.from(new Uint8Array(hashBuffer));
    emailHash = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
  }

  const payload = {
    event_name: eventName,
    event_id: eventId,
    user_data: {
      email_hash: emailHash,
      external_id: window.userData?.userId || null
    },
    custom_data: customData,
    timestamp: Date.now()
  };

  try {
    const response = await fetch('https://tracking.tuodominio.com/collect', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload)
    });

    const result = await response.json();
    console.log('Event sent:', result);
    return result;
  } catch (error) {
    console.error('Tracking error:', error);
  }
}

// Esempi di utilizzo
document.addEventListener('DOMContentLoaded', () => {
  // Traccia un evento di view_item quando un utente guarda un prodotto
  const productSku = document.querySelector('[data-product-sku]')?.dataset.productSku;
  if (productSku) {
    sendEvent('view_item', {
      currency: 'EUR',
      value: parseFloat(document.querySelector('[data-product-price]')?.innerText),
      items: [{ item_id: productSku }]
    });
  }

  // Traccia purchase al submit del form ordine
  document.getElementById('checkout-form')?.addEventListener('submit', (e) => {
    const orderTotal = document.querySelector('[data-order-total]')?.innerText;
    const orderItems = Array.from(document.querySelectorAll('[data-item-sku]'))
      .map(el => el.dataset.itemSku);

    sendEvent('purchase', {
      currency: 'EUR',
      value: parseFloat(orderTotal),
      content_ids: orderItems,
      content_type: 'product'
    });
  });
});

// Questo codice deve essere eseguito PRIMA di caricare GTM
window.dataLayer = window.dataLayer || [];
function gtag(){dataLayer.push(arguments);}

// Step 1: Imposta default a "denied" per tutti i segnali
gtag('consent', 'default', {
  'ad_storage': 'denied',
  'ad_user_data': 'denied',
  'ad_personalization': 'denied',
  'analytics_storage': 'denied',
  'wait_for_update': 500  // Aspetta 500ms per eventuali aggiornamenti
});

// Step 2: Il tuo CMP (Consent Management Platform) chiama questa funzione
// quando l'utente seleziona le preferenze
function onConsentPreferencesUpdate(preferences) {
  gtag('consent', 'update', {
    // Analytics: accettato se l'utente sceglie "Analytics"
    'analytics_storage': preferences.analytics ? 'granted' : 'denied',

    // Marketing: richiede consenso esplicito sia per ad_storage che ad_user_data
    'ad_storage': preferences.marketing ? 'granted' : 'denied',
    'ad_user_data': preferences.marketing ? 'granted' : 'denied',
    'ad_personalization': preferences.marketing ? 'granted' : 'denied',
  });

  // Log per debugging
  console.log('Consent updated:', {
    analytics: preferences.analytics,
    marketing: preferences.marketing
  });
}

// Step 3: Se usi Iubenda, Cookiebot o altro CMP, integra:
// Esempio con Cookiebot (callback automatico)
window.addEventListener('CookiebotOnConsentReady', function(e) {
  onConsentPreferencesUpdate({
    analytics: window.Cookiebot.consent.statistics || false,
    marketing: window.Cookiebot.consent.marketing || false
  });
});

-- Query per misurare l'impatto della modellazione v2 in BigQuery
SELECT
  DATE(event_timestamp) AS data,
  COUNT(DISTINCT user_id) AS total_users,
  COUNTIF(is_consent_granted) AS users_with_consent,
  COUNTIF(NOT is_consent_granted) AS users_modeled,
  ROUND(
    COUNTIF(NOT is_consent_granted) / COUNT(DISTINCT user_id) * 100,
    1
  ) AS modeled_traffic_pct,
  COUNT(DISTINCT CASE WHEN event_name = 'purchase' THEN event_id END) AS conversions,
  SUM(CASE WHEN event_name = 'purchase' THEN ecommerce.purchase_revenue ELSE 0 END) AS revenue
FROM `YOUR_PROJECT.analytics_XXXXXX.events_*`
WHERE _TABLE_SUFFIX BETWEEN '20260101' AND '20260131'
  AND event_date >= '2026-01-01'
GROUP BY 1
ORDER BY data DESC;

// Esempio di quiz per e-commerce di moda
const quizData = {
  "style_preference": ["casual", "formal", "streetwear", "vintage"],
  "body_type": ["pear", "apple", "hourglass", "rectangle"],
  "color_preference": ["neutral", "pastels", "bold", "all_colors"],
  "budget_range": ["<50", "50-100", "100-200", "200+"]
};

function saveZeroPartyData(responses) {
  // Salva nel localStorage per cross-session tracking
  localStorage.setItem('zero_party_profile', JSON.stringify(responses));

  // Invia al server (con consenso)
  fetch('/api/user-preferences', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      user_id: window.userData.userId,
      preferences: responses,
      timestamp: new Date().toISOString()
    })
  });

  // Usa le preferenze per personalizzare subito
  personalizeExperience(responses);
}

# Implementazione Python di Enhanced Conversions
import hashlib
import requests
from datetime import datetime

def hash_pii(value):
    """Hash SHA-256 per PII (email, telefono)"""
    if not value:
        return None
    normalized = value.strip().lower()
    return hashlib.sha256(normalized.encode()).hexdigest()

def send_enhanced_conversion_google(user_email, phone, order_id, revenue, currency='EUR'):
    """Invia conversione a Google Analytics con dati utente hashati"""
    GA_MEASUREMENT_ID = "G-XXXXXXXXXX"
    GA_API_SECRET = "your-secret"

    payload = {
        'measurement_id': GA_MEASUREMENT_ID,
        'api_secret': GA_API_SECRET,
        'events': [{
            'name': 'purchase',
            'params': {
                'transaction_id': order_id,
                'value': revenue,
                'currency': currency
            },
            'user_data': {
                'email_hash': hash_pii(user_email),
                'phone_number_hash': hash_pii(phone)
            }
        }]
    }

    response = requests.post(
        'https://www.google-analytics.com/mp/collect',
        json=payload
    )
    return response.status_code == 204

def send_conversion_meta(user_email, phone, order_id, revenue, currency='EUR'):
    """Invia conversione a Meta CAPI con dati utente hashati"""
    PIXEL_ID = "your-pixel-id"
    ACCESS_TOKEN = "your-access-token"

    payload = {
        'data': [{
            'event_name': 'Purchase',
            'event_time': int(datetime.now().timestamp()),
            'user_data': {
                'em': [hash_pii(user_email)] if user_email else [],
                'ph': [hash_pii(phone)] if phone else []
            },
            'custom_data': {
                'value': revenue,
                'currency': currency
            },
            'event_id': order_id
        }]
    }

    response = requests.post(
        f'https://graph.facebook.com/v18.0/{PIXEL_ID}/events?access_token={ACCESS_TOKEN}',
        json=payload
    )
    return response.status_code == 200

# Utilizzo
order_data = {
    'email': 'customer@example.com',
    'phone': '+39 333 1234567',
    'order_id': 'ORD-2026-001234',
    'revenue': 89.90,
    'currency': 'EUR'
}

send_enhanced_conversion_google(**order_data)
send_conversion_meta(**order_data)