AppHighway für E-Commerce: Top 10 Tool-Automatisierungen zur Umsatzsteigerung

// Shopify Produktbeschreibungs-Generator
const generateDescription = async (product) => {
  const response = await fetch('https://apphighway.com/api/v1/structify', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: `Produkt: ${product.title}\nSpezifikationen: ${JSON.stringify(product.specs)}\nKategorie: ${product.category}`,
      schema: {
        description: 'string (150-300 Wörter, SEO-optimiert)',
        keyFeatures: 'array mit 5-7 Aufzählungspunkten',
        targetKeywords: 'array relevanter SEO-Keywords'
      },
      instructions: 'Schreiben Sie ansprechenden, konversionsorientierten Text in freundlichem Ton. Betonen Sie Vorteile über Funktionen.'
    })
  });
  
  const data = await response.json();
  
  // Shopify-Produkt aktualisieren
  await shopify.product.update(product.id, {
    body_html: data.description,
    metafields: [
      { key: 'key_features', value: JSON.stringify(data.keyFeatures) },
      { key: 'seo_keywords', value: data.targetKeywords.join(', ') }
    ]
  });
};

// Massenverarbeitung aller Produkte
const products = await shopify.product.list({ limit: 250 });
for (const product of products) {
  if (!product.body_html) {
    await generateDescription(product);
    await sleep(1000); // Rate Limiting
  }
}

// WooCommerce Bewertungsanalyse
const analyzeReviews = async (productId) => {
  // Alle Bewertungen für Produkt abrufen
  const reviews = await wc.get(`products/${productId}/reviews`);
  const reviewTexts = reviews.map(r => r.review).join('\n\n---\n\n');
  
  // Sentiment-Analyse
  const sentimentResponse = await fetch('https://apphighway.com/api/v1/sentiment-summarizer', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: reviewTexts,
      options: {
        extractKeyPhrases: true,
        categorizeTopics: true,
        identifyIssues: true
      }
    })
  });
  
  const sentiment = await sentimentResponse.json();
  
  // Q&A aus Bewertungen extrahieren
  const qaResponse = await fetch('https://apphighway.com/api/v1/qa-extractor', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: reviewTexts,
      extractQuestions: true
    })
  });
  
  const qa = await qaResponse.json();
  
  // Insights speichern
  await db.productInsights.create({
    productId,
    sentimentScore: sentiment.score,
    positiveCount: sentiment.positive,
    negativeCount: sentiment.negative,
    keyPhrases: sentiment.keyPhrases,
    commonIssues: sentiment.issues,
    frequentQuestions: qa.questions,
    analyzedAt: new Date()
  });
  
  // Warnung bei negativem Sentiment-Anstieg
  if (sentiment.score < -0.3 && sentiment.negative > 10) {
    await sendAlert({
      type: 'NEGATIVE_REVIEWS',
      product: productId,
      message: `Produkt hat ${sentiment.negative} negative Bewertungen. Häufige Probleme: ${sentiment.issues.join(', ')}`
    });
  }
  
  return { sentiment, qa };
};

// Automatisierte Bewertungsantworten
const generateResponse = async (review) => {
  const response = await fetch('https://apphighway.com/api/v1/chatbot-completion', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: review.review,
      context: `Sie sind ein Kundenservice-Mitarbeiter für unseren E-Commerce-Shop. Generieren Sie eine professionelle, einfühlsame Antwort auf diese ${review.rating}-Sterne-Bewertung.`,
      tone: review.rating >= 4 ? 'grateful' : 'apologetic-helpful'
    })
  });
  
  return await response.json();
};

// Shopify Mehrwährungs-Implementierung
const convertPrices = async (prices, fromCurrency, toCurrency) => {
  const response = await fetch('https://apphighway.com/api/v1/currency-converter', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      from: fromCurrency,
      to: toCurrency,
      amounts: prices
    })
  });
  
  const { convertedAmounts, rate } = await response.json();
  return convertedAmounts;
};

// Frontend-Preisanzeige
const displayLocalizedPrices = async () => {
  // Kundenstandort erkennen
  const location = await fetch('https://ipapi.co/json/').then(r => r.json());
  const currency = location.currency || 'USD';
  
  // Alle Produktpreise abrufen
  const products = document.querySelectorAll('[data-product-price]');
  const prices = Array.from(products).map(p => parseFloat(p.dataset.basePrice));
  
  // Alle auf einmal umrechnen (1 API-Aufruf)
  const convertedPrices = await convertPrices(prices, 'USD', currency);
  
  // Anzeige aktualisieren
  products.forEach((product, index) => {
    const localPrice = convertedPrices[index];
    const formatted = new Intl.NumberFormat(location.country_code, {
      style: 'currency',
      currency: currency
    }).format(localPrice);
    
    product.textContent = formatted;
  });
  
  // Währungspräferenz speichern
  localStorage.setItem('preferredCurrency', currency);
};

// WooCommerce-Integration
add_filter('woocommerce_product_get_price', function($price, $product) {
  $customer_currency = WC()->session->get('customer_currency', 'USD');
  
  if ($customer_currency !== 'USD') {
    $cache_key = 'exchange_rate_' . $customer_currency;
    $rate = get_transient($cache_key);
    
    if (!$rate) {
      // Von AppHighway Currency API abrufen
      $response = wp_remote_post('https://apphighway.com/api/v1/currency-converter', [
        'headers' => ['Authorization' => 'Bearer ' . APPHIGHWAY_API_KEY],
        'body' => json_encode([
          'from' => 'USD',
          'to' => $customer_currency,
          'amounts' => [1]
        ])
      ]);
      
      $data = json_decode(wp_remote_retrieve_body($response));
      $rate = $data->convertedAmounts[0];
      
      // 1 Stunde cachen
      set_transient($cache_key, $rate, HOUR_IN_SECONDS);
    }
    
    return $price * $rate;
  }
  
  return $price;
}, 10, 2);

// Shopify Markets Übersetzung
const translateProduct = async (product, targetLanguage) => {
  const response = await fetch('https://apphighway.com/api/v1/translate', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: `Titel: ${product.title}\n\nBeschreibung: ${product.description}\n\nMerkmale: ${product.features.join(', ')}`,
      targetLanguage: targetLanguage,
      context: {
        industry: 'e-commerce',
        productCategory: product.category,
        tone: 'professional-friendly',
        preserveFormatting: true,
        optimizeForSEO: true
      }
    })
  });
  
  const translation = await response.json();
  
  // Übersetzte Abschnitte parsen
  const sections = translation.translatedText.split('\n\n');
  const translatedTitle = sections[0].replace('Titel: ', '');
  const translatedDesc = sections[1].replace('Beschreibung: ', '');
  const translatedFeatures = sections[2].replace('Merkmale: ', '').split(', ');
  
  return {
    title: translatedTitle,
    description: translatedDesc,
    features: translatedFeatures
  };
};

// Gesamten Katalog massenübersetzen
const translateCatalog = async (targetLanguages) => {
  const products = await shopify.product.list({ limit: 250 });
  
  for (const product of products) {
    for (const lang of targetLanguages) {
      const translated = await translateProduct(product, lang);
      
      // Übersetzung in Shopify erstellen/aktualisieren
      await shopify.translation.upsert({
        resourceId: product.id,
        locale: lang,
        key: 'title',
        value: translated.title
      });
      
      await shopify.translation.upsert({
        resourceId: product.id,
        locale: lang,
        key: 'body_html',
        value: translated.description
      });
      
      // Merkmale in Metafields speichern
      await shopify.metafield.create({
        ownerId: product.id,
        namespace: 'translations',
        key: `features_${lang}`,
        value: JSON.stringify(translated.features),
        type: 'json'
      });
      
      await sleep(500); // Rate Limiting
    }
    
    console.log(`Produkt ${product.id} in ${targetLanguages.length} Sprachen übersetzt`);
  }
};

// WooCommerce WPML-Integration
function auto_translate_product($post_id, $language) {
  $product = wc_get_product($post_id);
  
  $response = wp_remote_post('https://apphighway.com/api/v1/translate', [
    'headers' => [
      'Authorization' => 'Bearer ' . APPHIGHWAY_API_KEY,
      'Content-Type' => 'application/json'
    ],
    'body' => json_encode([
      'text' => $product->get_name() . '\n\n' . $product->get_description(),
      'targetLanguage' => $language,
      'context' => [
        'industry' => 'e-commerce',
        'productCategory' => $product->get_category_ids()[0],
        'optimizeForSEO' => true
      ]
    ])
  ]);
  
  $translation = json_decode(wp_remote_retrieve_body($response));
  
  // WPML-Übersetzung erstellen
  $translated_post_id = wpml_create_translation([
    'post_id' => $post_id,
    'language' => $language,
    'title' => $translation->title,
    'content' => $translation->description
  ]);
  
  return $translated_post_id;
}

// Shopify Merkmalsextraktion
const extractFeatures = async (product) => {
  const response = await fetch('https://apphighway.com/api/v1/feature-generator', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: product.body_html,
      productCategory: product.product_type,
      options: {
        featureCount: 7,
        categorizeFeatures: true,
        extractSpecifications: true,
        prioritizeSellingPoints: true
      }
    })
  });
  
  const { features, specifications, categories } = await response.json();
  
  // Produkt-Metafields aktualisieren
  await shopify.metafield.create({
    ownerId: product.id,
    namespace: 'product',
    key: 'key_features',
    value: JSON.stringify(features),
    type: 'json'
  });
  
  await shopify.metafield.create({
    ownerId: product.id,
    namespace: 'product',
    key: 'specifications',
    value: JSON.stringify(specifications),
    type: 'json'
  });
  
  return { features, specifications, categories };
};

// Vergleichstabelle für Varianten generieren
const generateComparisonTable = async (products) => {
  const allFeatures = [];
  
  for (const product of products) {
    const { features } = await extractFeatures(product);
    allFeatures.push({
      productId: product.id,
      title: product.title,
      features: features
    });
  }
  
  // Gemeinsame Merkmalskategorien finden
  const categories = [...new Set(
    allFeatures.flatMap(p => p.features.map(f => f.category))
  )];
  
  // Vergleichstabellen-HTML erstellen
  let tableHTML = '<table class="comparison-table"><thead><tr><th>Merkmal</th>';
  allFeatures.forEach(p => {
    tableHTML += `<th>${p.title}</th>`;
  });
  tableHTML += '</tr></thead><tbody>';
  
  categories.forEach(category => {
    tableHTML += `<tr class="category-row"><td colspan="${products.length + 1}">${category}</td></tr>`;
    
    // Alle Merkmale in dieser Kategorie abrufen
    const categoryFeatures = new Set();
    allFeatures.forEach(p => {
      p.features
        .filter(f => f.category === category)
        .forEach(f => categoryFeatures.add(f.name));
    });
    
    categoryFeatures.forEach(featureName => {
      tableHTML += `<tr><td>${featureName}</td>`;
      allFeatures.forEach(p => {
        const hasFeature = p.features.some(f => f.name === featureName);
        tableHTML += `<td>${hasFeature ? '✓' : '—'}</td>`;
      });
      tableHTML += '</tr>';
    });
  });
  
  tableHTML += '</tbody></table>';
  return tableHTML;
};

// Shopify Bestandsnachfragevorhersage
const analyzeInventoryDemand = async () => {
  // 12 Monate Verkaufsdaten exportieren
  const orders = await shopify.order.list({
    created_at_min: new Date(Date.now() - 365*24*60*60*1000),
    status: 'any',
    limit: 250
  });
  
  // In CSV-Format konvertieren
  const csv = convertToCSV(orders);
  
  // CSV in strukturiertes JSON konvertieren
  const csvResponse = await fetch('https://apphighway.com/api/v1/csv-to-json', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
      'Content-Type': 'text/csv'
    },
    body: csv
  });
  
  const salesData = await csvResponse.json();
  
  // Mit Structify für Nachfragemuster analysieren
  const analysisResponse = await fetch('https://apphighway.com/api/v1/structify', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: JSON.stringify(salesData),
      schema: {
        productId: 'string',
        averageMonthlySales: 'number',
        seasonalityFactor: 'number (1.0 = keine Saisonalität)',
        trendDirection: 'string (increasing/stable/decreasing)',
        predictedNextMonthSales: 'number',
        recommendedReorderPoint: 'number',
        recommendedOrderQuantity: 'number',
        stockoutRisk: 'string (low/medium/high)',
        daysUntilStockout: 'number'
      },
      instructions: 'Analysieren Sie Verkaufsgeschwindigkeit, identifizieren Sie saisonale Muster, berechnen Sie optimale Nachbestellpunkte basierend auf Lieferzeit von 14 Tagen und gewünschtem Service-Level von 95%.'
    })
  });
  
  const predictions = await analysisResponse.json();
  
  // Nachbestellwarnungen generieren
  const reorderNeeded = predictions.filter(p => 
    p.stockoutRisk === 'high' || p.daysUntilStockout < 21
  );
  
  // Bestellungen erstellen
  for (const product of reorderNeeded) {
    await createPurchaseOrder({
      productId: product.productId,
      quantity: product.recommendedOrderQuantity,
      reason: `Vorhergesagter Stockout in ${product.daysUntilStockout} Tagen`,
      urgency: product.stockoutRisk
    });
  }
  
  return {
    totalProducts: predictions.length,
    reorderNeeded: reorderNeeded.length,
    predictions: predictions
  };
};

// Identifikation langsam drehender Bestände
const identifySlowMovers = async () => {
  const inventory = await shopify.inventoryLevel.list();
  const products = await shopify.product.list();
  
  const analysis = [];
  
  for (const item of inventory) {
    const product = products.find(p => p.id === item.product_id);
    const salesLast90Days = await getSalesCount(product.id, 90);
    const inventoryValue = item.available * product.variants[0].price;
    
    const turnoverRate = salesLast90Days / (item.available || 1);
    const daysOfStock = item.available / (salesLast90Days / 90 || 1);
    
    if (daysOfStock > 180 || turnoverRate < 0.1) {
      analysis.push({
        productId: product.id,
        title: product.title,
        available: item.available,
        salesLast90Days,
        daysOfStock: Math.round(daysOfStock),
        inventoryValue: inventoryValue.toFixed(2),
        recommendation: daysOfStock > 365 ? 'Räumungsverkauf' : 'Werbekampagne'
      });
    }
  }
  
  return analysis.sort((a, b) => b.daysOfStock - a.daysOfStock);
};

// Zendesk KI-Chatbot-Integration
const handleCustomerInquiry = async (ticket) => {
  // Kundennachricht und Kontext extrahieren
  const message = ticket.description;
  const customerEmail = ticket.requester.email;
  
  // Kundenbestellhistorie abrufen
  const orders = await shopify.order.list({
    email: customerEmail,
    limit: 5
  });
  
  // Kontext für KI erstellen
  const context = `
Kunde: ${ticket.requester.name}
E-Mail: ${customerEmail}
Letzte Bestellungen: ${orders.map(o => `Bestellung #${o.order_number} (${o.created_at}, ${o.financial_status})`).join(', ')}
Rückgaberichtlinie: 30 Tage, kostenlose Rücksendungen
Versand: 3-5 Werktage Standard, 1-2 Tage Express
`;
  
  // KI-Antwort generieren
  const response = await fetch('https://apphighway.com/api/v1/chatbot-completion', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: message,
      context: context,
      instructions: 'Sie sind ein hilfsbereiter Kundenservice-Mitarbeiter. Geben Sie genaue, freundliche Antworten. Wenn Sie nicht definitiv antworten können, bieten Sie an, an einen menschlichen Mitarbeiter zu eskalieren.',
      tone: 'professional-friendly',
      maxLength: 300
    })
  });
  
  const aiResponse = await response.json();
  
  // Prüfen ob Eskalation erforderlich
  const needsEscalation = 
    aiResponse.confidence < 0.7 ||
    message.toLowerCase().includes('mit einem menschen sprechen') ||
    message.toLowerCase().includes('erstattung');
  
  if (needsEscalation) {
    // Für menschlichen Agent markieren
    await zendesk.ticket.update(ticket.id, {
      comment: {
        body: aiResponse.response + '\n\n[KI: Eskalation vorgeschlagen - geringe Konfidenz oder komplexes Problem]',
        public: false
      },
      tags: ['ai_escalation', 'needs_human_review'],
      status: 'open'
    });
  } else {
    // KI-Antwort direkt senden
    await zendesk.ticket.update(ticket.id, {
      comment: {
        body: aiResponse.response,
        public: true
      },
      status: 'solved',
      tags: ['ai_resolved']
    });
  }
  
  return { resolved: !needsEscalation, response: aiResponse };
};

// Live-Chat-Widget-Implementierung
const initChatbot = () => {
  window.chatWidget = {
    conversationHistory: [],
    
    async sendMessage(userMessage) {
      this.conversationHistory.push({
        role: 'user',
        message: userMessage,
        timestamp: new Date()
      });
      
      // Tippanzeige anzeigen
      this.showTypingIndicator();
      
      // KI-Antwort abrufen
      const response = await fetch('https://apphighway.com/api/v1/chatbot-completion', {
        method: 'POST',
        headers: {
          'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          message: userMessage,
          conversationHistory: this.conversationHistory.slice(-5), // Letzte 5 Nachrichten für Kontext
          context: `E-Commerce-Support-Bot. Website: ${window.location.hostname}`,
          tone: 'friendly-helpful'
        })
      });
      
      const aiResponse = await response.json();
      
      this.conversationHistory.push({
        role: 'assistant',
        message: aiResponse.response,
        timestamp: new Date()
      });
      
      // Antwort anzeigen
      this.hideTypingIndicator();
      this.displayMessage(aiResponse.response, 'bot');
      
      // Analytics verfolgen
      this.trackInteraction({
        intent: aiResponse.intent,
        confidence: aiResponse.confidence,
        resolved: aiResponse.confidence > 0.8
      });
    }
  };
};

// Shopify Checkout E-Mail-Validierung
const validateEmail = async (email) => {
  const response = await fetch('https://apphighway.com/api/v1/email-validator', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ email })
  });
  
  const result = await response.json();
  
  return {
    isValid: result.valid,
    riskScore: result.riskScore, // 0-100, höher = riskanter
    emailType: result.type, // personal, business, disposable, role-based
    suggestions: result.suggestions, // Tippfehler-Korrekturen (gmail.com vs gmial.com)
    domain: result.domain,
    disposable: result.disposable,
    acceptAll: result.acceptAll // Catch-all-Domain
  };
};

// WooCommerce Checkout-Validierung
add_action('woocommerce_after_checkout_validation', function($data, $errors) {
  $email = $data['billing_email'];
  
  // E-Mail validieren
  $response = wp_remote_post('https://apphighway.com/api/v1/email-validator', [
    'headers' => [
      'Authorization' => 'Bearer ' . APPHIGHWAY_API_KEY,
      'Content-Type' => 'application/json'
    ],
    'body' => json_encode(['email' => $email])
  ]);
  
  $result = json_decode(wp_remote_retrieve_body($response));
  
  // Ungültige oder Hochrisiko-E-Mails ablehnen
  if (!$result->valid) {
    $errors->add('email_invalid', 'Bitte geben Sie eine gültige E-Mail-Adresse ein.');
    
    if (!empty($result->suggestions)) {
      $errors->add('email_suggestion', 'Meinten Sie: ' . $result->suggestions[0] . '?');
    }
  }
  
  if ($result->disposable) {
    $errors->add('email_disposable', 'Temporäre E-Mail-Adressen sind nicht erlaubt. Bitte verwenden Sie eine permanente E-Mail.');
  }
  
  if ($result->riskScore > 70) {
    // Für manuelle Überprüfung markieren statt blockieren
    update_post_meta($order_id, '_high_risk_email', true);
    update_post_meta($order_id, '_email_risk_score', $result->riskScore);
    
    // Optional: Zusätzliche Verifizierung verlangen (Telefon, Adresse, etc.)
    $errors->add('email_verification', 'Zu Ihrer Sicherheit verifizieren Sie bitte Ihre Telefonnummer, um diese Bestellung abzuschließen.');
  }
}, 10, 2);

// Frontend Echtzeit-Validierung
const emailInput = document.querySelector('#email');
let validationTimeout;

emailInput.addEventListener('input', (e) => {
  clearTimeout(validationTimeout);
  
  validationTimeout = setTimeout(async () => {
    const email = e.target.value;
    
    if (email.includes('@')) {
      const validation = await validateEmail(email);
      
      if (!validation.isValid) {
        showError('Bitte geben Sie eine gültige E-Mail-Adresse ein');
        
        if (validation.suggestions.length > 0) {
          showSuggestion(`Meinten Sie: ${validation.suggestions[0]}?`);
        }
      } else if (validation.disposable) {
        showWarning('Temporäre E-Mails sind nicht erlaubt');
      } else {
        clearErrors();
        showSuccess('E-Mail validiert');
      }
    }
  }, 500); // Debounce
});

// Shopify QR-Code-Generierung für Produkte
const generateProductQR = async (product) => {
  // Tracking-URL mit UTM-Parametern erstellen
  const trackingUrl = `https://ihrshop.com/products/${product.handle}?utm_source=qr&utm_medium=packaging&utm_campaign=product_${product.id}`;
  
  const response = await fetch('https://apphighway.com/api/v1/qr-generator', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      data: trackingUrl,
      size: 1000, // 1000x1000px für Druckqualität
      format: 'png',
      errorCorrection: 'H', // Hoch (30% Schadenstoleranz)
      options: {
        color: '#000000',
        backgroundColor: '#FFFFFF',
        margin: 4,
        includeText: false
      }
    })
  });
  
  const qrData = await response.json();
  
  // QR-Code in Shopify-Dateien speichern
  await shopify.file.create({
    filename: `qr_${product.handle}.png`,
    contentType: 'image/png',
    data: qrData.image // Base64-kodiert
  });
  
  // QR-URL in Produkt-Metafield speichern
  await shopify.metafield.create({
    ownerId: product.id,
    namespace: 'marketing',
    key: 'qr_code_url',
    value: qrData.url,
    type: 'url'
  });
  
  return qrData;
};

// Massengenerierung für gesamten Katalog
const generateCatalogQRCodes = async () => {
  const products = await shopify.product.list({ limit: 250 });
  const qrCodes = [];
  
  for (const product of products) {
    const qr = await generateProductQR(product);
    qrCodes.push({
      productId: product.id,
      title: product.title,
      qrUrl: qr.url
    });
    
    await sleep(100); // Rate Limiting
  }
  
  // CSV für Druckanbieter generieren
  const csv = convertToCSV(qrCodes);
  await fs.writeFile('product_qr_codes.csv', csv);
  
  return qrCodes;
};

// Garantieregistrierungs-QR-Code
const generateWarrantyQR = async (order) => {
  const warrantyUrl = `https://ihrshop.com/warranty-register?order=${order.id}&email=${order.email}`;
  
  const response = await fetch('https://apphighway.com/api/v1/qr-generator', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      data: warrantyUrl,
      size: 500,
      format: 'png'
    })
  });
  
  const qrData = await response.json();
  
  // In Bestellbestätigungs-E-Mail einbeziehen
  await sendOrderEmail(order, {
    subject: 'Bestellbestätigung + Garantieregistrierung',
    qrCode: qrData.image,
    message: 'Scannen Sie diesen QR-Code, um Ihre Produktgarantie zu registrieren'
  });
};

// QR-Code-Scans verfolgen
app.get('/products/:handle', (req, res) => {
  const { utm_source, utm_medium, utm_campaign } = req.query;
  
  if (utm_source === 'qr') {
    // QR-Scan protokollieren
    analytics.track({
      event: 'QR Code Scan',
      properties: {
        productHandle: req.params.handle,
        medium: utm_medium,
        campaign: utm_campaign,
        timestamp: new Date(),
        userAgent: req.headers['user-agent']
      }
    });
  }
  
  // Produktseite rendern
  res.render('product', { handle: req.params.handle });
});

// Wettbewerber-Preisüberwachungssystem
const monitorCompetitorPrices = async () => {
  // Wettbewerber-URLs aus Datenbank laden
  const competitorProducts = await db.competitorProducts.findMany();
  
  for (const comp of competitorProducts) {
    try {
      // Seiten-Metadaten abrufen
      const metadataResponse = await fetch('https://apphighway.com/api/v1/url-metadata', {
        method: 'POST',
        headers: {
          'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ url: comp.url })
      });
      
      const metadata = await metadataResponse.json();
      
      // Preis mit Structify extrahieren
      const priceResponse = await fetch('https://apphighway.com/api/v1/structify', {
        method: 'POST',
        headers: {
          'Authorization': 'Bearer IHR_API_SCHLÜSSEL',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          text: metadata.content,
          schema: {
            price: 'number',
            currency: 'string (3-Buchstaben-Code)',
            inStock: 'boolean',
            shippingCost: 'number oder null',
            discount: 'number oder null (Prozent)',
            originalPrice: 'number oder null'
          },
          instructions: 'Extrahieren Sie aktuellen Produktpreis, Lagerstatus und eventuelle Rabatte. Suchen Sie nach Verkaufspreisen, durchgestrichenen Preisen und Versandinformationen.'
        })
      });
      
      const priceData = await priceResponse.json();
      
      // Historische Daten speichern
      await db.priceHistory.create({
        competitorProductId: comp.id,
        price: priceData.price,
        currency: priceData.currency,
        inStock: priceData.inStock,
        discount: priceData.discount,
        scrapedAt: new Date()
      });
      
      // Auf signifikante Preisänderungen prüfen
      const previousPrice = await db.priceHistory.findFirst({
        where: { competitorProductId: comp.id },
        orderBy: { scrapedAt: 'desc' },
        skip: 1 // Vorheriger Eintrag
      });
      
      if (previousPrice && previousPrice.price) {
        const priceChange = ((priceData.price - previousPrice.price) / previousPrice.price) * 100;
        
        // Warnung bei >5% Preisänderung
        if (Math.abs(priceChange) > 5) {
          await sendAlert({
            type: 'COMPETITOR_PRICE_CHANGE',
            product: comp.name,
            competitor: comp.competitorName,
            oldPrice: previousPrice.price,
            newPrice: priceData.price,
            changePercent: priceChange.toFixed(2),
            url: comp.url
          });
        }
        
        // Dynamische Preislogik
        if (comp.autoPriceMatch && priceData.inStock) {
          await adjustOwnPrice(comp.ownProductId, priceData.price, comp.pricingStrategy);
        }
      }
      
      await sleep(2000); // Rate Limiting
      
    } catch (error) {
      console.error(`Fehler bei Überwachung ${comp.url}:`, error);
      await db.monitoringErrors.create({
        competitorProductId: comp.id,
        error: error.message,
        timestamp: new Date()
      });
    }
  }
};

// Dynamische Preisstrategie
const adjustOwnPrice = async (productId, competitorPrice, strategy) => {
  const product = await shopify.product.get(productId);
  const currentPrice = parseFloat(product.variants[0].price);
  let newPrice;
  
  switch (strategy) {
    case 'MATCH':
      newPrice = competitorPrice;
      break;
    case 'UNDERCUT_5':
      newPrice = competitorPrice * 0.95;
      break;
    case 'MATCH_IF_LOWER':
      newPrice = Math.min(currentPrice, competitorPrice);
      break;
    case 'STAY_WITHIN_10':
      const diff = ((competitorPrice - currentPrice) / currentPrice) * 100;
      if (Math.abs(diff) > 10) {
        newPrice = diff > 0 ? currentPrice * 1.10 : currentPrice * 0.90;
      }
      break;
  }
  
  if (newPrice && newPrice !== currentPrice) {
    // Mindestpreis anwenden (nicht unter Kosten gehen)
    const floorPrice = product.metafields?.find(m => m.key === 'floor_price')?.value;
    if (floorPrice && newPrice < parseFloat(floorPrice)) {
      console.log(`Preis ${newPrice} unter Mindestpreis ${floorPrice}, überspringe`);
      return;
    }
    
    // Shopify-Preis aktualisieren
    await shopify.variant.update(product.variants[0].id, {
      price: newPrice.toFixed(2)
    });
    
    // Preisänderung protokollieren
    await db.priceChanges.create({
      productId,
      oldPrice: currentPrice,
      newPrice: newPrice,
      reason: `Wettbewerberpreis: ${competitorPrice} (${strategy})`,
      timestamp: new Date()
    });
  }
};