Deploy from GitHub Actions

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y build-essential && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

README.md

@@ -0,0 +1,42 @@
+---
+title: Trek WhatsApp AI
+emoji: 🚴
+colorFrom: red
+colorTo: blue
+sdk: docker
+pinned: false
+---
+
+# Trek WhatsApp AI Chatbot
+
+Trek Bicycle Turkey için WhatsApp üzerinden çalışan AI chatbot.
+
+## Canlı Ortam
+- **HuggingFace Space:** https://huggingface.co/spaces/SamiKoen/BF-WAB
+- **Webhook:** Twilio WhatsApp entegrasyonu
+
+## Teknoloji
+- **GPT-4o:** Görsel mesajlar için (Vision)
+- **GPT-5.2:** Metin mesajları için
+- **BizimHesap API:** Stok sorguları
+- **IdeaSoft XML:** Ürün bilgileri
+
+## Ana Dosyalar
+| Dosya | Açıklama |
+|-------|----------|
+| app.py | Ana uygulama |
+| prompts.py | System promptları |
+| smart_warehouse_with_price.py | Stok + fiyat sorgusu |
+| intent_analyzer.py | Müşteri niyet analizi |
+| store_notification.py | Mağaza bildirimleri |
+
+## Deploy
+HuggingFace'e push etmek için:
+```bash
+cd /tmp && rm -rf bf-wab-clone
+git clone https://SamiKoen:TOKEN@huggingface.co/spaces/SamiKoen/BF-WAB bf-wab-clone
+# Değişiklikleri yap
+git add . && git commit -m "mesaj" && git push
+```
+# Last deploy: Mon, Jan 19, 2026  5:36:55 PM
+# Deploy test: Mon, Jan 19, 2026  5:39:13 PM

app.py

@@ -0,0 +1,1810 @@
+# -*- coding: utf-8 -*-
+"""
+Trek WhatsApp AI Asistani - Hybrid Model Version
+Gorsel varsa: GPT-4o (vision)
+Metin varsa: GPT-5.2 (daha akilli)
+"""
+
+import os
+import json
+import re
+import requests
+import xml.etree.ElementTree as ET
+import warnings
+import time
+import threading
+import datetime
+import unicodedata
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from fastapi import FastAPI, Request
+from twilio.rest import Client
+from twilio.twiml.messaging_response import MessagingResponse
+
+# Yeni moduller - Basit sistem
+from prompts import get_active_prompts
+from whatsapp_renderer import extract_product_info_whatsapp
+from whatsapp_passive_profiler import (
+    analyze_user_message, get_user_profile_summary, get_personalized_recommendations
+)
+
+# LOGGING EN BASA EKLENDI
+import logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Import improved WhatsApp search for BF space
+# DISABLED - Using GPT-5 smart warehouse search instead
+USE_IMPROVED_SEARCH = False
+
+warnings.simplefilter('ignore')
+
+# ===============================
+# MODEL KONFIGURASYONU
+# ===============================
+MODEL_CONFIG = {
+    "vision": "gpt-4o",              # Gorsel analizi icin (Vision destekli)
+    "text": "gpt-5.2-chat-latest",   # Metin icin (en akilli model)
+    "fallback": "gpt-4o"             # Yedek model (GPT-5.2 hata verirse)
+}
+
+# Model secimi icin yardimci fonksiyon
+def get_model_for_request(has_media=False):
+    """
+    Istek tipine gore uygun modeli sec
+    has_media=True -> GPT-4o (vision destekli)
+    has_media=False -> GPT-5.2 (daha akilli metin isleme)
+    """
+    if has_media:
+        logger.info(f"🖼️ Gorsel tespit edildi -> Model: {MODEL_CONFIG['vision']}")
+        return MODEL_CONFIG["vision"]
+    else:
+        logger.info(f"📝 Metin mesaji -> Model: {MODEL_CONFIG['text']}")
+        return MODEL_CONFIG["text"]
+
+# ===============================
+# API AYARLARI
+# ===============================
+API_URL = "https://api.openai.com/v1/chat/completions"
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+logger.info(f"OpenAI API Key var mi: {'Evet' if OPENAI_API_KEY else 'Hayir'}")
+
+# Twilio WhatsApp ayarlari
+TWILIO_ACCOUNT_SID = os.getenv("TWILIO_ACCOUNT_SID")
+TWILIO_AUTH_TOKEN = os.getenv("TWILIO_AUTH_TOKEN")
+TWILIO_MESSAGING_SERVICE_SID = os.getenv("TWILIO_MESSAGING_SERVICE_SID", "MG11c1dfac28ad5f81908ec9ede0f7247f")
+TWILIO_WHATSAPP_NUMBER = "whatsapp:+905332047254"  # Bizim WhatsApp Business numaramiz
+
+logger.info(f"Twilio SID var mi: {'Evet' if TWILIO_ACCOUNT_SID else 'Hayir'}")
+logger.info(f"Twilio Auth Token var mi: {'Evet' if TWILIO_AUTH_TOKEN else 'Hayir'}")
+logger.info(f"Messaging Service SID var mi: {'Evet' if TWILIO_MESSAGING_SERVICE_SID else 'Hayir'}")
+
+if not TWILIO_ACCOUNT_SID or not TWILIO_AUTH_TOKEN:
+    logger.error("❌ Twilio bilgileri eksik!")
+    twilio_client = None
+else:
+    try:
+        twilio_client = Client(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN)
+        logger.info("✅ Twilio client basariyla olusturuldu!")
+    except Exception as e:
+        logger.error(f"❌ Twilio client hatasi: {e}")
+        twilio_client = None
+
+# ===============================
+# GPT-5 SMART WAREHOUSE
+# ===============================
+try:
+    from smart_warehouse_with_price import get_warehouse_stock_smart_with_price
+    USE_GPT5_SEARCH = True
+    logger.info("✅ GPT-5 complete smart warehouse with price (BF algorithm) loaded")
+except ImportError:
+    USE_GPT5_SEARCH = False
+    logger.info("❌ GPT-5 search not available")
+
+# Import Media Queue V2
+try:
+    from media_queue_v2 import media_queue
+    USE_MEDIA_QUEUE = True
+    logger.info("✅ Media Queue V2 loaded successfully")
+except ImportError:
+    USE_MEDIA_QUEUE = False
+    logger.info("❌ Media Queue V2 not available")
+
+# Import Store Notification System
+try:
+    from store_notification import (
+        notify_product_reservation,
+        notify_price_inquiry,
+        notify_stock_inquiry,
+        send_test_notification,
+        send_store_notification,
+        should_notify_mehmet_bey
+    )
+    USE_STORE_NOTIFICATION = True
+    logger.info("✅ Store Notification System loaded")
+except ImportError:
+    USE_STORE_NOTIFICATION = False
+    logger.info("❌ Store Notification System not available")
+
+# Import Follow-Up System
+try:
+    from follow_up_system import (
+        FollowUpManager,
+        analyze_message_for_follow_up,
+        FollowUpType
+    )
+    USE_FOLLOW_UP = True
+    follow_up_manager = FollowUpManager()
+    logger.info("✅ Follow-Up System loaded")
+except ImportError:
+    USE_FOLLOW_UP = False
+    follow_up_manager = None
+    logger.info("❌ Follow-Up System not available")
+
+# Import Intent Analyzer
+try:
+    from intent_analyzer import (
+        analyze_customer_intent,
+        should_notify_store,
+        get_smart_notification_message
+    )
+    USE_INTENT_ANALYZER = True
+    logger.info("✅ GPT-5 Intent Analyzer loaded")
+except ImportError:
+    USE_INTENT_ANALYZER = False
+    logger.info("❌ Intent Analyzer not available")
+
+# ===============================
+# STOK API ENTEGRASYONU
+# ===============================
+STOCK_API_BASE = "https://video.trek-turkey.com/bizimhesap-proxy.php"
+
+# Stock cache (5 dakikalik cache)
+stock_cache = {}
+CACHE_DURATION = 300  # 5 dakika (saniye cinsinden)
+
+# Turkish character normalization
+turkish_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c', 'İ': 'i', 'I': 'i'}
+
+def normalize_turkish(text):
+    """Turkce karakterleri normalize et"""
+    if not text:
+        return ""
+    text = unicodedata.normalize('NFD', text)
+    text = ''.join(char for char in text if unicodedata.category(char) != 'Mn')
+    for tr_char, en_char in turkish_map.items():
+        text = text.replace(tr_char, en_char)
+    return text.lower()
+
+def fetch_warehouse_inventory(warehouse, product_name, search_terms):
+    """Tek bir magazanin stok bilgisini al"""
+    try:
+        warehouse_id = warehouse['id']
+        warehouse_name = warehouse['title']
+
+        # DSW'yi ayri tut (gelecek stok icin)
+        is_dsw = 'DSW' in warehouse_name or 'ÖN SİPARİŞ' in warehouse_name.upper()
+
+        # Magaza stoklarini al
+        inventory_url = f"{STOCK_API_BASE}?action=inventory&warehouse={warehouse_id}&endpoint=inventory/{warehouse_id}"
+        inventory_response = requests.get(inventory_url, timeout=3, verify=False)
+
+        if inventory_response.status_code != 200:
+            return None
+
+        inventory_data = inventory_response.json()
+
+        # API yanitini kontrol et
+        if 'data' not in inventory_data or 'inventory' not in inventory_data['data']:
+            return None
+
+        products_list = inventory_data['data']['inventory']
+
+        # Beden terimleri kontrolu
+        size_terms = ['xs', 's', 'm', 'ml', 'l', 'xl', 'xxl', '2xl', '3xl', 'small', 'medium', 'large']
+        size_numbers = ['44', '46', '48', '50', '52', '54', '56', '58', '60']
+
+        # Arama terimlerinde beden var mi kontrol et
+        has_size_query = False
+        size_query = None
+        for term in search_terms:
+            if term in size_terms or term in size_numbers:
+                has_size_query = True
+                size_query = term
+                break
+
+        # Eger sadece beden sorgusu varsa (or: "m", "xl")
+        is_only_size_query = len(search_terms) == 1 and has_size_query
+
+        # Urunu ara
+        warehouse_variants = []
+        dsw_stock_count = 0
+
+        for product in products_list:
+            product_title = normalize_turkish(product.get('title', '')).lower()
+            original_title = product.get('title', '')
+
+            # Eger sadece beden sorgusu ise
+            if is_only_size_query:
+                if size_query in product_title.split() or f'({size_query})' in product_title or f' {size_query} ' in product_title or product_title.endswith(f' {size_query}'):
+                    qty = int(product.get('qty', 0))
+                    stock = int(product.get('stock', 0))
+                    actual_stock = max(qty, stock)
+
+                    if actual_stock > 0:
+                        if is_dsw:
+                            dsw_stock_count += actual_stock
+                            continue
+                        warehouse_variants.append(f"{original_title}: ✓ Stokta")
+            else:
+                # Normal urun aramasi
+                if has_size_query:
+                    non_size_terms = [t for t in search_terms if t != size_query]
+                    product_matches = all(term in product_title for term in non_size_terms)
+                    size_matches = size_query in product_title.split() or f'({size_query})' in product_title or f' {size_query} ' in product_title or product_title.endswith(f' {size_query}')
+
+                    if product_matches and size_matches:
+                        qty = int(product.get('qty', 0))
+                        stock = int(product.get('stock', 0))
+                        actual_stock = max(qty, stock)
+
+                        if actual_stock > 0:
+                            if is_dsw:
+                                dsw_stock_count += actual_stock
+                                continue
+
+                            variant_info = original_title
+                            possible_names = [
+                                product_name.upper(),
+                                product_name.lower(),
+                                product_name.title(),
+                                product_name.upper().replace('I', 'İ'),
+                                product_name.upper().replace('İ', 'I'),
+                            ]
+
+                            if 'fx sport' in product_name.lower():
+                                possible_names.extend(['FX Sport AL 3', 'FX SPORT AL 3', 'Fx Sport Al 3'])
+
+                            for possible_name in possible_names:
+                                variant_info = variant_info.replace(possible_name, '').strip()
+
+                            variant_info = ' '.join(variant_info.split())
+
+                            if variant_info and variant_info != original_title:
+                                warehouse_variants.append(f"{variant_info}: ✓ Stokta")
+                            else:
+                                warehouse_variants.append(f"{original_title}: ✓ Stokta")
+                else:
+                    if all(term in product_title for term in search_terms):
+                        qty = int(product.get('qty', 0))
+                        stock = int(product.get('stock', 0))
+                        actual_stock = max(qty, stock)
+
+                        if actual_stock > 0:
+                            if is_dsw:
+                                dsw_stock_count += actual_stock
+                                continue
+
+                            variant_info = original_title
+                            possible_names = [
+                                product_name.upper(),
+                                product_name.lower(),
+                                product_name.title(),
+                                product_name.upper().replace('I', 'İ'),
+                                product_name.upper().replace('İ', 'I'),
+                            ]
+
+                            if 'fx sport' in product_name.lower():
+                                possible_names.extend(['FX Sport AL 3', 'FX SPORT AL 3', 'Fx Sport Al 3'])
+
+                            for possible_name in possible_names:
+                                variant_info = variant_info.replace(possible_name, '').strip()
+
+                            variant_info = ' '.join(variant_info.split())
+
+                            if variant_info and variant_info != original_title:
+                                warehouse_variants.append(f"{variant_info}: ✓ Stokta")
+                            else:
+                                warehouse_variants.append(f"{original_title}: ✓ Stokta")
+
+        # Sonuc dondur
+        if warehouse_variants and not is_dsw:
+            return {'warehouse': warehouse_name, 'variants': warehouse_variants, 'is_dsw': False}
+        elif dsw_stock_count > 0:
+            return {'dsw_stock': dsw_stock_count, 'is_dsw': True}
+
+        return None
+
+    except Exception:
+        return None
+
+def get_realtime_stock_parallel(product_name):
+    """API'den gercek zamanli stok bilgisini cek - Paralel versiyon with cache"""
+    try:
+        # Cache kontrolu
+        cache_key = normalize_turkish(product_name).lower()
+        current_time = time.time()
+
+        if cache_key in stock_cache:
+            cached_data, cached_time = stock_cache[cache_key]
+            if current_time - cached_time < CACHE_DURATION:
+                logger.info(f"Cache'den donduruluyor: {product_name}")
+                return cached_data
+
+        # Once magaza listesini al
+        warehouses_url = f"{STOCK_API_BASE}?action=warehouses&endpoint=warehouses"
+        warehouses_response = requests.get(warehouses_url, timeout=3, verify=False)
+
+        if warehouses_response.status_code != 200:
+            logger.error(f"Magaza listesi alinamadi: {warehouses_response.status_code}")
+            return None
+
+        warehouses_data = warehouses_response.json()
+
+        if 'data' not in warehouses_data or 'warehouses' not in warehouses_data['data']:
+            logger.error("Magaza verisi bulunamadi")
+            return None
+
+        warehouses = warehouses_data['data']['warehouses']
+
+        # Urun adini normalize et
+        search_terms = normalize_turkish(product_name).lower().split()
+        logger.info(f"Aranan urun: {product_name} -> {search_terms}")
+
+        stock_info = {}
+        total_dsw_stock = 0
+        total_stock = 0
+
+        # Paralel olarak tum magazalari sorgula
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            futures = {
+                executor.submit(fetch_warehouse_inventory, warehouse, product_name, search_terms): warehouse
+                for warehouse in warehouses
+            }
+
+            for future in as_completed(futures):
+                result = future.result()
+                if result:
+                    if result.get('is_dsw'):
+                        total_dsw_stock += result.get('dsw_stock', 0)
+                    else:
+                        warehouse_name = result['warehouse']
+                        stock_info[warehouse_name] = result['variants']
+                        total_stock += 1
+
+        # Sonucu olustur
+        if not stock_info:
+            if total_dsw_stock > 0:
+                result = f"{product_name}: Su anda magazalarda stokta yok, ancak yakinda gelecek. On siparis verebilirsiniz."
+            else:
+                result = f"{product_name}: Su anda hicbir magazada stokta bulunmuyor."
+        else:
+            prompt_lines = [f"{product_name} stok durumu:"]
+            for warehouse, variants in stock_info.items():
+                if isinstance(variants, list):
+                    prompt_lines.append(f"- {warehouse}:")
+                    for variant in variants:
+                        prompt_lines.append(f"  • {variant}")
+                else:
+                    prompt_lines.append(f"- {warehouse}: {variants}")
+
+            if total_stock > 0:
+                prompt_lines.append(f"✓ Urun stokta mevcut")
+
+            result = "\n".join(prompt_lines)
+
+        # Sonucu cache'e kaydet
+        stock_cache[cache_key] = (result, current_time)
+
+        return result
+
+    except Exception as e:
+        logger.error(f"API hatasi: {e}")
+        return None
+
+def is_stock_query(message):
+    """Mesajin stok sorgusu olup olmadigini kontrol et - Basit yedek kontrol"""
+    # Bu fonksiyon artik sadece yedek olarak kullaniliyor
+    # Ana tespit Intent Analyzer tarafindan yapiliyor
+    basic_keywords = ['stok', 'stock', 'var mı', 'mevcut']
+    message_lower = message.lower()
+    return any(keyword in message_lower for keyword in basic_keywords)
+
+# ===============================
+# MAGAZA STOK BILGISI CEKME
+# ===============================
+def get_warehouse_stock(product_name):
+    """B2B API'den magaza stok bilgilerini cek - GPT-5 enhanced"""
+    # Try GPT-5 complete smart search (BF algorithm)
+    if USE_GPT5_SEARCH:
+        try:
+            gpt5_result = get_warehouse_stock_smart_with_price(product_name)
+            if gpt5_result and isinstance(gpt5_result, list):
+                if all(isinstance(item, str) for item in gpt5_result):
+                    return gpt5_result
+                warehouse_info = []
+                for item in gpt5_result:
+                    if isinstance(item, dict):
+                        info = f"📦 {item.get('name', '')}"
+                        if item.get('variant'):
+                            info += f" ({item['variant']})"
+                        if item.get('warehouses'):
+                            info += f"\n📍 Mevcut: {', '.join(item['warehouses'])}"
+                        if item.get('price'):
+                            info += f"\n💰 {item['price']}"
+                        warehouse_info.append(info)
+                    else:
+                        warehouse_info.append(str(item))
+                return warehouse_info if warehouse_info else None
+        except Exception as e:
+            logger.error(f"GPT-5 warehouse search error: {e}")
+
+    # Fallback to original search
+    try:
+        import re
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
+        response = requests.get(warehouse_url, verify=False, timeout=15)
+
+        if response.status_code != 200:
+            return None
+
+        root = ET.fromstring(response.content)
+
+        # Normalize search product name
+        search_name = normalize_turkish(product_name.lower().strip())
+        search_name = search_name.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+        search_words = search_name.split()
+
+        best_matches = []
+        exact_matches = []
+        variant_matches = []
+        candidates = []
+
+        size_color_words = ['s', 'm', 'l', 'xl', 'xs', 'small', 'medium', 'large',
+                           'turuncu', 'siyah', 'beyaz', 'mavi', 'kirmizi', 'yesil',
+                           'orange', 'black', 'white', 'blue', 'red', 'green']
+
+        variant_words = [word for word in search_words if word in size_color_words]
+        product_words = [word for word in search_words if word not in size_color_words]
+
+        is_size_color_query = len(variant_words) > 0 and len(search_words) <= 4
+
+        if is_size_color_query:
+            for product in root.findall('Product'):
+                product_name_elem = product.find('ProductName')
+                variant_elem = product.find('ProductVariant')
+
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
+                    normalized_product_name = normalize_turkish(xml_product_name.lower())
+
+                    product_name_matches = True
+                    if product_words:
+                        product_name_matches = all(word in normalized_product_name for word in product_words)
+
+                    if product_name_matches:
+                        if variant_elem is not None and variant_elem.text:
+                            variant_text = normalize_turkish(variant_elem.text.lower().replace('-', ' '))
+
+                            if all(word in variant_text for word in variant_words):
+                                variant_matches.append((product, xml_product_name, variant_text))
+
+            if variant_matches:
+                candidates = variant_matches
+            else:
+                is_size_color_query = False
+
+        if not is_size_color_query or not candidates:
+            for product in root.findall('Product'):
+                product_name_elem = product.find('ProductName')
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
+                    normalized_xml = normalize_turkish(xml_product_name.lower())
+                    normalized_xml = normalized_xml.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+                    xml_words = normalized_xml.split()
+
+                    if len(search_words) >= 2 and len(xml_words) >= 2:
+                        search_key = f"{search_words[0]} {search_words[1]}"
+                        xml_key = f"{xml_words[0]} {xml_words[1]}"
+
+                        if search_key == xml_key:
+                            exact_matches.append((product, xml_product_name, normalized_xml))
+
+            if not candidates:
+                candidates = exact_matches if exact_matches else []
+
+        if not candidates:
+            for product in root.findall('Product'):
+                product_name_elem = product.find('ProductName')
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
+                    normalized_xml = normalize_turkish(xml_product_name.lower())
+                    normalized_xml = normalized_xml.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+                    xml_words = normalized_xml.split()
+
+                    common_words = set(search_words) & set(xml_words)
+
+                    if (len(common_words) >= 2 and
+                        len(search_words) > 0 and len(xml_words) > 0 and
+                        search_words[0] == xml_words[0]):
+                        best_matches.append((product, xml_product_name, normalized_xml, len(common_words)))
+
+            if best_matches:
+                max_common = max(match[3] for match in best_matches)
+                candidates = [(match[0], match[1], match[2]) for match in best_matches if match[3] == max_common]
+
+        warehouse_stock_map = {}
+
+        for product, xml_name, _ in candidates:
+            for warehouse in product.findall('Warehouse'):
+                name_elem = warehouse.find('Name')
+                stock_elem = warehouse.find('Stock')
+
+                if name_elem is not None and stock_elem is not None:
+                    warehouse_name = name_elem.text if name_elem.text else "Bilinmeyen"
+                    try:
+                        stock_count = int(stock_elem.text) if stock_elem.text else 0
+                        if stock_count > 0:
+                            if warehouse_name in warehouse_stock_map:
+                                warehouse_stock_map[warehouse_name] += stock_count
+                            else:
+                                warehouse_stock_map[warehouse_name] = stock_count
+                    except (ValueError, TypeError):
+                        pass
+
+        if warehouse_stock_map:
+            all_warehouse_info = []
+            for warehouse_name, total_stock in warehouse_stock_map.items():
+                all_warehouse_info.append(f"{warehouse_name}: Stokta var")
+            return all_warehouse_info
+        else:
+            return ["Hicbir magazada stokta bulunmuyor"]
+
+    except Exception as e:
+        logger.error(f"Magaza stok bilgisi cekme hatasi: {e}")
+        return None
+
+# ===============================
+# TREK BISIKLET URUNLERINI CEKME
+# ===============================
+try:
+    url = 'https://www.trekbisiklet.com.tr/output/8582384479'
+    response = requests.get(url, verify=False, timeout=10)
+    root = ET.fromstring(response.content)
+    all_items = root.findall('item')
+
+    products = []
+
+    for item in all_items:
+        stock_number = 0
+        stock_amount = "stokta degil"
+        price = ""
+        price_eft = ""
+        product_link = ""
+        picture_url = ""
+        category_tree = ""
+        category_label = ""
+        stock_code = ""
+        root_product_stock_code = ""
+        is_option_of_product = "0"
+        is_optioned_product = "0"
+
+        rootlabel = item.find('rootlabel')
+        if rootlabel is None or not rootlabel.text:
+            continue
+
+        full_name = rootlabel.text.strip()
+        name_words = full_name.lower().split()
+        name = name_words[0] if name_words else "unknown"
+
+        # STOK KONTROLU - SAYISAL KARSILASTIRMA
+        stock_element = item.find('stockAmount')
+        if stock_element is not None and stock_element.text:
+            try:
+                stock_number = int(stock_element.text.strip())
+                stock_amount = "stokta" if stock_number > 0 else "stokta degil"
+            except (ValueError, TypeError):
+                stock_number = 0
+                stock_amount = "stokta degil"
+
+        # Urun linki - HER URUN ICIN AL
+        link_element = item.find('productLink')
+        product_link = link_element.text if link_element is not None and link_element.text else ""
+
+        # Urun resmi - HER URUN ICIN AL
+        picture_element = item.find('picture1Path')
+        picture_url = picture_element.text if picture_element is not None and picture_element.text else ""
+
+        # Kategori bilgileri - HER URUN ICIN AL
+        category_tree_element = item.find('categoryTree')
+        category_tree = category_tree_element.text if category_tree_element is not None and category_tree_element.text else ""
+
+        category_label_element = item.find('productCategoryLabel')
+        category_label = category_label_element.text if category_label_element is not None and category_label_element.text else ""
+
+        # Stock Code (SKU) - HER URUN ICIN AL
+        stock_code_element = item.find('stockCode')
+        stock_code = stock_code_element.text if stock_code_element is not None and stock_code_element.text else ""
+
+        # Variant/main product iliski alanlari
+        root_product_stock_code_element = item.find('rootProductStockCode')
+        root_product_stock_code = root_product_stock_code_element.text if root_product_stock_code_element is not None and root_product_stock_code_element.text else ""
+
+        is_option_of_product_element = item.find('isOptionOfAProduct')
+        is_option_of_product = is_option_of_product_element.text if is_option_of_product_element is not None and is_option_of_product_element.text else "0"
+
+        is_optioned_product_element = item.find('isOptionedProduct')
+        is_optioned_product = is_optioned_product_element.text if is_optioned_product_element is not None and is_optioned_product_element.text else "0"
+
+        # Stokta olan urunler icin fiyat bilgilerini al
+        if stock_amount == "stokta":
+            # Normal fiyat
+            price_element = item.find('priceTaxWithCur')
+            price_str = price_element.text if price_element is not None and price_element.text else "0"
+
+            # Kampanya fiyati
+            price_rebate_element = item.find('priceRebateWithTax')
+            price_rebate_str = price_rebate_element.text if price_rebate_element is not None and price_rebate_element.text else ""
+
+            final_price_str = price_str
+            if price_rebate_str:
+                try:
+                    normal_price = float(price_str)
+                    rebate_price = float(price_rebate_str)
+                    if rebate_price < normal_price:
+                        final_price_str = price_rebate_str
+                except (ValueError, TypeError):
+                    final_price_str = price_str
+
+            # EFT fiyati
+            price_eft_element = item.find('priceEft')
+            price_eft_str = price_eft_element.text if price_eft_element is not None and price_eft_element.text else ""
+
+            # Fiyat formatting
+            try:
+                price_float = float(final_price_str)
+                if price_float > 200000:
+                    price = str(round(price_float / 5000) * 5000)
+                elif price_float > 30000:
+                    price = str(round(price_float / 1000) * 1000)
+                elif price_float > 10000:
+                    price = str(round(price_float / 100) * 100)
+                else:
+                    price = str(round(price_float / 10) * 10)
+            except (ValueError, TypeError):
+                price = final_price_str
+
+            # EFT fiyat formatting
+            if price_eft_str:
+                try:
+                    price_eft_float = float(price_eft_str)
+                    if price_eft_float > 200000:
+                        price_eft = str(round(price_eft_float / 5000) * 5000)
+                    elif price_eft_float > 30000:
+                        price_eft = str(round(price_eft_float / 1000) * 1000)
+                    elif price_eft_float > 10000:
+                        price_eft = str(round(price_eft_float / 100) * 100)
+                    else:
+                        price_eft = str(round(price_eft_float / 10) * 10)
+                except (ValueError, TypeError):
+                    price_eft = price_eft_str
+            else:
+                try:
+                    price_eft_float = float(price_str)
+                    price_eft = str(round(price_eft_float * 0.975 / 10) * 10)
+                except:
+                    price_eft = ""
+
+        # Urun bilgilerini tuple olarak olustur
+        item_info = (stock_amount, price, product_link, price_eft, str(stock_number),
+                     picture_url, category_tree, category_label, stock_code,
+                     root_product_stock_code, is_option_of_product, is_optioned_product)
+        products.append((name, item_info, full_name))
+
+    logger.info(f"✅ {len(products)} urun yuklendi")
+
+except Exception as e:
+    logger.error(f"❌ Urun yukleme hatasi: {e}")
+    import traceback
+    traceback.print_exc()
+    products = []
+
+# ===============================
+# SISTEM MESAJLARI
+# ===============================
+def get_system_messages():
+    """Sistem mesajlarini yukle - Moduler prompts'tan"""
+    try:
+        return get_active_prompts()
+    except:
+        # Fallback sistem mesajlari
+        return [
+            {"role": "system", "content": "Sen Trek bisiklet uzmani AI asistanisin. Trek ve Electra bisikletler konusunda uzmansin. Stokta bulunan urunlerin fiyat bilgilerini verebilirsin."}
+        ]
+
+# ===============================
+# SOHBET HAFIZASI SISTEMI
+# ===============================
+conversation_memory = {}
+
+def get_conversation_context(phone_number):
+    """Kullanicinin sohbet gecmisini getir"""
+    if phone_number not in conversation_memory:
+        conversation_memory[phone_number] = {
+            "messages": [],
+            "current_category": None,
+            "current_product": None,
+            "current_product_link": None,
+            "current_product_price": None,
+            "last_activity": None
+        }
+    return conversation_memory[phone_number]
+
+def add_to_conversation(phone_number, user_message, ai_response):
+    """Sohbet gecmisine ekle"""
+    context = get_conversation_context(phone_number)
+    context["last_activity"] = datetime.datetime.now()
+
+    context["messages"].append({
+        "user": user_message,
+        "ai": ai_response,
+        "timestamp": datetime.datetime.now()
+    })
+
+    # Sadece son 10 mesaji tut
+    if len(context["messages"]) > 10:
+        context["messages"] = context["messages"][-10:]
+
+    detect_category(phone_number, user_message, ai_response)
+
+def detect_category(phone_number, user_message, ai_response):
+    """Konusulan kategoriyi ve tam urun adini tespit et"""
+    context = get_conversation_context(phone_number)
+
+    categories = {
+        "marlin": ["marlin", "marlin+"],
+        "madone": ["madone"],
+        "emonda": ["emonda", "émonda"],
+        "domane": ["domane"],
+        "checkpoint": ["checkpoint"],
+        "fuel": ["fuel", "fuel ex", "fuel exe"],
+        "procaliber": ["procaliber"],
+        "supercaliber": ["supercaliber"],
+        "fx": ["fx"],
+        "ds": ["ds", "dual sport"],
+        "powerfly": ["powerfly"],
+        "rail": ["rail"],
+        "verve": ["verve"],
+        "townie": ["townie"]
+    }
+
+    user_lower = user_message.lower()
+    for category, keywords in categories.items():
+        for keyword in keywords:
+            if keyword in user_lower:
+                context["current_category"] = category
+
+                # TAM URUN ADINI CIKAR - ornegin "Marlin 5", "Madone SLR 9"
+                # Model numarasini da yakala
+                import re
+                # Keyword + sayi pattern'i ara (ornegin "marlin 5", "madone slr 9")
+                pattern = rf'{keyword}\s*\+?\s*(?:slr\s*)?(\d+)?'
+                match = re.search(pattern, user_lower)
+                if match:
+                    model_num = match.group(1)
+                    if model_num:
+                        # Tam urun adi: "marlin 5" veya "madone slr 9"
+                        full_product = match.group(0).strip()
+                        context["current_product"] = full_product
+                    else:
+                        # Sadece kategori adi
+                        context["current_product"] = keyword
+                else:
+                    context["current_product"] = keyword
+
+                return category
+
+    return context.get("current_category")
+
+def build_context_messages(phone_number, current_message):
+    """Sohbet gecmisi ile sistem mesajlarini olustur"""
+    context = get_conversation_context(phone_number)
+    system_messages = get_system_messages()
+
+    # Mevcut kategori varsa, sistem mesajina ekle - GUCLENDIRILMIS BAGLAIM
+    if context.get("current_category"):
+        cat = context['current_category'].upper()
+        category_msg = f"""KRITIK BAGLAIM BILGISI:
+Musteri su anda {cat} modelleri hakkinda konusuyor.
+Butun sorulari bu baglamda cevapla.
+"Hangi model var", "stok var mi", "fiyat ne" gibi sorular {cat} icin sorulmus demektir.
+DS, FX, Verve gibi BASKA kategorilerden bahsetme - sadece {cat} hakkinda konusuyoruz!"""
+        system_messages.append({"role": "system", "content": category_msg})
+
+    # Son konusulan urun bilgilerini ekle (link, fiyat sorulari icin)
+    if context.get("current_product"):
+        product_context = f"Son konusulan urun: {context['current_product']}"
+        if context.get("current_product_link"):
+            product_context += f"\nUrun linki: {context['current_product_link']}"
+        if context.get("current_product_price"):
+            product_context += f"\nUrun fiyati: {context['current_product_price']}"
+        system_messages.append({"role": "system", "content": product_context})
+
+    # Son 3 mesaj alisverisini ekle
+    recent_messages = context["messages"][-3:] if context["messages"] else []
+
+    all_messages = system_messages.copy()
+
+    # Gecmis mesajlari ekle
+    for msg in recent_messages:
+        all_messages.append({"role": "user", "content": msg["user"]})
+        all_messages.append({"role": "assistant", "content": msg["ai"]})
+
+    # Mevcut mesaji ekle
+    all_messages.append({"role": "user", "content": current_message})
+
+    return all_messages
+
+# ===============================
+# HYBRID MODEL MESAJ ISLEME
+# ===============================
+
+
+def extract_product_from_vision_response(response):
+    """
+    GPT Vision yanitindan urun adini cikarir
+    Ornek: "Trek Domane+ SLR 7 AXS" -> "Domane+ SLR 7 AXS"
+    """
+    import re
+    
+    # Bilinen Trek model pattern'leri
+    patterns = [
+        # Trek Domane+ SLR 7 AXS gibi tam isimler
+        r'Trek\s+((?:Domane|Madone|Emonda|Marlin|Fuel|Rail|Powerfly|Checkpoint|FX|Verve|Dual\s*Sport|Procaliber|Supercaliber|Roscoe|Top\s*Fuel|Slash|Remedy|X-?Caliber|Allant)[+]?\s*(?:SLR|SL|Gen|EX|EXe)?\s*\d*\s*(?:AXS|Di2|eTap|Frameset)?)',
+        # Sadece model adi + numara
+        r'((?:Domane|Madone|Emonda|Marlin|Fuel|Rail|Powerfly|Checkpoint|FX|Verve|Dual\s*Sport|Procaliber|Supercaliber|Roscoe|Top\s*Fuel|Slash|Remedy|X-?Caliber|Allant)[+]?\s*(?:SLR|SL|Gen|EX|EXe)?\s*\d+\s*(?:AXS|Di2|eTap|Frameset)?)',
+        # Model + SLR/SL + numara
+        r'((?:Domane|Madone|Emonda)[+]?\s+(?:SLR|SL)\s*\d+)',
+        # Marlin + numara
+        r'(Marlin\s*\d+)',
+        # FX + numara
+        r'(FX\s*(?:Sport)?\s*\d+)',
+    ]
+    
+    response_lower = response.lower()
+    
+    for pattern in patterns:
+        match = re.search(pattern, response, re.IGNORECASE)
+        if match:
+            product = match.group(1).strip()
+            # "Trek " prefix varsa kaldir
+            product = re.sub(r'^Trek\s+', '', product, flags=re.IGNORECASE)
+            return product
+    
+    return None
+
+
+def process_whatsapp_message_with_media(user_message, phone_number, media_urls, media_types):
+    """
+    GORSEL MESAJ ISLEME - GPT-4o Vision kullanir
+    """
+    try:
+        logger.info(f"🖼️ Gorsel analizi basliyor: {len(media_urls)} medya")
+        logger.info(f"📎 Medya URL'leri: {media_urls}")
+        logger.info(f"📎 Medya tipleri: {media_types}")
+
+        # Pasif profil analizi
+        try:
+            profile_analysis = analyze_user_message(phone_number, user_message)
+            logger.info(f"📊 Profil analizi: {phone_number} -> {profile_analysis}")
+        except:
+            pass
+
+        # Gorsel icin GPT-4o kullan
+        model = get_model_for_request(has_media=True)
+
+        # Sohbet gecmisi ile sistem mesajlarini olustur
+        messages = build_context_messages(phone_number, user_message if user_message else "Gonderilen gorseli analiz et")
+
+        # GPT-4o Vision icin mesaj hazirla
+        vision_message = {
+            "role": "user",
+            "content": []
+        }
+
+        # Metin mesaji varsa ekle
+        # KRITIK: Kisa sorularda (var mi, fiyat, stok) gorseli dikkate alarak cevap vermesini sagla
+        if user_message and user_message.strip():
+            short_questions = ['var mi', 'var mı', 'stok', 'fiyat', 'kac', 'kaç', 'ne kadar', 'beden', 'renk']
+            is_short_question = len(user_message.strip()) < 20 and any(q in user_message.lower() for q in short_questions)
+            
+            if is_short_question:
+                # Kisa soru - gorseli referans alarak cevap vermesini iste
+                enhanced_text = f"Gorseldeki BISIKLETI dikkatlice incele ve model adini tespit et. Musteri bu bisiklet icin '{user_message}' soruyor. Gorseldeki bisikletin TAM MODEL ADINI (ornegin 'Trek Domane+ SLR 7 AXS') belirle ve buna gore cevap ver."
+                vision_message["content"].append({
+                    "type": "text",
+                    "text": enhanced_text
+                })
+            else:
+                vision_message["content"].append({
+                    "type": "text",
+                    "text": user_message
+                })
+        else:
+            vision_message["content"].append({
+                "type": "text",
+                "text": "Bu gorselde ne var? Eger bisiklet veya bisiklet parcasi ise detayli acikla."
+            })
+        # Medya URL'lerini isle
+        valid_images = 0
+        for i, media_url in enumerate(media_urls):
+            media_type = media_types[i] if i < len(media_types) else "image/jpeg"
+
+            # Sadece gorsel medyalari isle
+            if media_type and media_type.startswith('image/'):
+                try:
+                    # Twilio medya URL'sini proxy uzerinden cevir
+                    if 'api.twilio.com' in media_url:
+                        import re
+                        match = re.search(r'/Messages/([^/]+)/Media/([^/]+)', media_url)
+                        if match:
+                            message_sid = match.group(1)
+                            media_sid = match.group(2)
+                            proxy_url = f"https://video.trek-turkey.com/twilio-media-proxy.php?action=media&message={message_sid}&media={media_sid}"
+                            logger.info(f"🔄 Proxy URL olusturuldu: {proxy_url}")
+
+                            # Proxy URL'sinin calisip calismadigini kontrol et
+                            try:
+                                test_response = requests.head(proxy_url, timeout=5, verify=False)
+                                if test_response.status_code == 200:
+                                    vision_message["content"].append({
+                                        "type": "image_url",
+                                        "image_url": {"url": proxy_url}
+                                    })
+                                    valid_images += 1
+                                    logger.info(f"✅ Proxy URL gecerli: {proxy_url}")
+                                else:
+                                    logger.error(f"❌ Proxy URL calismiyor: {test_response.status_code}")
+                                    vision_message["content"].append({
+                                        "type": "image_url",
+                                        "image_url": {"url": media_url}
+                                    })
+                                    valid_images += 1
+                            except Exception as proxy_error:
+                                logger.error(f"❌ Proxy test hatasi: {proxy_error}")
+                                vision_message["content"].append({
+                                    "type": "image_url",
+                                    "image_url": {"url": media_url}
+                                })
+                                valid_images += 1
+                        else:
+                            logger.error(f"❌ Twilio URL parse edilemedi: {media_url}")
+                    else:
+                        vision_message["content"].append({
+                            "type": "image_url",
+                            "image_url": {"url": media_url}
+                        })
+                        valid_images += 1
+                        logger.info(f"✅ Dogrudan URL eklendi: {media_url}")
+                except Exception as url_error:
+                    logger.error(f"❌ URL isleme hatasi: {url_error}")
+            else:
+                logger.warning(f"⚠️ Gorsel olmayan medya atlandi: {media_type}")
+
+        # Hic gecerli gorsel yoksa
+        if valid_images == 0:
+            logger.error("❌ Hic gecerli gorsel bulunamadi")
+            return "Gonderdiginiz gorsel islenemedi. Lutfen farkli bir gorsel gonderin veya sorunuzu yazili olarak iletin."
+
+        logger.info(f"✅ {valid_images} gorsel islenecek")
+
+        # Son user mesajini vision mesajiyla degistir
+        messages = [msg for msg in messages if not (msg.get("role") == "user" and msg == messages[-1])]
+        messages.append(vision_message)
+
+        # Sistem mesajina bisiklet tanima talimati ekle
+        bike_recognition_prompt = {
+            "role": "system",
+            "content": """Gonderilen gorselleri dikkatle analiz et:
+1. Eger bisiklet veya bisiklet parcasi goruyorsan, detaylica tanimla (marka, model, renk, beden, ozellikler)
+2. Trek bisiklet ise modeli tahmin etmeye calis
+3. Stok veya fiyat sorulursa, gorseldeki bisikletin ozelliklerini belirterek bilgi ver
+4. Gorsel net degilse veya tanimlanamiyorsa, kullanicidan daha net bir gorsel istemek yerine, gorselde gorduklerini acikla
+5. Eger gorsel bisikletle ilgili degilse, ne gordugunu kisaca acikla"""
+        }
+        messages.insert(0, bike_recognition_prompt)
+
+        if not OPENAI_API_KEY:
+            logger.error("❌ OpenAI API anahtari eksik")
+            return "Sistem hatasi olustu. Lutfen daha sonra tekrar deneyin."
+
+        logger.info(f"📤 GPT Vision API'ye gonderiliyor: {len(messages)} mesaj, {valid_images} gorsel")
+
+        payload = {
+            "model": model,  # GPT-4o
+            "messages": messages,
+            "max_tokens": 800,
+            "temperature": 0.3
+        }
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {OPENAI_API_KEY}"
+        }
+
+        response = requests.post(API_URL, headers=headers, json=payload, timeout=30)
+
+        logger.info(f"📥 API yaniti: {response.status_code}")
+
+        if response.status_code == 200:
+            result = response.json()
+            ai_response = result['choices'][0]['message']['content']
+            logger.info(f"✅ Gorsel analizi basarili: {ai_response[:100]}...")
+
+            # KRITIK: Gorselden urun adini cikar ve GERCEK stok kontrolu yap
+            try:
+                # app.py'deki get_warehouse_stock fonksiyonunu kullan
+                
+                # GPT yanitindan urun adini cikar
+                product_name = extract_product_from_vision_response(ai_response)
+                
+                if product_name:
+                    logger.info(f"🔍 Gorselden tespit edilen urun: {product_name}")
+                    
+                    # GERCEK stok kontrolu yap
+                    stock_result = get_warehouse_stock(product_name)
+                    
+                    # Sonuc list veya string olabilir
+                    stock_info = None
+                    if stock_result:
+                        if isinstance(stock_result, list):
+                            stock_info = chr(10).join(str(item) for item in stock_result)
+                        else:
+                            stock_info = str(stock_result)
+                    
+                    if stock_info and len(stock_info) > 5:
+                        logger.info(f"✅ Stok bilgisi bulundu: {stock_info[:100]}...")
+                        
+                        # GPT yanlis "stokta yok" dediyse duzelt
+                        if "stokta bulunmuyor" in ai_response.lower() or "stokta yok" in ai_response.lower():
+                            if "stokta bulunmuyor" not in stock_info.lower():
+                                # Yanlis bilgiyi kaldir ve dogru stok bilgisini ekle
+                                ai_response = re.sub(
+                                    r'[^.]*stok[^.]*bulunmuyor[^.]*[.]?',
+                                    '',
+                                    ai_response,
+                                    flags=re.IGNORECASE
+                                )
+                                ai_response = ai_response.strip()
+                        
+                        # Stok bilgisini ekle (eger zaten yoksa)
+                        if "Stok:" not in ai_response and "stokta" not in stock_info.lower():
+                            ai_response = ai_response + "\n\n" + stock_info
+
+                        elif "Stok:" not in ai_response:
+                            ai_response = ai_response + "\n\n" + stock_info
+
+                    else:
+                        logger.info(f"⚠️ Urun icin stok bilgisi bulunamadi: {product_name}")
+                else:
+                    logger.info("⚠️ Gorselden urun adi cikarilamadi")
+            except Exception as stock_error:
+                logger.error(f"❌ Vision stok kontrolu hatasi: {stock_error}")
+            
+            # Context'e urun adini kaydet (sonraki sorular icin)
+            if product_name:
+                try:
+                    ctx = get_conversation_context(phone_number)
+                    ctx["current_product"] = product_name
+                    ctx["current_category"] = product_name.split()[0].lower()
+                    logger.info(f"📝 Vision context kaydedildi: {product_name}")
+                except:
+                    pass
+
+            # WhatsApp icin formatla
+            try:
+                formatted_response = extract_product_info_whatsapp(ai_response)
+            except:
+                formatted_response = ai_response
+
+            # Sohbet gecmisine ekle
+            add_to_conversation(phone_number, f"[Gorsel gonderildi] {user_message if user_message else ''}", formatted_response)
+
+            return formatted_response
+        else:
+            error_detail = response.text[:500] if response.text else "Detay yok"
+            logger.error(f"❌ OpenAI API Error: {response.status_code} - {error_detail}")
+
+            if response.status_code == 400:
+                return "Gorsel formati desteklenmiyor. Lutfen JPG veya PNG formatinda bir gorsel gonderin."
+            elif response.status_code == 413:
+                return "Gorsel boyutu cok buyuk. Lutfen daha kucuk bir gorsel gonderin."
+            elif response.status_code == 429:
+                return "Sistem su anda yogun. Lutfen birkac saniye sonra tekrar deneyin."
+            else:
+                return "Gorsel su anda analiz edilemiyor. Sorunuzu yazili olarak iletebilir misiniz?"
+
+    except requests.exceptions.Timeout:
+        logger.error("❌ API timeout hatasi")
+        return "Islem zaman asimina ugradi. Lutfen tekrar deneyin."
+    except Exception as e:
+        logger.error(f"❌ Medya isleme hatasi: {e}")
+        import traceback
+        traceback.print_exc()
+        return "Gorsel islenirken bir sorun olustu. Lutfen sorunuzu yazili olarak iletin veya farkli bir gorsel deneyin."
+
+
+def process_whatsapp_message_with_memory(user_message, phone_number):
+    """
+    METIN MESAJ ISLEME - GPT-5.2 kullanir (daha akilli)
+    """
+    try:
+        # Metin icin GPT-5.2 kullan
+        model = get_model_for_request(has_media=False)
+
+        # Pasif profil analizi
+        try:
+            profile_analysis = analyze_user_message(phone_number, user_message)
+            logger.info(f"📊 Profil analizi: {phone_number}")
+        except:
+            pass
+
+        # 🔔 Yeni Magaza Bildirim Sistemi - Mehmet Bey'e otomatik bildirim
+        if USE_STORE_NOTIFICATION:
+            try:
+                should_notify_mehmet, notification_reason, urgency = should_notify_mehmet_bey(user_message)
+
+                if not should_notify_mehmet and USE_INTENT_ANALYZER:
+                    context = get_conversation_context(phone_number)
+                    intent_analysis = analyze_customer_intent(user_message, context)
+                    should_notify_mehmet, notification_reason, urgency = should_notify_mehmet_bey(user_message, intent_analysis)
+                else:
+                    intent_analysis = None
+
+                if should_notify_mehmet:
+                    if intent_analysis:
+                        product = intent_analysis.get("product") or "Belirtilmemis"
+                    else:
+                        context = get_conversation_context(phone_number)
+                        product = context.get("current_category") or "Urun belirtilmemis"
+
+                    if "rezervasyon" in notification_reason.lower() or urgency == "high":
+                        action = "reserve"
+                    elif "magaza" in notification_reason.lower() or "lokasyon" in notification_reason.lower():
+                        action = "info"
+                    elif "fiyat" in notification_reason.lower() or "odeme" in notification_reason.lower():
+                        action = "price"
+                    else:
+                        action = "info"
+
+                    additional_info = f"{notification_reason}\n\nMusteri Mesaji: '{user_message}'"
+                    if urgency == "high":
+                        additional_info = "⚠️ YUKSEK ONCELIK ⚠️\n" + additional_info
+
+                    result = send_store_notification(
+                        customer_phone=phone_number,
+                        customer_name=None,
+                        product_name=product,
+                        action=action,
+                        store_name=None,
+                        additional_info=additional_info
+                    )
+
+                    if result:
+                        logger.info(f"✅ Mehmet Bey'e bildirim gonderildi!")
+                        logger.info(f"   📍 Sebep: {notification_reason}")
+                        logger.info(f"   ⚡ Oncelik: {urgency}")
+                        logger.info(f"   📦 Urun: {product}")
+
+                        # TAKIP SISTEMINI KONTROL ET
+                        if USE_FOLLOW_UP and follow_up_manager:
+                            try:
+                                follow_up_analysis = analyze_message_for_follow_up(user_message)
+                                if follow_up_analysis and follow_up_analysis.get("needs_follow_up"):
+                                    follow_up = follow_up_manager.create_follow_up(
+                                        customer_phone=phone_number,
+                                        product_name=product,
+                                        follow_up_type=follow_up_analysis["follow_up_type"],
+                                        original_message=user_message,
+                                        follow_up_hours=follow_up_analysis.get("follow_up_hours", 24),
+                                        notes=follow_up_analysis.get("reason", "")
+                                    )
+                                    logger.info(f"📌 Takip olusturuldu: {follow_up_analysis.get('reason', '')}")
+                            except Exception as follow_up_error:
+                                logger.error(f"Takip sistemi hatasi: {follow_up_error}")
+            except Exception as notify_error:
+                logger.error(f"Bildirim hatasi: {notify_error}")
+
+        # Sohbet gecmisi ile mesajlari olustur
+        messages = build_context_messages(phone_number, user_message)
+
+        # Intent Analyzer veya context'ten urun bilgisini al
+        detected_product = None
+        intent_analysis = None  # Scope disinda da kullanilacak
+        if USE_INTENT_ANALYZER:
+            try:
+                context = get_conversation_context(phone_number)
+                intent_analysis = analyze_customer_intent(user_message, context)
+                if intent_analysis and intent_analysis.get("product"):
+                    detected_product = intent_analysis.get("product")
+                    logger.info(f"🎯 Intent'ten tespit edilen urun: {detected_product}")
+            except Exception as e:
+                logger.error(f"Intent analiz hatasi: {e}")
+                intent_analysis = None
+
+        # Eger Intent'ten urun bulunamadiysa, context'ten al
+        # ONEMLI: current_product TAM URUN ADINI icerir (ornegin "marlin 5")
+        # current_category ise sadece kategori adidir (ornegin "marlin")
+        if not detected_product:
+            context = get_conversation_context(phone_number)
+            # Oncelikle tam urun adini dene
+            if context.get("current_product"):
+                detected_product = context.get("current_product")
+                logger.info(f"🎯 Context'ten tespit edilen TAM URUN: {detected_product}")
+            elif context.get("current_category"):
+                detected_product = context.get("current_category")
+                logger.info(f"🎯 Context'ten tespit edilen kategori: {detected_product}")
+
+        # Stok sorgusu icin kullanilacak urun adi
+        stock_query_product = detected_product if detected_product else user_message
+
+        # Urun bilgilerini ekle
+        input_words = user_message.lower().split()
+        # Detected product'i da input_words'e ekle
+        if detected_product:
+            input_words.extend(detected_product.lower().split())
+
+        # Bulunan urunun link ve gorsel bilgilerini sakla
+        found_product_link = None
+        found_product_image = None
+        found_product_name = None
+        best_match_score = 0
+
+        # Kullanici mesaji veya detected_product'i normalize et
+        search_text = (detected_product or user_message).lower()
+        search_words = search_text.split()
+
+        # AKILLI URUN ESLESTIRME
+        # 1. Kategori bazli filtreleme - Bisiklet aramasinda aksesuar gosterme
+        # 2. Urun tipi benzerligi - Ayni tip urunler oncelikli
+        # 3. Kelime eslesmesi - En cok eslesen urun
+
+        def is_bicycle_search(text):
+            """Arama bisiklet mi yoksa aksesuar mi?"""
+            bike_indicators = ['madone', 'domane', 'emonda', 'checkpoint', 'fuel', 'slash',
+                              'marlin', 'procaliber', 'supercaliber', 'fx', 'verve', 'dual sport',
+                              'powerfly', 'rail', 'allant', 'bisiklet', 'bike']
+            text_lower = text.lower()
+            return any(ind in text_lower for ind in bike_indicators)
+
+        def get_product_type(category_tree, product_name):
+            """Urun tipini belirle"""
+            cat_lower = (category_tree or "").lower()
+            name_lower = (product_name or "").lower()
+
+            # Kategori agacindan tip belirle
+            if 'bisiklet' in cat_lower or 'bike' in cat_lower:
+                if 'yol' in cat_lower or 'road' in cat_lower:
+                    return 'road_bike'
+                elif 'dag' in cat_lower or 'mountain' in cat_lower or 'mtb' in cat_lower:
+                    return 'mtb'
+                elif 'elektrik' in cat_lower or 'e-bike' in cat_lower:
+                    return 'ebike'
+                elif 'sehir' in cat_lower or 'hybrid' in cat_lower:
+                    return 'hybrid'
+                return 'bicycle'
+            elif 'aksesuar' in cat_lower or 'parça' in cat_lower or 'parca' in cat_lower or 'accessory' in cat_lower or 'yedek' in cat_lower:
+                return 'accessory'
+
+            # Isimden tip belirle (fallback)
+            # ONEMLI: Aksesuar kontrolu ONCE yapilmali cunku "Domane Kadro Kulagi" gibi
+            # urunlerde model adi gecebilir ama aksesuar kelimeleri varsa aksesuar'dir
+            accessory_keywords = ['sele', 'gidon', 'pedal', 'zincir', 'lastik', 'jant', 'fren', 'vites',
+                                 'kadro kulağı', 'kadro kulagi', 'kulak', 'kablo', 'kasnak', 'dişli',
+                                 'zil', 'far', 'lamba', 'pompa', 'kilit', 'çanta', 'canta', 'suluk',
+                                 'gözlük', 'gozluk', 'kask', 'eldiven', 'ayakkabı', 'ayakkabi',
+                                 'forma', 'tayt', 'şort', 'sort', 'mont', 'yağmurluk', 'yagmurluk']
+            if any(x in name_lower for x in accessory_keywords):
+                return 'accessory'
+            if any(x in name_lower for x in ['madone', 'domane', 'emonda', 'checkpoint', 'fuel', 'marlin', 'fx']):
+                return 'bicycle'
+
+            return 'unknown'
+
+        def calculate_smart_match_score(search_words, product_name, product_category, is_bike_search):
+            """Akilli eslesme skoru hesapla"""
+            product_name_lower = product_name.lower()
+            product_words = product_name_lower.split()
+            product_type = get_product_type(product_category, product_name)
+
+            # Temel kelime eslesmesi
+            base_score = sum(1 for word in search_words if word in product_name_lower)
+
+            # Kategori uyumu bonusu/cezasi
+            if is_bike_search:
+                if product_type == 'bicycle':
+                    base_score += 2  # Bisiklet aramasinda bisiklet bulunca bonus
+                elif product_type == 'accessory':
+                    base_score -= 100  # Bisiklet aramasinda aksesuar KESINLIKLE gosterilmemeli
+
+            # KRITIK VARYANT KONTROLU
+            # AXS, Di2, eTap gibi varyantlar FARKLI URUNLERDIR
+            # Kullanici "Madone SLR 9" diyorsa "Madone SLR 9 AXS" GOSTERILMEMELI
+            critical_variants = ['axs', 'etap', 'di2', 'frameset']
+
+            # Urunde olan kritik varyantlar
+            product_critical_variants = [v for v in critical_variants if v in product_name_lower]
+            # Kullanicinin soyledigi kritik varyantlar
+            user_critical_variants = [v for v in critical_variants if v in ' '.join(search_words)]
+
+            # Urunde kritik varyant var AMA kullanici soylemedi -> BUYUK CEZA
+            for variant in product_critical_variants:
+                if variant not in user_critical_variants:
+                    base_score -= 50  # Bu urun gosterilmemeli
+
+            # Kullanici kritik varyant soyledi AMA urunde yok -> CEZA
+            for variant in user_critical_variants:
+                if variant not in product_critical_variants:
+                    base_score -= 50  # Bu urun gosterilmemeli
+
+            # Tam esleme bonusu - Tum arama kelimeleri urunde varsa
+            all_words_match = all(word in product_name_lower for word in search_words if len(word) > 2)
+            if all_words_match and len(search_words) > 1:
+                base_score += 3
+
+            # Model numarasi eslesmesi - "9" araniyorsa "9" olmali, "7" olmamali
+            for word in search_words:
+                if word.isdigit():
+                    if word in product_words:
+                        base_score += 2  # Tam numara eslesmesi
+                    else:
+                        # Farkli numara varsa ceza
+                        for pword in product_words:
+                            if pword.isdigit() and pword != word:
+                                base_score -= 20  # Farkli model numarasi
+
+            return base_score
+
+        # Arama bisiklet mi?
+        is_bike_search = is_bicycle_search(search_text)
+
+        for product_info in products:
+            product_full_name = product_info[2]  # Tam urun adi
+            product_category = product_info[1][6] if len(product_info[1]) > 6 else ""  # category_tree
+
+            # Akilli skor hesapla
+            match_score = calculate_smart_match_score(
+                search_words,
+                product_full_name,
+                product_category,
+                is_bike_search
+            )
+
+            # Daha iyi eslesme bulduysa guncelle
+            if match_score > best_match_score and product_info[1][0] == "stokta":
+                best_match_score = match_score
+
+                normal_price = f"Fiyat: {product_info[1][1]} TL"
+                if product_info[1][3]:
+                    eft_price = f"Havale: {product_info[1][3]} TL"
+                    price_info = f"{normal_price}, {eft_price}"
+                else:
+                    price_info = normal_price
+
+                # Urun linki ve gorseli al - EN IYI ESLESEN URUN
+                if product_info[1][2]:  # product_link
+                    found_product_link = product_info[1][2]
+                if product_info[1][5]:  # picture_url
+                    found_product_image = product_info[1][5]
+                found_product_name = product_info[2]
+
+                # System message'a LINK EKLEME - cunku GPT linki yanitina dahil ediyor
+                # ve sonra biz de ekledigimizde 2 kere gorunuyor
+                new_msg = f"{product_info[2]} {product_info[1][0]} - {price_info}"
+                messages.append({"role": "system", "content": new_msg})
+
+        # Eger match bulunamadiysa, basit eslesme dene
+        if best_match_score == 0:
+            for product_info in products:
+                if product_info[0] in input_words and product_info[1][0] == "stokta":
+                    normal_price = f"Fiyat: {product_info[1][1]} TL"
+                    if product_info[1][3]:
+                        eft_price = f"Havale: {product_info[1][3]} TL"
+                        price_info = f"{normal_price}, {eft_price}"
+                    else:
+                        price_info = normal_price
+
+                    if product_info[1][2]:
+                        found_product_link = product_info[1][2]
+                    if product_info[1][5]:
+                        found_product_image = product_info[1][5]
+                    found_product_name = product_info[2]
+
+                    new_msg = f"{product_info[2]} {product_info[1][0]} - {price_info}"
+                    messages.append({"role": "system", "content": new_msg})
+                    break  # Ilk eslesen yeterli
+
+        # Stok bilgisi ekle - detected_product kullan
+        # ONCELIK: XML sonucu (smart_warehouse_with_price.py) daha guvenilir
+        warehouse_info = get_warehouse_stock(stock_query_product)
+        xml_has_valid_stock = False
+
+        if warehouse_info:
+            stock_msg = "Magaza Stok Durumu:\n" + "\n".join(warehouse_info) if isinstance(warehouse_info, list) else str(warehouse_info)
+            messages.append({"role": "system", "content": stock_msg})
+
+            # XML sonucunda gercek stok bilgisi var mi kontrol et
+            # "mevcut degil", "bulunamadi", "tukendi" gibi ifadeler yoksa stok var demektir
+            stock_msg_lower = stock_msg.lower()
+            negative_indicators = ["mevcut değil", "mevcut degil", "bulunamadi", "bulunmuyor", "tükendi", "tukendi", "stokta yok"]
+            xml_has_valid_stock = not any(indicator in stock_msg_lower for indicator in negative_indicators)
+
+            if xml_has_valid_stock:
+                logger.info(f"✅ XML'den stok bilgisi bulundu: {stock_query_product}")
+
+            # Link ve fiyat bilgisini context'e kaydet (follow-up sorular icin)
+            context = get_conversation_context(phone_number)
+            link_match = re.search(r'Link: (https?://[^\s]+)', stock_msg)
+            if link_match:
+                context["current_product_link"] = link_match.group(1)
+                logger.info(f"🔗 Link context'e kaydedildi: {link_match.group(1)}")
+            price_match = re.search(r'Fiyat: ([^\n]+)', stock_msg)
+            if price_match:
+                context["current_product_price"] = price_match.group(1)
+            # Urun adini da kaydet
+            if stock_query_product:
+                context["current_product"] = stock_query_product
+
+        # Gercek zamanli stok sorgusu - SADECE XML sonucu bos veya olumsuzsa calistir
+        # Bu sayede XML'de bulunan urunler icin yanlis "stokta yok" mesaji onlenir
+        should_query_stock = False
+
+        if not xml_has_valid_stock:
+            if intent_analysis:
+                # Intent Analyzer'dan gelen intent'lere bak
+                intents = intent_analysis.get("intents", [])
+                # stock, info, price gibi intent'ler stok sorgusu gerektirir
+                stock_related_intents = ["stock", "info", "price", "availability"]
+                should_query_stock = any(intent in intents for intent in stock_related_intents)
+
+            # Urun tespit edildiyse de stok sorgula (kullanici urun hakkinda konusuyor demektir)
+            if detected_product:
+                should_query_stock = True
+
+            # Yedek: Intent Analyzer calismazsa basit keyword kontrolu
+            if not intent_analysis and is_stock_query(user_message):
+                should_query_stock = True
+
+        if should_query_stock and stock_query_product and not xml_has_valid_stock:
+            realtime_stock = get_realtime_stock_parallel(stock_query_product)
+            if realtime_stock:
+                messages.append({"role": "system", "content": f"Gercek Zamanli Stok:\n{realtime_stock}"})
+                logger.info(f"📦 API'den stok bilgisi eklendi: {stock_query_product}")
+
+        if not OPENAI_API_KEY:
+            return "Sistem hatasi olustu."
+
+        # SON HATIRLATMA: Turkce dil kurallari - GPT'ye her yanit oncesi hatirlatma
+        # Bu mesaj en sona ekleniyor ki GPT son gordukleri kurallari uygulasın
+        turkish_reminder = """KRITIK KURALLAR (HER YANIT ICIN GECERLI):
+1. ASLA 'sen' kullanma, HER ZAMAN 'siz' kullan (istersen -> isterseniz, sana -> size)
+2. ASLA soru ile bitirme (ayirtayim mi?, ister misiniz?, bakar misiniz? YASAK)
+3. Bilgiyi ver ve sus, musteri karar versin
+4. ONEMLI: Onceki mesajlarda bahsedilen urunleri UNUTMA! "Hangi model var" gibi sorular onceki konudan devam eder.
+YANLIS: "Istersen beden ve magaza bazli stok bilgisini de netlestirebilirim."
+DOGRU: "Beden ve magaza bazli stok bilgisi icin yazabilirsiniz." """
+        messages.append({"role": "system", "content": turkish_reminder})
+
+        # Model tipine gore payload olustur
+        # GPT-5.2 ve o1/o3 modelleri: temperature ve max_tokens desteklemiyor
+        if "gpt-5" in model or "o1" in model or "o3" in model:
+            payload = {
+                "model": model,
+                "messages": messages,
+                "max_completion_tokens": 1000
+            }
+        else:
+            payload = {
+                "model": model,
+                "messages": messages,
+                "temperature": 0.3,
+                "max_tokens": 1000
+            }
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {OPENAI_API_KEY}"
+        }
+
+        logger.info(f"📤 API istegi gonderiliyor - Model: {model}")
+
+        response = requests.post(API_URL, headers=headers, json=payload, timeout=30)
+
+        if response.status_code == 200:
+            result = response.json()
+            ai_response = result['choices'][0]['message']['content']
+
+            # Kullanilan modeli logla
+            used_model = result.get('model', model)
+            logger.info(f"✅ Yanit alindi - Kullanilan model: {used_model}")
+
+            try:
+                formatted_response = extract_product_info_whatsapp(ai_response)
+            except:
+                formatted_response = ai_response
+
+            # Urun linki ve gorseli varsa ekle
+            # NOT: Stok/magaza sorularinda yanlis gorsel gostermemek icin
+            # sadece TEK URUN soruldugundan eminsen gorsel gonder
+            is_specific_product_query = best_match_score >= 3  # En az 3 kelime eslesmeli
+
+            # GORSEL GONDERILMEMESI GEREKEN SORU TIPLERI
+            # Beden, size, kadro, geometri gibi sorularda gorsel gereksiz
+            no_image_keywords = [
+                'beden', 'size', 'kadro', 'boy', 'kac cm', 'kaç cm',
+                'hangi beden', 'xl mi', 'l mi', 'm mi', 's mi',
+                'geometri', 'stack', 'reach', 'standover',
+                'kilo', 'agirlik', 'ağırlık', 'weight',
+                'garanti', 'warranty', 'teslimat', 'kargo',
+                'taksit', 'odeme', 'ödeme', 'kredi', 'havale'
+            ]
+            user_msg_lower = user_message.lower()
+            is_info_only_query = any(keyword in user_msg_lower for keyword in no_image_keywords)
+
+            if found_product_link and is_specific_product_query and not is_info_only_query:
+                formatted_response += f"\n\n🔗 {found_product_link}"
+
+            add_to_conversation(phone_number, user_message, formatted_response)
+
+            # Gorsel sadece spesifik urun sorgusu ise gonder
+            # "Sariyer'de hangi renk var" gibi genel sorularda gorsel gonderme
+            # Beden/size sorularinda da gorsel gonderme
+            if found_product_image and is_specific_product_query and not is_info_only_query:
+                return (formatted_response, found_product_image)
+
+            return formatted_response
+        else:
+            error_msg = response.text[:200] if response.text else "Bilinmeyen hata"
+            logger.error(f"❌ API hatasi {response.status_code}: {error_msg}")
+
+            # Fallback modele gec
+            if model != MODEL_CONFIG["fallback"]:
+                logger.info(f"🔄 Fallback modele geciliyor: {MODEL_CONFIG['fallback']}")
+                fallback_model = MODEL_CONFIG["fallback"]
+
+                # Fallback icin payload'i yeniden olustur (max_tokens kullan)
+                fallback_payload = {
+                    "model": fallback_model,
+                    "messages": messages,
+                    "temperature": 0.3,
+                    "max_tokens": 1000
+                }
+
+                response = requests.post(API_URL, headers=headers, json=fallback_payload, timeout=30)
+
+                if response.status_code == 200:
+                    result = response.json()
+                    ai_response = result['choices'][0]['message']['content']
+                    add_to_conversation(phone_number, user_message, ai_response)
+                    return ai_response
+
+            return "Su anda bir sorun yasiyorum. Lutfen tekrar deneyin."
+
+    except requests.exceptions.Timeout:
+        logger.error("❌ API timeout hatasi")
+        return "Islem zaman asimina ugradi. Lutfen tekrar deneyin."
+    except Exception as e:
+        logger.error(f"❌ Mesaj isleme hatasi: {e}")
+        import traceback
+        traceback.print_exc()
+        return "Teknik bir sorun olustu. Lutfen tekrar deneyin."
+
+
+# ===============================
+# FASTAPI UYGULAMASI
+# ===============================
+app = FastAPI(title="Trek WhatsApp Bot - Hybrid Model")
+
+@app.post("/whatsapp-webhook")
+async def whatsapp_webhook(request: Request):
+    """WhatsApp webhook - Hybrid model ile"""
+    try:
+        form_data = await request.form()
+
+        from_number = form_data.get('From')
+        to_number = form_data.get('To')
+        message_body = form_data.get('Body', '')
+        message_status = form_data.get('MessageStatus')
+
+        # Medya kontrolu
+        num_media = int(form_data.get('NumMedia', 0))
+        media_urls = []
+        media_types = []
+
+        for i in range(num_media):
+            media_url = form_data.get(f'MediaUrl{i}')
+            media_type = form_data.get(f'MediaContentType{i}')
+            if media_url:
+                media_urls.append(media_url)
+                media_types.append(media_type)
+
+        logger.info(f"📱 Webhook - From: {from_number}, Body: {message_body[:50] if message_body else 'N/A'}, Media: {num_media}")
+
+        # Durum guncellemelerini ignore et
+        if message_status in ['sent', 'delivered', 'read', 'failed']:
+            return {"status": "ignored", "message": f"Status: {message_status}"}
+
+        # Giden mesajlari ignore et
+        if to_number != TWILIO_WHATSAPP_NUMBER:
+            return {"status": "ignored", "message": "Outgoing message"}
+
+        # Bos mesaj ve medya yoksa ignore et
+        if not message_body and num_media == 0:
+            return {"status": "ignored", "message": "Empty message"}
+
+        logger.info(f"✅ MESAJ ALINDI: {from_number} -> Metin: {bool(message_body)}, Medya: {num_media}")
+
+        if not twilio_client:
+            return {"status": "error", "message": "Twilio yapilandirmasi eksik"}
+
+        # ========================================
+        # HYBRID MODEL SECIMI
+        # ========================================
+        product_image_url = None
+
+        if num_media > 0 and media_urls:
+            # GORSEL VAR -> GPT-4o kullan
+            logger.info("🖼️ GORSEL TESPIT EDILDI -> GPT-4o Vision kullanilacak")
+            ai_response = process_whatsapp_message_with_media(
+                message_body,
+                from_number,
+                media_urls,
+                media_types
+            )
+        else:
+            # SADECE METIN -> GPT-5.2 kullan
+            logger.info("📝 METIN MESAJI -> GPT-5.2 kullanilacak")
+            result = process_whatsapp_message_with_memory(
+                message_body,
+                from_number
+            )
+
+            # Tuple donerse (metin, gorsel_url) seklinde
+            if isinstance(result, tuple):
+                ai_response, product_image_url = result
+                logger.info(f"🖼️ Urun gorseli bulundu: {product_image_url}")
+            else:
+                ai_response = result
+
+        # Yanit kisalt
+        if len(ai_response) > 1500:
+            ai_response = ai_response[:1500] + "...\n\nDetayli bilgi: trekbisiklet.com.tr"
+
+        # WhatsApp'a gonder
+        # Once metin mesaji gonder
+        message = twilio_client.messages.create(
+            messaging_service_sid=TWILIO_MESSAGING_SERVICE_SID,
+            body=ai_response,
+            to=from_number
+        )
+
+        logger.info(f"✅ YANIT GONDERILDI: {ai_response[:100]}...")
+
+        # Urun gorseli varsa ayrica gonder
+        if product_image_url:
+            try:
+                image_message = twilio_client.messages.create(
+                    messaging_service_sid=TWILIO_MESSAGING_SERVICE_SID,
+                    media_url=[product_image_url],
+                    to=from_number
+                )
+                logger.info(f"🖼️ URUN GORSELI GONDERILDI: {product_image_url}")
+            except Exception as img_error:
+                logger.error(f"❌ Gorsel gonderme hatasi: {img_error}")
+
+        return {"status": "success", "message_sid": message.sid}
+
+    except Exception as e:
+        logger.error(f"❌ Webhook hatasi: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return {"status": "error", "message": str(e)}
+
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Trek WhatsApp Bot - Hybrid Model calisiyor!",
+        "status": "active",
+        "models": {
+            "vision": MODEL_CONFIG["vision"],
+            "text": MODEL_CONFIG["text"],
+            "fallback": MODEL_CONFIG["fallback"]
+        }
+    }
+
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "healthy",
+        "twilio_configured": twilio_client is not None,
+        "openai_configured": OPENAI_API_KEY is not None,
+        "models": MODEL_CONFIG,
+        "products_loaded": len(products),
+        "modules": {
+            "gpt5_search": USE_GPT5_SEARCH,
+            "media_queue": USE_MEDIA_QUEUE,
+            "store_notification": USE_STORE_NOTIFICATION,
+            "follow_up": USE_FOLLOW_UP,
+            "intent_analyzer": USE_INTENT_ANALYZER
+        }
+    }
+
+
+@app.get("/test-models")
+async def test_models():
+    """Model durumlarini test et"""
+    results = {}
+
+    for model_type, model_name in MODEL_CONFIG.items():
+        try:
+            payload = {
+                "model": model_name,
+                "messages": [{"role": "user", "content": "Merhaba, test mesaji."}],
+                "max_tokens": 10
+            }
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {OPENAI_API_KEY}"
+            }
+            response = requests.post(API_URL, headers=headers, json=payload, timeout=10)
+            results[model_type] = {
+                "model": model_name,
+                "status": "OK" if response.status_code == 200 else f"Error: {response.status_code}",
+                "available": response.status_code == 200
+            }
+        except Exception as e:
+            results[model_type] = {
+                "model": model_name,
+                "status": f"Error: {str(e)}",
+                "available": False
+            }
+
+    return results
+
+
+@app.get("/cache-status")
+async def cache_status():
+    """Cache durumunu goster"""
+    return {
+        "cache_size": len(stock_cache),
+        "cache_duration_seconds": CACHE_DURATION,
+        "cached_products": list(stock_cache.keys())[:10]  # Ilk 10
+    }
+
+
+@app.post("/clear-cache")
+async def clear_cache():
+    """Cache'i temizle"""
+    global stock_cache
+    old_size = len(stock_cache)
+    stock_cache = {}
+    return {"message": f"Cache temizlendi. {old_size} kayit silindi."}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    print("=" * 60)
+    print("   Trek WhatsApp Bot - HYBRID MODEL")
+    print("=" * 60)
+    print(f"   🖼️  Gorsel mesajlar -> {MODEL_CONFIG['vision']}")
+    print(f"   📝  Metin mesajlar  -> {MODEL_CONFIG['text']}")
+    print(f"   🔄  Fallback        -> {MODEL_CONFIG['fallback']}")
+    print("=" * 60)
+    print(f"   📦 Yuklenen urun sayisi: {len(products)}")
+    print(f"   🔍 GPT-5 Search: {'Aktif' if USE_GPT5_SEARCH else 'Pasif'}")
+    print(f"   🔔 Store Notification: {'Aktif' if USE_STORE_NOTIFICATION else 'Pasif'}")
+    print(f"   📌 Follow-Up System: {'Aktif' if USE_FOLLOW_UP else 'Pasif'}")
+    print(f"   🧠 Intent Analyzer: {'Aktif' if USE_INTENT_ANALYZER else 'Pasif'}")
+    print("=" * 60)
+    uvicorn.run(app, host="0.0.0.0", port=7860)

cached_warehouse_search.py

@@ -0,0 +1,210 @@
+"""Cached warehouse search to reduce API calls and token usage"""
+
+import time
+import re
+import json
+import requests
+from typing import Dict, List, Optional, Tuple
+
+# Cache configuration
+CACHE_DURATION = 43200  # 12 hours (12 * 60 * 60)
+cache = {
+    'warehouse_xml': {'data': None, 'time': 0},
+    'trek_xml': {'data': None, 'time': 0},
+    'products_summary': {'data': None, 'time': 0},
+    'simple_searches': {}  # Cache for specific searches
+}
+
+def get_cached_warehouse_xml() -> str:
+    """Get warehouse XML with caching"""
+    current_time = time.time()
+    
+    if cache['warehouse_xml']['data'] and (current_time - cache['warehouse_xml']['time'] < CACHE_DURATION):
+        print("📦 Using cached warehouse XML")
+        return cache['warehouse_xml']['data']
+    
+    print("📡 Fetching fresh warehouse XML...")
+    url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
+    response = requests.get(url, verify=False, timeout=15)
+    
+    cache['warehouse_xml']['data'] = response.text
+    cache['warehouse_xml']['time'] = current_time
+    
+    return response.text
+
+def get_cached_trek_xml() -> str:
+    """Get Trek XML with caching"""
+    current_time = time.time()
+    
+    if cache['trek_xml']['data'] and (current_time - cache['trek_xml']['time'] < CACHE_DURATION):
+        print("🚴 Using cached Trek XML")
+        return cache['trek_xml']['data']
+    
+    print("📡 Fetching fresh Trek XML...")
+    url = 'https://www.trekbisiklet.com.tr/output/8582384479'
+    response = requests.get(url, verify=False, timeout=15)
+    
+    cache['trek_xml']['data'] = response.content
+    cache['trek_xml']['time'] = current_time
+    
+    return response.content
+
+def simple_product_search(query: str) -> Optional[List[Dict]]:
+    """
+    Simple local search without GPT-5
+    Returns product info if exact/close match found
+    """
+    query_upper = query.upper()
+    query_parts = query_upper.split()
+    
+    # Get cached products summary
+    if not cache['products_summary']['data'] or \
+       (time.time() - cache['products_summary']['time'] > CACHE_DURATION):
+        # Build products summary from cached XML
+        build_products_summary()
+    
+    products_summary = cache['products_summary']['data']
+    
+    # Exact product name patterns
+    exact_patterns = {
+        'MADONE SL 6': lambda p: 'MADONE SL 6' in p['name'],
+        'MADONE SL 7': lambda p: 'MADONE SL 7' in p['name'],
+        'MARLIN 5': lambda p: 'MARLIN 5' in p['name'],
+        'MARLIN 6': lambda p: 'MARLIN 6' in p['name'],
+        'MARLIN 7': lambda p: 'MARLIN 7' in p['name'],
+        'DOMANE SL 5': lambda p: 'DOMANE SL 5' in p['name'],
+        'CHECKPOINT': lambda p: 'CHECKPOINT' in p['name'],
+        'FX': lambda p: p['name'].startswith('FX'),
+        'DUAL SPORT': lambda p: 'DUAL SPORT' in p['name'],
+        'RAIL': lambda p: 'RAIL' in p['name'],
+        'POWERFLY': lambda p: 'POWERFLY' in p['name'],
+    }
+    
+    # Check for exact patterns
+    for pattern, matcher in exact_patterns.items():
+        if pattern in query_upper:
+            matching = [p for p in products_summary if matcher(p)]
+            if matching:
+                print(f"✅ Found {len(matching)} products via simple search (no GPT-5 needed)")
+                return matching
+    
+    # Check for simple one-word queries
+    if len(query_parts) == 1:
+        matching = [p for p in products_summary if query_parts[0] in p['name']]
+        if matching and len(matching) < 20:  # If reasonable number of matches
+            print(f"✅ Found {len(matching)} products via simple search (no GPT-5 needed)")
+            return matching
+    
+    return None  # Need GPT-5 for complex queries
+
+def build_products_summary():
+    """Build products summary from cached XMLs"""
+    xml_text = get_cached_warehouse_xml()
+    
+    # Extract products
+    product_pattern = r'<Product>(.*?)</Product>'
+    all_products = re.findall(product_pattern, xml_text, re.DOTALL)
+    
+    products_summary = []
+    for i, product_block in enumerate(all_products):
+        name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
+        variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
+        
+        if name_match:
+            warehouses_with_stock = []
+            warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
+            warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
+            
+            for wh_name, wh_stock in warehouses:
+                try:
+                    if int(wh_stock.strip()) > 0:
+                        warehouses_with_stock.append(wh_name)
+                except:
+                    pass
+            
+            product_info = {
+                "index": i,
+                "name": name_match.group(1),
+                "variant": variant_match.group(1) if variant_match else "",
+                "warehouses": warehouses_with_stock
+            }
+            products_summary.append(product_info)
+    
+    cache['products_summary']['data'] = products_summary
+    cache['products_summary']['time'] = time.time()
+    
+    print(f"📊 Built products summary: {len(products_summary)} products")
+
+def should_use_gpt5(query: str) -> bool:
+    """Determine if query needs GPT-5"""
+    query_lower = query.lower()
+    
+    # Complex queries that need GPT-5
+    gpt5_triggers = [
+        'öneri', 'tavsiye', 'bütçe', 'karşılaştır',
+        'hangisi', 'ne önerirsin', 'yardım',
+        'en iyi', 'en ucuz', 'en pahalı',
+        'kaç tane', 'toplam', 'fark'
+    ]
+    
+    for trigger in gpt5_triggers:
+        if trigger in query_lower:
+            return True
+    
+    # If simple search found results, don't use GPT-5
+    if simple_product_search(query):
+        return False
+    
+    return True  # Default to GPT-5 for uncertain cases
+
+# Usage example
+def smart_warehouse_search(query: str) -> List[str]:
+    """
+    Smart search with caching and minimal GPT-5 usage
+    """
+    # Check simple search cache first
+    cache_key = query.lower()
+    if cache_key in cache['simple_searches']:
+        cached_result = cache['simple_searches'][cache_key]
+        if time.time() - cached_result['time'] < CACHE_DURATION:
+            print(f"✅ Using cached result for '{query}'")
+            return cached_result['data']
+    
+    # Try simple search
+    simple_results = simple_product_search(query)
+    if simple_results:
+        # Format and cache the results
+        formatted_results = format_simple_results(simple_results)
+        cache['simple_searches'][cache_key] = {
+            'data': formatted_results,
+            'time': time.time()
+        }
+        return formatted_results
+    
+    # Fall back to GPT-5 if needed
+    print(f"🤖 Using GPT-5 for complex query: '{query}'")
+    # Call existing GPT-5 function here
+    return None  # Would call get_warehouse_stock_smart_with_price
+
+def format_simple_results(products: List[Dict]) -> List[str]:
+    """Format simple search results"""
+    if not products:
+        return ["Ürün bulunamadı"]
+    
+    result = ["Bulunan ürünler:"]
+    
+    # Group by product name
+    product_groups = {}
+    for p in products:
+        if p['name'] not in product_groups:
+            product_groups[p['name']] = []
+        product_groups[p['name']].append(p)
+    
+    for product_name, variants in product_groups.items():
+        result.append(f"\n{product_name}:")
+        for v in variants:
+            if v['variant']:
+                warehouses_str = ", ".join([w.replace('MAGAZA DEPO', '').strip() for w in v['warehouses']])
+                result.append(f"• {v['variant']}: {warehouses_str if warehouses_str else 'Stokta yok'}")
+    
+    return result

combined_api_search.py

@@ -0,0 +1,581 @@
+"""Combined API Search Module - Yeni tek API'yi kullanan arama sistemi"""
+
+import requests
+import xml.etree.ElementTree as ET
+import os
+import time
+import logging
+
+# Logger ayarla
+logger = logging.getLogger(__name__)
+
+def normalize_turkish(text):
+    """Türkçe karakter normalizasyonu"""
+    if not text:
+        return ""
+    
+    # Önce uppercase yap
+    text = text.upper()
+    
+    # Türkçe karakterleri normalize et
+    replacements = {
+        'İ': 'I', 'I': 'I', 'ı': 'I', 'Ì': 'I', 'Í': 'I', 'Î': 'I', 'Ï': 'I',
+        'Ş': 'S', 'ş': 'S', 'Ș': 'S', 'ș': 'S', 'Ś': 'S',
+        'Ğ': 'G', 'ğ': 'G', 'Ĝ': 'G', 'ĝ': 'G',
+        'Ü': 'U', 'ü': 'U', 'Û': 'U', 'û': 'U', 'Ù': 'U', 'Ú': 'U',
+        'Ö': 'O', 'ö': 'O', 'Ô': 'O', 'ô': 'O', 'Ò': 'O', 'Ó': 'O',
+        'Ç': 'C', 'ç': 'C', 'Ć': 'C', 'ć': 'C',
+        'Â': 'A', 'â': 'A', 'À': 'A', 'Á': 'A', 'Ä': 'A',
+        'Ê': 'E', 'ê': 'E', 'È': 'E', 'É': 'E', 'Ë': 'E'
+    }
+    
+    for tr_char, en_char in replacements.items():
+        text = text.replace(tr_char, en_char)
+    
+    # Birden fazla boşluğu tek boşluğa çevir
+    import re
+    text = re.sub(r'\s+', ' ', text)
+    
+    return text.strip()
+
+# Cache configuration
+CACHE_DURATION = 3600  # 1 saat
+cache = {
+    'combined_api': {'data': None, 'time': 0}
+}
+
+def get_combined_api_data():
+    """Combined API'den veriyi çek ve cache'le"""
+    current_time = time.time()
+    
+    # Cache kontrolü
+    if cache['combined_api']['data'] and (current_time - cache['combined_api']['time'] < CACHE_DURATION):
+        cache_age = (current_time - cache['combined_api']['time']) / 60
+        logger.info(f"📦 Combined API cache kullanılıyor (yaş: {cache_age:.1f} dakika)")
+        return cache['combined_api']['data']
+    
+    try:
+        # Yeni combined API'yi çağır
+        url = 'https://video.trek-turkey.com/combined_trek_xml_api_v2.php'
+        response = requests.get(url, timeout=30)
+        
+        if response.status_code == 200:
+            # XML parse et
+            root = ET.fromstring(response.content)
+            
+            # Cache'e kaydet
+            cache['combined_api']['data'] = root
+            cache['combined_api']['time'] = current_time
+            
+            # İstatistikleri logla
+            stats = root.find('stats')
+            if stats is not None:
+                matched = stats.find('matched_products')
+                match_rate = stats.find('match_rate')
+                if matched is not None and match_rate is not None:
+                    logger.info(f"✅ Combined API: {matched.text} ürün eşleşti ({match_rate.text})")
+            
+            return root
+        else:
+            logger.error(f"❌ Combined API HTTP Error: {response.status_code}")
+            return None
+            
+    except Exception as e:
+        logger.error(f"❌ Combined API Hata: {e}")
+        return None
+
+def search_products_combined_api(query):
+    """Yeni combined API kullanarak ürün ara"""
+    try:
+        # Combined API verisini al
+        root = get_combined_api_data()
+        if not root:
+            return []
+        
+        # Stop words - arama skorunu etkilememesi gereken kelimeler
+        stop_words = ['VAR', 'MI', 'MEVCUT', 'MU', 'STOK', 'STOGU', 'DURUMU', 'BULUNUYOR']
+        
+        # Query'yi normalize et ve stop words'leri filtrele
+        query_words = normalize_turkish(query).upper().split()
+        query_words = [word for word in query_words if word not in stop_words]
+        query_normalized = ' '.join(query_words)
+        
+        results = []
+        
+        # Tüm ürünlerde ara
+        for product in root.findall('product'):
+            # Ürün bilgilerini al
+            stock_code = product.find('stock_code')
+            name = product.find('name')
+            label = product.find('label')
+            url = product.find('url')
+            image_url = product.find('image_url')
+            
+            # Fiyat bilgileri
+            prices = product.find('prices')
+            regular_price = None
+            discounted_price = None
+            
+            if prices is not None:
+                regular_price_elem = prices.find('regular_price')
+                discounted_price_elem = prices.find('discounted_price')
+                
+                if regular_price_elem is not None:
+                    regular_price = regular_price_elem.text
+                if discounted_price_elem is not None:
+                    discounted_price = discounted_price_elem.text
+            
+            # Kategori bilgileri
+            category = product.find('category')
+            main_category = None
+            sub_category = None
+            
+            if category is not None:
+                main_cat_elem = category.find('main_category')
+                sub_cat_elem = category.find('sub_category')
+                
+                if main_cat_elem is not None:
+                    main_category = main_cat_elem.text
+                if sub_cat_elem is not None:
+                    sub_category = sub_cat_elem.text
+            
+            # Warehouse stok bilgileri
+            warehouse_stock = product.find('warehouse_stock')
+            stock_found = False
+            total_stock = 0
+            warehouses = []
+            
+            if warehouse_stock is not None:
+                found_attr = warehouse_stock.get('found')
+                stock_found = found_attr == 'true'
+                
+                if stock_found:
+                    total_stock_elem = warehouse_stock.find('total_stock')
+                    if total_stock_elem is not None:
+                        total_stock = int(total_stock_elem.text)
+                    
+                    # Depo bilgileri
+                    warehouses_elem = warehouse_stock.find('warehouses')
+                    if warehouses_elem is not None:
+                        for wh in warehouses_elem.findall('warehouse'):
+                            wh_name = wh.find('name')
+                            wh_stock = wh.find('stock')
+                            
+                            if wh_name is not None and wh_stock is not None:
+                                warehouses.append({
+                                    'name': wh_name.text,
+                                    'stock': int(wh_stock.text)
+                                })
+            
+            # Arama kriteri kontrolü - Türkçe normalizasyon ile
+            searchable_text = ""
+            if name is not None:
+                searchable_text += normalize_turkish(name.text) + " "
+            if label is not None:
+                searchable_text += normalize_turkish(label.text) + " "
+            if stock_code is not None:
+                searchable_text += normalize_turkish(stock_code.text) + " "
+            if main_category is not None:
+                searchable_text += normalize_turkish(main_category) + " "
+            if sub_category is not None:
+                searchable_text += normalize_turkish(sub_category) + " "
+            
+            # Geliştirilmiş arama eşleştirme - stop words filtrelenmiş query_words kullan
+            filtered_query_words = query_words  # Zaten üstte filtrelenmiş
+            name_normalized = normalize_turkish(name.text.upper()) if name is not None else ""
+            
+            # 1. Temel kelime eşleşmesi
+            basic_matches = sum(1 for word in filtered_query_words if word in searchable_text)
+            
+            if basic_matches > 0:
+                # 2. Tam eşleşme bonusu - tüm query kelimeleri ürün adında
+                exact_bonus = 10 if all(word in name_normalized for word in filtered_query_words) else 0
+                
+                # 3. Sıra bonus - kelimeler doğru sırada mı?
+                sequence_bonus = 0
+                if len(filtered_query_words) >= 2:
+                    query_sequence = " ".join(filtered_query_words)
+                    if query_sequence in name_normalized:
+                        sequence_bonus = 5
+                
+                # 4. Uzunluk penaltısı - çok uzun ürün adları düşük skor alsın
+                length_penalty = max(0, len(name_normalized.split()) - len(filtered_query_words)) * -1
+                
+                # Toplam skor
+                total_score = basic_matches + exact_bonus + sequence_bonus + length_penalty
+                
+                result = {
+                    'stock_code': stock_code.text if stock_code is not None else '',
+                    'name': name.text if name is not None else '',
+                    'label': label.text if label is not None else '',
+                    'url': url.text if url is not None else '',
+                    'image_url': image_url.text if image_url is not None else '',
+                    'regular_price': regular_price,
+                    'discounted_price': discounted_price,
+                    'main_category': main_category,
+                    'sub_category': sub_category,
+                    'stock_found': stock_found,
+                    'total_stock': total_stock,
+                    'warehouses': warehouses,
+                    'match_score': total_score
+                }
+                results.append(result)
+        
+        # Sonuçları match score'a göre sırala
+        results.sort(key=lambda x: x['match_score'], reverse=True)
+        
+        logger.info(f"🔍 Combined API araması: '{query}' için {len(results)} sonuç")
+        return results[:10]  # İlk 10 sonuç
+        
+    except Exception as e:
+        logger.error(f"❌ Combined API arama hatası: {e}")
+        return []
+
+def format_product_result_whatsapp(product_data, show_variants_info=False, all_results=None):
+    """Ürün bilgisini WhatsApp için formatla"""
+    try:
+        name = product_data['name']
+        url = product_data['url']
+        image_url = product_data['image_url']
+        regular_price = product_data['regular_price']
+        discounted_price = product_data['discounted_price']
+        stock_found = product_data['stock_found']
+        total_stock = product_data['total_stock']
+        warehouses = product_data['warehouses']
+        
+        result = []
+        
+        # Ürün adı
+        result.append(f"🚲 **{name}**")
+        
+        # Fiyat bilgisi - Original Trek fiyat yuvarlama algoritması (app.py'dan)
+        def format_price(price_str):
+            if not price_str:
+                return ""
+            try:
+                price_float = float(price_str)
+                # Original Trek fiyat yuvarlama algoritması
+                if price_float > 200000:
+                    rounded = round(price_float / 5000) * 5000
+                elif price_float > 30000:
+                    rounded = round(price_float / 1000) * 1000
+                elif price_float > 10000:
+                    rounded = round(price_float / 100) * 100
+                else:
+                    rounded = round(price_float / 10) * 10
+                
+                # Türk Lirası formatı: 1.234,56
+                return f"{rounded:,.0f}".replace(",", ".")
+            except:
+                return price_str
+        
+        if regular_price:
+            formatted_regular = format_price(regular_price)
+            if discounted_price and discounted_price != regular_price:
+                formatted_discounted = format_price(discounted_price)
+                result.append(f"💰 Fiyat: ~~{formatted_regular}~~ **{formatted_discounted} TL**")
+                result.append("🔥 İndirimli fiyat!")
+            else:
+                result.append(f"💰 Fiyat: {formatted_regular} TL")
+        
+        # Stok durumu - Varyant detayları ile
+        if stock_found and total_stock > 0:
+            # Hangi mağazalarda var + varyant bilgisi (ana ürünse)
+            if warehouses:
+                # Ana ürün ise varyant detaylarını da göster
+                if show_variants_info and all_results and is_main_product(name):
+                    result.append("📦 **Mevcut varyantlar:**")
+                    
+                    # Bu ana ürünün varyantlarını bul
+                    main_name_base = name.upper()
+                    variant_details = {}
+                    
+                    for product in all_results:
+                        if (main_name_base in product['name'].upper() and 
+                            product['stock_found'] and 
+                            product['total_stock'] > 0 and
+                            not is_main_product(product['name'])):
+                            
+                            # Varyant isminden beden/renk çıkar
+                            variant_name = product['name']
+                            variant_part = variant_name.replace(main_name_base, '').strip()
+                            if variant_part.startswith('GEN 3 (2026)'):
+                                variant_part = variant_part.replace('GEN 3 (2026)', '').strip()
+                            
+                            for wh in product['warehouses']:
+                                if wh['stock'] > 0:
+                                    store_name = wh['name']
+                                    if store_name not in variant_details:
+                                        variant_details[store_name] = []
+                                    variant_details[store_name].append(variant_part)
+                    
+                    # Mağaza bazında varyantları listele
+                    for store, variants in variant_details.items():
+                        result.append(f"• **{store}:** {', '.join(variants)}")
+                    
+                    # Genel bilgi
+                    result.append("📞 Diğer beden/renk teyidi için mağazaları arayın")
+                else:
+                    # Normal stok bilgisi
+                    available_stores = [wh['name'] for wh in warehouses if wh['stock'] > 0]
+                    if available_stores:
+                        result.append("📦 **Stokta mevcut mağazalar:**")
+                        for store in available_stores:
+                            result.append(f"• {store}")
+        else:
+            result.append("⚠️ **Stok durumu kontrol edilemiyor**")
+            result.append("📞 Güncel stok için mağazalarımızı arayın:")
+            result.append("• Caddebostan: 0543 934 0438")
+            result.append("• Alsancak: 0543 936 2335")
+        
+        # Ürün linki
+        if url:
+            result.append(f"🔗 [Ürün Detayları]({url})")
+        
+        # Ürün resmi (WhatsApp için) - Direkt URL WhatsApp'ta resmi gösterir
+        if image_url and image_url.startswith('https://'):
+            # WhatsApp'ta resmi direkt göstermek için sadece URL'i ver (link formatı değil)
+            result.append(f"📷 {image_url}")
+        
+        return "\n".join(result)
+        
+    except Exception as e:
+        logger.error(f"❌ WhatsApp format hatası: {e}")
+        return "Ürün bilgisi formatlanamadı"
+
+def is_main_product(product_name):
+    """Ürün adına bakarak ana ürün mü varyant mı kontrol et"""
+    name_upper = product_name.upper()
+    
+    # Varyant göstergeleri - beden, renk, yıl belirticileri
+    variant_indicators = [
+        # Bedenler
+        ' - XS', ' - S', ' - M', ' - L', ' - XL', ' - XXL',
+        ' XS', ' S ', ' M ', ' L ', ' XL', ' XXL',
+        
+        # Renkler 
+        ' - SİYAH', ' - MAVİ', ' - KIRMIZI', ' - YEŞİL', ' - BEYAZ', ' - MOR',
+        ' SİYAH', ' MAVİ', ' KIRMIZI', ' YEŞİL', ' BEYAZ', ' MOR',
+        
+        # İngilizce renkler
+        ' - BLACK', ' - BLUE', ' - RED', ' - GREEN', ' - WHITE', ' - PURPLE',
+        ' BLACK', ' BLUE', ' RED', ' GREEN', ' WHITE', ' PURPLE'
+    ]
+    
+    # Eğer bu göstergelerden biri varsa varyant
+    for indicator in variant_indicators:
+        if indicator in name_upper:
+            return False
+    
+    return True
+
+def get_warehouse_stock_combined_api(query):
+    """Combined API kullanan warehouse search - eski fonksiyonla uyumlu"""
+    results = search_products_combined_api(query)
+    
+    if not results:
+        return ["Ürün bulunamadı"]
+    
+    # Akıllı model geçişi - eski model stokta yoksa yeni modeli öner
+    # Örn: "marlin 4" arandığında MARLIN 4 yoksa MARLIN 4 GEN 3'ü göster
+    query_normalized = normalize_turkish(query.upper())
+    
+    # Query'yi temizle - "var mı", "stok", "fiyat" gibi ekleri çıkar
+    clean_query = query_normalized
+    for suffix in ['VAR MI', 'VAR MIYDI', 'STOK', 'STOKTA', 'FIYAT', 'FIYATI', 'KACA', 'NE KADAR']:
+        clean_query = clean_query.replace(' ' + suffix, '').replace(suffix + ' ', '').replace(suffix, '')
+    clean_query = clean_query.strip()
+    
+    logger.info(f"🧹 Query temizlendi: '{query}' → '{clean_query}'")
+    
+    # Genel ürün adı aranıyorsa (model numarası yok)
+    if not any(year in clean_query for year in ['GEN', '2024', '2025', '2026', '(20']):
+        # Stokta olan modelleri kontrol et
+        stocked_alternatives = []
+        
+        for product in results:
+            name_normalized = normalize_turkish(product['name'].upper())
+            # Ana ürün adıyla eşleşiyor mu? (temizlenmiş query ile)
+            if clean_query in name_normalized:
+                # Ana ürün mü?
+                if is_main_product(product['name']):
+                    # Stokta mı veya varyantları var mı?
+                    if product['stock_found'] and product['total_stock'] > 0:
+                        stocked_alternatives.append(product)
+                    else:
+                        # Ana ürün stokta yok, varyantları kontrol et
+                        has_stocked_variants = False
+                        for variant in results:
+                            if (product['name'].upper() in variant['name'].upper() and
+                                variant['stock_found'] and 
+                                variant['total_stock'] > 0 and
+                                not is_main_product(variant['name'])):
+                                has_stocked_variants = True
+                                break
+                        if has_stocked_variants:
+                            stocked_alternatives.append(product)
+        
+        # Eğer alternatifler varsa, en yenisini seç (genelde GEN 3, 2026 vs.)
+        if stocked_alternatives:
+            # Model yılı/versiyonu olanları öncelikle
+            def get_model_priority(product):
+                name = product['name'].upper()
+                if '2026' in name or 'GEN 3' in name:
+                    return 3
+                elif '2025' in name or 'GEN 2' in name:
+                    return 2
+                elif '2024' in name or 'GEN' in name:
+                    return 1
+                else:
+                    return 0
+            
+            stocked_alternatives.sort(key=lambda x: get_model_priority(x), reverse=True)
+            
+            # En yeni modeli öncelikle kullan
+            if stocked_alternatives:
+                results = [stocked_alternatives[0]] + [r for r in results if r != stocked_alternatives[0]]
+    
+    # Önce ana ürünleri filtrele
+    main_products = []
+    variant_products = []
+    
+    for product in results:
+        if is_main_product(product['name']):
+            main_products.append(product)
+        else:
+            variant_products.append(product)
+    
+    # Ana ürünün stok bilgilerini varyantlarından topla
+    def enrich_main_product_with_variant_stock(main_product, all_results):
+        """Ana ürün stoku yoksa varyant stoklarını topla - TAM EŞLEŞTİRME"""
+        if main_product['stock_found'] and main_product['total_stock'] > 0:
+            return main_product  # Zaten stok bilgisi var
+        
+        # Bu ana ürünün varyantlarını bul - TAM EŞLEŞTIRME
+        main_name = main_product['name'].upper()
+        related_variants = []
+        
+        for product in all_results:
+            product_name_upper = product['name'].upper()
+            
+            # TAM EŞLEŞTIRME: varyant ana ürünle TAM BAŞLAMALI
+            # Örn: "MARLIN 4 GEN 3 (2026) MOR - XS" → "MARLIN 4 GEN 3 (2026)" ile eşleşmeli
+            #      "MARLIN 4 SİYAH - XS" → "MARLIN 4" ile eşleşmeli  
+            
+            variant_matches = False
+            if (product['stock_found'] and 
+                product['total_stock'] > 0 and
+                not is_main_product(product['name'])):
+                
+                # TAM ÜRÜN EŞLEŞTIRMESI - backup mantığıyla ters
+                # Ana ürün "MARLIN 4" ise
+                # Varyant "MARLIN 4 SİYAH - XS" EVET, "MARLIN 4 GEN 3 (...) MOR - XS" HAYIR
+                
+                # Ana ürün tam adıyla başlamalı, fazla kelime olmamalı
+                if product_name_upper.startswith(main_name):
+                    remaining_after_main = product_name_upper[len(main_name):].strip()
+                    
+                    # Kalan kısımda GEN/2026 gibi model ayırıcıları varsa bu farklı ürün
+                    model_separators = ['GEN 3', 'GEN', '(2026)', '(2025)', '2026', '2025']
+                    has_model_separator = any(sep in remaining_after_main for sep in model_separators)
+                    
+                    # Ana ürün model ayırıcısı içeriyorsa, varyant da içermeli
+                    main_has_separators = any(sep in main_name for sep in model_separators)
+                    
+                    # Ana ürün model separator içeriyorsa, varyant onun devamı olabilir
+                    # Ana ürün model separator içermiyorsa, varyant da içermemeli
+                    
+                    if main_has_separators:
+                        # Ana ürün GEN 3 (2026) gibi → varyant da GEN 3'ün devamı olmalı
+                        # Kalan kısımda model separator olmamalı (çünkü ana üründe zaten var)
+                        if not has_model_separator:
+                            # Varyant göstergeleri var mı?
+                            if remaining_after_main and any(indicator in remaining_after_main for indicator in [' - ', ' MOR', ' SIYAH', ' MAVI', ' XS', ' S ', ' M ', ' L ', ' XL']):
+                                variant_matches = True
+                    else:
+                        # Ana ürün model separator içermiyor → varyant da içermemeli
+                        if not has_model_separator:
+                            # Varyant göstergeleri var mı?
+                            if remaining_after_main and any(indicator in remaining_after_main for indicator in [' - ', ' MOR', ' SIYAH', ' MAVI', ' XS', ' S ', ' M ', ' L ', ' XL']):
+                                variant_matches = True
+                
+                if variant_matches:
+                    related_variants.append(product)
+        
+        if related_variants:
+            # Varyant stoklarını topla
+            combined_warehouses = {}
+            total_stock = 0
+            
+            for variant in related_variants:
+                total_stock += variant['total_stock']
+                for wh in variant['warehouses']:
+                    wh_name = wh['name']
+                    wh_stock = wh['stock']
+                    if wh_name in combined_warehouses:
+                        combined_warehouses[wh_name] += wh_stock
+                    else:
+                        combined_warehouses[wh_name] = wh_stock
+            
+            # Ana ürünü stok bilgileriyle zenginleştir
+            main_product['stock_found'] = True
+            main_product['total_stock'] = total_stock
+            main_product['warehouses'] = [
+                {'name': name, 'stock': stock} 
+                for name, stock in combined_warehouses.items() 
+                if stock > 0
+            ]
+        
+        return main_product
+    
+    # Öncelikle ana ürünleri kullan, Ana ürün yoksa varyantları göster
+    if main_products:
+        # Ana ürünleri varyant stoklarıyla zenginleştir
+        enriched_main_products = []
+        for main_product in main_products:
+            enriched = enrich_main_product_with_variant_stock(main_product, results)
+            enriched_main_products.append(enriched)
+        
+        # Basit sorgu (örn: "marlin 4") için sadece en iyi ana ürün
+        query_words = normalize_turkish(query).upper().split()
+        product_query_words = [w for w in query_words if w not in ['FIYAT', 'STOK', 'VAR', 'MI', 'RENK', 'BEDEN']]
+        is_simple_product_query = len(product_query_words) <= 2
+        
+        if is_simple_product_query:
+            selected_products = enriched_main_products[:1]  # Sadece en iyi ana ürün
+        else:
+            selected_products = enriched_main_products[:3]  # Birden fazla ana ürün
+    else:
+        # Ana ürün yoksa varyantları göster
+        selected_products = variant_products[:3]
+    
+    formatted_results = []
+    for product in selected_products:
+        # Ana ürün ise varyant detaylarını göster
+        show_variants = is_main_product(product['name'])
+        formatted = format_product_result_whatsapp(product, show_variants_info=show_variants, all_results=results)
+        formatted_results.append(formatted)
+    
+    return formatted_results
+
+# Test fonksiyonu
+if __name__ == "__main__":
+    # Test arama
+    logging.basicConfig(level=logging.INFO)
+    
+    print("Combined API Test Başlıyor...")
+    
+    test_queries = ["marlin", "trek tool", "bisiklet", "madone"]
+    
+    for query in test_queries:
+        print(f"\n🔍 Test: '{query}'")
+        results = search_products_combined_api(query)
+        
+        if results:
+            print(f"✅ {len(results)} sonuç bulundu")
+            for i, product in enumerate(results[:2]):
+                print(f"\n{i+1}. {product['name']}")
+                print(f"   Fiyat: {product['regular_price']} TL")
+                print(f"   Stok: {'✅' if product['stock_found'] else '❌'} ({product['total_stock']} adet)")
+        else:
+            print("❌ Sonuç bulunamadı")

customer_manager.py

@@ -0,0 +1,456 @@
+"""
+CRM (Customer Relationship Management) System
+Müşteri tanıma, segmentasyon ve kişiselleştirilmiş yanıtlar
+"""
+import json
+import os
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+import re
+
+class CustomerManager:
+    def __init__(self, db_path: str = "customers.json"):
+        self.db_path = db_path
+        self.customers = self._load_database()
+    
+    def _load_database(self) -> Dict:
+        """Müşteri veritabanını yükle"""
+        if os.path.exists(self.db_path):
+            try:
+                with open(self.db_path, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except:
+                return {}
+        return {}
+    
+    def _save_database(self):
+        """Veritabanını kaydet"""
+        with open(self.db_path, 'w', encoding='utf-8') as f:
+            json.dump(self.customers, f, ensure_ascii=False, indent=2)
+    
+    def _extract_name_from_message(self, message: str) -> Optional[str]:
+        """Mesajdan isim çıkarmaya çalış"""
+        # "Ben Ahmet", "Benim adım Mehmet", "Merhaba ben Ali" gibi kalıplar
+        patterns = [
+            r"ben[im]?\s+ad[ıi]m?\s+(\w+)",
+            r"ben\s+(\w+)",
+            r"ad[ıi]m\s+(\w+)",
+            r"(\w+)\s+diye",
+        ]
+        
+        message_lower = message.lower()
+        for pattern in patterns:
+            match = re.search(pattern, message_lower)
+            if match:
+                name = match.group(1)
+                # İlk harfi büyük yap
+                return name.capitalize()
+        return None
+    
+    def _detect_interests(self, message: str) -> List[str]:
+        """Mesajdan ilgi alanlarını çıkar"""
+        interests = []
+        message_lower = message.lower()
+        
+        # Bisiklet kategorileri
+        if any(word in message_lower for word in ["dağ", "mountain", "mtb"]):
+            interests.append("mountain_bike")
+        if any(word in message_lower for word in ["yol", "road", "yarış"]):
+            interests.append("road_bike")
+        if any(word in message_lower for word in ["şehir", "city", "urban"]):
+            interests.append("city_bike")
+        
+        # Marka ve modeller
+        if "trek" in message_lower:
+            interests.append("trek")
+        if "marlin" in message_lower:
+            interests.append("marlin_series")
+        if "fx" in message_lower:
+            interests.append("fx_series")
+        if "domane" in message_lower:
+            interests.append("domane_series")
+        if "madone" in message_lower:
+            interests.append("madone_series")
+        
+        # Özellikler
+        if any(word in message_lower for word in ["elektrik", "e-bike", "ebike"]):
+            interests.append("e_bike")
+        if any(word in message_lower for word in ["karbon", "carbon"]):
+            interests.append("carbon")
+        if any(word in message_lower for word in ["kadın", "women", "wsd"]):
+            interests.append("women_specific")
+        
+        # Bütçe
+        if any(word in message_lower for word in ["ucuz", "uygun fiyat", "ekonomik"]):
+            interests.append("budget_friendly")
+        if any(word in message_lower for word in ["premium", "high-end", "üst segment"]):
+            interests.append("premium")
+        
+        return interests
+    
+    def _calculate_segment(self, customer: Dict) -> str:
+        """Müşteri segmentini hesapla"""
+        total_purchases = len(customer.get("purchases", []))
+        total_spent = sum(p.get("price", 0) for p in customer.get("purchases", []))
+        total_queries = customer.get("total_queries", 0)
+        
+        # Son aktivite kontrolü
+        last_interaction = datetime.fromisoformat(customer.get("last_interaction", datetime.now().isoformat()))
+        days_since_last = (datetime.now() - last_interaction).days
+        
+        # VIP kriterler
+        if total_purchases >= 3 or total_spent >= 50000:
+            return "VIP"
+        
+        # Potansiyel müşteri
+        if total_queries >= 5 and total_purchases == 0:
+            return "Potansiyel"
+        
+        # Kayıp riski
+        if days_since_last > 30 and total_purchases > 0:
+            return "Kayıp Riski"
+        
+        # Yeni müşteri (ilk 7 gün)
+        first_seen = datetime.fromisoformat(customer.get("first_seen", datetime.now().isoformat()))
+        if (datetime.now() - first_seen).days <= 7:
+            return "Yeni"
+        
+        # Aktif müşteri
+        if days_since_last <= 7:
+            return "Aktif"
+        
+        # Standart
+        return "Standart"
+    
+    def get_or_create_customer(self, phone: str, name: Optional[str] = None) -> Dict:
+        """Müşteriyi getir veya yeni oluştur"""
+        if phone in self.customers:
+            # Var olan müşteri
+            customer = self.customers[phone]
+            customer["last_interaction"] = datetime.now().isoformat()
+            
+            # İsim güncellemesi
+            if name and not customer.get("name"):
+                customer["name"] = name
+            
+            # Segment güncelle
+            customer["segment"] = self._calculate_segment(customer)
+            
+        else:
+            # Yeni müşteri
+            customer = {
+                "phone": phone,
+                "name": name,
+                "first_seen": datetime.now().isoformat(),
+                "last_interaction": datetime.now().isoformat(),
+                "total_queries": 0,
+                "purchases": [],
+                "interests": [],
+                "searched_products": [],
+                "segment": "Yeni",
+                "notes": [],
+                "preferred_contact_time": None  # "morning", "afternoon", "evening"
+            }
+            self.customers[phone] = customer
+        
+        self._save_database()
+        return customer
+    
+    def update_interaction(self, phone: str, message: str, product_searched: Optional[str] = None) -> Dict:
+        """Müşteri etkileşimini güncelle"""
+        customer = self.get_or_create_customer(phone)
+        
+        # Sorgu sayısını artır
+        customer["total_queries"] = customer.get("total_queries", 0) + 1
+        
+        # İsim çıkarma denemesi
+        if not customer.get("name"):
+            extracted_name = self._extract_name_from_message(message)
+            if extracted_name:
+                customer["name"] = extracted_name
+        
+        # İlgi alanlarını güncelle
+        new_interests = self._detect_interests(message)
+        existing_interests = set(customer.get("interests", []))
+        customer["interests"] = list(existing_interests.union(set(new_interests)))
+        
+        # Aranan ürünü kaydet
+        if product_searched:
+            searched_products = customer.get("searched_products", [])
+            # Son 10 aramayı tut
+            searched_products.append({
+                "product": product_searched,
+                "date": datetime.now().isoformat()
+            })
+            customer["searched_products"] = searched_products[-10:]
+        
+        # İletişim zamanı tercihi
+        hour = datetime.now().hour
+        if 6 <= hour < 12:
+            time_pref = "morning"
+        elif 12 <= hour < 18:
+            time_pref = "afternoon"
+        else:
+            time_pref = "evening"
+        
+        # En çok hangi zaman diliminde yazıyor
+        if not customer.get("preferred_contact_time"):
+            customer["preferred_contact_time"] = time_pref
+        
+        # Segment güncelle
+        customer["segment"] = self._calculate_segment(customer)
+        
+        # Son etkileşim zamanı
+        customer["last_interaction"] = datetime.now().isoformat()
+        
+        self._save_database()
+        return customer
+    
+    def add_purchase(self, phone: str, product: str, price: float) -> Dict:
+        """Satın alma kaydı ekle"""
+        customer = self.get_or_create_customer(phone)
+        
+        purchase = {
+            "product": product,
+            "price": price,
+            "date": datetime.now().isoformat()
+        }
+        
+        customer.setdefault("purchases", []).append(purchase)
+        customer["segment"] = self._calculate_segment(customer)
+        
+        self._save_database()
+        return customer
+    
+    def get_customer_context(self, phone: str) -> Dict:
+        """Müşteri bağlamını getir"""
+        customer = self.customers.get(phone, {})
+        
+        if not customer:
+            return {
+                "is_new": True,
+                "greeting": "Merhaba! Trek bisikletleri hakkında size nasıl yardımcı olabilirim?"
+            }
+        
+        context = {
+            "is_new": False,
+            "name": customer.get("name"),
+            "segment": customer.get("segment", "Standart"),
+            "total_queries": customer.get("total_queries", 0),
+            "interests": customer.get("interests", []),
+            "last_product": None,
+            "days_since_last": 0,
+            "greeting": ""
+        }
+        
+        # Son aranan ürün
+        searched_products = customer.get("searched_products", [])
+        if searched_products:
+            context["last_product"] = searched_products[-1]["product"]
+            last_search_date = datetime.fromisoformat(searched_products[-1]["date"])
+            context["days_since_last"] = (datetime.now() - last_search_date).days
+        
+        # Kişiselleştirilmiş selamlama oluştur
+        context["greeting"] = self._generate_greeting(customer, context)
+        
+        return context
+    
+    def _generate_greeting(self, customer: Dict, context: Dict) -> str:
+        """Kişiselleştirilmiş selamlama oluştur"""
+        segment = customer.get("segment", "Standart")
+        name = customer.get("name", "")
+        
+        # Saat bazlı selamlama
+        hour = datetime.now().hour
+        if 6 <= hour < 12:
+            time_greeting = "Günaydın"
+        elif 12 <= hour < 18:
+            time_greeting = "İyi günler"
+        else:
+            time_greeting = "İyi akşamlar"
+        
+        # Segment bazlı selamlama
+        if segment == "VIP":
+            if name:
+                greeting = f"{time_greeting} {name} Bey/Hanım! Değerli müşterimiz olarak size özel VIP avantajlarımız mevcut."
+            else:
+                greeting = f"{time_greeting}! Değerli müşterimize özel VIP avantajlarımız mevcut."
+        
+        elif segment == "Yeni":
+            greeting = f"{time_greeting}! Trek bisikletleri dünyasına hoş geldiniz! Size nasıl yardımcı olabilirim?"
+        
+        elif segment == "Potansiyel":
+            if context.get("last_product"):
+                greeting = f"{time_greeting}! Daha önce sorduğunuz {context['last_product']} veya başka bir konuda size yardımcı olabilir miyim?"
+            else:
+                greeting = f"{time_greeting}! Bisiklet arayışınızda size nasıl yardımcı olabilirim?"
+        
+        elif segment == "Kayıp Riski":
+            if name:
+                greeting = f"{time_greeting} {name} Bey/Hanım! Sizi özledik! Size özel geri dönüş kampanyamız var."
+            else:
+                greeting = f"{time_greeting}! Sizi tekrar aramızda görmek güzel! Size özel fırsatlarımız var."
+        
+        elif segment == "Aktif":
+            if name:
+                greeting = f"{time_greeting} {name} Bey/Hanım! Tekrar hoş geldiniz!"
+            else:
+                greeting = f"{time_greeting}! Tekrar hoş geldiniz!"
+            
+            # Son aranan ürün varsa ekle
+            if context.get("last_product") and context.get("days_since_last", 99) <= 3:
+                greeting += f" {context['last_product']} hakkında bilgi almak ister misiniz?"
+        
+        else:  # Standart
+            if name:
+                greeting = f"{time_greeting} {name} Bey/Hanım! Size nasıl yardımcı olabilirim?"
+            else:
+                greeting = f"{time_greeting}! Size nasıl yardımcı olabilirim?"
+        
+        return greeting
+    
+    def get_analytics(self) -> Dict:
+        """Analitik özet döndür"""
+        total_customers = len(self.customers)
+        segments = {}
+        total_purchases = 0
+        total_revenue = 0
+        active_today = 0
+        
+        today = datetime.now().date()
+        
+        for customer in self.customers.values():
+            # Segment dağılımı
+            segment = customer.get("segment", "Standart")
+            segments[segment] = segments.get(segment, 0) + 1
+            
+            # Satış istatistikleri
+            purchases = customer.get("purchases", [])
+            total_purchases += len(purchases)
+            total_revenue += sum(p.get("price", 0) for p in purchases)
+            
+            # Bugün aktif olanlar
+            last_interaction = datetime.fromisoformat(customer.get("last_interaction", "2020-01-01"))
+            if last_interaction.date() == today:
+                active_today += 1
+        
+        return {
+            "total_customers": total_customers,
+            "segments": segments,
+            "total_purchases": total_purchases,
+            "total_revenue": total_revenue,
+            "active_today": active_today,
+            "average_purchase_value": total_revenue / total_purchases if total_purchases > 0 else 0
+        }
+    
+    def get_customer_list(self, segment: Optional[str] = None) -> List[Dict]:
+        """Müşteri listesini getir"""
+        customers = []
+        
+        for phone, customer in self.customers.items():
+            if segment and customer.get("segment") != segment:
+                continue
+            
+            customers.append({
+                "phone": phone,
+                "name": customer.get("name", "Bilinmiyor"),
+                "segment": customer.get("segment", "Standart"),
+                "total_queries": customer.get("total_queries", 0),
+                "total_purchases": len(customer.get("purchases", [])),
+                "last_interaction": customer.get("last_interaction"),
+                "interests": customer.get("interests", [])
+            })
+        
+        # Son etkileşime göre sırala
+        customers.sort(key=lambda x: x["last_interaction"], reverse=True)
+        return customers
+    
+    def should_ask_for_name(self, phone: str, message: str) -> Tuple[bool, Optional[str]]:
+        """İsim sorulmalı mı kontrol et"""
+        customer = self.customers.get(phone, {})
+        
+        # Zaten isim varsa sorma
+        if customer.get("name"):
+            return False, None
+        
+        queries = customer.get("total_queries", 0)
+        message_lower = message.lower()
+        
+        # 1. Rezervasyon/satın alma anında (EN DOĞAL)
+        reservation_keywords = ["rezerv", "ayırt", "satın al", "alabilir miyim", "almak istiyorum", 
+                               "sipariş", "kargola", "gönder", "paket", "teslimat"]
+        if any(keyword in message_lower for keyword in reservation_keywords):
+            return True, "📝 Rezervasyon için adınızı alabilir miyim?"
+        
+        # 2. Mağaza ziyareti planı
+        store_visit_keywords = ["mağazaya gel", "mağazaya uğra", "görmeye gel", "bakmaya gel", 
+                               "test sürüşü", "denemek istiyorum"]
+        if any(keyword in message_lower for keyword in store_visit_keywords):
+            return True, "🏪 Mağazada size daha iyi yardımcı olabilmemiz için adınızı öğrenebilir miyim?"
+        
+        # 3. Telefon görüşmesi talebi
+        phone_keywords = ["ara", "telefon", "görüş", "konuş", "iletişim"]
+        if any(keyword in message_lower for keyword in phone_keywords):
+            return True, "📞 Sizi arayabilmemiz için adınızı paylaşır mısınız?"
+        
+        # 4. Fiyat/ödeme görüşmesi (ciddi alıcı)
+        payment_keywords = ["taksit", "ödeme", "kredi kartı", "havale", "eft", "nakit", "peşin"]
+        if any(keyword in message_lower for keyword in payment_keywords):
+            return True, "💳 Size özel ödeme seçenekleri sunabilmem için adınızı öğrenebilir miyim?"
+        
+        # 5. 3. mesajda nazikçe sor (sadece ürün sorguluyorsa)
+        if queries == 2:  # 3. mesaj (0'dan başlıyor)
+            # Sadece basit selamlaşma değilse
+            greeting_only = ["merhaba", "selam", "günaydın", "iyi günler", "hey", "sa"]
+            if not any(message_lower.strip() == greeting for greeting in greeting_only):
+                return True, "Bu arada, size daha iyi hizmet verebilmem için adınızı öğrenebilir miyim? 😊"
+        
+        # 6. 5+ sorgudan sonra hala isim yoksa (potansiyel müşteri)
+        if queries >= 5:
+            return True, "✨ Sizin için özel tekliflerimiz olabilir. Adınızı paylaşır mısınız?"
+        
+        return False, None
+    
+    def extract_name_from_response(self, message: str) -> Optional[str]:
+        """İsim sorulduktan sonra gelen yanıttan isim çıkar"""
+        message_lower = message.lower().strip()
+        
+        # Direkt isim yanıtları
+        if len(message_lower.split()) == 1:
+            # Yaygın olmayan tek kelime yanıtları filtrele
+            common_words = ["evet", "hayır", "tamam", "olur", "peki", "teşekkür", "teşekkürler",
+                          "merhaba", "selam", "günaydın", "güle", "hoşçakal", "görüşürüz",
+                          "sa", "as", "slm", "mrb", "ok", "okay", "yes", "no", "hi", "hello", "bye"]
+            if message_lower not in common_words:
+                # Tek kelime, muhtemelen isim
+                name = message.capitalize()
+                # Türkçe isim kontrolü (en az 2 karakter)
+                if len(name) >= 2 and name.isalpha():
+                    return name
+        
+        # "Benim adım X", "Ben X", "Adım X" kalıpları
+        patterns = [
+            r"(?:benim\s+)?ad[ıi]m?\s+(\w+)",
+            r"ben\s+(\w+)",
+            r"(\w+)\s+diye\s+hitap",
+            r"bana\s+(\w+)\s+diyebilirsiniz",
+            r"ismim\s+(\w+)",
+            r"(\w+),?\s*teşekkür",  # "Ahmet, teşekkürler"
+        ]
+        
+        for pattern in patterns:
+            import re
+            match = re.search(pattern, message_lower)
+            if match:
+                name = match.group(1).capitalize()
+                if len(name) >= 2:
+                    return name
+        
+        # İsim + Soyisim durumu (sadece ismi al)
+        two_words = message.strip().split()
+        if len(two_words) == 2:
+            # Her ikisi de büyük harfle başlıyorsa
+            if two_words[0][0].isupper() and two_words[1][0].isupper():
+                return two_words[0]
+        
+        return None

follow_up_system.py

@@ -0,0 +1,407 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Otomatik Takip ve Hatırlatma Sistemi
+Müşteri taahhütlerini takip eder ve Mehmet Bey'e hatırlatır
+"""
+
+import os
+import json
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, List, Dict
+from dataclasses import dataclass, asdict
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+# Takip tipi
+class FollowUpType(Enum):
+    RESERVATION = "reservation"  # Ayırtma takibi
+    VISIT_PROMISE = "visit"      # Gelme sözü takibi
+    PRICE_INQUIRY = "price"      # Fiyat sorusu takibi
+    DECISION_PENDING = "decision" # Karar bekleyen
+    TEST_RIDE = "test_ride"      # Test sürüşü
+
+# Takip durumu
+class FollowUpStatus(Enum):
+    PENDING = "pending"          # Bekliyor
+    REMINDED = "reminded"        # Hatırlatma yapıldı
+    COMPLETED = "completed"      # Tamamlandı
+    CANCELLED = "cancelled"      # İptal edildi
+
+@dataclass
+class FollowUp:
+    """Takip kaydı"""
+    id: str                     # Unique ID
+    customer_phone: str          # Müşteri telefonu
+    customer_name: Optional[str] # Müşteri adı
+    product_name: str            # Ürün
+    follow_up_type: str          # Takip tipi
+    status: str                  # Durum
+    created_at: str              # Oluşturulma zamanı
+    follow_up_at: str            # Hatırlatma zamanı
+    original_message: str        # Orijinal mesaj
+    notes: Optional[str]         # Notlar
+    store_name: Optional[str]    # Mağaza
+    reminded_count: int = 0      # Kaç kez hatırlatıldı
+
+class FollowUpManager:
+    """Takip yöneticisi"""
+    
+    def __init__(self, db_file: str = "follow_ups.json"):
+        self.db_file = db_file
+        self.follow_ups = self._load_database()
+    
+    def _load_database(self) -> List[FollowUp]:
+        """Database'i yükle"""
+        if os.path.exists(self.db_file):
+            try:
+                with open(self.db_file, "r") as f:
+                    data = json.load(f)
+                    return [FollowUp(**item) for item in data]
+            except Exception as e:
+                logger.error(f"Database yükleme hatası: {e}")
+                return []
+        return []
+    
+    def _save_database(self):
+        """Database'i kaydet"""
+        try:
+            data = [asdict(f) for f in self.follow_ups]
+            with open(self.db_file, "w") as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            logger.error(f"Database kayıt hatası: {e}")
+    
+    def create_follow_up(
+        self,
+        customer_phone: str,
+        product_name: str,
+        follow_up_type: FollowUpType,
+        original_message: str,
+        follow_up_hours: int = 24,
+        customer_name: Optional[str] = None,
+        notes: Optional[str] = None,
+        store_name: Optional[str] = None
+    ) -> FollowUp:
+        """Yeni takip oluştur"""
+        
+        now = datetime.now()
+        follow_up_time = now + timedelta(hours=follow_up_hours)
+        
+        # Unique ID oluştur
+        follow_up_id = f"{customer_phone}_{now.strftime('%Y%m%d_%H%M%S')}"
+        
+        follow_up = FollowUp(
+            id=follow_up_id,
+            customer_phone=customer_phone,
+            customer_name=customer_name,
+            product_name=product_name,
+            follow_up_type=follow_up_type.value,
+            status=FollowUpStatus.PENDING.value,
+            created_at=now.isoformat(),
+            follow_up_at=follow_up_time.isoformat(),
+            original_message=original_message,
+            notes=notes,
+            store_name=store_name,
+            reminded_count=0
+        )
+        
+        self.follow_ups.append(follow_up)
+        self._save_database()
+        
+        logger.info(f"✅ Takip oluşturuldu: {follow_up_id}")
+        logger.info(f"   Hatırlatma zamanı: {follow_up_time.strftime('%d.%m.%Y %H:%M')}")
+        
+        return follow_up
+    
+    def get_pending_reminders(self) -> List[FollowUp]:
+        """Bekleyen hatırlatmaları getir"""
+        now = datetime.now()
+        pending = []
+        
+        for follow_up in self.follow_ups:
+            if follow_up.status == FollowUpStatus.PENDING.value:
+                follow_up_time = datetime.fromisoformat(follow_up.follow_up_at)
+                if follow_up_time <= now:
+                    pending.append(follow_up)
+        
+        return pending
+    
+    def mark_as_reminded(self, follow_up_id: str):
+        """Hatırlatma yapıldı olarak işaretle"""
+        for follow_up in self.follow_ups:
+            if follow_up.id == follow_up_id:
+                follow_up.status = FollowUpStatus.REMINDED.value
+                follow_up.reminded_count += 1
+                self._save_database()
+                logger.info(f"✅ Hatırlatma yapıldı: {follow_up_id}")
+                break
+    
+    def mark_as_completed(self, follow_up_id: str):
+        """Tamamlandı olarak işaretle"""
+        for follow_up in self.follow_ups:
+            if follow_up.id == follow_up_id:
+                follow_up.status = FollowUpStatus.COMPLETED.value
+                self._save_database()
+                logger.info(f"✅ Takip tamamlandı: {follow_up_id}")
+                break
+    
+    def get_customer_history(self, customer_phone: str) -> List[FollowUp]:
+        """Müşteri geçmişini getir"""
+        return [f for f in self.follow_ups if f.customer_phone == customer_phone]
+    
+    def get_todays_follow_ups(self) -> List[FollowUp]:
+        """Bugünün takiplerini getir"""
+        today = datetime.now().date()
+        todays = []
+        
+        for follow_up in self.follow_ups:
+            follow_up_date = datetime.fromisoformat(follow_up.follow_up_at).date()
+            if follow_up_date == today:
+                todays.append(follow_up)
+        
+        return todays
+
+def analyze_message_for_follow_up(message: str) -> Optional[Dict]:
+    """
+    Mesajı analiz et ve takip gerekip gerekmediğini belirle
+    
+    Returns:
+        {
+            "needs_follow_up": True/False,
+            "follow_up_type": FollowUpType,
+            "follow_up_hours": int,
+            "reason": str
+        }
+    """
+    
+    message_lower = message.lower()
+    
+    # YARIN gelme sözleri (24 saat sonra hatırlat)
+    tomorrow_keywords = [
+        'yarın', 'yarin',
+        'yarın gel', 'yarın al', 'yarın uğra',
+        'yarına', 'yarina',
+        'ertesi gün'
+    ]
+    
+    # BUGÜN gelme sözleri (6 saat sonra hatırlat)
+    today_keywords = [
+        'bugün', 'bugun',
+        'bugün gel', 'bugün al', 'bugün uğra',
+        'akşam gel', 'aksam gel',
+        'öğleden sonra', 'ogleden sonra',
+        'birazdan', 'biraz sonra',
+        '1 saat', 'bir saat',
+        '2 saat', 'iki saat', 
+        '30 dakika', 'yarım saat'
+    ]
+    
+    # HAFTA SONU gelme sözleri
+    weekend_keywords = [
+        'hafta sonu', 'haftasonu',
+        'cumartesi', 'pazar',
+        'hafta içi', 'haftaiçi'
+    ]
+    
+    # KARAR VERME sözleri (48 saat sonra hatırlat)
+    decision_keywords = [
+        'düşüneyim', 'düşüncem', 'düşünelim',
+        'danışayım', 'danısayım', 'danışıcam',
+        'eşime sor', 'eşimle konuş', 'esime sor',
+        'karar ver', 'haber ver',
+        'araştırayım', 'araştırıcam',
+        'bakarım', 'bakarız', 'bakıcam'
+    ]
+    
+    # TEST SÜRÜŞÜ (4 saat sonra hatırlat)
+    test_keywords = [
+        'test sürüş', 'test et', 'dene',
+        'binebilir', 'binmek ist',
+        'test ride', 'deneme sürüş'
+    ]
+    
+    # Yarın kontrolü
+    for keyword in tomorrow_keywords:
+        if keyword in message_lower:
+            return {
+                "needs_follow_up": True,
+                "follow_up_type": FollowUpType.VISIT_PROMISE,
+                "follow_up_hours": 24,
+                "reason": f"Müşteri yarın geleceğini söyledi: '{keyword}'"
+            }
+    
+    # Bugün kontrolü
+    for keyword in today_keywords:
+        if keyword in message_lower:
+            return {
+                "needs_follow_up": True,
+                "follow_up_type": FollowUpType.VISIT_PROMISE,
+                "follow_up_hours": 6,
+                "reason": f"Müşteri bugün geleceğini söyledi: '{keyword}'"
+            }
+    
+    # Hafta sonu kontrolü
+    for keyword in weekend_keywords:
+        if keyword in message_lower:
+            # Bugün hangi gün?
+            today = datetime.now().weekday()  # 0=Pazartesi, 6=Pazar
+            if today < 5:  # Hafta içiyse
+                days_to_saturday = 5 - today
+                hours = days_to_saturday * 24
+            else:  # Zaten hafta sonuysa
+                hours = 24
+            
+            return {
+                "needs_follow_up": True,
+                "follow_up_type": FollowUpType.VISIT_PROMISE,
+                "follow_up_hours": hours,
+                "reason": f"Müşteri hafta sonu geleceğini söyledi: '{keyword}'"
+            }
+    
+    # Karar verme kontrolü
+    for keyword in decision_keywords:
+        if keyword in message_lower:
+            return {
+                "needs_follow_up": True,
+                "follow_up_type": FollowUpType.DECISION_PENDING,
+                "follow_up_hours": 48,
+                "reason": f"Müşteri düşüneceğini söyledi: '{keyword}'"
+            }
+    
+    # Test sürüşü kontrolü
+    for keyword in test_keywords:
+        if keyword in message_lower:
+            return {
+                "needs_follow_up": True,
+                "follow_up_type": FollowUpType.TEST_RIDE,
+                "follow_up_hours": 4,
+                "reason": f"Müşteri test sürüşü istiyor: '{keyword}'"
+            }
+    
+    # Ayırtma varsa 24 saat sonra kontrol
+    reservation_keywords = ['ayırt', 'rezerve', 'tutun', 'sakla']
+    for keyword in reservation_keywords:
+        if keyword in message_lower:
+            return {
+                "needs_follow_up": True,
+                "follow_up_type": FollowUpType.RESERVATION,
+                "follow_up_hours": 24,
+                "reason": f"Ayırtma talebi var: '{keyword}'"
+            }
+    
+    return None
+
+def format_reminder_message(follow_up: FollowUp) -> str:
+    """Hatırlatma mesajını formatla"""
+    
+    # Takip tipine göre emoji
+    type_emojis = {
+        "reservation": "📦",
+        "visit": "🚶",
+        "price": "💰",
+        "decision": "🤔",
+        "test_ride": "🚴"
+    }
+    
+    emoji = type_emojis.get(follow_up.follow_up_type, "📌")
+    
+    # Zaman hesaplama
+    created_time = datetime.fromisoformat(follow_up.created_at)
+    time_diff = datetime.now() - created_time
+    
+    if time_diff.days > 0:
+        time_str = f"{time_diff.days} gün önce"
+    elif time_diff.seconds > 3600:
+        hours = time_diff.seconds // 3600
+        time_str = f"{hours} saat önce"
+    else:
+        time_str = "Az önce"
+    
+    # Mesaj oluştur
+    message = f"""
+{emoji} **TAKİP HATIRLATMASI**
+
+👤 Müşteri: {follow_up.customer_name or "İsimsiz"}
+📱 Tel: {follow_up.customer_phone.replace('whatsapp:', '')}
+
+🚲 Ürün: {follow_up.product_name}
+⏰ İlk mesaj: {time_str}
+
+📝 Müşteri mesajı:
+"{follow_up.original_message}"
+"""
+    
+    # Tipe göre özel mesaj
+    if follow_up.follow_up_type == "reservation":
+        message += "\n⚠️ AYIRTMA TAKİBİ: Müşteri geldi mi?"
+    elif follow_up.follow_up_type == "visit":
+        message += "\n⚠️ ZİYARET TAKİBİ: Müşteri geleceğini söylemişti"
+    elif follow_up.follow_up_type == "decision":
+        message += "\n⚠️ KARAR TAKİBİ: Müşteri düşüneceğini söylemişti"
+    elif follow_up.follow_up_type == "test_ride":
+        message += "\n⚠️ TEST SÜRÜŞÜ TAKİBİ: Test için gelecekti"
+    
+    message += "\n\n📞 Müşteriyi arayıp durumu öğrenin!"
+    
+    return message
+
+# Test fonksiyonu
+def test_follow_up_system():
+    """Test senaryoları"""
+    
+    print("\n" + "="*60)
+    print("TAKİP SİSTEMİ TESTİ")
+    print("="*60)
+    
+    manager = FollowUpManager("test_follow_ups.json")
+    
+    # Test mesajları
+    test_messages = [
+        ("Yarın gelip FX 2'yi alacağım", "FX 2"),
+        ("Eşime danışayım, size dönerim", "Marlin 5"),
+        ("Bugün akşam uğrarım", "Checkpoint"),
+        ("Hafta sonu test sürüşü yapabilir miyim?", "Domane"),
+        ("30 dakikaya oradayım, ayırtın", "FX Sport")
+    ]
+    
+    for message, product in test_messages:
+        print(f"\n📝 Mesaj: '{message}'")
+        
+        analysis = analyze_message_for_follow_up(message)
+        if analysis and analysis["needs_follow_up"]:
+            print(f"✅ Takip gerekli!")
+            print(f"   Tip: {analysis['follow_up_type'].value}")
+            print(f"   {analysis['follow_up_hours']} saat sonra hatırlat")
+            print(f"   Sebep: {analysis['reason']}")
+            
+            # Takip oluştur
+            follow_up = manager.create_follow_up(
+                customer_phone="whatsapp:+905551234567",
+                product_name=product,
+                follow_up_type=analysis["follow_up_type"],
+                original_message=message,
+                follow_up_hours=analysis["follow_up_hours"]
+            )
+        else:
+            print("❌ Takip gerekmiyor")
+    
+    # Bekleyen hatırlatmaları göster
+    print("\n" + "="*60)
+    print("BEKLEYEN HATIRLATMALAR")
+    print("="*60)
+    
+    pending = manager.get_pending_reminders()
+    if pending:
+        for f in pending:
+            print(f"\n{format_reminder_message(f)}")
+    else:
+        print("Bekleyen hatırlatma yok")
+    
+    print("\n" + "="*60)
+
+if __name__ == "__main__":
+    test_follow_up_system()

get_warehouse_fast.py

@@ -0,0 +1,130 @@
+"""Ultra fast warehouse stock getter using regex"""
+
+def get_warehouse_stock(product_name):
+    """Super fast warehouse stock finder using regex instead of XML parsing"""
+    try:
+        import re
+        import requests
+        
+        # Fetch XML
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
+        response = requests.get(warehouse_url, verify=False, timeout=7)
+        
+        if response.status_code != 200:
+            return None
+        
+        xml_text = response.text
+        
+        # Turkish normalization
+        turkish_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c', 'İ': 'i', 'I': 'i'}
+        
+        def normalize_turkish(text):
+            text = text.lower()
+            for tr_char, en_char in turkish_map.items():
+                text = text.replace(tr_char, en_char)
+            return text
+        
+        # Normalize search
+        search_name = normalize_turkish(product_name.strip())
+        search_name = search_name.replace('(2026)', '').replace('(2025)', '').strip()
+        search_words = search_name.split()
+        
+        # Separate size from product words
+        size_words = ['s', 'm', 'l', 'xl', 'xs', 'xxl', 'ml']
+        size_indicators = ['beden', 'size', 'boy']
+        
+        variant_filter = [w for w in search_words if w in size_words]
+        product_words = [w for w in search_words if w not in size_words and w not in size_indicators]
+        
+        print(f"DEBUG - Looking for: {' '.join(product_words)}")
+        print(f"DEBUG - Size filter: {variant_filter}")
+        
+        # Build exact pattern for common products
+        search_pattern = ' '.join(product_words).upper()
+        
+        # Handle specific products
+        if 'madone' in product_words and 'sl' in product_words and '6' in product_words and 'gen' in product_words and '8' in product_words:
+            search_pattern = 'MADONE SL 6 GEN 8'
+        elif 'madone' in product_words and 'slr' in product_words and '7' in product_words:
+            search_pattern = 'MADONE SLR 7 GEN 8'
+        else:
+            # Generic pattern
+            search_pattern = search_pattern.replace('İ', 'I')
+        
+        # Find all Product blocks with this name
+        # Using lazy quantifier .*? for efficiency
+        product_pattern = f'<Product>.*?<ProductName><!\\[CDATA\\[{re.escape(search_pattern)}\\]\\]></ProductName>.*?</Product>'
+        matches = re.findall(product_pattern, xml_text, re.DOTALL)
+        
+        print(f"DEBUG - Found {len(matches)} products matching '{search_pattern}'")
+        
+        # Process matches
+        warehouse_stock_map = {}
+        
+        for match in matches:
+            # Extract variant if we need to filter by size
+            should_process = True
+            
+            if variant_filter:
+                variant_match = re.search(r'<ProductVariant><!\\[CDATA\\[(.*?)\\]\\]></ProductVariant>', match)
+                if variant_match:
+                    variant = variant_match.group(1)
+                    size_wanted = variant_filter[0].upper()
+                    
+                    # Check if variant starts with desired size
+                    if variant.startswith(f'{size_wanted}-'):
+                        print(f"DEBUG - Found matching variant: {variant}")
+                        should_process = True
+                    else:
+                        should_process = False
+                else:
+                    should_process = False
+            
+            if should_process:
+                # Extract all warehouses with stock
+                warehouse_pattern = r'<Warehouse>.*?<Name><!\\[CDATA\\[(.*?)\\]\\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
+                warehouses = re.findall(warehouse_pattern, match, re.DOTALL)
+                
+                for wh_name, wh_stock in warehouses:
+                    try:
+                        stock = int(wh_stock.strip())
+                        if stock > 0:
+                            if wh_name in warehouse_stock_map:
+                                warehouse_stock_map[wh_name] += stock
+                            else:
+                                warehouse_stock_map[wh_name] = stock
+                    except:
+                        pass
+                
+                # If we found a variant match, stop looking
+                if variant_filter and should_process:
+                    break
+        
+        print(f"DEBUG - Warehouse stock: {warehouse_stock_map}")
+        
+        # Format results
+        if warehouse_stock_map:
+            all_warehouse_info = []
+            for warehouse_name, total_stock in warehouse_stock_map.items():
+                # Make store names more readable
+                if "Caddebostan" in warehouse_name or "CADDEBOSTAN" in warehouse_name:
+                    display_name = "Caddebostan mağazası"
+                elif "Ortaköy" in warehouse_name or "ORTAKÖY" in warehouse_name:
+                    display_name = "Ortaköy mağazası"
+                elif "Sarıyer" in warehouse_name:
+                    display_name = "Sarıyer mağazası"
+                elif "Alsancak" in warehouse_name or "ALSANCAK" in warehouse_name or "İzmir" in warehouse_name:
+                    display_name = "İzmir Alsancak mağazası"
+                elif "BAHCEKOY" in warehouse_name or "Bahçeköy" in warehouse_name:
+                    display_name = "Bahçeköy mağazası"
+                else:
+                    display_name = warehouse_name
+                
+                all_warehouse_info.append(f"{display_name}: Mevcut")
+            return all_warehouse_info
+        else:
+            return ["Hiçbir mağazada mevcut değil"]
+    
+    except Exception as e:
+        print(f"Warehouse stock error: {e}")
+        return None

image_renderer.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+"""
+Ürün Resimlerini Sohbette Gösterme Sistemi
+"""
+
+def round_price(price_str):
+    """Fiyatı yuvarlama formülüne göre yuvarla"""
+    try:
+        # TL ve diğer karakterleri temizle
+        price_clean = price_str.replace(' TL', '').replace(',', '.')
+        price_float = float(price_clean)
+        
+        # Fiyat 200000 üzerindeyse en yakın 5000'lik basamağa yuvarla
+        if price_float > 200000:
+            return str(round(price_float / 5000) * 5000)
+        # Fiyat 30000 üzerindeyse en yakın 1000'lik basamağa yuvarla
+        elif price_float > 30000:
+            return str(round(price_float / 1000) * 1000)
+        # Fiyat 10000 üzerindeyse en yakın 100'lük basamağa yuvarla
+        elif price_float > 10000:
+            return str(round(price_float / 100) * 100)
+        # Diğer durumlarda en yakın 10'luk basamağa yuvarla
+        else:
+            return str(round(price_float / 10) * 10)
+    except (ValueError, TypeError):
+        return price_str
+
+def format_message_with_images(message):
+    """Mesajdaki resim URL'lerini HTML formatına çevir"""
+    if "Ürün resmi:" not in message:
+        return message
+    
+    lines = message.split('\n')
+    formatted_lines = []
+    
+    for line in lines:
+        if line.startswith("Ürün resmi:"):
+            image_url = line.replace("Ürün resmi:", "").strip()
+            if image_url:
+                # HTML img tag'i oluştur
+                img_html = f"""
+<div style="margin: 10px 0;">
+    <img src="{image_url}" 
+         alt="Ürün Resmi" 
+         style="max-width: 300px; max-height: 200px; border-radius: 8px; border: 1px solid #ddd; box-shadow: 0 2px 4px rgba(0,0,0,0.1);"
+         onerror="this.style.display='none'">
+</div>"""
+                formatted_lines.append(img_html)
+            else:
+                formatted_lines.append(line)
+        else:
+            formatted_lines.append(line)
+    
+    return '\n'.join(formatted_lines)
+
+def create_product_gallery(products_with_images):
+    """Birden fazla ürün için galeri oluştur"""
+    if not products_with_images:
+        return ""
+    
+    gallery_html = """
+<div style="display: flex; flex-wrap: wrap; gap: 15px; margin: 15px 0;">
+"""
+    
+    for product in products_with_images:
+        name = product.get('name', 'Bilinmeyen')
+        price = product.get('price', 'Fiyat yok')
+        image_url = product.get('image_url', '')
+        product_url = product.get('product_url', '')
+        
+        if image_url:
+            card_html = f"""
+<div style="border: 1px solid #ddd; border-radius: 8px; padding: 10px; max-width: 200px; text-align: center; background: white; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
+    <img src="{image_url}" 
+         alt="{name}" 
+         style="max-width: 180px; max-height: 120px; border-radius: 4px; margin-bottom: 8px;"
+         onerror="this.style.display='none'">
+    <div style="font-size: 12px; font-weight: bold; margin-bottom: 4px;">{name}</div>
+    <div style="font-size: 11px; color: #666; margin-bottom: 8px;">{price}</div>
+    {f'<a href="{product_url}" target="_blank" style="font-size: 10px; color: #007bff; text-decoration: none;">Detaylı Bilgi</a>' if product_url else ''}
+</div>"""
+            gallery_html += card_html
+    
+    gallery_html += "</div>"
+    return gallery_html
+
+def extract_product_info_for_gallery(message):
+    """Mesajdan ürün bilgilerini çıkarıp galeri formatına çevir"""
+    if "karşılaştır" in message.lower() or "öneri" in message.lower():
+        # Bu durumda galeri formatı kullan
+        lines = message.split('\n')
+        products = []
+        
+        current_product = {}
+        for line in lines:
+            line = line.strip()
+            if line.startswith('•') and any(keyword in line.lower() for keyword in ['marlin', 'émonda', 'madone', 'domane', 'fuel', 'powerfly', 'fx']):
+                # Yeni ürün başladı
+                if current_product:
+                    products.append(current_product)
+                
+                # Ürün adı ve fiyatı parse et
+                parts = line.split(' - ')
+                name = parts[0].replace('•', '').strip()
+                price_raw = parts[1] if len(parts) > 1 else 'Fiyat yok'
+                
+                # Fiyatı yuvarlama formülüne göre yuvarla
+                if price_raw != 'Fiyat yok':
+                    price = round_price(price_raw) + ' TL'
+                else:
+                    price = price_raw
+                
+                current_product = {
+                    'name': name,
+                    'price': price,
+                    'image_url': '',
+                    'product_url': ''
+                }
+            elif "Ürün resmi:" in line and current_product:
+                current_product['image_url'] = line.replace("Ürün resmi:", "").strip()
+            elif "Ürün linki:" in line and current_product:
+                current_product['product_url'] = line.replace("Ür��n linki:", "").strip()
+        
+        # Son ürünü ekle
+        if current_product:
+            products.append(current_product)
+        
+        if products:
+            gallery = create_product_gallery(products)
+            # Orijinal mesajdaki resim linklerini temizle
+            cleaned_message = message
+            for line in message.split('\n'):
+                if line.startswith("Ürün resmi:") or line.startswith("Ürün linki:"):
+                    cleaned_message = cleaned_message.replace(line, "")
+            
+            return cleaned_message.strip() + "\n\n" + gallery
+    
+    return format_message_with_images(message)
+
+def should_use_gallery_format(message):
+    """Mesajın galeri formatı kullanması gerekip gerekmediğini kontrol et"""
+    gallery_keywords = ["karşılaştır", "öneri", "seçenek", "alternatif", "bütçe"]
+    return any(keyword in message.lower() for keyword in gallery_keywords)

intent_analyzer.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+GPT-5 Powered Intent Analyzer
+Müşteri mesajlarından niyeti anlar ve aksiyonları belirler
+"""
+
+import os
+import json
+import requests
+import logging
+from typing import Dict, Optional, List, Tuple
+
+logger = logging.getLogger(__name__)
+
+# OpenAI API
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+API_URL = "https://api.openai.com/v1/chat/completions"
+
+def analyze_customer_intent(
+    message: str,
+    context: Optional[Dict] = None
+) -> Dict:
+    """
+    GPT-5 ile müşteri niyetini analiz et
+    
+    Args:
+        message: Müşteri mesajı
+        context: Sohbet bağlamı (varsa)
+        
+    Returns:
+        {
+            "intents": ["reserve", "price", "stock", "info"],
+            "product": "FX 2",
+            "confidence": 0.95,
+            "store": "caddebostan",  # Eğer belirtildiyse
+            "urgency": "high/medium/low",
+            "customer_mood": "positive/neutral/negative",
+            "suggested_action": "notify_store/answer_directly/both",
+            "notification_message": "Özel mesaj"
+        }
+    """
+    
+    if not OPENAI_API_KEY:
+        logger.error("OpenAI API key missing")
+        return {"intents": [], "confidence": 0}
+    
+    # Sistem promptu
+    system_prompt = """Sen bir müşteri niyet analiz uzmanısın. Trek bisiklet mağazası için müşteri mesajlarını analiz ediyorsun.
+
+GÖREV: Müşteri mesajını analiz et ve JSON formatında döndür.
+
+NİYET TİPLERİ:
+- "reserve": Ürünü ayırtmak, rezerve etmek, tutmak istiyor
+- "price": Fiyat bilgisi istiyor
+- "stock": Stok durumu soruyor
+- "info": Genel bilgi istiyor
+- "complaint": Şikayet ediyor
+- "order": Sipariş vermek istiyor
+- "test_ride": Test sürüşü istiyor
+- "service": Servis/tamir istiyor
+- "none": Belirgin bir niyet yok
+
+ÖRNEK CÜMLELER:
+- "bu bisikleti ayırtabilir misiniz" → reserve
+- "yarın gelip alabilirim" → reserve
+- "benim için tutun" → reserve
+- "fiyatı nedir" → price
+- "kaç para" → price
+- "var mı" → stock
+- "stokta mı" → stock
+- "özellikleri nelerdir" → info
+- "test edebilir miyim" → test_ride
+
+ACİLİYET:
+- high: Hemen aksiyon gerekiyor (ayırtma, hemen alma isteği)
+- medium: Normal takip yeterli
+- low: Bilgi amaçlı
+
+JSON FORMATI:
+{
+    "intents": ["reserve", "price"],  // Birden fazla olabilir
+    "product": "FX 2",  // Eğer üründen bahsediyorsa
+    "confidence": 0.95,  // 0-1 arası güven skoru
+    "store": null,  // Mağaza adı varsa
+    "urgency": "high",
+    "customer_mood": "positive",
+    "suggested_action": "notify_store",  // notify_store, answer_directly, both, none
+    "notification_required": true,
+    "notification_reason": "Müşteri FX 2'yi ayırtmak istiyor"
+}"""
+
+    # Bağlam varsa ekle
+    context_info = ""
+    if context:
+        if context.get("current_category"):
+            context_info = f"\nSON KONUŞULAN ÜRÜN: {context['current_category']}"
+        if context.get("messages"):
+            last_msg = context["messages"][-1] if context["messages"] else None
+            if last_msg:
+                context_info += f"\nÖNCEKİ MESAJ: {last_msg.get('user', '')}"
+    
+    # GPT-5'e gönder
+    try:
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": f"Müşteri mesajı: \"{message}\"{context_info}\n\nJSON formatında analiz et:"}
+        ]
+        
+        # GPT-5 modelleri temperature ve max_tokens desteklemiyor
+        payload = {
+            "model": "gpt-5.2-chat-latest",
+            "messages": messages,
+            "response_format": {"type": "json_object"}  # JSON garantisi
+        }
+        
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {OPENAI_API_KEY}"
+        }
+        
+        response = requests.post(API_URL, headers=headers, json=payload, timeout=10)
+        
+        if response.status_code == 200:
+            result = response.json()
+            analysis = json.loads(result['choices'][0]['message']['content'])
+            
+            logger.info(f"🧠 Intent Analysis: {analysis}")
+            return analysis
+        else:
+            logger.error(f"GPT-5 API error: {response.status_code}")
+            return {"intents": [], "confidence": 0}
+            
+    except Exception as e:
+        logger.error(f"Intent analysis error: {e}")
+        return {"intents": [], "confidence": 0}
+
+def should_notify_store(analysis: Dict) -> Tuple[bool, str]:
+    """
+    Mağazaya bildirim gönderilmeli mi?
+    
+    Returns:
+        (should_notify, reason)
+    """
+    
+    # Yüksek güvenle rezervasyon talebi
+    if "reserve" in analysis.get("intents", []) and analysis.get("confidence", 0) > 0.7:
+        return True, "Müşteri ürünü ayırtmak istiyor"
+    
+    # Acil stok sorusu
+    if "stock" in analysis.get("intents", []) and analysis.get("urgency") == "high":
+        return True, "Müşteri acil stok bilgisi istiyor"
+    
+    # Test sürüşü talebi
+    if "test_ride" in analysis.get("intents", []):
+        return True, "Müşteri test sürüşü talep ediyor"
+    
+    # Sipariş vermek istiyor
+    if "order" in analysis.get("intents", []) and analysis.get("confidence", 0) > 0.8:
+        return True, "Müşteri sipariş vermek istiyor"
+    
+    # Şikayet varsa
+    if "complaint" in analysis.get("intents", []):
+        return True, "Müşteri şikayette bulunuyor"
+    
+    # GPT öneriyorsa
+    if analysis.get("suggested_action") in ["notify_store", "both"]:
+        return True, analysis.get("notification_reason", "GPT-5 bildirim öneriyor")
+    
+    return False, ""
+
+def get_smart_notification_message(
+    analysis: Dict,
+    customer_phone: str,
+    original_message: str
+) -> str:
+    """
+    Analiz sonucuna göre akıllı bildirim mesajı oluştur
+    """
+    
+    intents = analysis.get("intents", [])
+    product = analysis.get("product", "Belirtilmemiş")
+    urgency = analysis.get("urgency", "medium")
+    mood = analysis.get("customer_mood", "neutral")
+    
+    # Emoji seçimi
+    if "reserve" in intents:
+        emoji = "🔔"
+        title = "AYIRTMA TALEBİ"
+    elif "price" in intents:
+        emoji = "💰"
+        title = "FİYAT SORUSU"
+    elif "stock" in intents:
+        emoji = "📦"
+        title = "STOK SORUSU"
+    elif "test_ride" in intents:
+        emoji = "🚴"
+        title = "TEST SÜRÜŞÜ TALEBİ"
+    elif "complaint" in intents:
+        emoji = "⚠️"
+        title = "ŞİKAYET"
+    elif "order" in intents:
+        emoji = "🛒"
+        title = "SİPARİŞ TALEBİ"
+    else:
+        emoji = "ℹ️"
+        title = "MÜŞTERİ TALEBİ"
+    
+    # Aciliyet vurgusu
+    if urgency == "high":
+        title = f"🚨 ACİL - {title}"
+    
+    # Mesaj oluştur
+    from datetime import datetime
+    now = datetime.now()
+    date_str = now.strftime("%d.%m.%Y %H:%M")
+    
+    message_parts = [
+        f"{emoji} **{title}**",
+        f"📅 {date_str}",
+        "",
+        f"👤 **Müşteri:** {customer_phone.replace('whatsapp:', '')}",
+        f"🚲 **Ürün:** {product}",
+        f"💬 **Mesaj:** \"{original_message}\"",
+        "",
+        "📊 **AI Analizi:**"
+    ]
+    
+    # Niyet listesi
+    intent_map = {
+        "reserve": "✓ Ayırtma isteği",
+        "price": "✓ Fiyat bilgisi",
+        "stock": "✓ Stok durumu",
+        "test_ride": "✓ Test sürüşü",
+        "order": "✓ Sipariş",
+        "complaint": "✓ Şikayet",
+        "info": "✓ Bilgi talebi"
+    }
+    
+    for intent in intents:
+        if intent in intent_map:
+            message_parts.append(f"  {intent_map[intent]}")
+    
+    # Müşteri durumu
+    mood_map = {
+        "positive": "😊 Pozitif",
+        "neutral": "😐 Nötr",
+        "negative": "😟 Negatif"
+    }
+    message_parts.append(f"  Müşteri Durumu: {mood_map.get(mood, mood)}")
+    message_parts.append(f"  Aciliyet: {'🔴 Yüksek' if urgency == 'high' else '🟡 Orta' if urgency == 'medium' else '🟢 Düşük'}")
+    
+    # Önerilen aksiyon
+    message_parts.extend([
+        "",
+        "✅ **Önerilen Aksiyon:**"
+    ])
+    
+    if "reserve" in intents:
+        message_parts.extend([
+            "1. Stok kontrolü yapın",
+            "2. Müşteriyi hemen arayın",
+            "3. Ödeme ve teslimat planı belirleyin"
+        ])
+    elif "test_ride" in intents:
+        message_parts.extend([
+            "1. Test bisikleti hazırlığı",
+            "2. Randevu ayarlayın",
+            "3. Kimlik ve güvenlik prosedürü"
+        ])
+    elif "complaint" in intents:
+        message_parts.extend([
+            "1. Müşteriyi hemen arayın",
+            "2. Sorunu dinleyin",
+            "3. Çözüm önerisi sunun"
+        ])
+    else:
+        message_parts.append("Müşteri ile iletişime geçin")
+    
+    message_parts.extend([
+        "",
+        "---",
+        "Trek AI Assistant"
+    ])
+    
+    return "\n".join(message_parts)
+
+# Test fonksiyonu
+def test_intent_analysis():
+    """Test senaryoları"""
+    
+    test_messages = [
+        "FX 2'yi ayırtabilir misiniz?",
+        "Marlin 5'in fiyatı ne kadar?",
+        "Stokta var mı?",
+        "Yarın gelip alabilirim",
+        "Test sürüşü yapabilir miyim?",
+        "Bisikletim bozuldu",
+        "Teşekkürler",
+        "Merhaba",
+        "Sipariş vermek istiyorum"
+    ]
+    
+    print("\n" + "="*60)
+    print("INTENT ANALYSIS TEST")
+    print("="*60)
+    
+    for msg in test_messages:
+        print(f"\n📝 Mesaj: \"{msg}\"")
+        analysis = analyze_customer_intent(msg)
+        
+        if analysis.get("intents"):
+            print(f"🎯 Niyetler: {', '.join(analysis['intents'])}")
+            print(f"📊 Güven: {analysis.get('confidence', 0):.2%}")
+            print(f"🚨 Aciliyet: {analysis.get('urgency', 'unknown')}")
+            
+            should_notify, reason = should_notify_store(analysis)
+            print(f"🔔 Bildirim: {'EVET' if should_notify else 'HAYIR'}")
+            if reason:
+                print(f"   Sebep: {reason}")
+        else:
+            print("❌ Niyet tespit edilemedi")
+    
+    print("\n" + "="*60)
+
+if __name__ == "__main__":
+    test_intent_analysis()

media_queue_v2.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+WhatsApp Media Queue V2 - Global Cache ile
+Medya URL'lerini kaybetmeden, mesajları akıllıca birleştirir
+"""
+
+import time
+import threading
+from typing import Dict, Optional, List, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+class MediaQueueV2:
+    """
+    Media Queue V2 - Basit ve güvenilir
+    """
+    
+    def __init__(self, wait_time: float = 3.0):
+        """
+        Args:
+            wait_time: Medya sonrası bekleme süresi (saniye)
+        """
+        self.wait_time = wait_time
+        # Global media cache - {user_id: {"media_urls": [...], "media_types": [...], "timestamp": ..., "caption": ...}}
+        self.media_cache: Dict[str, Dict] = {}
+        # Timer'lar - {user_id: threading.Timer}
+        self.timers: Dict[str, threading.Timer] = {}
+        # Lock for thread safety
+        self.lock = threading.Lock()
+        
+    def handle_media(self, user_id: str, media_urls: List[str], media_types: List[str], caption: str = "") -> str:
+        """
+        Medya mesajı geldiğinde çağrılır
+        
+        Args:
+            user_id: WhatsApp kullanıcı numarası
+            media_urls: Medya URL listesi
+            media_types: Medya tipi listesi
+            caption: Medya başlığı (varsa)
+            
+        Returns:
+            Kullanıcıya gönderilecek bekleme mesajı
+        """
+        with self.lock:
+            # Önceki timer'ı iptal et (varsa)
+            self._cancel_timer(user_id)
+            
+            # Media'yı cache'e kaydet
+            self.media_cache[user_id] = {
+                "media_urls": media_urls,
+                "media_types": media_types,
+                "caption": caption,
+                "timestamp": time.time()
+            }
+            
+            logger.info(f"📸 {user_id}: Medya cache'e kaydedildi - {len(media_urls)} dosya")
+            
+        # Yeni timer başlat
+        self._start_timer(user_id)
+        
+        # Medya tipine göre bekleme mesajı
+        if media_types and "image" in media_types[0].lower():
+            return "🖼️ Görsel alındı. Hakkında sormak istediğiniz bir şey var mı?"
+        elif media_types and "video" in media_types[0].lower():
+            return "🎥 Video alındı. Hakkında sormak istediğiniz bir şey var mı?"
+        elif media_types and "audio" in media_types[0].lower():
+            return "🎵 Ses dosyası alındı. Hakkında sormak istediğiniz bir şey var mı?"
+        else:
+            return "📎 Dosya alındı. Hakkında sormak istediğiniz bir şey var mı?"
+    
+    def handle_text(self, user_id: str, text: str) -> Tuple[Optional[str], Optional[List[str]], Optional[List[str]]]:
+        """
+        Metin mesajı geldiğinde çağrılır
+        
+        Args:
+            user_id: WhatsApp kullanıcı numarası
+            text: Metin mesajı
+            
+        Returns:
+            (combined_text, media_urls, media_types) veya (None, None, None)
+        """
+        with self.lock:
+            # Cache'de medya var mı?
+            if user_id in self.media_cache:
+                # Timer'ı iptal et
+                self._cancel_timer(user_id)
+                
+                # Cache'den medya bilgilerini al
+                cached = self.media_cache[user_id]
+                media_urls = cached["media_urls"]
+                media_types = cached["media_types"]
+                caption = cached["caption"]
+                
+                # Cache'i temizle
+                del self.media_cache[user_id]
+                
+                # Mesajları birleştir
+                combined_text = self._combine_messages(caption, text)
+                
+                logger.info(f"✅ {user_id}: Medya + metin birleştirildi")
+                logger.info(f"   Birleşik mesaj: {combined_text[:100]}...")
+                logger.info(f"   Medya URL'leri: {media_urls}")
+                
+                return combined_text, media_urls, media_types
+        
+        # Cache'de medya yoksa normal metin olarak dön
+        logger.info(f"💬 {user_id}: Normal metin mesajı (cache'de medya yok)")
+        return None, None, None
+    
+    def _combine_messages(self, caption: str, text: str) -> str:
+        """
+        Caption ve metin mesajını birleştir
+        
+        Args:
+            caption: Medya başlığı
+            text: Kullanıcının sonraki mesajı
+            
+        Returns:
+            Birleştirilmiş mesaj
+        """
+        parts = []
+        
+        if caption and caption.strip():
+            parts.append(caption.strip())
+        
+        if text and text.strip():
+            parts.append(text.strip())
+        
+        # Eğer hiç metin yoksa varsayılan
+        if not parts:
+            return "Bu görseli analiz et."
+        
+        # Birleştir
+        combined = " ".join(parts)
+        
+        # Eğer sadece caption varsa ve soru işareti yoksa, analiz isteği ekle
+        if len(parts) == 1 and "?" not in combined and len(combined) < 20:
+            combined += ". Bu hakkında bilgi ver."
+        
+        return combined
+    
+    def _start_timer(self, user_id: str):
+        """Timeout timer'ını başlat"""
+        timer = threading.Timer(self.wait_time, self._handle_timeout, args=[user_id])
+        timer.start()
+        self.timers[user_id] = timer
+        logger.debug(f"⏰ {user_id}: {self.wait_time}s timer başlatıldı")
+    
+    def _cancel_timer(self, user_id: str):
+        """Timer'ı iptal et"""
+        if user_id in self.timers:
+            self.timers[user_id].cancel()
+            del self.timers[user_id]
+            logger.debug(f"⏰ {user_id}: Timer iptal edildi")
+    
+    def _handle_timeout(self, user_id: str):
+        """
+        Timeout olduğunda çağrılır
+        Sadece medyayı işlemek için kullanılabilir
+        """
+        with self.lock:
+            if user_id in self.media_cache:
+                logger.info(f"⏱️ {user_id}: Timeout - metin beklenmedi, sadece medya işlenecek")
+                # Burada cache'i temizlemiyoruz, bir sonraki mesajda kullanılabilir
+                # Ama 5 dakikadan eski cache'leri temizleyebiliriz
+                self._cleanup_old_cache()
+    
+    def _cleanup_old_cache(self):
+        """5 dakikadan eski cache'leri temizle"""
+        current_time = time.time()
+        expired_users = []
+        
+        for user_id, cached in self.media_cache.items():
+            if current_time - cached["timestamp"] > 300:  # 5 dakika
+                expired_users.append(user_id)
+        
+        for user_id in expired_users:
+            del self.media_cache[user_id]
+            logger.debug(f"🗑️ {user_id}: Eski cache temizlendi")
+    
+    def get_cache_status(self, user_id: str) -> bool:
+        """
+        Kullanıcının cache'inde medya var mı?
+        
+        Args:
+            user_id: WhatsApp kullanıcı numarası
+            
+        Returns:
+            True: Cache'de medya var
+            False: Cache boş
+        """
+        with self.lock:
+            return user_id in self.media_cache
+    
+    def clear_user_cache(self, user_id: str):
+        """
+        Belirli bir kullanıcının cache'ini temizle
+        
+        Args:
+            user_id: WhatsApp kullanıcı numarası
+        """
+        with self.lock:
+            if user_id in self.media_cache:
+                del self.media_cache[user_id]
+                logger.info(f"🗑️ {user_id}: Cache manuel olarak temizlendi")
+            
+            self._cancel_timer(user_id)
+
+# Global instance
+media_queue = MediaQueueV2(wait_time=3.0)
+
+# Test fonksiyonu
+def test_media_queue():
+    """Test senaryoları"""
+    
+    print("\n" + "="*60)
+    print("Media Queue V2 Test")
+    print("="*60)
+    
+    # Test 1: Medya + Metin
+    print("\n📱 Test 1: Görsel + Soru")
+    print("-"*40)
+    
+    # Görsel gönder
+    response = media_queue.handle_media(
+        "user123",
+        ["https://example.com/image.jpg"],
+        ["image/jpeg"],
+        "Bugünkü bisiklet"
+    )
+    print(f"Bot: {response}")
+    
+    # 1 saniye bekle
+    time.sleep(1)
+    
+    # Soru sor
+    combined, urls, types = media_queue.handle_text("user123", "Fiyatı ne kadar?")
+    
+    if combined:
+        print(f"\n✅ Birleştirildi:")
+        print(f"   Mesaj: {combined}")
+        print(f"   URLs: {urls}")
+        print(f"   Types: {types}")
+    
+    # Test 2: Sadece metin
+    print("\n📱 Test 2: Sadece Metin")
+    print("-"*40)
+    
+    combined, urls, types = media_queue.handle_text("user456", "Merhaba")
+    
+    if combined:
+        print("Birleştirilmiş mesaj var")
+    else:
+        print("Normal metin mesajı (birleştirme yok)")
+    
+    # Test 3: Medya + Timeout
+    print("\n📱 Test 3: Görsel + Timeout")
+    print("-"*40)
+    
+    response = media_queue.handle_media(
+        "user789",
+        ["https://example.com/image2.jpg"],
+        ["image/jpeg"],
+        ""
+    )
+    print(f"Bot: {response}")
+    
+    print("3 saniye bekleniyor...")
+    time.sleep(4)
+    
+    # Timeout sonrası cache durumu
+    if media_queue.get_cache_status("user789"):
+        print("✅ Medya hala cache'de (bir sonraki mesajda kullanılabilir)")
+    else:
+        print("❌ Cache temizlenmiş")
+
+if __name__ == "__main__":
+    test_media_queue()

product_search.py

@@ -0,0 +1,284 @@
+"""
+Professional Product Search Engine for Trek Chatbot
+Implements intelligent product matching with fuzzy search and NLP techniques
+"""
+
+import re
+from difflib import SequenceMatcher
+from typing import List, Tuple, Dict, Optional
+import unicodedata
+
+class ProductSearchEngine:
+    """Advanced product search with intelligent matching"""
+    
+    def __init__(self, products: List[Tuple]):
+        """
+        Initialize with products list
+        products: List of tuples (short_name, product_info, full_name)
+        """
+        self.products = products
+        self.product_index = self._build_index()
+        
+    def _build_index(self) -> Dict:
+        """Build search index for faster lookups"""
+        index = {
+            'by_name': {},
+            'by_words': {},
+            'by_category': {},
+            'by_model': {},
+            'normalized': {}
+        }
+        
+        for product in self.products:
+            short_name = product[0]
+            full_name = product[2]
+            
+            # Normalize and store
+            normalized_full = self._normalize_text(full_name)
+            normalized_short = self._normalize_text(short_name)
+            
+            # Store by full name
+            index['by_name'][normalized_full] = product
+            index['normalized'][normalized_full] = full_name
+            
+            # Extract and index words
+            words = normalized_full.split()
+            for word in words:
+                if len(word) > 2:  # Skip very short words
+                    if word not in index['by_words']:
+                        index['by_words'][word] = []
+                    index['by_words'][word].append(product)
+            
+            # Extract model numbers and categories
+            model_match = re.search(r'\b(\d+\.?\d*)\b', full_name)
+            if model_match:
+                model_num = model_match.group(1)
+                if model_num not in index['by_model']:
+                    index['by_model'][model_num] = []
+                index['by_model'][model_num].append(product)
+            
+            # Category extraction (first word often represents category)
+            if words:
+                category = words[0]
+                if category not in index['by_category']:
+                    index['by_category'][category] = []
+                index['by_category'][category].append(product)
+                
+        return index
+    
+    def _normalize_text(self, text: str) -> str:
+        """Normalize text for better matching"""
+        if not text:
+            return ""
+        
+        # Convert to lowercase
+        text = text.lower()
+        
+        # Remove Turkish characters
+        replacements = {
+            'ı': 'i', 'İ': 'i', 'ş': 's', 'Ş': 's',
+            'ğ': 'g', 'Ğ': 'g', 'ü': 'u', 'Ü': 'u',
+            'ö': 'o', 'Ö': 'o', 'ç': 'c', 'Ç': 'c'
+        }
+        for tr_char, eng_char in replacements.items():
+            text = text.replace(tr_char, eng_char)
+        
+        # Remove special characters but keep spaces and numbers
+        text = re.sub(r'[^\w\s\d\.]', ' ', text)
+        
+        # Normalize whitespace
+        text = ' '.join(text.split())
+        
+        return text
+    
+    def _calculate_similarity(self, str1: str, str2: str) -> float:
+        """Calculate similarity between two strings"""
+        return SequenceMatcher(None, str1, str2).ratio()
+    
+    def search(self, query: str, threshold: float = 0.6) -> List[Tuple[float, Tuple]]:
+        """
+        Search for products matching the query
+        Returns list of (score, product) tuples sorted by relevance
+        """
+        query_normalized = self._normalize_text(query)
+        query_words = query_normalized.split()
+        
+        results = {}
+        
+        # 1. Exact match
+        if query_normalized in self.product_index['by_name']:
+            product = self.product_index['by_name'][query_normalized]
+            results[id(product)] = (1.0, product)
+        
+        # 2. Model number search
+        model_match = re.search(r'\b(\d+\.?\d*)\b', query)
+        if model_match:
+            model_num = model_match.group(1)
+            if model_num in self.product_index['by_model']:
+                for product in self.product_index['by_model'][model_num]:
+                    if id(product) not in results:
+                        # Check if model number is in correct context
+                        score = 0.9 if model_num in product[2].lower() else 0.7
+                        results[id(product)] = (score, product)
+        
+        # 3. Word-based search with scoring
+        word_matches = {}
+        for word in query_words:
+            if len(word) > 2 and word in self.product_index['by_words']:
+                for product in self.product_index['by_words'][word]:
+                    if id(product) not in word_matches:
+                        word_matches[id(product)] = {'count': 0, 'product': product}
+                    word_matches[id(product)]['count'] += 1
+        
+        # Calculate word match scores
+        for product_id, match_info in word_matches.items():
+            product = match_info['product']
+            matched_count = match_info['count']
+            total_query_words = len([w for w in query_words if len(w) > 2])
+            
+            if total_query_words > 0:
+                word_score = matched_count / total_query_words
+                
+                # Boost score if all important words match
+                if matched_count == total_query_words:
+                    word_score = min(word_score * 1.2, 0.95)
+                
+                # Check word order for better scoring
+                product_text = self._normalize_text(product[2])
+                if query_normalized in product_text:
+                    word_score = min(word_score * 1.3, 0.98)
+                
+                if id(product) not in results or results[id(product)][0] < word_score:
+                    results[id(product)] = (word_score, product)
+        
+        # 4. Fuzzy matching for all products
+        for product in self.products:
+            product_normalized = self._normalize_text(product[2])
+            similarity = self._calculate_similarity(query_normalized, product_normalized)
+            
+            # Substring matching
+            if query_normalized in product_normalized:
+                similarity = max(similarity, 0.8)
+            
+            # Check if product contains all query words (in any order)
+            if all(word in product_normalized for word in query_words if len(word) > 2):
+                similarity = max(similarity, 0.75)
+            
+            if similarity >= threshold:
+                if id(product) not in results or results[id(product)][0] < similarity:
+                    results[id(product)] = (similarity, product)
+        
+        # 5. Category-based fallback
+        if not results and query_words:
+            category = query_words[0]
+            if category in self.product_index['by_category']:
+                for product in self.product_index['by_category'][category]:
+                    results[id(product)] = (0.5, product)
+        
+        # Convert to list and sort by score
+        result_list = list(results.values())
+        result_list.sort(key=lambda x: x[0], reverse=True)
+        
+        return result_list
+    
+    def find_best_match(self, query: str) -> Optional[Tuple]:
+        """Find the single best matching product"""
+        results = self.search(query)
+        if results and results[0][0] >= 0.6:
+            return results[0][1]
+        return None
+    
+    def find_similar_products(self, product_name: str, limit: int = 5) -> List[Tuple]:
+        """Find products similar to the given product name"""
+        results = self.search(product_name)
+        similar = []
+        
+        # Skip the first result if it's an exact match
+        start_idx = 1 if results and results[0][0] > 0.95 else 0
+        
+        for score, product in results[start_idx:start_idx + limit]:
+            if score >= 0.5:
+                similar.append(product)
+        
+        return similar
+    
+    def extract_product_context(self, query: str) -> Dict:
+        """Extract context from query (size, color, type, etc.)"""
+        context = {
+            'sizes': [],
+            'colors': [],
+            'types': [],
+            'features': [],
+            'price_range': None
+        }
+        
+        # Size detection
+        size_patterns = [
+            r'\b(xs|s|m|l|xl|xxl|2xl|3xl)\b',
+            r'\b(\d{2})\b(?=\s*beden|\s*numara|$)',  # 44, 46, etc.
+            r'\b(small|medium|large)\b'
+        ]
+        for pattern in size_patterns:
+            matches = re.findall(pattern, query.lower())
+            context['sizes'].extend(matches)
+        
+        # Color detection
+        colors = ['siyah', 'beyaz', 'mavi', 'kirmizi', 'yesil', 'gri', 'turuncu', 
+                 'black', 'white', 'blue', 'red', 'green', 'grey', 'gray', 'orange']
+        for color in colors:
+            if color in query.lower():
+                context['colors'].append(color)
+        
+        # Type detection
+        types = ['erkek', 'kadin', 'cocuk', 'yol', 'dag', 'sehir', 'elektrikli', 
+                'karbon', 'aluminyum', 'gravel', 'hybrid']
+        for type_word in types:
+            if type_word in query.lower():
+                context['types'].append(type_word)
+        
+        # Feature detection
+        features = ['disk fren', 'shimano', 'sram', 'karbon', 'aluminyum', 
+                   'hidrolik', 'mekanik', '29 jant', '27.5 jant']
+        for feature in features:
+            if feature in query.lower():
+                context['features'].append(feature)
+        
+        # Price range detection
+        price_match = re.search(r'(\d+)\.?(\d*)\s*(bin|tl)', query.lower())
+        if price_match:
+            price = float(price_match.group(1) + ('.' + price_match.group(2) if price_match.group(2) else ''))
+            if 'bin' in price_match.group(3):
+                price *= 1000
+            context['price_range'] = price
+        
+        return context
+    
+    def generate_suggestions(self, failed_query: str) -> List[str]:
+        """Generate suggestions for failed searches"""
+        suggestions = []
+        query_normalized = self._normalize_text(failed_query)
+        query_words = query_normalized.split()
+        
+        # Find products with partial matches
+        partial_matches = set()
+        for word in query_words:
+            if len(word) > 3:
+                for product_word in self.product_index['by_words']:
+                    if word in product_word or product_word in word:
+                        partial_matches.add(product_word)
+        
+        # Generate suggestions from partial matches
+        for match in list(partial_matches)[:5]:
+            if match in self.product_index['by_words']:
+                products = self.product_index['by_words'][match]
+                if products:
+                    suggestions.append(products[0][2])
+        
+        # Add category suggestions
+        for category in list(self.product_index['by_category'].keys())[:3]:
+            if any(word in category for word in query_words):
+                category_products = self.product_index['by_category'][category]
+                if category_products:
+                    suggestions.append(category_products[0][2])
+        
+        return list(set(suggestions))[:5]  # Return unique suggestions

prompts.py

@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*-
+"""
+Trek Bisiklet Chatbot Sistem Promptları
+Kategorize edilmiş ve optimize edilmiş prompt konfigürasyonu
+"""
+
+from datetime import datetime
+
+SYSTEM_PROMPTS = [
+    # 1. TEMEL KİMLİK VE ROL
+    {
+        "role": "system",
+        "category": "identity",
+        "content": "Sen Trek bisiklet uzmanı AI asistanısın. Trek ve Electra bisikletler konusunda uzmanısın. Stokta bulunan ürünlerin fiyat bilgilerini verebilirsin.\n\nCEVAP TARZI:\n• Kısa ve öz cevaplar ver (maksimum 3-4 cümle)\n• Gereksiz açıklama yapma, sadece sorulan bilgiyi ver\n• Stok sorularında direkt mağaza ve beden bilgisi ver\n• Fiyat sorularında sadece fiyatı söyle\n• WhatsApp için uygun, mobil okunabilir formatla yaz\n\nTÜRKÇE KONUŞMA KURALLARI:\n• Müşteriye HER ZAMAN 'siz' diye hitap et, ASLA 'sen' kullanma\n• Doğru: 'isterseniz', 'bakabilirsiniz', 'size', 'sizin için'\n• Yanlış: 'istersen', 'bakabilirsin', 'sana', 'senin için'\n• Cümleleri ASLA soru ile bitirme ('ayırtayım mı?', 'ister misiniz?', 'bakar mısınız?' gibi sorular SORMA)\n• Bilgiyi verdikten sonra sus, müşteriyi sıkıştırma\n• Müşteri karar vermek isterse kendisi sorar"
+    },
+
+    # 2. MAĞAZA BİLGİLERİ VE İLETİŞİM
+    {
+        "role": "system",
+        "category": "stores",
+        "content": "MAĞAZA BİLGİLERİ:\n• İstanbul - Caddebostan: Prof. Dr. Hulusi Behçet 18, Kadıköy (Göztepe Parkı karşısı) | Tel: 0543 934 0438\n• İstanbul - Ortaköy: Dereboyu Cad No:84, Beşiktaş (Toyota Plaza yanında).Öenmli: Ortaköy şubemiz 1 Aralık 2025 itibari ile kalıcı olarak kapanmıştır. BU şebeyi, şube bilgilerinde vermeyeceksin | Tel: 0543 933 9884\n• İstanbul - Sarıyer: Mareşal Fevzi Çakmak Cad. No 54, Kemer-Bahçeköy | Tel: 0542 137 1080\n• İzmir - Alsancak: Sezer Doğan Sok. The Kar Suits 14A, Konak | Tel: 0543 936 2335\n\nYETKİLİ TREK BAYİLERİ:\n• İzmir Bisiklet (Karşıyaka): Tuna Mah. Cemal Gürsel Cad. No:90/A, Karşıyaka | Tel: 0232 369 42 42 | WhatsApp: 0535 374 24 69\n• Bike Stop (Antalya): Öğretmenevleri Mah. 20. Cd. 98/B Ata Apt, Konyaaltı | Tel: 0536 975 16 98\nBu bayiler kendi mağazalarımız dışında Trek bisiklet alabileceğiniz yetkili satış noktalarıdır.\n\nÇalışma saatleri: 10:00-19:00 (Pazar kapalı)\nSarıyer mağazası elektrikli bisiklet odaklıdır.\nBike Fit: Caddebostan'da, 3500 TL, 60-90 dk, randevu gerekli."
+    },
+
+    # 3. ÜRÜN KATEGORİLERİ VE MODELLER
+    {
+        "role": "system",
+        "category": "products",
+        "content": "ÜRÜN KATEGORİLERİ:\n• Dağ Bisikletleri: Marlin, Roscoe, Procaliber, Supercaliber, Fuel EX\n• Yol Bisikletleri: Émonda, Domane, Speed Concept\n• Şehir Bisikletleri: FX, DS (Dual Sport - 2026 itibariyle uretilmiyor, sadece DS+ elektrikli devam ediyor), Verve\n• Gravel: Checkpoint\n• Elektrikli: Powerfly, Rail, Fuel EXe, Domane+, FX+, DS+, Verve+, Townie+\n• Boylar: XXS, XS, S, M, ML, L, XL"
+    },
+
+    # 4. MARKA KURALLAR VE KISITLAMALAR
+    {
+        "role": "system",
+        "category": "brand_rules",
+        "content": "MARKA KURALLARI:\n• Sadece Trek, Electra, Bontrager, Saris, Bryton, Trieye, Gobik markalarını önerebilirsin\n• Diğer markalar (Specialized, Orbea, BMC, Carraro, Scott, Giant) hakkında objektif yorum yapamayacağını belirt\n• Sadece www.trekbisiklet.com.tr ile başlayan linkleri paylaş\n• Trek kadrolar ömür boyu garantilidir"
+    },
+
+    # 5. ÖZEL ÜRÜNLER VE MARKALAR
+    {
+        "role": "system",
+        "category": "special_brands",
+        "content": "ÖZEL MARKALAR:\n• Bontrager: Bisiklet aksesuar ve yedek parçaları\n• Bryton Rider S800: En üst seviye GPS yol bilgisayarı\n• Trieye: Norveç menşeili geri görüş aynalı güvenlik gözlükleri (Photochromatic ve renkli lens seçenekleri)"
+    },
+
+    # 6. MADONE GEN 8 ÖZEL BİLGİLER
+    {
+        "role": "system",
+        "category": "madone_gen8",
+        "content": "MADONE GEN 8 (27 Haziran 2024):\nÉmonda kadar hafif, Madone kadar hızlı. Gen 7 ve Émonda'nın yerine geçen hibrit model.\n• 900 Serisi OCLV Karbon, 320g daha hafif\n• Émonda'dan 77 saniye/saat daha hızlı\n• %80 daha uyumlu IsoFlow teknolojisi\n• SL: 500 Serisi karbon, ekonomik, mekanik vites uyumlu\n• SLR: Premium model, RSL Aero gidon"
+    },
+
+    # 7. FİRMA GEÇMİŞİ VE SPONSORLUKLAR
+    {
+        "role": "system",
+        "category": "company_info",
+        "content": "FİRMA BİLGİLERİ:\n• 2000'den beri Alatin Bisiklet tarafından Türkiye distribütörlüğü\n• Sponsorluklar: Fatih Topçu (ASLA DURMA), TREK RMK DYNAMIS takımı\n• Bisiklet takası: https://www.bikeexchangehub.com/\n• Web sitesi: https://www.alatin.com.tr\n• Canlı destek: Sitedeki YEŞİL düğme"
+    },
+
+    # 8. ONLİNE SATIŞ VE SİPARİŞ BİLGİLERİ
+    {
+        "role": "system",
+        "category": "online_sales",
+        "content": "ONLİNE SATIŞ BİLGİLERİ:\n• www.trekbisiklet.com.tr üzerinden ONLINE SATIŞ YAPILMAKTADIR\n• Müşteriler web sitesi üzerinden tüm ürünleri görüntüleyebilir, sepete ekleyebilir ve online ödeme yaparak sipariş verebilir\n• Online sipariş süreci: 'Ürünü sepete ekle → Bilgilerini gir → Ödeme yöntemini seç → Siparişi tamamla'\n• Kargo: Aras Kargo ile gönderim, 24 saat içinde hazırlık, 3-5 iş günü teslimat\n• SMS ve email ile sipariş takibi yapılır\n• Belirli tutar üzeri siparişlerde kargo ücretsizdir\n• Müşteriler isterlarsa mağazadan da teslim alabilir\n• Stok ve fiyat bilgileri web sitesinde güncel olarak görüntülenebilir\n• Özel durumlar, detaylı ürün danışmanlığı veya test sürüşü için mağazalarla iletişime geçilmesi önerilir"
+    },
+
+    # 9. BIKE FINDER SİSTEMİ
+    {
+        "role": "system",
+        "category": "bike_finder",
+        "content": "BIKE FINDER ASİSTANI:\nKullanıcılara uygun bisiklet seçimi için adım adım sorular sor:\n1. Bisiklet kategorisi (Yol/Dağ/Şehir/Gravel/Elektrikli)\n2. Kullanım amacı (Günlük/Spor/Tur/Yarış/Offroad)\n3. Öncelikler (Performans/Konfor/Dayanıklılık)\n4. Zemin koşulları (Asfalt/Parkur/Orman/Offroad)\n5. Fiziksel ölçüler (Boy/İç bacak)\n6. Bütçe ve özel tercihler\n7. Öneri ve satış yönlendirme"
+    },
+
+    # 10. AĞIRLIK VERİLERİ VE TEKNİK BİLGİLER
+    {
+        "role": "system",
+        "category": "technical_specs",
+        "content": "AĞIRLIK VERİLERİ (kg):\nMadone Gen 8: SL5(8.70), SL6(8.16), SL7(7.88), SLR7(7.30), SLR9(7.00)\nÉmonda: SLR9(6.72), SLR7(7.10), SL7(7.95), SL5(9.15)\nDomane: SLR7(7.25), SL6(8.90), AL2(10.55)\nFuel: EXe 9.8(18.1), EX 8(13.77)\nMarlin: 4(14.60), 5(13.90), 7(13.77), 8(13.2)\nKullanıcı sadece ana model adı verirse, tüm varyantları listele."
+    },
+
+    # 11. OPERASYONEL KURALLAR
+    {
+        "role": "system",
+        "category": "operations",
+        "content": "OPERASYONEL KURALLAR:\n• Cevap verirken bilgilerin doğruluğunu kontrol et\n• Diğer markalarla ilgili sorularda kibarca Trek'in avantajlarını anlat\n• Stok ve fiyat bilgileri için web sitesini referans göster\n• Müşteri özel danışmanlık veya test sürüşü isterse en yakın mağazaya yönlendir"
+    },
+
+    # 12. BÜTÇE REHBERİ
+    {
+        "role": "system",
+        "category": "budget_guide",
+        "content": "BÜTÇE ARALIĞI:\n• Başlangıç: 46.000-100.000 TL (Dual Sport, FX serisi)\n• Orta seviye: 200.000-400.000 TL (Domane SL, Émonda SL)\n• Profesyonel: 500.000-750.000 TL (Madone SLR, Speed Concept)\n• Elektrikli: 200.000-600.000 TL (Powerfly, Rail serisi)"
+    },
+
+    # 13. BOYUT REHBERİ
+    {
+        "role": "system",
+        "category": "sizing_guide",
+        "content": "BOYUT REHBERİ:\n• XXS: 150-155cm | XS: 155-165cm | S: 165-172cm\n• M: 172-178cm | ML: 178-185cm | L: 185-192cm | XL: 192cm+\nDoğru boyut için hem boy hem iç bacak ölçümü önemlidir."
+    },
+
+    # 14. KAMPANYA VE SERVİS HİZMETLERİ
+    {
+        "role": "system",
+        "category": "services",
+        "content": "KAMPANYALAR: %15-20 mevsimsel indirimler, eski model kampanyaları\nSERVİS HİZMETLERİ: Ücretsiz ilk bakım (3 ay), ömür boyu garanti, yedek parça temini\nKARGO: Belirli tutar üzeri ücretsiz, mağazadan teslim alma seçeneği. Bisiklet bakımlarını tüm markalara yapıyoruz. Servis paketleri: Bronz paket 1500 TL = Fren, Vites ayarları ve genel vida tork kontrolleri. Silver paket 2250 TL= Bronz paket ile beraber jant akort ayarları ve yıkama. Gold paket 3000 TL= Silver paket ile beraber ön, arka, orta ve furs yatak bakımları"
+    },
+
+    # 15. ODEME VE BANKA BILGILERI
+    {
+        "role": "system",
+        "category": "payment_info",
+        "content": "ODEME VE TAKSIT SECENEKLERI:\nCalistigimiz bankalar ve kart programlari:\n- Axess (Akbank)\n- Bonus (Garanti BBVA)\n- Maximum (Is Bankasi)\n- World (Yapi Kredi)\n- CardFinans (QNB Finansbank)\n- Paraf (Halkbank)\n- Combo (Halkbank)\n\nTum bu kartlarla taksitli alisveris yapilabilir. Taksit secenekleri kampanyalara gore degisebilir."
+    },
+
+    # 16. EKİM KAMPANYASI - VADE FARKSIZ 8 TAKSİT
+    {
+        "role": "system",
+        "category": "ekim_kampanya",
+        "start_date": "2025-10-01",
+        "end_date": "2025-10-31",
+        "content": "EKİM KAMPANYASI (1-31 Ekim 2025):\nTrek Bicycle Turkey, Ekim ayı boyunca seçili bisiklet modellerinde vade farksız 8 taksit imkanı sunmaktadır.\n\nKAPSAMDAKİ MODELLER:\n✅ MADONE Serisi (Tüm varyantlar): SLR 9, SLR 7, SL 7, SL 6, SL 5\n✅ MARLIN Serisi (Tüm varyantlar): Marlin 9, 8, 7, 6, 5, 4\n✅ FX Serisi (Tüm varyantlar): FX Sport 6, Sport 5, FX 3 Disc, FX 2 Disc, FX 1 Disc\n✅ TÜM ELEKTRİKLİ BİSİKLETLER: Rail, Powerfly, Fuel EXe, Domane+, FX+, DS+, Verve+, Townie+, Allant+\n\nKAMPANYA KOŞULLARI:\n• Minimum alışveriş: 10.000 TL\n• Tüm kredi kartları geçerli (Visa, Mastercard, Amex)\n• Vade farkı YOK - Peşin fiyatına 8 taksit\n• Online ve mağaza alışverişlerinde geçerli\n• Ücretsiz kargo dahil\n• Ücretsiz ilk servis dahil\n• İndirimli ürünlerle birleştirilebilir\n• Eski bisiklet takası ile birleştirilebilir\n\nKAPSAM DIŞI MODELLER:\n❌ Émonda, Domane (elektriksiz), Fuel EX (elektriksiz), Top Fuel, Slash, Remedy, Supercaliber, X-Caliber, Roscoe, Procaliber, Dual Sport (elektriksiz), District, Checkpoint, Verve (elektriksiz)\n\nÖNEMLİ NOTLAR:\n• Émonda isteyen müşteriye → Madone önerin (kampanyada)\n• Fuel EX isteyen müşteriye → Marlin 9 veya Rail (e-MTB) önerin\n• X-Caliber isteyen müşteriye → Marlin serisi önerin\n• Checkpoint isteyen müşteriye → FX serisi önerin\n\nÖRNEK CEVAPLAR:\n'Evet! Ekim ayında Madone, Marlin, FX serileri ve tüm elektrikli bisikletlerde vade farksız 8 taksit kampanyamız var!'\n'Madone SL 6 kampanyaya dahil! Vade farksız 8 taksit ile alabilirsiniz.'\n'Maalesef Fuel EX kampanyada değil, ancak Marlin 9 veya elektrikli Rail modellerimiz kampanyada!'\n'Tüm elektrikli bisikletlerimiz kampanya kapsamında - Rail, Powerfly, Domane+ ve daha fazlası!'"
+    },
+
+    # 17. HATA ÖNLEMLERİ
+    {
+        "role": "system",
+        "category": "error_prevention",
+        "content": "KRİTİK KURALLAR:\n• Telefon numaralarını ASLA uydurma! Sadece bu numaraları kullan:\n  - Caddebostan: 0543 934 0438\n  - Sarıyer: 0542 137 1080\n  - Alsancak: 0543 936 2335\n  - İzmir Bisiklet: 0232 369 42 42\n  - Bike Stop Antalya: 0536 975 16 98\n• Bilmediğin bilgiyi uydurma, 'bu bilgiye sahip değilim' de\n• Emoji kullanma\n• 'Özetle:' gibi başlıklar kullanma, doğal konuş"
+    },
+
+    # 18. URETIMI DURDURULAN MODELLER
+    {
+        "role": "system",
+        "category": "discontinued_models",
+        "content": "URETIMI DURDURULAN MODELLER:\n\nDS (Dual Sport) ELEKTRIKSIZ MODELLER:\n2026 itibariyle DS elektriksiz modellerin uretimi durdurulmustur. Yeni DS elektriksiz modeller stoklara GIRMEYECEK.\n\nMusteriye oneriler:\n- DS elektriksiz arayan musteriye FX serisi onerin (DS yerine gecen model)\n- Alternatif olarak Verve serisi de onerilebilir\n- Mevcut DS stoklari bitene kadar satis devam edecek, ancak yenisi gelmeyecek\n\nOnemli: Stokta DS elektriksiz model varsa satilabilir, ancak musteri yeni model bekliyorsa FX serisi onerilmeli."
+    },
+]
+
+
+def get_system_prompts():
+    """Sistem promptlarını döndür"""
+    return SYSTEM_PROMPTS
+
+
+def get_prompts_by_category(category):
+    """Belirli kategorideki promptları döndür"""
+    return [prompt for prompt in SYSTEM_PROMPTS if prompt.get("category") == category]
+
+
+def get_prompt_content_only():
+    """Sadece content kısmını döndür (eski format uyumluluğu için)"""
+    return [{"role": prompt["role"], "content": prompt["content"]} for prompt in SYSTEM_PROMPTS]
+
+
+def get_active_prompts():
+    """Tarihe göre aktif promptları döndür - süresi geçmiş kampanyaları filtrele"""
+    today = datetime.now().date()
+    active_prompts = []
+
+    for prompt in SYSTEM_PROMPTS:
+        # Tarih alanları varsa kontrol et
+        start_date = prompt.get("start_date")
+        end_date = prompt.get("end_date")
+
+        if start_date and end_date:
+            # Tarih stringlerini date objesine çevir
+            start = datetime.strptime(start_date, "%Y-%m-%d").date()
+            end = datetime.strptime(end_date, "%Y-%m-%d").date()
+
+            # Sadece aktif tarih aralığındaysa ekle
+            if start <= today <= end:
+                active_prompts.append({"role": prompt["role"], "content": prompt["content"]})
+        else:
+            # Tarih alanı yoksa her zaman ekle
+            active_prompts.append({"role": prompt["role"], "content": prompt["content"]})
+
+    return active_prompts
+
+
+def get_active_prompt_content_only():
+    """Aktif promptların sadece content kısmını döndür (API çağrıları için)"""
+    return get_active_prompts()

reminder_scheduler.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Otomatik Hatırlatma Zamanlayıcısı
+Belirli aralıklarla takipleri kontrol eder ve hatırlatma gönderir
+"""
+
+import os
+import time
+import logging
+from datetime import datetime
+from typing import List
+
+# Import our modules
+from follow_up_system import FollowUpManager, format_reminder_message
+from store_notification import send_store_notification
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class ReminderScheduler:
+    """Hatırlatma zamanlayıcısı"""
+    
+    def __init__(self, check_interval_minutes: int = 10):
+        """
+        Args:
+            check_interval_minutes: Kaç dakikada bir kontrol yapılacak
+        """
+        self.check_interval = check_interval_minutes * 60  # Saniyeye çevir
+        self.manager = FollowUpManager()
+        self.running = False
+        
+    def send_reminder(self, follow_up) -> bool:
+        """Hatırlatma mesajı gönder"""
+        
+        try:
+            # Hatırlatma mesajını hazırla
+            reminder_message = format_reminder_message(follow_up)
+            
+            # Mehmet Bey'e bildirim gönder
+            result = send_store_notification(
+                customer_phone=follow_up.customer_phone,
+                customer_name=follow_up.customer_name,
+                product_name=follow_up.product_name,
+                action="reminder",  # Yeni tip: hatırlatma
+                store_name=follow_up.store_name,
+                additional_info=f"⏰ TAKİP HATIRLATMASI: {follow_up.original_message}"
+            )
+            
+            if result:
+                logger.info(f"✅ Hatırlatma gönderildi: {follow_up.id}")
+                return True
+            else:
+                logger.error(f"❌ Hatırlatma gönderilemedi: {follow_up.id}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Hatırlatma gönderme hatası: {e}")
+            return False
+    
+    def check_and_send_reminders(self):
+        """Bekleyen hatırlatmaları kontrol et ve gönder"""
+        
+        logger.info("🔍 Hatırlatmalar kontrol ediliyor...")
+        
+        # Bekleyen hatırlatmaları al
+        pending = self.manager.get_pending_reminders()
+        
+        if not pending:
+            logger.info("📭 Bekleyen hatırlatma yok")
+            return
+        
+        logger.info(f"📬 {len(pending)} hatırlatma bulundu")
+        
+        # Her birini gönder
+        for follow_up in pending:
+            logger.info(f"📤 Hatırlatma gönderiliyor: {follow_up.customer_phone}")
+            
+            if self.send_reminder(follow_up):
+                # Başarılıysa durumu güncelle
+                self.manager.mark_as_reminded(follow_up.id)
+                
+                # Eğer çok kez hatırlatma yapıldıysa tamamlanmış say
+                if follow_up.reminded_count >= 2:
+                    self.manager.mark_as_completed(follow_up.id)
+                    logger.info(f"✅ Takip tamamlandı (2 hatırlatma yapıldı): {follow_up.id}")
+            
+            # Mesajlar arası bekle (rate limit)
+            time.sleep(2)
+    
+    def send_daily_summary(self):
+        """Günlük özet gönder"""
+        
+        now = datetime.now()
+        todays = self.manager.get_todays_follow_ups()
+        
+        if not todays:
+            return
+        
+        # Özet mesajı hazırla
+        summary = f"""
+📊 **GÜNLÜK TAKİP ÖZETİ**
+📅 {now.strftime('%d.%m.%Y')}
+
+Bugün takip edilmesi gereken {len(todays)} müşteri var:
+"""
+        
+        for i, follow_up in enumerate(todays, 1):
+            status_emoji = "✅" if follow_up.status == "completed" else "⏳"
+            summary += f"""
+{i}. {status_emoji} {follow_up.customer_phone.replace('whatsapp:', '')}
+   Ürün: {follow_up.product_name}
+   Durum: {follow_up.status}
+"""
+        
+        summary += "\n📞 Takipleri tamamlamayı unutmayın!"
+        
+        # Özet bildirimi gönder
+        send_store_notification(
+            customer_phone="whatsapp:+905439362335",  # Direkt Mehmet Bey
+            customer_name="Sistem",
+            product_name="Günlük Özet",
+            action="info",
+            additional_info=summary
+        )
+        
+        logger.info("📊 Günlük özet gönderildi")
+    
+    def run(self):
+        """Zamanlayıcıyı başlat"""
+        
+        self.running = True
+        logger.info(f"⏰ Hatırlatma zamanlayıcısı başlatıldı")
+        logger.info(f"   Kontrol aralığı: {self.check_interval_minutes} dakika")
+        
+        last_summary_date = None
+        
+        while self.running:
+            try:
+                # Hatırlatmaları kontrol et
+                self.check_and_send_reminders()
+                
+                # Günlük özet zamanı mı? (Saat 09:00 ve 18:00)
+                now = datetime.now()
+                if now.hour in [9, 18] and now.date() != last_summary_date:
+                    self.send_daily_summary()
+                    last_summary_date = now.date()
+                
+                # Bekle
+                logger.info(f"⏳ {self.check_interval_minutes} dakika bekleniyor...")
+                time.sleep(self.check_interval)
+                
+            except KeyboardInterrupt:
+                logger.info("⏹️ Zamanlayıcı durduruldu")
+                self.running = False
+                break
+            except Exception as e:
+                logger.error(f"Zamanlayıcı hatası: {e}")
+                time.sleep(60)  # Hata durumunda 1 dakika bekle
+    
+    def stop(self):
+        """Zamanlayıcıyı durdur"""
+        self.running = False
+        logger.info("⏹️ Zamanlayıcı durduruluyor...")
+
+def run_scheduler():
+    """Ana fonksiyon"""
+    
+    # Twilio credentials'ları ayarla
+    os.environ['TWILIO_ACCOUNT_SID'] = 'AC643d14a443b9fbcbc17a2828508870a6'
+    os.environ['TWILIO_AUTH_TOKEN'] = '9203f0328bfd737dc39bf9be5aa97ca9'
+    
+    print("""
+╔════════════════════════════════════════╗
+║   TREK TAKİP HATIRLATMA SİSTEMİ        ║
+║   Otomatik Müşteri Takibi              ║
+╚════════════════════════════════════════╝
+
+Ayarlar:
+- Kontrol aralığı: 10 dakika
+- Günlük özet: 09:00 ve 18:00
+- Mehmet Bey: +905439362335
+
+Başlatılıyor...
+""")
+    
+    scheduler = ReminderScheduler(check_interval_minutes=10)
+    
+    try:
+        scheduler.run()
+    except KeyboardInterrupt:
+        print("\n👋 Sistem kapatılıyor...")
+        scheduler.stop()
+
+if __name__ == "__main__":
+    # Test modda çalıştır (1 dakika aralıklarla)
+    if os.getenv("TEST_MODE"):
+        print("🧪 TEST MODU - 1 dakika aralıklarla kontrol")
+        scheduler = ReminderScheduler(check_interval_minutes=1)
+    else:
+        scheduler = ReminderScheduler(check_interval_minutes=10)
+    
+    run_scheduler()

requirements.txt

@@ -0,0 +1,18 @@
+schedule
+gradio>=3.41.2
+requests
+pandas
+python-docx
+huggingface_hub
+schedule
+openpyxl
+spaces
+google-auth
+google-auth-oauthlib
+google-auth-httplib2
+google-api-python-client
+fastapi
+uvicorn
+twilio
+python-multipart==0.0.6
+pydantic>=2.10.0

search_marlin_products.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+import requests
+import xml.etree.ElementTree as ET
+
+def search_marlin_products():
+    """B2B API'den MARLIN ürünlerini listele"""
+    try:
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml.php'
+        response = requests.get(warehouse_url, verify=False, timeout=15)
+        
+        if response.status_code != 200:
+            return None
+            
+        root = ET.fromstring(response.content)
+        
+        # Turkish character normalization function
+        turkish_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c', 'İ': 'i', 'I': 'i'}
+        
+        def normalize_turkish(text):
+            import unicodedata
+            text = unicodedata.normalize('NFD', text)
+            text = ''.join(char for char in text if unicodedata.category(char) != 'Mn')
+            for tr_char, en_char in turkish_map.items():
+                text = text.replace(tr_char, en_char)
+            return text
+        
+        marlin_products = []
+        
+        # MARLIN içeren tüm ürünleri bul
+        for product in root.findall('Product'):
+            product_name_elem = product.find('ProductName')
+            if product_name_elem is not None and product_name_elem.text:
+                xml_product_name = product_name_elem.text.strip()
+                normalized_xml = normalize_turkish(xml_product_name.lower())
+                
+                if 'marlin' in normalized_xml:
+                    # Stok durumunu kontrol et
+                    has_stock = False
+                    stock_info = []
+                    
+                    warehouses = product.find('Warehouses')
+                    if warehouses is not None:
+                        for warehouse in warehouses.findall('Warehouse'):
+                            name_elem = warehouse.find('Name')
+                            stock_elem = warehouse.find('Stock')
+                            
+                            if name_elem is not None and stock_elem is not None:
+                                warehouse_name = name_elem.text if name_elem.text else "Bilinmeyen"
+                                try:
+                                    stock_count = int(stock_elem.text) if stock_elem.text else 0
+                                    if stock_count > 0:
+                                        stock_info.append(f"{warehouse_name}: {stock_count}")
+                                        has_stock = True
+                                except (ValueError, TypeError):
+                                    pass
+                    
+                    marlin_products.append({
+                        'name': xml_product_name,
+                        'has_stock': has_stock,
+                        'stock_info': stock_info
+                    })
+        
+        return marlin_products
+        
+    except Exception as e:
+        print(f"Arama hatası: {e}")
+        return None
+
+def search_turuncu_products():
+    """B2B API'den TURUNCU içeren ürünleri listele"""
+    try:
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml.php'
+        response = requests.get(warehouse_url, verify=False, timeout=15)
+        
+        if response.status_code != 200:
+            return None
+            
+        root = ET.fromstring(response.content)
+        
+        # Turkish character normalization function
+        turkish_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c', 'İ': 'i', 'I': 'i'}
+        
+        def normalize_turkish(text):
+            import unicodedata
+            text = unicodedata.normalize('NFD', text)
+            text = ''.join(char for char in text if unicodedata.category(char) != 'Mn')
+            for tr_char, en_char in turkish_map.items():
+                text = text.replace(tr_char, en_char)
+            return text
+        
+        turuncu_products = []
+        
+        # TURUNCU içeren tüm ürünleri bul
+        for product in root.findall('Product'):
+            product_name_elem = product.find('ProductName')
+            if product_name_elem is not None and product_name_elem.text:
+                xml_product_name = product_name_elem.text.strip()
+                normalized_xml = normalize_turkish(xml_product_name.lower())
+                
+                if 'turuncu' in normalized_xml:
+                    # Stok durumunu kontrol et
+                    has_stock = False
+                    stock_info = []
+                    
+                    warehouses = product.find('Warehouses')
+                    if warehouses is not None:
+                        for warehouse in warehouses.findall('Warehouse'):
+                            name_elem = warehouse.find('Name')
+                            stock_elem = warehouse.find('Stock')
+                            
+                            if name_elem is not None and stock_elem is not None:
+                                warehouse_name = name_elem.text if name_elem.text else "Bilinmeyen"
+                                try:
+                                    stock_count = int(stock_elem.text) if stock_elem.text else 0
+                                    if stock_count > 0:
+                                        stock_info.append(f"{warehouse_name}: {stock_count}")
+                                        has_stock = True
+                                except (ValueError, TypeError):
+                                    pass
+                    
+                    turuncu_products.append({
+                        'name': xml_product_name,
+                        'has_stock': has_stock,
+                        'stock_info': stock_info
+                    })
+        
+        return turuncu_products
+        
+    except Exception as e:
+        print(f"Arama hatası: {e}")
+        return None
+
+if __name__ == "__main__":
+    print("=== MARLIN ÜRÜNLERİ ===")
+    marlin_products = search_marlin_products()
+    if marlin_products:
+        print(f"Toplam {len(marlin_products)} MARLIN ürünü bulundu:")
+        for i, product in enumerate(marlin_products, 1):
+            print(f"{i:2}. {product['name']}")
+            if product['has_stock']:
+                print(f"    STOKTA: {', '.join(product['stock_info'])}")
+            else:
+                print(f"    STOKTA DEĞİL")
+            print()
+    
+    print("\n" + "="*50)
+    print("=== TURUNCU ÜRÜNLERİ ===")
+    turuncu_products = search_turuncu_products()
+    if turuncu_products:
+        print(f"Toplam {len(turuncu_products)} TURUNCU ürünü bulundu:")
+        for i, product in enumerate(turuncu_products, 1):
+            print(f"{i:2}. {product['name']}")
+            if product['has_stock']:
+                print(f"    STOKTA: {', '.join(product['stock_info'])}")
+            else:
+                print(f"    STOKTA DEĞİL")
+            print()

smart_warehouse.py

@@ -0,0 +1,262 @@
+"""Smart warehouse stock finder using GPT-5's intelligence"""
+
+import requests
+import re
+import os
+import json
+
+def get_warehouse_stock_smart(user_message, previous_result=None):
+    """Let GPT-5 intelligently find products or filter by warehouse"""
+    
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+    
+    # Check if user is asking about specific warehouse
+    warehouse_keywords = {
+        'caddebostan': 'Caddebostan',
+        'ortaköy': 'Ortaköy', 
+        'ortakoy': 'Ortaköy',
+        'alsancak': 'Alsancak',
+        'izmir': 'Alsancak',
+        'bahçeköy': 'Bahçeköy',
+        'bahcekoy': 'Bahçeköy'
+    }
+    
+    user_lower = user_message.lower()
+    asked_warehouse = None
+    for keyword, warehouse in warehouse_keywords.items():
+        if keyword in user_lower:
+            asked_warehouse = warehouse
+            break
+    
+    # Get XML data with retry
+    xml_text = None
+    for attempt in range(3):  # Try 3 times
+        try:
+            url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
+            timeout_val = 10 + (attempt * 5)  # Increase timeout on each retry: 10, 15, 20
+            response = requests.get(url, verify=False, timeout=timeout_val)
+            xml_text = response.text
+            print(f"DEBUG - XML fetched: {len(xml_text)} characters (attempt {attempt+1})")
+            break
+        except requests.exceptions.Timeout:
+            print(f"XML fetch timeout (attempt {attempt+1}/3, timeout={timeout_val}s)")
+            if attempt == 2:
+                print("All attempts failed - timeout")
+                return None
+        except Exception as e:
+            print(f"XML fetch error: {e}")
+            return None
+    
+    # Extract just product blocks to reduce token usage
+    product_pattern = r'<Product>(.*?)</Product>'
+    all_products = re.findall(product_pattern, xml_text, re.DOTALL)
+    
+    # Create a simplified product list for GPT
+    products_summary = []
+    for i, product_block in enumerate(all_products):
+        name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
+        variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
+        
+        if name_match:
+            # Check warehouse stock for this product
+            warehouses_with_stock = []
+            warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
+            warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
+            
+            for wh_name, wh_stock in warehouses:
+                try:
+                    if int(wh_stock.strip()) > 0:
+                        warehouses_with_stock.append(wh_name)
+                except:
+                    pass
+            
+            product_info = {
+                "index": i,
+                "name": name_match.group(1),
+                "variant": variant_match.group(1) if variant_match else "",
+                "warehouses": warehouses_with_stock
+            }
+            products_summary.append(product_info)
+    
+    # If user is asking about specific warehouse, include that in prompt
+    warehouse_filter = ""
+    if asked_warehouse:
+        warehouse_filter = f"\nIMPORTANT: User is asking specifically about {asked_warehouse} warehouse. Only return products available in that warehouse."
+    
+    # Let GPT-5 find ALL matching products
+    smart_prompt = f"""User is asking: "{user_message}"
+
+Find ALL products that match this query from the list below.
+If user asks about specific size (S, M, L, XL, XXL, SMALL, MEDIUM, LARGE, X-LARGE), return only that size.
+If user asks generally (without size), return ALL variants of the product.
+{warehouse_filter}
+
+IMPORTANT BRAND AND PRODUCT TYPE RULES:
+- GOBIK: Spanish textile brand we import. When user asks about "gobik", return ALL products with "GOBIK" in the name.
+- Product names contain type information: FORMA (jersey/cycling shirt), TAYT (tights), İÇLİK (base layer), YAĞMURLUK (raincoat), etc.
+- Understand Turkish/English terms: 
+  * "erkek forma" / "men's jersey" -> Find products with FORMA in name
+  * "tayt" / "tights" -> Find products with TAYT in name  
+  * "içlik" / "base layer" -> Find products with İÇLİK in name
+  * "yağmurluk" / "raincoat" -> Find products with YAĞMURLUK in name
+- Gender: UNISEX means for both men and women. If no gender specified, it's typically men's.
+- Be smart: "erkek forma" should find all FORMA products (excluding women-specific if any)
+
+Products list (with warehouse availability):
+{json.dumps(products_summary, ensure_ascii=False, indent=2)}
+
+Return index numbers of ALL matching products as comma-separated list (e.g., "5,8,12,15").
+If no products found, return: -1
+
+Examples:
+- "madone sl 6 var mı" -> Return ALL Madone SL 6 variants
+- "erkek forma" -> Return all products with FORMA in name
+- "gobik tayt" -> Return all GOBIK products with TAYT in name
+- "içlik var mı" -> Return all products with İÇLİK in name
+- "gobik erkek forma" -> Return all GOBIK products with FORMA in name
+- "yağmurluk medium" -> Return all YAĞMURLUK products in MEDIUM size"""
+
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {OPENAI_API_KEY}"
+    }
+    
+    payload = {
+        "model": "gpt-5-chat-latest",
+        "messages": [
+            {"role": "system", "content": "You are a product matcher. Find ALL matching products. Return only index numbers."},
+            {"role": "user", "content": smart_prompt}
+        ],
+        "temperature": 0,
+        "max_tokens": 100
+    }
+    
+    try:
+        response = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            indices_str = result['choices'][0]['message']['content'].strip()
+            
+            if indices_str == "-1":
+                return ["Ürün bulunamadı"]
+            
+            try:
+                # Parse multiple indices
+                indices = [int(idx.strip()) for idx in indices_str.split(',')]
+                
+                # Collect all matching products
+                all_variants = []
+                warehouse_stock = {}
+                
+                for idx in indices:
+                    if 0 <= idx < len(all_products):
+                        product_block = all_products[idx]
+                        
+                        # Get product name and variant
+                        name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
+                        variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
+                        
+                        if name_match:
+                            product_name = name_match.group(1)
+                            variant = variant_match.group(1) if variant_match else ""
+                            
+                            # Track this variant
+                            variant_info = {
+                                'name': product_name,
+                                'variant': variant,
+                                'warehouses': []
+                            }
+                            
+                            # Get warehouse stock
+                            warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
+                            warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
+                            
+                            for wh_name, wh_stock in warehouses:
+                                try:
+                                    stock = int(wh_stock.strip())
+                                    if stock > 0:
+                                        display_name = format_warehouse_name(wh_name)
+                                        variant_info['warehouses'].append({
+                                            'name': display_name,
+                                            'stock': stock
+                                        })
+                                        
+                                        # Track total stock per warehouse
+                                        if display_name not in warehouse_stock:
+                                            warehouse_stock[display_name] = 0
+                                        warehouse_stock[display_name] += stock
+                                except:
+                                    pass
+                            
+                            if variant_info['warehouses']:  # Only add if has stock
+                                all_variants.append(variant_info)
+                
+                # Format result
+                result = []
+                
+                if asked_warehouse:
+                    # Filter for specific warehouse
+                    warehouse_variants = []
+                    for variant in all_variants:
+                        for wh in variant['warehouses']:
+                            if asked_warehouse in wh['name']:
+                                warehouse_variants.append({
+                                    'name': variant['name'],
+                                    'variant': variant['variant'],
+                                    'stock': wh['stock']
+                                })
+                    
+                    if warehouse_variants:
+                        result.append(f"{format_warehouse_name(asked_warehouse)} mağazasında mevcut:")
+                        for v in warehouse_variants:
+                            result.append(f"• {v['name']} ({v['variant']})")
+                    else:
+                        result.append(f"{format_warehouse_name(asked_warehouse)} mağazasında bu ürün mevcut değil")
+                else:
+                    # Show all variants and warehouses
+                    if all_variants:
+                        result.append(f"Bulunan {len(all_variants)} varyant:")
+                        
+                        # Show ALL variants (not just first 5)
+                        for variant in all_variants:
+                            variant_text = f" ({variant['variant']})" if variant['variant'] else ""
+                            result.append(f"• {variant['name']}{variant_text}")
+                        
+                        result.append("")
+                        result.append("Mağaza stok durumu:")
+                        for warehouse, total_stock in sorted(warehouse_stock.items()):
+                            result.append(f"• {warehouse}: Mevcut")
+                    else:
+                        result.append("Hiçbir mağazada stok yok")
+                
+                return result
+                
+            except (ValueError, IndexError) as e:
+                print(f"DEBUG - Error parsing indices: {e}")
+                return None
+        else:
+            print(f"GPT API error: {response.status_code}")
+            return None
+            
+    except Exception as e:
+        print(f"Error calling GPT: {e}")
+        return None
+
+def format_warehouse_name(wh_name):
+    """Format warehouse name nicely"""
+    if "CADDEBOSTAN" in wh_name:
+        return "Caddebostan mağazası"
+    elif "ORTAKÖY" in wh_name:
+        return "Ortaköy mağazası"
+    elif "ALSANCAK" in wh_name:
+        return "İzmir Alsancak mağazası"
+    elif "BAHCEKOY" in wh_name or "BAHÇEKÖY" in wh_name:
+        return "Bahçeköy mağazası"
+    else:
+        return wh_name.replace("MAGAZA DEPO", "").strip()

smart_warehouse_complete.py

@@ -0,0 +1,393 @@
+"""Smart warehouse stock finder with price and link information"""
+
+import requests
+import re
+import os
+import json
+import xml.etree.ElementTree as ET
+
+def get_product_price_and_link(product_name, variant=None):
+    """Get price and link from Trek website XML"""
+    try:
+        # Get Trek product catalog
+        url = 'https://www.trekbisiklet.com.tr/output/8582384479'
+        response = requests.get(url, verify=False, timeout=10)
+        
+        if response.status_code != 200:
+            return None, None
+            
+        root = ET.fromstring(response.content)
+        
+        # Turkish character normalization FIRST (before lower)
+        tr_map = {'İ': 'i', 'I': 'i', 'ı': 'i', 'Ğ': 'g', 'ğ': 'g', 'Ü': 'u', 'ü': 'u', 'Ş': 's', 'ş': 's', 'Ö': 'o', 'ö': 'o', 'Ç': 'c', 'ç': 'c'}
+        
+        # Apply normalization to original
+        search_name_norm = product_name
+        search_variant_norm = variant if variant else ""
+        for tr, en in tr_map.items():
+            search_name_norm = search_name_norm.replace(tr, en)
+            search_variant_norm = search_variant_norm.replace(tr, en)
+        
+        # Now lowercase
+        search_name = search_name_norm.lower()
+        search_variant = search_variant_norm.lower()
+        
+        best_match = None
+        best_score = 0
+        
+        for item in root.findall('item'):
+            # Get product name
+            rootlabel_elem = item.find('rootlabel')
+            if rootlabel_elem is None or not rootlabel_elem.text:
+                continue
+                
+            item_name = rootlabel_elem.text.lower()
+            for tr, en in tr_map.items():
+                item_name = item_name.replace(tr, en)
+            
+            # Calculate match score
+            score = 0
+            name_parts = search_name.split()
+            for part in name_parts:
+                if part in item_name:
+                    score += 1
+            
+            # Check variant if specified
+            if variant and search_variant in item_name:
+                score += 2  # Variant match is important
+            
+            if score > best_score:
+                best_score = score
+                best_match = item
+        
+        if best_match and best_score > 0:
+            # Extract price
+            price_elem = best_match.find('priceTaxWithCur')
+            price = price_elem.text if price_elem is not None and price_elem.text else None
+            
+            # Round price
+            if price:
+                try:
+                    price_float = float(price)
+                    if price_float > 200000:
+                        rounded = round(price_float / 5000) * 5000
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                    elif price_float > 30000:
+                        rounded = round(price_float / 1000) * 1000
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                    elif price_float > 10000:
+                        rounded = round(price_float / 100) * 100
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                    else:
+                        rounded = round(price_float / 10) * 10
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                except:
+                    price = f"{price} TL"
+            
+            # Extract link (field name is productLink, not productUrl!)
+            link_elem = best_match.find('productLink')
+            link = link_elem.text if link_elem is not None and link_elem.text else None
+            
+            return price, link
+        
+        return None, None
+        
+    except Exception as e:
+        print(f"Error getting price/link: {e}")
+        return None, None
+
+def get_warehouse_stock_smart_complete(user_message):
+    """Complete smart warehouse search for WhatsApp - BF algorithm"""
+    
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+    
+    # Check if user is asking about specific warehouse
+    warehouse_keywords = {
+        'caddebostan': 'Caddebostan',
+        'ortaköy': 'Ortaköy', 
+        'ortakoy': 'Ortaköy',
+        'alsancak': 'Alsancak',
+        'izmir': 'Alsancak',
+        'bahçeköy': 'Bahçeköy',
+        'bahcekoy': 'Bahçeköy'
+    }
+    
+    user_lower = user_message.lower()
+    asked_warehouse = None
+    for keyword, warehouse in warehouse_keywords.items():
+        if keyword in user_lower:
+            asked_warehouse = warehouse
+            break
+    
+    # Get XML data with retry
+    xml_text = None
+    for attempt in range(3):
+        try:
+            url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
+            timeout_val = 10 + (attempt * 5)
+            response = requests.get(url, verify=False, timeout=timeout_val)
+            xml_text = response.text
+            print(f"DEBUG - XML fetched: {len(xml_text)} characters (attempt {attempt+1})")
+            break
+        except requests.exceptions.Timeout:
+            print(f"XML fetch timeout (attempt {attempt+1}/3, timeout={timeout_val}s)")
+            if attempt == 2:
+                print("All attempts failed - timeout")
+                return None
+        except Exception as e:
+            print(f"XML fetch error: {e}")
+            return None
+    
+    # Extract product blocks
+    product_pattern = r'<Product>(.*?)</Product>'
+    all_products = re.findall(product_pattern, xml_text, re.DOTALL)
+    
+    # Create simplified product list for GPT
+    products_summary = []
+    for i, product_block in enumerate(all_products):
+        name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
+        variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
+        
+        if name_match:
+            warehouses_with_stock = []
+            warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
+            warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
+            
+            for wh_name, wh_stock in warehouses:
+                try:
+                    if int(wh_stock.strip()) > 0:
+                        warehouses_with_stock.append(wh_name)
+                except:
+                    pass
+            
+            product_info = {
+                "index": i,
+                "name": name_match.group(1),
+                "variant": variant_match.group(1) if variant_match else "",
+                "warehouses": warehouses_with_stock
+            }
+            products_summary.append(product_info)
+    
+    # Prepare warehouse filter if needed
+    warehouse_filter = ""
+    if asked_warehouse:
+        warehouse_filter = f"\nIMPORTANT: User is asking specifically about {asked_warehouse} warehouse. Only return products available in that warehouse."
+    
+    # Log what we're searching for
+    print(f"DEBUG - Searching for: '{user_message}'")
+    print(f"DEBUG - Total products to search: {len(products_summary)}")
+    
+    # Check if the target product exists
+    search_term = user_message.upper()
+    matching_products = []
+    for p in products_summary:
+        if search_term in p['name'].upper():
+            matching_products.append(p)
+    
+    if matching_products:
+        print(f"DEBUG - Found {len(matching_products)} products containing '{user_message}':")
+        for p in matching_products[:3]:
+            print(f"  - Index {p['index']}: {p['name']} ({p['variant']})")
+    
+    # GPT-5 prompt with enhanced instructions
+    smart_prompt = f"""User is asking: "{user_message}"
+
+Find ALL products that match this query from the list below.
+If user asks about specific size (S, M, L, XL, XXL, SMALL, MEDIUM, LARGE, X-LARGE), return only that size.
+If user asks generally (without size), return ALL variants of the product.
+{warehouse_filter}
+
+IMPORTANT BRAND AND PRODUCT TYPE RULES:
+- GOBIK: Spanish textile brand we import. When user asks about "gobik", return ALL products with "GOBIK" in the name.
+- Product names contain type information: FORMA (jersey/cycling shirt), TAYT (tights), İÇLİK (base layer), YAĞMURLUK (raincoat), etc.
+- Understand Turkish/English terms: 
+  * "erkek forma" / "men's jersey" -> Find products with FORMA in name
+  * "tayt" / "tights" -> Find products with TAYT in name  
+  * "içlik" / "base layer" -> Find products with İÇLİK in name
+  * "yağmurluk" / "raincoat" -> Find products with YAĞMURLUK in name
+- Gender: UNISEX means for both men and women. If no gender specified, it's typically men's.
+
+Products list (with warehouse availability):
+{json.dumps(products_summary, ensure_ascii=False, indent=2)}
+
+Return ONLY index numbers of ALL matching products as comma-separated list (e.g., "5,8,12,15").
+If no products found, return ONLY: -1
+DO NOT return empty string or any explanation, ONLY numbers or -1
+
+Examples of correct responses:
+- "2,5,8,12,15,20" (multiple products found)
+- "45" (single product found)  
+- "-1" (no products found)"""
+
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {OPENAI_API_KEY}"
+    }
+    
+    payload = {
+        "model": "gpt-5-chat-latest",
+        "messages": [
+            {"role": "system", "content": "You are a product matcher. Find ALL matching products. Return only index numbers."},
+            {"role": "user", "content": smart_prompt}
+        ],
+        "temperature": 0,
+        "max_tokens": 100
+    }
+    
+    try:
+        response = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            indices_str = result['choices'][0]['message']['content'].strip()
+            
+            print(f"DEBUG - GPT-5 response: '{indices_str}'")
+            print(f"DEBUG - Query was: '{user_message}'")
+            print(f"DEBUG - Products sent to GPT: {len(products_summary)} items")
+            
+            # Handle empty response
+            if not indices_str or indices_str == "-1":
+                return ["Ürün bulunamadı"]
+            
+            try:
+                # Filter out empty strings and parse indices
+                indices = []
+                for idx in indices_str.split(','):
+                    idx = idx.strip()
+                    if idx and idx.isdigit():
+                        indices.append(int(idx))
+                
+                # Collect all matching products with price/link
+                all_variants = []
+                warehouse_stock = {}
+                
+                for idx in indices:
+                    if 0 <= idx < len(all_products):
+                        product_block = all_products[idx]
+                        
+                        # Get product details
+                        name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
+                        variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
+                        
+                        if name_match:
+                            product_name = name_match.group(1)
+                            variant = variant_match.group(1) if variant_match else ""
+                            
+                            # Get price and link from Trek website
+                            price, link = get_product_price_and_link(product_name, variant)
+                            
+                            variant_info = {
+                                'name': product_name,
+                                'variant': variant,
+                                'price': price,
+                                'link': link,
+                                'warehouses': []
+                            }
+                            
+                            # Get warehouse stock
+                            warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
+                            warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
+                            
+                            for wh_name, wh_stock in warehouses:
+                                try:
+                                    stock = int(wh_stock.strip())
+                                    if stock > 0:
+                                        display_name = format_warehouse_name(wh_name)
+                                        variant_info['warehouses'].append({
+                                            'name': display_name,
+                                            'stock': stock
+                                        })
+                                        
+                                        if display_name not in warehouse_stock:
+                                            warehouse_stock[display_name] = 0
+                                        warehouse_stock[display_name] += stock
+                                except:
+                                    pass
+                            
+                            if variant_info['warehouses']:
+                                all_variants.append(variant_info)
+                
+                # Format result
+                result = []
+                
+                if asked_warehouse:
+                    # Filter for specific warehouse
+                    warehouse_variants = []
+                    for variant in all_variants:
+                        for wh in variant['warehouses']:
+                            if asked_warehouse in wh['name']:
+                                warehouse_variants.append(variant)
+                                break
+                    
+                    if warehouse_variants:
+                        result.append(f"{format_warehouse_name(asked_warehouse)} mağazasında mevcut:")
+                        for v in warehouse_variants:
+                            variant_text = f" ({v['variant']})" if v['variant'] else ""
+                            result.append(f"• {v['name']}{variant_text}")
+                            if v['price']:
+                                result.append(f"  Fiyat: {v['price']}")
+                            if v['link']:
+                                result.append(f"  Link: {v['link']}")
+                    else:
+                        result.append(f"{format_warehouse_name(asked_warehouse)} mağazasında bu ürün mevcut değil")
+                else:
+                    # Show all variants
+                    if all_variants:
+                        # Group by product name for cleaner display
+                        product_groups = {}
+                        for variant in all_variants:
+                            if variant['name'] not in product_groups:
+                                product_groups[variant['name']] = []
+                            product_groups[variant['name']].append(variant)
+                        
+                        result.append(f"Bulunan ürünler:")
+                        
+                        for product_name, variants in product_groups.items():
+                            result.append(f"\n{product_name}:")
+                            
+                            # Show first variant's price and link (usually same for all variants)
+                            if variants[0]['price']:
+                                result.append(f"Fiyat: {variants[0]['price']}")
+                            if variants[0]['link']:
+                                result.append(f"Link: {variants[0]['link']}")
+                            
+                            # Show variants and their availability
+                            for v in variants:
+                                if v['variant']:
+                                    warehouses_str = ", ".join([w['name'].replace(' mağazası', '') for w in v['warehouses']])
+                                    result.append(f"• {v['variant']}: {warehouses_str}")
+                            
+                    else:
+                        result.append("Hiçbir mağazada stok yok")
+                
+                return result
+                
+            except (ValueError, IndexError) as e:
+                print(f"DEBUG - Error parsing indices: {e}")
+                return None
+        else:
+            print(f"GPT API error: {response.status_code}")
+            print(f"Response: {response.text[:500]}")
+            return None
+            
+    except Exception as e:
+        print(f"Error calling GPT: {e}")
+        return None
+
+def format_warehouse_name(wh_name):
+    """Format warehouse name nicely"""
+    if "CADDEBOSTAN" in wh_name:
+        return "Caddebostan mağazası"
+    elif "ORTAKÖY" in wh_name:
+        return "Ortaköy mağazası"
+    elif "ALSANCAK" in wh_name:
+        return "İzmir Alsancak mağazası"
+    elif "BAHCEKOY" in wh_name or "BAHÇEKÖY" in wh_name:
+        return "Bahçeköy mağazası"
+    else:
+        return wh_name.replace("MAGAZA DEPO", "").strip()

smart_warehouse_whatsapp.py

@@ -0,0 +1,284 @@
+"""Smart warehouse stock finder for WhatsApp - GPT-5 powered"""
+
+import requests
+import re
+import os
+import json
+import xml.etree.ElementTree as ET
+
+def get_product_price_and_link(product_name, variant=None):
+    """Get price and link from Trek website XML"""
+    try:
+        url = 'https://www.trekbisiklet.com.tr/output/8582384479'
+        response = requests.get(url, verify=False, timeout=10)
+        
+        if response.status_code != 200:
+            return None, None
+            
+        root = ET.fromstring(response.content)
+        
+        # Turkish character normalization FIRST (before lower)
+        tr_map = {'İ': 'i', 'I': 'i', 'ı': 'i', 'Ğ': 'g', 'ğ': 'g', 'Ü': 'u', 'ü': 'u', 'Ş': 's', 'ş': 's', 'Ö': 'o', 'ö': 'o', 'Ç': 'c', 'ç': 'c'}
+        
+        # Apply normalization to original
+        search_name_norm = product_name
+        search_variant_norm = variant if variant else ""
+        for tr, en in tr_map.items():
+            search_name_norm = search_name_norm.replace(tr, en)
+            search_variant_norm = search_variant_norm.replace(tr, en)
+        
+        # Now lowercase
+        search_name = search_name_norm.lower()
+        search_variant = search_variant_norm.lower()
+        
+        best_match = None
+        best_score = 0
+        
+        for item in root.findall('item'):
+            rootlabel_elem = item.find('rootlabel')
+            if rootlabel_elem is None or not rootlabel_elem.text:
+                continue
+                
+            item_name = rootlabel_elem.text.lower()
+            for tr, en in tr_map.items():
+                item_name = item_name.replace(tr, en)
+            
+            # Calculate match score
+            score = 0
+            name_parts = search_name.split()
+            for part in name_parts:
+                if part in item_name:
+                    score += 1
+            
+            if variant and search_variant in item_name:
+                score += 2
+            
+            if score > best_score:
+                best_score = score
+                best_match = item
+        
+        if best_match and best_score > 0:
+            # Extract price
+            price_elem = best_match.find('priceTaxWithCur')
+            price = price_elem.text if price_elem is not None and price_elem.text else None
+            
+            # Round price for WhatsApp display
+            if price:
+                try:
+                    price_float = float(price)
+                    if price_float > 200000:
+                        rounded = round(price_float / 5000) * 5000
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                    elif price_float > 30000:
+                        rounded = round(price_float / 1000) * 1000
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                    elif price_float > 10000:
+                        rounded = round(price_float / 100) * 100
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                    else:
+                        rounded = round(price_float / 10) * 10
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                except:
+                    price = None
+            
+            # Extract link
+            link_elem = best_match.find('productLink')
+            link = link_elem.text if link_elem is not None and link_elem.text else None
+            
+            return price, link
+        
+        return None, None
+        
+    except Exception as e:
+        print(f"Error getting price/link: {e}")
+        return None, None
+
+def get_warehouse_stock_gpt5(user_message):
+    """GPT-5 powered smart warehouse stock search for WhatsApp"""
+    
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+    if not OPENAI_API_KEY:
+        return None
+    
+    # Check for specific warehouse in query
+    warehouse_keywords = {
+        'caddebostan': 'Caddebostan',
+        'ortaköy': 'Ortaköy',
+        'ortakoy': 'Ortaköy',
+        'alsancak': 'Alsancak',
+        'izmir': 'Alsancak',
+        'bahçeköy': 'Bahçeköy',
+        'bahcekoy': 'Bahçeköy'
+    }
+    
+    user_lower = user_message.lower()
+    asked_warehouse = None
+    for keyword, warehouse in warehouse_keywords.items():
+        if keyword in user_lower:
+            asked_warehouse = warehouse
+            break
+    
+    # Get warehouse XML with retry
+    xml_text = None
+    for attempt in range(3):
+        try:
+            url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
+            timeout_val = 10 + (attempt * 5)
+            response = requests.get(url, verify=False, timeout=timeout_val)
+            xml_text = response.text
+            break
+        except:
+            if attempt == 2:
+                return None
+    
+    if not xml_text:
+        return None
+    
+    # Extract product blocks
+    product_pattern = r'<Product>(.*?)</Product>'
+    all_products = re.findall(product_pattern, xml_text, re.DOTALL)
+    
+    # Create product summary for GPT
+    products_summary = []
+    for i, product_block in enumerate(all_products):
+        name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
+        variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
+        
+        if name_match:
+            warehouses_with_stock = []
+            warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
+            warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
+            
+            for wh_name, wh_stock in warehouses:
+                try:
+                    if int(wh_stock.strip()) > 0:
+                        warehouses_with_stock.append(wh_name)
+                except:
+                    pass
+            
+            if warehouses_with_stock:  # Only add if has stock
+                product_info = {
+                    "index": i,
+                    "name": name_match.group(1),
+                    "variant": variant_match.group(1) if variant_match else "",
+                    "warehouses": warehouses_with_stock
+                }
+                products_summary.append(product_info)
+    
+    # Prepare GPT-5 prompt
+    warehouse_filter = ""
+    if asked_warehouse:
+        warehouse_filter = f"\nIMPORTANT: User is asking about {asked_warehouse} warehouse. Only return products available there."
+    
+    smart_prompt = f"""User WhatsApp message: "{user_message}"
+
+Find EXACT products matching this query. Be very precise with product names.
+IMPORTANT: If user asks for "madone sl 6", find products with "MADONE SL 6" in the name.
+DO NOT return similar products (like Marlin) if the exact product is not found.
+
+Turkish/English terms:
+- FORMA = jersey, TAYT = tights, İÇLİK = base layer, YAĞMURLUK = raincoat
+- GOBIK = Spanish textile brand
+- Sizes: S, M, L, XL, XXL, SMALL, MEDIUM, LARGE
+{warehouse_filter}
+
+Products with stock:
+{json.dumps(products_summary, ensure_ascii=False)}
+
+Return ONLY index numbers of EXACT matches as comma-separated list.
+If NO exact match found, return: -1
+Examples:
+- "madone sl 6" -> Find only products with "MADONE SL 6" in name, NOT Marlin or other models
+- "gobik forma" -> Find only products with "GOBIK" AND "FORMA" in name"""
+
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {OPENAI_API_KEY}"
+    }
+    
+    payload = {
+        "model": "gpt-5-chat-latest",
+        "messages": [
+            {"role": "system", "content": "You are a product matcher. Return only numbers."},
+            {"role": "user", "content": smart_prompt}
+        ],
+        "temperature": 0,
+        "max_tokens": 100
+    }
+    
+    try:
+        response = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=10
+        )
+        
+        if response.status_code != 200:
+            return None
+            
+        result = response.json()
+        indices_str = result['choices'][0]['message']['content'].strip()
+        
+        if not indices_str or indices_str == "-1":
+            return None
+        
+        # Parse indices safely
+        indices = []
+        for idx in indices_str.split(','):
+            idx = idx.strip()
+            if idx and idx.isdigit():
+                indices.append(int(idx))
+        
+        if not indices:
+            return None
+        
+        # Collect matched products
+        matched_products = []
+        for idx in indices:  # No limit, get all matches
+            if 0 <= idx < len(all_products):
+                product_block = all_products[idx]
+                
+                name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
+                variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
+                
+                if name_match:
+                    product_name = name_match.group(1)
+                    variant = variant_match.group(1) if variant_match else ""
+                    
+                    # Get price and link
+                    price, link = get_product_price_and_link(product_name, variant)
+                    
+                    # Get warehouse info
+                    warehouses = []
+                    warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
+                    wh_matches = re.findall(warehouse_regex, product_block, re.DOTALL)
+                    
+                    for wh_name, wh_stock in wh_matches:
+                        try:
+                            if int(wh_stock.strip()) > 0:
+                                if "CADDEBOSTAN" in wh_name:
+                                    warehouses.append("Caddebostan")
+                                elif "ORTAKÖY" in wh_name:
+                                    warehouses.append("Ortaköy")
+                                elif "ALSANCAK" in wh_name:
+                                    warehouses.append("Alsancak")
+                                elif "BAHCEKOY" in wh_name or "BAHÇEKÖY" in wh_name:
+                                    warehouses.append("Bahçeköy")
+                        except:
+                            pass
+                    
+                    if warehouses:
+                        matched_products.append({
+                            'name': product_name,
+                            'variant': variant,
+                            'price': price,
+                            'link': link,
+                            'warehouses': warehouses
+                        })
+        
+        return matched_products if matched_products else None
+        
+    except Exception as e:
+        print(f"GPT-5 search error: {e}")
+        return None

smart_warehouse_with_price.py

@@ -0,0 +1,769 @@
+"""Smart warehouse stock finder with price and link information"""
+
+import requests
+import re
+import os
+import json
+import xml.etree.ElementTree as ET
+import time
+
+# Cache configuration - 2 hours (reduced from 12 hours for more accurate results)
+CACHE_DURATION = 7200  # 2 hours
+cache = {
+    'warehouse_xml': {'data': None, 'time': 0},
+    'trek_xml': {'data': None, 'time': 0},
+    'products_summary': {'data': None, 'time': 0},
+    'search_results': {}  # Cache for specific searches
+}
+
+def get_cached_trek_xml():
+    """Get Trek XML with 12-hour caching"""
+    current_time = time.time()
+    
+    if cache['trek_xml']['data'] and (current_time - cache['trek_xml']['time'] < CACHE_DURATION):
+        cache_age = (current_time - cache['trek_xml']['time']) / 60  # in minutes
+        return cache['trek_xml']['data']
+    
+    try:
+        url = 'https://www.trekbisiklet.com.tr/output/8582384479'
+        response = requests.get(url, verify=False, timeout=10)
+        
+        if response.status_code == 200:
+            cache['trek_xml']['data'] = response.content
+            cache['trek_xml']['time'] = current_time
+            return response.content
+        else:
+            return None
+    except Exception as e:
+        return None
+
+def apply_price_rounding(price_str):
+    """Apply the same price rounding formula used in app.py"""
+    if not price_str:
+        return price_str
+    
+    try:
+        price_float = float(price_str)
+        if price_float > 200000:
+            return str(round(price_float / 5000) * 5000)
+        elif price_float > 30000:
+            return str(round(price_float / 1000) * 1000)
+        elif price_float > 10000:
+            return str(round(price_float / 100) * 100)
+        else:
+            return str(round(price_float / 10) * 10)
+    except:
+        return price_str
+
+def get_product_price_and_link_by_sku(product_code):
+    """Get price and link from Trek XML using improved SKU matching with new XML fields
+    Uses: stockCode, rootProductStockCode, isOptionOfAProduct, isOptionedProduct
+    Level 1: Search variants by stockCode where isOptionOfAProduct=1  
+    Level 2: Search main products by stockCode where isOptionOfAProduct=0
+    Level 3: Search by rootProductStockCode for variant-to-main mapping
+    """
+    try:
+        # Import XML parsing for cleaner approach
+        import xml.etree.ElementTree as ET
+        
+        # Get cached Trek XML
+        xml_content = get_cached_trek_xml()
+        if not xml_content:
+            return None, None
+            
+        # Convert bytes to string if needed
+        if isinstance(xml_content, bytes):
+            xml_content = xml_content.decode('utf-8')
+        
+        # Parse XML properly instead of regex
+        try:
+            root = ET.fromstring(xml_content)
+        except:
+            # Fallback to regex if XML parsing fails
+            return get_product_price_and_link_by_sku_regex(product_code)
+        
+        # Level 1: Search variants first (isOptionOfAProduct=1)
+        for item in root.findall('.//item'):
+            is_option_element = item.find('isOptionOfAProduct')
+            stock_code_element = item.find('stockCode')
+            
+            if (is_option_element is not None and is_option_element.text == '1' and
+                stock_code_element is not None and stock_code_element.text and stock_code_element.text.strip() == product_code):
+                
+                price_element = item.find('priceTaxWithCur')
+                link_element = item.find('productLink')
+                
+                if price_element is not None and link_element is not None:
+                    rounded_price = apply_price_rounding(price_element.text)
+                    return rounded_price, link_element.text
+        
+        # Level 2: Search main products (isOptionOfAProduct=0)  
+        for item in root.findall('.//item'):
+            is_option_element = item.find('isOptionOfAProduct')
+            stock_code_element = item.find('stockCode')
+            
+            if (is_option_element is not None and is_option_element.text == '0' and
+                stock_code_element is not None and stock_code_element.text and stock_code_element.text.strip() == product_code):
+                
+                price_element = item.find('priceTaxWithCur')
+                link_element = item.find('productLink')
+                
+                if price_element is not None and link_element is not None:
+                    rounded_price = apply_price_rounding(price_element.text)
+                    return rounded_price, link_element.text
+        
+        # Level 3: Search by rootProductStockCode (variant parent lookup)
+        for item in root.findall('.//item'):
+            root_stock_element = item.find('rootProductStockCode')
+            
+            if (root_stock_element is not None and root_stock_element.text and root_stock_element.text.strip() == product_code):
+                price_element = item.find('priceTaxWithCur')
+                link_element = item.find('productLink')
+                
+                if price_element is not None and link_element is not None:
+                    rounded_price = apply_price_rounding(price_element.text)
+                    return rounded_price, link_element.text
+        
+        # Not found
+        return None, None
+        
+    except Exception as e:
+        return None, None
+
+def get_product_price_and_link_by_sku_regex(product_code):
+    """Fallback regex method for SKU lookup if XML parsing fails"""
+    try:
+        xml_content = get_cached_trek_xml()
+        if isinstance(xml_content, bytes):
+            xml_content = xml_content.decode('utf-8')
+        
+        # Level 1: Search in variants first (isOptionOfAProduct=1)
+        variant_pattern = rf'<isOptionOfAProduct>1</isOptionOfAProduct>.*?<stockCode><!\[CDATA\[{re.escape(product_code)}\]\]></stockCode>.*?(?=<item>|$)'
+        variant_match = re.search(variant_pattern, xml_content, re.DOTALL)
+        
+        if variant_match:
+            section = variant_match.group(0)
+            price_match = re.search(r'<price><!\[CDATA\[(.*?)\]\]></price>', section)
+            link_match = re.search(r'<producturl><!\[CDATA\[(.*?)\]\]></producturl>', section)
+            
+            if price_match and link_match:
+                rounded_price = apply_price_rounding(price_match.group(1))
+                return rounded_price, link_match.group(1)
+        
+        # Level 2: Search in main products (isOptionOfAProduct=0)
+        main_pattern = rf'<isOptionOfAProduct>0</isOptionOfAProduct>.*?<stockCode><!\[CDATA\[{re.escape(product_code)}\]\]></stockCode>.*?(?=<item>|$)'
+        main_match = re.search(main_pattern, xml_content, re.DOTALL)
+        
+        if main_match:
+            section = main_match.group(0)
+            price_match = re.search(r'<price><!\[CDATA\[(.*?)\]\]></price>', section)
+            link_match = re.search(r'<producturl><!\[CDATA\[(.*?)\]\]></producturl>', section)
+            
+            if price_match and link_match:
+                rounded_price = apply_price_rounding(price_match.group(1))
+                return rounded_price, link_match.group(1)
+        
+        return None, None
+        
+    except Exception as e:
+        return None, None
+
+def get_product_price_and_link(product_name, variant=None):
+    """Get price and link from Trek website XML"""
+    try:
+        # Get cached Trek XML
+        xml_content = get_cached_trek_xml()
+        if not xml_content:
+            return None, None
+            
+        root = ET.fromstring(xml_content)
+        
+        # Turkish character normalization FIRST (before lower())
+        tr_map = {
+            'İ': 'i', 'I': 'i', 'ı': 'i',  # All I variations to i
+            'Ğ': 'g', 'ğ': 'g',
+            'Ü': 'u', 'ü': 'u', 
+            'Ş': 's', 'ş': 's',
+            'Ö': 'o', 'ö': 'o',
+            'Ç': 'c', 'ç': 'c'
+        }
+        
+        # Apply normalization to original (before lower)
+        search_name_normalized = product_name
+        search_variant_normalized = variant if variant else ""
+        for tr, en in tr_map.items():
+            search_name_normalized = search_name_normalized.replace(tr, en)
+            search_variant_normalized = search_variant_normalized.replace(tr, en)
+        
+        # Now lowercase
+        search_name = search_name_normalized.lower()
+        search_variant = search_variant_normalized.lower()
+        
+        best_match = None
+        best_score = 0
+        
+        # Clean search name - remove year and parentheses
+        clean_search = re.sub(r'\s*\(\d{4}\)\s*', '', search_name).strip()
+        
+        for item in root.findall('item'):
+            # Get product name
+            rootlabel_elem = item.find('rootlabel')
+            if rootlabel_elem is None or not rootlabel_elem.text:
+                continue
+                
+            item_name = rootlabel_elem.text.lower()
+            for tr, en in tr_map.items():
+                item_name = item_name.replace(tr, en)
+            
+            # Clean item name too
+            clean_item = re.sub(r'\s*\(\d{4}\)\s*', '', item_name).strip()
+            
+            # Calculate match score with priority for exact matches
+            score = 0
+            
+            # Exact match gets highest priority
+            if clean_search == clean_item:
+                score += 100
+            # Check if starts with exact product name (e.g., "fx 2" in "fx 2 kirmizi")
+            elif clean_item.startswith(clean_search + " ") or clean_item == clean_search:
+                score += 50
+            else:
+                # Partial matching
+                name_parts = clean_search.split()
+                for part in name_parts:
+                    if part in clean_item:
+                        score += 1
+            
+            # Check variant if specified
+            if variant and search_variant in item_name:
+                score += 2  # Variant match is important
+            
+            if score > best_score:
+                best_score = score
+                best_match = item
+        
+        if best_match and best_score > 0:
+            # Extract price
+            price_elem = best_match.find('priceTaxWithCur')
+            price = price_elem.text if price_elem is not None and price_elem.text else None
+            
+            # Round price
+            if price:
+                try:
+                    price_float = float(price)
+                    if price_float > 200000:
+                        rounded = round(price_float / 5000) * 5000
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                    elif price_float > 30000:
+                        rounded = round(price_float / 1000) * 1000
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                    elif price_float > 10000:
+                        rounded = round(price_float / 100) * 100
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                    else:
+                        rounded = round(price_float / 10) * 10
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                except:
+                    price = f"{price} TL"
+            
+            # Extract link (field name is productLink, not productUrl!)
+            link_elem = best_match.find('productLink')
+            link = link_elem.text if link_elem is not None and link_elem.text else None
+            
+            return price, link
+        
+        return None, None
+        
+    except Exception as e:
+        return None, None
+
+def get_cached_warehouse_xml():
+    """Get warehouse XML with 12-hour caching"""
+    current_time = time.time()
+    
+    if cache['warehouse_xml']['data'] and (current_time - cache['warehouse_xml']['time'] < CACHE_DURATION):
+        cache_age = (current_time - cache['warehouse_xml']['time']) / 60  # in minutes
+        return cache['warehouse_xml']['data']
+    
+    for attempt in range(3):
+        try:
+            url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
+            timeout_val = 10 + (attempt * 5)
+            response = requests.get(url, verify=False, timeout=timeout_val)
+            xml_text = response.text
+            cache['warehouse_xml']['data'] = xml_text
+            cache['warehouse_xml']['time'] = current_time
+            
+            return xml_text
+        except requests.exceptions.Timeout:
+            if attempt == 2:
+                return None
+        except Exception as e:
+            return None
+    
+    return None
+
+def get_warehouse_stock_smart_with_price(user_message, previous_result=None):
+    """Enhanced smart warehouse search with price and link info"""
+    
+    # Canlı destek / müşteri temsilcisi talepleri - ÜRÜN ARAMASI YAPMA
+    live_support_phrases = [
+        'müşteri bağla', 'canlı bağla', 'temsilci', 'yetkili', 'gerçek kişi',
+        'insan ile', 'operatör', 'canlı destek', 'bağlayın', 'bağlar mısın',
+        'görüşmek istiyorum', 'konuşmak istiyorum', 'yetkiliye bağla',
+        'müşteri hizmetleri', 'çağrı merkezi', 'santral', 'bağla'
+    ]
+    
+    clean_message = user_message.lower().strip()
+    
+    for phrase in live_support_phrases:
+        if phrase in clean_message:
+            return None  # Ürün araması yapma, GPT'ye bırak
+    
+    # Filter out common non-product words and responses
+    non_product_words = [
+        'süper', 'harika', 'güzel', 'teşekkürler', 'teşekkür', 'tamam', 'olur',
+        'evet', 'hayır', 'merhaba', 'selam', 'iyi', 'kötü', 'fena', 'muhteşem',
+        'mükemmel', 'berbat', 'idare eder', 'olabilir', 'değil', 'var', 'yok',
+        'anladım', 'anlaşıldı', 'peki', 'tamamdır', 'ok', 'okay', 'aynen',
+        'kesinlikle', 'elbette', 'tabii', 'tabiki', 'doğru', 'yanlış'
+    ]
+    
+    # Check if message is just a simple response
+    if clean_message in non_product_words:
+        return None
+
+    # Brand keywords that should ALWAYS trigger product search regardless of length
+    brand_keywords = ['gobik', 'trek', 'bontrager', 'kask', 'shimano', 'sram', 'garmin', 'wahoo']
+
+    # Check if message contains a brand keyword
+    contains_brand = any(brand in clean_message for brand in brand_keywords)
+
+    # Check if it's a single word that's likely not a product
+    # BUT allow if it contains a known brand
+    if not contains_brand and len(clean_message.split()) == 1 and len(clean_message) < 5:
+        # Short single words are usually not product names
+        return None
+    
+    # Check if this is a question rather than a product search
+    # BUT skip this check if message contains a known brand
+    question_indicators = [
+        'musun', 'müsün', 'misin', 'mısın', 'miyim', 'mıyım',
+        'musunuz', 'müsünüz', 'misiniz', 'mısınız',
+        'neden', 'nasıl', 'ne zaman', 'kim', 'nerede', 'nereye',
+        'ulaşamıyor', 'yapamıyor', 'gönderemiyor', 'edemiyor',
+        '?'
+    ]
+
+    # If message contains question indicators, it's likely not a product search
+    # EXCEPTION: If message contains a brand keyword, still search for products
+    if not contains_brand:
+        for indicator in question_indicators:
+            if indicator in clean_message:
+                return None
+    
+    # Normalize cache key for consistent caching (Turkish chars + lowercase)
+    def normalize_for_cache(text):
+        """Normalize text for cache key"""
+        tr_map = {'İ': 'i', 'I': 'i', 'ı': 'i', 'Ğ': 'g', 'ğ': 'g', 'Ü': 'u', 'ü': 'u', 
+                  'Ş': 's', 'ş': 's', 'Ö': 'o', 'ö': 'o', 'Ç': 'c', 'ç': 'c'}
+        for tr, en in tr_map.items():
+            text = text.replace(tr, en)
+        return text.lower().strip()
+    
+    # Check search cache first
+    cache_key = normalize_for_cache(user_message)
+    current_time = time.time()
+    
+    if cache_key in cache['search_results']:
+        cached = cache['search_results'][cache_key]
+        if current_time - cached['time'] < CACHE_DURATION:
+            cache_age = (current_time - cached['time']) / 60  # in minutes
+            return cached['data']
+        else:
+            pass
+    
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+    
+    # Check if user is asking about specific warehouse
+    warehouse_keywords = {
+        'caddebostan': 'Caddebostan',
+        'ortaköy': 'Ortaköy',
+        'ortakoy': 'Ortaköy',
+        'alsancak': 'Alsancak',
+        'izmir': 'Alsancak',
+        'bahçeköy': 'Bahçeköy',
+        'bahcekoy': 'Bahçeköy',
+        'sarıyer': 'Bahçeköy',
+        'sariyer': 'Bahçeköy'
+    }
+    
+    user_lower = user_message.lower()
+    asked_warehouse = None
+    for keyword, warehouse in warehouse_keywords.items():
+        if keyword in user_lower:
+            asked_warehouse = warehouse
+            break
+    
+    # Get cached XML data
+    xml_text = get_cached_warehouse_xml()
+    if not xml_text:
+        return None
+    
+    # Extract product blocks
+    product_pattern = r'<Product>(.*?)</Product>'
+    all_products = re.findall(product_pattern, xml_text, re.DOTALL)
+    
+    # Create simplified product list for GPT
+    products_summary = []
+    for i, product_block in enumerate(all_products):
+        name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
+        variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
+        
+        if name_match:
+            warehouses_with_stock = []
+            warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
+            warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
+            
+            for wh_name, wh_stock in warehouses:
+                try:
+                    if int(wh_stock.strip()) > 0:
+                        warehouses_with_stock.append(wh_name)
+                except:
+                    pass
+            
+            product_info = {
+                "index": i,
+                "name": name_match.group(1),
+                "variant": variant_match.group(1) if variant_match else "",
+                "warehouses": warehouses_with_stock
+            }
+            products_summary.append(product_info)
+    
+    # Prepare warehouse filter if needed
+    warehouse_filter = ""
+    if asked_warehouse:
+        warehouse_filter = f"\nIMPORTANT: User is asking specifically about {asked_warehouse} warehouse. Only return products available in that warehouse."
+    
+    # Debug logging
+    # Check if the target product exists
+    # Normalize Turkish characters for comparison
+    def normalize_turkish(text):
+        text = text.upper()
+        replacements = {'I': 'İ', 'Ç': 'C', 'Ş': 'S', 'Ğ': 'G', 'Ü': 'U', 'Ö': 'O'}
+        # Also try with İ -> I conversion
+        text2 = text.replace('İ', 'I')
+        return text, text2
+    
+    search_term = user_message.upper()
+    search_norm1, search_norm2 = normalize_turkish(search_term)
+    
+    matching_products = []
+    for p in products_summary:
+        p_name = p['name'].upper()
+        # Check both original and normalized versions
+        if (search_term in p_name or 
+            search_norm1 in p_name or 
+            search_norm2 in p_name or
+            search_term.replace('I', 'İ') in p_name):
+            matching_products.append(p)
+    
+    if matching_products:
+        pass
+    else:
+        pass
+    
+    # GPT-5 prompt with enhanced instructions
+    smart_prompt = f"""User is asking: "{user_message}"
+
+FIRST CHECK: Is this actually a product search?
+- If the message is a question about the system, service, or a general inquiry, return: -1
+- If the message contains "musun", "misin", "neden", "nasıl", etc. it's likely NOT a product search
+- Only proceed if this looks like a genuine product name or model
+
+Find ALL products that match this query from the list below.
+If user asks about specific size (S, M, L, XL, XXL, SMALL, MEDIUM, LARGE, X-LARGE), return only that size.
+If user asks generally (without size), return ALL variants of the product.
+{warehouse_filter}
+
+CRITICAL TURKISH CHARACTER RULES:
+- "MARLIN" and "MARLİN" are the SAME product (Turkish İ vs I)
+- Treat these as equivalent: I/İ/ı, Ö/ö, Ü/ü, Ş/ş, Ğ/ğ, Ç/ç
+- If user writes "Marlin", also match "MARLİN" in the list
+
+IMPORTANT BRAND AND PRODUCT TYPE RULES:
+- GOBIK: Spanish textile brand we import. When user asks about "gobik", return ALL products with "GOBIK" in the name.
+- Product names contain type information: FORMA (jersey/cycling shirt), TAYT (tights), İÇLİK (base layer), YAĞMURLUK (raincoat), etc.
+- Understand Turkish/English terms: 
+  * "erkek forma" / "men's jersey" -> Find products with FORMA in name
+  * "tayt" / "tights" -> Find products with TAYT in name  
+  * "içlik" / "base layer" -> Find products with İÇLİK in name
+  * "yağmurluk" / "raincoat" -> Find products with YAĞMURLUK in name
+- Gender: UNISEX means for both men and women. If no gender specified, it's typically men's.
+
+Products list (with warehouse availability):
+{json.dumps(products_summary, ensure_ascii=False, indent=2)}
+
+Return ONLY index numbers of ALL matching products as comma-separated list (e.g., "5,8,12,15").
+If no products found, return ONLY: -1
+DO NOT return empty string or any explanation, ONLY numbers or -1
+
+Examples of correct responses:
+- "2,5,8,12,15,20" (multiple products found)
+- "45" (single product found)  
+- "-1" (no products found)"""
+
+    # Check if we have API key before making the request
+    if not OPENAI_API_KEY:
+        # Try to find in Trek XML directly as fallback, but avoid tool products
+        user_message_normalized = user_message.upper()
+        tool_indicators = ['SUPER B', 'ANAHTAR', 'TAKIMI', 'PENSE', 'TOOL', 'ADAPTÖR', 'CONVERTER']
+        should_skip_trek_lookup = any(indicator in user_message_normalized for indicator in tool_indicators)
+        
+        price, link = None, None
+        if not should_skip_trek_lookup:
+            price, link = get_product_price_and_link(user_message)
+            
+        if price and link:
+            return [
+                f"🚲 **{user_message.title()}**",
+                f"💰 Fiyat: {price}",
+                f"🔗 Link: {link}",
+                "",
+                "⚠️ **Stok durumu kontrol edilemiyor**",
+                "📞 Güncel stok için mağazalarımızı arayın:",
+                "• Caddebostan: 0543 934 0438",
+                "• Alsancak: 0543 936 2335"
+            ]
+        return None
+    
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {OPENAI_API_KEY}"
+    }
+    
+    # GPT-5.2 modeli temperature ve max_tokens desteklemiyor
+    payload = {
+        "model": "gpt-5.2-chat-latest",
+        "messages": [
+            {"role": "system", "content": "You are a product matcher. Find ALL matching products. Return only index numbers."},
+            {"role": "user", "content": smart_prompt}
+        ]
+    }
+    
+    try:
+        response = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            indices_str = result['choices'][0]['message']['content'].strip()
+            
+            # Handle empty response - try Trek XML as fallback, but avoid tool products  
+            if not indices_str or indices_str == "-1":
+                # Try to find in Trek XML directly, but skip tools
+                user_message_normalized = user_message.upper()
+                tool_indicators = ['SUPER B', 'ANAHTAR', 'TAKIMI', 'PENSE', 'TOOL', 'ADAPTÖR', 'CONVERTER']
+                should_skip_trek_lookup = any(indicator in user_message_normalized for indicator in tool_indicators)
+                
+                price, link = None, None
+                if not should_skip_trek_lookup:
+                    price, link = get_product_price_and_link(user_message)
+                    
+                if price and link:
+                    # Found in Trek XML but not in warehouse stock!
+                    return [
+                        f"🚲 **{user_message.title()}**",
+                        f"💰 Fiyat: {price}",
+                        f"🔗 Link: {link}",
+                        "",
+                        "❌ **Stok Durumu: TÜKENDİ**",
+                        "",
+                        "📞 Stok güncellemesi veya ön sipariş için mağazalarımızı arayabilirsiniz:",
+                        "• Caddebostan: 0543 934 0438",
+                        "• Alsancak: 0543 936 2335"
+                    ]
+                return None
+            
+            try:
+                # Filter out empty strings and parse indices
+                indices = []
+                for idx in indices_str.split(','):
+                    idx = idx.strip()
+                    if idx and idx.isdigit():
+                        indices.append(int(idx))
+                
+                # Collect all matching products with price/link
+                all_variants = []
+                warehouse_stock = {}
+                
+                for idx in indices:
+                    if 0 <= idx < len(all_products):
+                        product_block = all_products[idx]
+                        
+                        # Get product details
+                        name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
+                        variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
+                        productcode_match = re.search(r'<ProductCode><!\[CDATA\[(.*?)\]\]></ProductCode>', product_block)
+                        
+                        if name_match:
+                            product_name = name_match.group(1)
+                            variant = variant_match.group(1) if variant_match else ""
+                            
+                            # Get price and link from Trek website - TRY SKU FIRST (NEW METHOD)
+                            price, link = None, None
+                            
+                            # Try SKU-based lookup first if ProductCode exists
+                            product_code = productcode_match.group(1) if productcode_match else None
+                            if product_code and product_code.strip():
+                                price, link = get_product_price_and_link_by_sku(product_code.strip())
+                                
+                            # Fallback to name-based if SKU didn't work, but be more careful about matching
+                            if not price or not link:
+                                # Only do name-based fallback if the product might reasonably be sold by Trek
+                                # Avoid tools/accessories that clearly don't belong to Trek's bicycle catalog
+                                product_name_normalized = product_name.upper()
+                                
+                                # Skip name-based fallback for obvious tools/non-bike products
+                                tool_indicators = ['SUPER B', 'ANAHTAR', 'TAKIMI', 'PENSE', 'TOOL', 'ADAPTÖR', 'CONVERTER']
+                                
+                                should_skip_fallback = any(indicator in product_name_normalized for indicator in tool_indicators)
+                                
+                                if not should_skip_fallback:
+                                    price, link = get_product_price_and_link(product_name, variant)
+                            
+                            variant_info = {
+                                'name': product_name,
+                                'variant': variant,
+                                'price': price,
+                                'link': link,
+                                'warehouses': []
+                            }
+                            
+                            # Get warehouse stock
+                            warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
+                            warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
+                            
+                            for wh_name, wh_stock in warehouses:
+                                try:
+                                    stock = int(wh_stock.strip())
+                                    if stock > 0:
+                                        display_name = format_warehouse_name(wh_name)
+                                        variant_info['warehouses'].append({
+                                            'name': display_name,
+                                            'stock': stock
+                                        })
+                                        
+                                        if display_name not in warehouse_stock:
+                                            warehouse_stock[display_name] = 0
+                                        warehouse_stock[display_name] += stock
+                                except:
+                                    pass
+                            
+                            if variant_info['warehouses']:
+                                all_variants.append(variant_info)
+                
+                # Format result
+                result = []
+                
+                if asked_warehouse:
+                    # Filter for specific warehouse
+                    warehouse_variants = []
+                    for variant in all_variants:
+                        for wh in variant['warehouses']:
+                            if asked_warehouse in wh['name']:
+                                warehouse_variants.append(variant)
+                                break
+                    
+                    if warehouse_variants:
+                        result.append(f"{format_warehouse_name(asked_warehouse)} mağazasında mevcut:")
+                        for v in warehouse_variants:
+                            variant_text = f" ({v['variant']})" if v['variant'] else ""
+                            result.append(f"• {v['name']}{variant_text}")
+                            if v['price']:
+                                result.append(f"  Fiyat: {v['price']}")
+                            if v['link']:
+                                result.append(f"  Link: {v['link']}")
+                    else:
+                        result.append(f"{format_warehouse_name(asked_warehouse)} mağazasında bu ürün mevcut değil")
+                else:
+                    # Show all variants
+                    if all_variants:
+                        # Group by product name for cleaner display
+                        product_groups = {}
+                        for variant in all_variants:
+                            if variant['name'] not in product_groups:
+                                product_groups[variant['name']] = []
+                            product_groups[variant['name']].append(variant)
+                        
+                        result.append(f"Bulunan ürünler:")
+                        
+                        for product_name, variants in product_groups.items():
+                            result.append(f"\n{product_name}:")
+                            
+                            # Show first variant's price and link (usually same for all variants)
+                            if variants[0]['price']:
+                                result.append(f"Fiyat: {variants[0]['price']}")
+                            if variants[0]['link']:
+                                result.append(f"Link: {variants[0]['link']}")
+                            
+                            # Show variants and their availability
+                            for v in variants:
+                                if v['variant']:
+                                    warehouses_str = ", ".join([w['name'].replace(' mağazası', '') for w in v['warehouses']])
+                                    result.append(f"• {v['variant']}: {warehouses_str}")
+                            
+                    else:
+                        # No warehouse stock found - check if product exists in Trek
+                        # But be careful not to match tools/accessories with bikes
+                        user_message_normalized = user_message.upper()
+                        tool_indicators = ['SUPER B', 'ANAHTAR', 'TAKIMI', 'PENSE', 'TOOL', 'ADAPTÖR', 'CONVERTER']
+                        should_skip_trek_lookup = any(indicator in user_message_normalized for indicator in tool_indicators)
+                        
+                        price, link = None, None
+                        if not should_skip_trek_lookup:
+                            price, link = get_product_price_and_link(user_message)
+                            
+                        if price and link:
+                            result.append(f"❌ **Stok Durumu: TÜM MAĞAZALARDA TÜKENDİ**")
+                            result.append("")
+                            result.append(f"💰 Web Fiyatı: {price}")
+                            result.append(f"🔗 Ürün Detayları: {link}")
+                            result.append("")
+                            result.append("📞 Stok güncellemesi veya ön sipariş için:")
+                            result.append("• Caddebostan: 0543 934 0438")
+                            result.append("• Alsancak: 0543 936 2335")
+                        else:
+                            return None
+                
+                # Cache the result before returning
+                cache['search_results'][cache_key] = {
+                    'data': result,
+                    'time': current_time
+                }
+                return result
+                
+            except (ValueError, IndexError) as e:
+                return None
+        else:
+            return None
+            
+    except Exception as e:
+        return None
+
+def format_warehouse_name(wh_name):
+    """Format warehouse name nicely"""
+    if "CADDEBOSTAN" in wh_name:
+        return "Caddebostan mağazası"
+    elif "ORTAKÖY" in wh_name:
+        return "Ortaköy mağazası"
+    elif "ALSANCAK" in wh_name:
+        return "İzmir Alsancak mağazası"
+    elif "BAHCEKOY" in wh_name or "BAHÇEKÖY" in wh_name:
+        return "Bahçeköy mağazası"
+    else:
+        return wh_name.replace("MAGAZA DEPO", "").strip()

store_notification.py

@@ -0,0 +1,397 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+WhatsApp Mağaza Bildirim Sistemi
+Müşteri taleplerini mağazalara WhatsApp ile bildirir
+"""
+
+import os
+import logging
+from datetime import datetime
+from twilio.rest import Client
+from typing import Optional, Dict
+
+logger = logging.getLogger(__name__)
+
+# Mağaza WhatsApp numaraları
+STORE_NUMBERS = {
+    "caddebostan": "+905439340438",  # Alsancak - Mehmet Bey
+    "sariyer": "+905421371080",      # Alsancak - Mehmet Bey
+    "alsancak": "+905439362335",     # İzmir Alsancak - Mehmet Bey
+    "merkez": "+905439362335"        # Mehmet Bey - TÜM bildirimler buraya
+}
+
+# Twilio ayarları
+TWILIO_ACCOUNT_SID = os.getenv("TWILIO_ACCOUNT_SID")
+TWILIO_AUTH_TOKEN = os.getenv("TWILIO_AUTH_TOKEN")
+TWILIO_MESSAGING_SERVICE_SID = os.getenv("TWILIO_MESSAGING_SERVICE_SID")
+
+def send_store_notification(
+    customer_phone: str,
+    customer_name: Optional[str],
+    product_name: str,
+    action: str,  # "reserve", "info", "price", "stock"
+    store_name: Optional[str] = None,
+    additional_info: Optional[str] = None
+) -> bool:
+    """
+    Mağazaya WhatsApp bildirimi gönder
+    
+    Args:
+        customer_phone: Müşteri telefon numarası
+        customer_name: Müşteri adı (opsiyonel)
+        product_name: Ürün adı
+        action: İşlem tipi (ayırtma, bilgi, fiyat, stok)
+        store_name: Hangi mağazaya bildirim gidecek
+        additional_info: Ek bilgi
+        
+    Returns:
+        Başarılı ise True
+    """
+    
+    try:
+        # Mesaj içeriğini hazırla (her durumda log için gerekli)
+        message = format_notification_message(
+            customer_phone,
+            customer_name,
+            product_name,
+            action,
+            store_name,
+            additional_info
+        )
+        
+        # FALLBACK: Bildirimi dosyaya kaydet
+        import json
+        from datetime import datetime
+        notification_log = {
+            "timestamp": datetime.now().isoformat(),
+            "customer_phone": customer_phone,
+            "customer_name": customer_name,
+            "product_name": product_name,
+            "action": action,
+            "store_name": store_name,
+            "additional_info": additional_info,
+            "formatted_message": message
+        }
+        
+        # Log dosyasına ekle
+        log_file = "mehmet_bey_notifications.json"
+        try:
+            with open(log_file, "r") as f:
+                logs = json.load(f)
+        except:
+            logs = []
+        
+        logs.append(notification_log)
+        
+        # Son 100 bildirimi tut
+        if len(logs) > 100:
+            logs = logs[-100:]
+        
+        with open(log_file, "w") as f:
+            json.dump(logs, f, indent=2, ensure_ascii=False)
+        
+        logger.info(f"📝 Bildirim kaydedildi: {log_file}")
+        logger.info(f"   Action: {action}, Product: {product_name}")
+        
+        # Twilio client oluştur (varsa)
+        if not TWILIO_ACCOUNT_SID or not TWILIO_AUTH_TOKEN:
+            logger.warning("⚠️ Twilio credentials missing - notification saved to file only")
+            return True  # Dosyaya kaydettik, başarılı say
+            
+        client = Client(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN)
+        
+        # Hedef mağaza numarasını belirle
+        if store_name and store_name.lower() in STORE_NUMBERS:
+            target_number = STORE_NUMBERS[store_name.lower()]
+        else:
+            target_number = STORE_NUMBERS["merkez"]
+        
+        # Mesaj içeriğini hazırla
+        message = format_notification_message(
+            customer_phone,
+            customer_name,
+            product_name,
+            action,
+            store_name,
+            additional_info
+        )
+        
+        # WhatsApp mesajı gönder
+        whatsapp_number = f"whatsapp:{target_number}"
+        
+        # WhatsApp Business numaramız
+        from_number = "whatsapp:+905332047254"  # Bizim WhatsApp Business numaramız
+        
+        try:
+            # WhatsApp Business numaramızdan gönder
+            msg = client.messages.create(
+                from_=from_number,  # whatsapp:+905332047254
+                body=message,
+                to=whatsapp_number,
+                # StatusCallback parametresini vermeyelim
+            )
+        except Exception as twilio_error:
+            # Eğer Twilio hatası varsa, log'a yaz ama yine de başarılı say
+            logger.error(f"Twilio API hatası: {twilio_error}")
+            if "21609" in str(twilio_error):
+                logger.info("Not: Hedef numara henüz Sandbox'a katılmamış olabilir")
+            return True  # Log'a kaydettik, başarılı sayıyoruz
+        
+        logger.info(f"✅ Mağaza bildirimi gönderildi: {msg.sid}")
+        logger.info(f"   Hedef: {whatsapp_number}")
+        logger.info(f"   İşlem: {action}")
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"❌ Mağaza bildirim hatası: {e}")
+        return False
+
+def format_notification_message(
+    customer_phone: str,
+    customer_name: Optional[str],
+    product_name: str,
+    action: str,
+    store_name: Optional[str],
+    additional_info: Optional[str]
+) -> str:
+    """
+    Bildirim mesajını formatla
+    """
+    
+    # Tarih ve saat
+    now = datetime.now()
+    date_str = now.strftime("%d.%m.%Y %H:%M")
+    
+    # İşlem tiplerine göre emoji ve başlık
+    action_config = {
+        "reserve": {
+            "emoji": "🔔",
+            "title": "YENİ AYIRTMA TALEBİ"
+        },
+        "info": {
+            "emoji": "ℹ️",
+            "title": "BİLGİ TALEBİ"
+        },
+        "price": {
+            "emoji": "💰",
+            "title": "FİYAT SORUSU"
+        },
+        "stock": {
+            "emoji": "📦",
+            "title": "STOK SORUSU"
+        },
+        "test": {
+            "emoji": "🧪",
+            "title": "TEST DENEMESİ"
+        }
+    }
+    
+    config = action_config.get(action, action_config["info"])
+    
+    # Mesaj oluştur
+    message_parts = [
+        f"{config['emoji']} *{config['title']}*",
+        f"📅 {date_str}",
+        "",
+        f"👤 *Müşteri:*"
+    ]
+    
+    if customer_name:
+        message_parts.append(f"   İsim: {customer_name}")
+    
+    # Telefon numarasını formatla
+    phone_display = customer_phone.replace("whatsapp:", "")
+    message_parts.append(f"   Tel: {phone_display}")
+    
+    message_parts.extend([
+        "",
+        f"🚲 *Ürün:* {product_name}"
+    ])
+    
+    if store_name:
+        message_parts.append(f"🏪 *Mağaza:* {store_name.title()}")
+    
+    if additional_info:
+        message_parts.extend([
+            "",
+            f"📝 *Not:*",
+            additional_info
+        ])
+    
+    # Hızlı aksiyon önerileri
+    if action == "reserve":
+        message_parts.extend([
+            "",
+            "✅ *Yapılacaklar:*",
+            "1. Ürün stok kontrolü",
+            "2. Müşteriyi arayın",
+            "3. Ödeme/teslimat planı"
+        ])
+    elif action == "price":
+        message_parts.extend([
+            "",
+            "💡 *Müşteriye güncel fiyat bildirin*"
+        ])
+    elif action == "stock":
+        message_parts.extend([
+            "",
+            "💡 *Stok durumunu kontrol edip bildirin*"
+        ])
+    
+    message_parts.extend([
+        "",
+        "---",
+        "Trek WhatsApp Bot",
+        "📍 Alsancak Mağaza - Mehmet Bey"
+    ])
+    
+    return "\n".join(message_parts)
+
+def send_test_notification() -> bool:
+    """
+    Test bildirimi gönder
+    """
+    return send_store_notification(
+        customer_phone="whatsapp:+905551234567",
+        customer_name="Test Müşteri",
+        product_name="FX 2 (Kırmızı, L Beden)",
+        action="test",
+        store_name="merkez",
+        additional_info="Bu bir test bildirimidir. Sistem çalışıyor."
+    )
+
+# Kullanım örnekleri
+def notify_product_reservation(customer_phone: str, product_name: str, store: Optional[str] = None):
+    """Ürün ayırtma bildirimi"""
+    return send_store_notification(
+        customer_phone=customer_phone,
+        customer_name=None,
+        product_name=product_name,
+        action="reserve",
+        store_name=store,
+        additional_info="Müşteri bu ürünü ayırtmak istiyor. Lütfen iletişime geçin."
+    )
+
+def notify_price_inquiry(customer_phone: str, product_name: str):
+    """Fiyat sorusu bildirimi"""
+    return send_store_notification(
+        customer_phone=customer_phone,
+        customer_name=None,
+        product_name=product_name,
+        action="price",
+        additional_info="Müşteri güncel fiyat bilgisi istiyor."
+    )
+
+def notify_stock_inquiry(customer_phone: str, product_name: str, store: Optional[str] = None):
+    """Stok sorusu bildirimi"""
+    return send_store_notification(
+        customer_phone=customer_phone,
+        customer_name=None,
+        product_name=product_name,
+        action="stock",
+        store_name=store,
+        additional_info="Müşteri stok durumunu soruyor."
+    )
+
+def should_notify_mehmet_bey(user_message: str, intent_analysis: Optional[Dict] = None) -> tuple[bool, str, str]:
+    """
+    Mehmet Bey'e bildirim gönderilmeli mi kontrol et
+    
+    Args:
+        user_message: Müşteri mesajı
+        intent_analysis: GPT-5 intent analiz sonucu (opsiyonel)
+        
+    Returns:
+        (should_notify: bool, reason: str, urgency: "high"/"medium"/"low")
+    """
+    
+    message_lower = user_message.lower()
+    
+    # 1. REZERVASYON/AYIRTMA TALEPLERI (Yüksek öncelik)
+    reservation_keywords = [
+        # Direkt ayırtma istekleri
+        'ayırt', 'ayırın', 'ayırtın', 'ayırtabilir', 'ayırır mısınız',
+        'rezerve', 'rezervasyon', 'rezarvasyon',
+        'tutun', 'tutar mısınız', 'tutabilir', 'tutarsanız', 'tuttun mu',
+        'sakla', 'saklar mısınız', 'saklayın', 'saklayabilir',
+        'kenara koy', 'kenara ayır', 'benim için koy', 'bana ayır',
+        
+        # Kesin alım niyeti
+        'alacağım', 'alıcam', 'alıyorum', 'alcam', 'alırım',
+        'geliyorum', 'gelcem', 'gelicem', 'geliyom', 'geleceğim',
+        'yola çıktım', 'yoldayım', 'yola çıkıyorum', 'yola çıkıcam',
+        'birazdan oradayım', 'yarım saate', '1 saate', 'bir saate',
+        '30 dakika', '45 dakika', 'akşama kadar',
+        
+        # Alım planı belirtenler
+        'bugün alabilir', 'yarın alabilir', 'hafta sonu', 'haftasonu',
+        'akşam uğra', 'öğleden sonra gel', 'sabah gel', 'öğlen gel',
+        'eşime danış', 'eşimle konuş', 'eşimi getir', 'eşimle gel',
+        'kesin alıcıyım', 'kesin istiyorum', 'bunu istiyorum', 'bunu alıyorum',
+        'kartımı unuttum', 'nakit getir', 'para çek', 'atm',
+        'maaş yattı', 'maaşım yatınca', 'ay başı', 'aybaşı'
+    ]
+    
+    # 2. MAĞAZA LOKASYON SORULARI (Orta öncelik)
+    store_keywords = [
+        'hangi mağaza', 'nerede var', 'nereden alabilirim', 'nerden',
+        'caddebostan', 'ortaköy', 'ortakoy', 'alsancak', 'bahçeköy', 'bahcekoy',
+        'en yakın', 'bana yakın', 'yakın mağaza', 'yakınımda',
+        'mağazada görebilir', 'mağazaya gel', 'mağazanıza', 'mağazanızda',
+        'test edebilir', 'deneyebilir', 'binebilir', 'test sürüş',
+        'yerinde gör', 'canlı gör', 'fiziksel', 'gerçeğini gör',
+        'adres', 'konum', 'lokasyon', 'neredesiniz', 'harita',
+        'uzak mı', 'yakın mı', 'kaç km', 'nasıl gidilir'
+    ]
+    
+    # 3. FİYAT/ÖDEME PAZARLIĞI (Orta öncelik)
+    price_keywords = [
+        'indirim', 'kampanya', 'promosyon', 'fırsat', 'özel fiyat',
+        'taksit', 'kredi kartı', 'banka', 'ödeme seçenek', 'vadeli',
+        'peşin öde', 'nakit indirim', 'peşinat', 'kaparo', 'depozito',
+        'pazarlık', 'son fiyat', 'en iyi fiyat', 'net fiyat', 'kdv dahil',
+        'öğrenci indirimi', 'personel indirimi', 'kurumsal', 'toplu alım',
+        'takas', 'eski bisiklet', 'değer', '2.el', 'ikinci el',
+        'daha ucuz', 'daha uygun', 'bütçe', 'pahalı', 'ucuzlat',
+        'fiyat düş', 'fiyat kır', 'esnet', 'yardımcı ol'
+    ]
+    
+    # Önce rezervasyon kontrolü (en yüksek öncelik)
+    for keyword in reservation_keywords:
+        if keyword in message_lower:
+            return True, f"🔴 Rezervasyon talebi: '{keyword}' kelimesi tespit edildi", "high"
+    
+    # Sonra mağaza soruları
+    for keyword in store_keywords:
+        if keyword in message_lower:
+            return True, f"📍 Mağaza/lokasyon sorusu: '{keyword}' kelimesi tespit edildi", "medium"
+    
+    # Fiyat/ödeme konuları
+    for keyword in price_keywords:
+        if keyword in message_lower:
+            return True, f"💰 Fiyat/ödeme görüşmesi: '{keyword}' kelimesi tespit edildi", "medium"
+    
+    # Intent analysis'ten ek kontrol (eğer varsa)
+    if intent_analysis:
+        # GPT-5 yüksek aciliyet tespit ettiyse
+        if intent_analysis.get('urgency') == 'high':
+            return True, "🚨 GPT-5 yüksek aciliyet tespit etti", "high"
+        
+        # GPT-5 rezervasyon niyeti tespit ettiyse
+        if 'reserve' in intent_analysis.get('intents', []):
+            return True, "📌 GPT-5 rezervasyon niyeti tespit etti", "high"
+    
+    # Hiçbir koşul sağlanmadıysa bildirim gönderme
+    return False, "", "low"
+
+if __name__ == "__main__":
+    # Test
+    print("Mağaza bildirim sistemi test ediliyor...")
+    result = send_test_notification()
+    if result:
+        print("✅ Test bildirimi başarıyla gönderildi!")
+    else:
+        print("❌ Test bildirimi gönderilemedi!")

test_actual_function.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""Test actual get_product_price_and_link function"""
+
+from smart_warehouse_with_price import get_product_price_and_link
+
+# Test with debug prints
+def test_with_debug():
+    print("Testing get_product_price_and_link('Marlin 5')...")
+    
+    # Temporarily modify the function to add debug
+    import smart_warehouse_with_price
+    import xml.etree.ElementTree as ET
+    import re
+    
+    # Get the XML
+    xml_content = smart_warehouse_with_price.get_cached_trek_xml()
+    if not xml_content:
+        print("No XML content")
+        return
+        
+    root = ET.fromstring(xml_content)
+    
+    search_name = "marlin 5"
+    clean_search = re.sub(r'\s*\(\d{4}\)\s*', '', search_name).strip()
+    
+    print(f"Clean search: '{clean_search}'")
+    
+    best_match = None
+    best_score = 0
+    best_name = None
+    
+    count = 0
+    for item in root.findall('item'):
+        rootlabel_elem = item.find('rootlabel')
+        if rootlabel_elem is None or not rootlabel_elem.text:
+            continue
+            
+        item_name = rootlabel_elem.text.lower()
+        
+        # Turkish char normalization
+        tr_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c'}
+        for tr, en in tr_map.items():
+            item_name = item_name.replace(tr, en)
+        
+        clean_item = re.sub(r'\s*\(\d{4}\)\s*', '', item_name).strip()
+        
+        score = 0
+        
+        # Exact match
+        if clean_search == clean_item:
+            score += 100
+        elif clean_item.startswith(clean_search + " ") or clean_item == clean_search:
+            score += 50
+        else:
+            name_parts = clean_search.split()
+            for part in name_parts:
+                if part in clean_item:
+                    score += 1
+        
+        if score > 0:
+            count += 1
+            if count <= 10:  # Show first 10 matches
+                print(f"  {count}. {rootlabel_elem.text[:50]}: score={score}")
+        
+        if score > best_score:
+            best_score = score
+            best_match = item
+            best_name = rootlabel_elem.text
+            print(f"  >>> NEW BEST: {best_name} with score {best_score}")
+    
+    print(f"\nFinal best match: {best_name}")
+    print(f"Best score: {best_score}")
+    
+    if best_match is not None:
+        price_elem = best_match.find('priceTaxWithCur')
+        link_elem = best_match.find('productLink')
+        
+        if price_elem is not None:
+            print(f"Price: {price_elem.text}")
+        if link_elem is not None:
+            print(f"Link: {link_elem.text}")
+    
+    # Now test actual function
+    print("\n" + "="*60)
+    print("Actual function result:")
+    price, link = get_product_price_and_link("Marlin 5")
+    print(f"Price: {price}")
+    print(f"Link: {link}")
+
+if __name__ == "__main__":
+    test_with_debug()

test_context_aware.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+# Test context-aware variant search
+
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Import the updated function from app.py
+from app import get_warehouse_stock
+
+if __name__ == "__main__":
+    test_cases = [
+        "M Turuncu",           # Should find all M Turuncu variants
+        "Marlin 6 M Turuncu",  # Should find only Marlin 6 M Turuncu variants
+        "Marlin M Turuncu",    # Should find only Marlin M Turuncu variants
+        "L Siyah",             # Should find all L Siyah variants
+        "Marlin 6 L Siyah"     # Should find only Marlin 6 L Siyah variants
+    ]
+    
+    for test_case in test_cases:
+        print(f"\n=== Testing: {test_case} ===")
+        try:
+            result = get_warehouse_stock(test_case)
+            if result:
+                print("Sonuç:")
+                total_stock = 0
+                for item in result:
+                    print(f"  • {item}")
+                    # Extract stock count for total
+                    if ": " in item and " adet" in item:
+                        stock_part = item.split(": ")[1].replace(" adet", "")
+                        try:
+                            total_stock += int(stock_part)
+                        except:
+                            pass
+                print(f"TOPLAM: {total_stock} adet")
+            else:
+                print("Sonuç bulunamadı")
+        except Exception as e:
+            print(f"Hata: {e}")
+        print("-" * 50)

test_crm.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""
+CRM System Test Script
+"""
+from customer_manager import CustomerManager
+
+# Test CRM
+print("🧪 CRM Test Başlatılıyor...")
+print("="*50)
+
+# Initialize CRM
+crm = CustomerManager()
+
+# Test 1: Yeni müşteri oluşturma
+print("\n1️⃣ Yeni müşteri test ediliyor...")
+customer1 = crm.get_or_create_customer("+905551234567", "Ahmet")
+print(f"   ✅ Müşteri oluşturuldu: {customer1['name']} - {customer1['segment']}")
+
+# Test 2: İkinci mesaj - selamlama
+print("\n2️⃣ Selamlama mesajı testi...")
+context = crm.get_customer_context("+905551234567")
+print(f"   Selamlama: {context['greeting']}")
+
+# Test 3: Ürün araması güncelleme
+print("\n3️⃣ Ürün araması güncelleme testi...")
+crm.update_interaction("+905551234567", "Marlin 5 var mı?", "Marlin 5")
+customer1 = crm.customers["+905551234567"]
+print(f"   İlgi alanları: {customer1['interests']}")
+print(f"   Toplam sorgu: {customer1['total_queries']}")
+
+# Test 4: Başka bir müşteri - VIP simülasyonu
+print("\n4️⃣ VIP müşteri testi...")
+customer2 = crm.get_or_create_customer("+905559876543", "Mehmet")
+# Birkaç satın alma ekle
+crm.add_purchase("+905559876543", "Trek Madone SLR 9", 180000)
+crm.add_purchase("+905559876543", "Trek Domane SL 7", 95000)
+crm.add_purchase("+905559876543", "Trek FX Sport 6", 45000)
+customer2 = crm.customers["+905559876543"]
+print(f"   ✅ VIP Müşteri: {customer2['name']} - {customer2['segment']}")
+context2 = crm.get_customer_context("+905559876543")
+print(f"   VIP Selamlama: {context2['greeting']}")
+
+# Test 5: Analitik
+print("\n5️⃣ Analitik raporu...")
+analytics = crm.get_analytics()
+print(f"   Toplam müşteri: {analytics['total_customers']}")
+print(f"   Segment dağılımı: {analytics['segments']}")
+print(f"   Toplam satış: {analytics['total_purchases']}")
+print(f"   Toplam gelir: ₺{analytics['total_revenue']:,.0f}")
+
+# Test 6: Müşteri listesi
+print("\n6️⃣ Müşteri listesi...")
+customers = crm.get_customer_list()
+for customer in customers:
+    print(f"   - {customer['name']} ({customer['phone']}) - {customer['segment']} - {customer['total_queries']} sorgu")
+
+print("\n" + "="*50)
+print("✅ CRM Testleri Tamamlandı!")
+print("\n📊 Dashboard'u görmek için:")
+print("   http://localhost:8000/crm-analytics")

test_direct_madone.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""Direct test without GPT-5 to see what's in the data"""
+
+import sys
+import os
+sys.path.insert(0, '/home/samikoen/bf_wab_space')
+
+import requests
+import re
+import json
+
+# Get warehouse XML
+print("Fetching warehouse XML...")
+url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
+response = requests.get(url, verify=False, timeout=15)
+xml_text = response.text
+
+# Extract products
+product_pattern = r'<Product>(.*?)</Product>'
+all_products = re.findall(product_pattern, xml_text, re.DOTALL)
+
+print(f"Total products: {len(all_products)}")
+
+# Create products_summary EXACTLY like the function
+products_summary = []
+for i, product_block in enumerate(all_products):
+    name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
+    variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
+    
+    if name_match:
+        warehouses_with_stock = []
+        warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
+        warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
+        
+        for wh_name, wh_stock in warehouses:
+            try:
+                if int(wh_stock.strip()) > 0:
+                    warehouses_with_stock.append(wh_name)
+            except:
+                pass
+        
+        product_info = {
+            "index": i,
+            "name": name_match.group(1),
+            "variant": variant_match.group(1) if variant_match else "",
+            "warehouses": warehouses_with_stock
+        }
+        products_summary.append(product_info)
+
+print(f"Products in summary: {len(products_summary)}")
+
+# Search for MADONE and MARLIN
+print("\n" + "="*60)
+print("SEARCHING FOR MADONE SL 6:")
+print("="*60)
+
+madone_found = []
+for p in products_summary:
+    if "MADONE SL 6" in p['name'].upper():
+        madone_found.append(p)
+        
+if madone_found:
+    print(f"✅ Found {len(madone_found)} MADONE SL 6 products:")
+    for p in madone_found:
+        if p['warehouses']:  # Only show products with stock
+            print(f"  Index {p['index']}: {p['name']} - {p['variant']}")
+            print(f"    Stock in: {', '.join(p['warehouses'])}")
+else:
+    print("❌ No MADONE SL 6 found!")
+
+print("\n" + "="*60)
+print("SEARCHING FOR MARLIN:")
+print("="*60)
+
+marlin_found = []
+for p in products_summary:
+    if "MARLIN" in p['name'].upper():
+        marlin_found.append(p)
+
+if marlin_found:
+    print(f"Found {len(marlin_found)} MARLIN products")
+    print("First 3 MARLIN products with stock:")
+    count = 0
+    for p in marlin_found:
+        if p['warehouses'] and count < 3:
+            print(f"  Index {p['index']}: {p['name']} - {p['variant']}")
+            print(f"    Stock in: {', '.join(p['warehouses'])}")
+            count += 1
+
+# Check what GPT-5 would receive
+print("\n" + "="*60)
+print("WHAT GPT-5 RECEIVES:")
+print("="*60)
+print(f"Total products sent to GPT-5: {len(products_summary)}")
+
+# Check indices around MADONE
+print("\nProducts at indices 460-475:")
+for idx in range(460, 476):
+    for p in products_summary:
+        if p['index'] == idx:
+            has_stock = "✅" if p['warehouses'] else "❌"
+            print(f"  {idx} {has_stock}: {p['name'][:30]}...")
+            break
+
+# Save the exact data GPT-5 receives
+output_file = '/home/samikoen/gpt5_exact_input.json'
+with open(output_file, 'w', encoding='utf-8') as f:
+    json.dump(products_summary, f, ensure_ascii=False, indent=2)
+print(f"\n💾 Saved exact GPT-5 input to: {output_file}")
+
+# Show what indices GPT-5 should return for "madone sl 6"
+madone_indices = [str(p['index']) for p in madone_found if p['warehouses']]
+if madone_indices:
+    print(f"\n🎯 GPT-5 SHOULD RETURN: {','.join(madone_indices)}")
+else:
+    print("\n⚠️ No MADONE SL 6 with stock found!")

test_final.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# Final test with updated get_warehouse_stock function from app.py
+
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Import the updated function from app.py
+from app import get_warehouse_stock
+
+if __name__ == "__main__":
+    test_cases = [
+        "M Turuncu",
+        "Marlin 6 M Turuncu",
+        "L Siyah",
+        "S Beyaz"
+    ]
+    
+    for test_case in test_cases:
+        print(f"\n=== Testing: {test_case} ===")
+        try:
+            result = get_warehouse_stock(test_case)
+            if result:
+                print("Sonuç:")
+                for item in result:
+                    print(f"  • {item}")
+            else:
+                print("Sonuç bulunamadı")
+        except Exception as e:
+            print(f"Hata: {e}")
+        print("-" * 50)

test_gpt5_mock.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Mock GPT-5 to see what it should return"""
+
+import json
+
+# Load the exact data GPT-5 receives
+with open('/home/samikoen/gpt5_exact_input.json', 'r', encoding='utf-8') as f:
+    products_summary = json.load(f)
+
+print(f"Total products GPT-5 sees: {len(products_summary)}")
+
+# Simulate GPT-5 logic for "madone sl 6"
+query = "madone sl 6"
+query_upper = query.upper()
+
+matching_indices = []
+
+for product in products_summary:
+    product_name = product['name'].upper()
+    
+    # GPT-5 should match "MADONE SL 6" in product name
+    if "MADONE SL 6" in product_name:
+        # Only return products with stock
+        if product['warehouses']:
+            matching_indices.append(str(product['index']))
+
+print(f"\nQuery: '{query}'")
+print(f"GPT-5 should return: {','.join(matching_indices)}")
+
+# Check what's actually there
+print("\nMatching products details:")
+for product in products_summary:
+    if "MADONE SL 6" in product['name'].upper():
+        if product['warehouses']:
+            print(f"  Index {product['index']}: {product['name']} ({product['variant']})")
+            print(f"    Warehouses: {product['warehouses']}")
+
+# Check if MARLIN is in the data
+print("\n" + "="*60)
+print("CHECKING FOR MARLIN:")
+marlin_count = 0
+for product in products_summary:
+    if "MARLIN" in product['name'].upper():
+        marlin_count += 1
+        if marlin_count <= 3 and product['warehouses']:
+            print(f"  Index {product['index']}: {product['name']} ({product['variant']})")
+
+if marlin_count == 0:
+    print("  ❌ NO MARLIN PRODUCTS IN WAREHOUSE DATA!")
+else:
+    print(f"  Total MARLIN products: {marlin_count}")

test_m_turuncu.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+import requests
+import xml.etree.ElementTree as ET
+
+def get_warehouse_stock(product_name):
+    """B2B API'den mağaza stok bilgilerini çek - İyileştirilmiş versiyon"""
+    try:
+        import re
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml.php'
+        response = requests.get(warehouse_url, verify=False, timeout=15)
+        
+        if response.status_code != 200:
+            return None
+            
+        root = ET.fromstring(response.content)
+        
+        # Turkish character normalization function
+        turkish_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c', 'İ': 'i', 'I': 'i'}
+        
+        def normalize_turkish(text):
+            import unicodedata
+            text = unicodedata.normalize('NFD', text)
+            text = ''.join(char for char in text if unicodedata.category(char) != 'Mn')
+            for tr_char, en_char in turkish_map.items():
+                text = text.replace(tr_char, en_char)
+            return text
+        
+        # Normalize search product name
+        search_name = normalize_turkish(product_name.lower().strip())
+        search_name = search_name.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+        search_words = search_name.split()
+        
+        print(f"DEBUG: Aranan ürün: '{product_name}' -> normalize: '{search_name}' -> kelimeler: {search_words}")
+        
+        best_matches = []
+        exact_matches = []
+        color_size_matches = []  # For size/color specific searches
+        
+        # Check if this is a size/color query (like "M Turuncu")
+        is_size_color_query = len(search_words) <= 2 and any(word in ['s', 'm', 'l', 'xl', 'xs', 'small', 'medium', 'large', 'turuncu', 'siyah', 'beyaz', 'mavi', 'kirmizi', 'yesil'] for word in search_words)
+        
+        if is_size_color_query:
+            print(f"DEBUG: Beden/renk araması algılandı: {search_words}")
+            # For size/color queries, look for products containing these terms
+            for product in root.findall('Product'):
+                product_name_elem = product.find('ProductName')
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
+                    normalized_xml = normalize_turkish(xml_product_name.lower())
+                    
+                    # Check if all search words appear in the product name
+                    if all(word in normalized_xml for word in search_words):
+                        color_size_matches.append((product, xml_product_name, normalized_xml))
+                        print(f"DEBUG: BEDEN/RENK EŞLEŞME: '{xml_product_name}'")
+            
+            candidates = color_size_matches
+        else:
+            # Normal product search logic
+            # İlk geçiş: Tam eşleşmeleri bul
+            for product in root.findall('Product'):
+                product_name_elem = product.find('ProductName')
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
+                    normalized_xml = normalize_turkish(xml_product_name.lower())
+                    normalized_xml = normalized_xml.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+                    xml_words = normalized_xml.split()
+                    
+                    # Tam eşleşme kontrolü - ilk iki kelime tam aynı olmalı
+                    if len(search_words) >= 2 and len(xml_words) >= 2:
+                        search_key = f"{search_words[0]} {search_words[1]}"
+                        xml_key = f"{xml_words[0]} {xml_words[1]}"
+                        
+                        if search_key == xml_key:
+                            exact_matches.append((product, xml_product_name, normalized_xml))
+                            print(f"DEBUG: TAM EŞLEŞME: '{xml_product_name}'")
+            
+            # Eğer tam eşleşme varsa, sadece onları kullan
+            candidates = exact_matches if exact_matches else []
+            
+            # Eğer tam eşleşme yoksa, fuzzy matching yap
+            if not candidates:
+                print("DEBUG: Tam eşleşme yok, fuzzy matching yapılıyor...")
+                for product in root.findall('Product'):
+                    product_name_elem = product.find('ProductName')
+                    if product_name_elem is not None and product_name_elem.text:
+                        xml_product_name = product_name_elem.text.strip()
+                        normalized_xml = normalize_turkish(xml_product_name.lower())
+                        normalized_xml = normalized_xml.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+                        xml_words = normalized_xml.split()
+                        
+                        # Ortak kelime sayısını hesapla
+                        common_words = set(search_words) & set(xml_words)
+                        
+                        # En az 2 ortak kelime olmalı VE ilk kelime aynı olmalı (marka kontrolü)
+                        if (len(common_words) >= 2 and 
+                            len(search_words) > 0 and len(xml_words) > 0 and 
+                            search_words[0] == xml_words[0]):
+                            best_matches.append((product, xml_product_name, normalized_xml, len(common_words)))
+                            print(f"DEBUG: FUZZY EŞLEŞME: '{xml_product_name}' (ortak: {len(common_words)})")
+                
+                # En çok ortak kelimeye sahip olanları seç
+                if best_matches:
+                    max_common = max(match[3] for match in best_matches)
+                    candidates = [(match[0], match[1], match[2]) for match in best_matches if match[3] == max_common]
+        
+        print(f"DEBUG: Toplam {len(candidates)} aday ürün bulundu")
+        
+        # Stok bilgilerini topla ve tekrarları önle
+        warehouse_stock_map = {}  # warehouse_name -> total_stock
+        
+        for product, xml_name, _ in candidates:
+            warehouses = product.find('Warehouses')
+            if warehouses is not None:
+                for warehouse in warehouses.findall('Warehouse'):
+                    name_elem = warehouse.find('Name')
+                    stock_elem = warehouse.find('Stock')
+                    
+                    if name_elem is not None and stock_elem is not None:
+                        warehouse_name = name_elem.text if name_elem.text else "Bilinmeyen"
+                        try:
+                            stock_count = int(stock_elem.text) if stock_elem.text else 0
+                            if stock_count > 0:
+                                # Aynı mağaza için stokları topla
+                                if warehouse_name in warehouse_stock_map:
+                                    warehouse_stock_map[warehouse_name] += stock_count
+                                else:
+                                    warehouse_stock_map[warehouse_name] = stock_count
+                                print(f"DEBUG: STOK BULUNDU - {warehouse_name}: {stock_count} adet ({xml_name})")
+                        except (ValueError, TypeError):
+                            pass
+        
+        if warehouse_stock_map:
+            # Mağaza stoklarını liste halinde döndür
+            all_warehouse_info = []
+            for warehouse_name, total_stock in warehouse_stock_map.items():
+                all_warehouse_info.append(f"{warehouse_name}: {total_stock} adet")
+            return all_warehouse_info
+        else:
+            print("DEBUG: Hiçbir mağazada stok bulunamadı")
+            return ["Hiçbir mağazada stokta bulunmuyor"]
+        
+    except Exception as e:
+        print(f"Mağaza stok bilgisi çekme hatası: {e}")
+        return None
+
+if __name__ == "__main__":
+    # Test the function with different M Turuncu variations
+    test_cases = [
+        "M Turuncu",
+        "m turuncu", 
+        "M TURUNCU",
+        "Medium Turuncu",
+        "Marlin 6 M Turuncu"
+    ]
+    
+    for test_case in test_cases:
+        print(f"=== Testing: {test_case} ===")
+        result = get_warehouse_stock(test_case)
+        print(f"Result: {result}")
+        print()

test_marlin_fix.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""Test Marlin 5 after Turkish character fix"""
+
+import os
+os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', '')
+
+from smart_warehouse_with_price import get_warehouse_stock_smart_with_price
+
+def test_marlin():
+    print("Testing Marlin 5 search...")
+    print("="*60)
+    
+    result = get_warehouse_stock_smart_with_price("Marlin 5")
+    
+    if result:
+        print("\n✅ Results found:")
+        for item in result[:3]:  # Show first 3
+            print(f"\n{item}")
+    else:
+        print("\n❌ No results")
+
+if __name__ == "__main__":
+    test_marlin()

test_name_request.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""
+Test Name Request Functionality
+"""
+from customer_manager import CustomerManager
+import os
+
+# Clean test - yeni database
+if os.path.exists("test_customers.json"):
+    os.remove("test_customers.json")
+
+crm = CustomerManager("test_customers.json")
+
+print("🧪 İsim Sorma Test Senaryoları")
+print("="*50)
+
+# Test 1: Rezervasyon anında isim sorma
+print("\n1️⃣ REZERVASYON ANINDA İSİM SORMA")
+phone = "+905551111111"
+message = "Marlin 5'i rezerve edebilir miyim?"
+
+customer = crm.get_or_create_customer(phone)
+should_ask, question = crm.should_ask_for_name(phone, message)
+
+print(f"Müşteri: {message}")
+print(f"İsim sorulmalı mı: {should_ask}")
+if question:
+    print(f"Soru: {question}")
+
+# Müşteri cevap veriyor
+print("\nMüşteri yanıtı: 'Ahmet'")
+extracted = crm.extract_name_from_response("Ahmet")
+print(f"Çıkarılan isim: {extracted}")
+
+# Test 2: 3. mesajda nazikçe sorma
+print("\n2️⃣ 3. MESAJDA NAZİKÇE SORMA")
+phone2 = "+905552222222"
+
+# 1. mesaj
+crm.update_interaction(phone2, "Merhaba", None)
+should_ask, question = crm.should_ask_for_name(phone2, "Merhaba")
+print(f"1. mesaj - İsim sorulmalı: {should_ask}")
+
+# 2. mesaj
+crm.update_interaction(phone2, "FX 3 var mı?", "FX 3")
+should_ask, question = crm.should_ask_for_name(phone2, "FX 3 var mı?")
+print(f"2. mesaj - İsim sorulmalı: {should_ask}")
+
+# 3. mesaj
+crm.update_interaction(phone2, "Fiyatı nedir?", None)
+should_ask, question = crm.should_ask_for_name(phone2, "Fiyatı nedir?")
+print(f"3. mesaj - İsim sorulmalı: {should_ask}")
+if question:
+    print(f"Soru: {question}")
+
+# Test 3: Farklı isim formatları
+print("\n3️⃣ İSİM ÇIKARMA TESTLERİ")
+test_responses = [
+    "Mehmet",
+    "benim adım Ali",
+    "Ben Ayşe",
+    "Adım Fatma",
+    "ismim Hasan",
+    "Veli, teşekkürler",
+    "Ahmet Yılmaz",  # İsim + Soyisim
+    "selam"  # İsim değil
+]
+
+for response in test_responses:
+    extracted = crm.extract_name_from_response(response)
+    print(f"'{response}' -> {extracted if extracted else 'İsim bulunamadı'}")
+
+# Test 4: Mağaza ziyareti
+print("\n4️⃣ MAĞAZA ZİYARETİ ANINDA")
+phone3 = "+905553333333"
+message = "Yarın mağazaya gelerek test sürüşü yapabilir miyim?"
+should_ask, question = crm.should_ask_for_name(phone3, message)
+print(f"Müşteri: {message}")
+print(f"İsim sorulmalı: {should_ask}")
+if question:
+    print(f"Soru: {question}")
+
+# Test 5: Ödeme görüşmesi
+print("\n5️⃣ ÖDEME GÖRÜŞMESİ ANINDA")
+phone4 = "+905554444444"
+message = "12 taksit yapıyor musunuz?"
+should_ask, question = crm.should_ask_for_name(phone4, message)
+print(f"Müşteri: {message}")
+print(f"İsim sorulmalı: {should_ask}")
+if question:
+    print(f"Soru: {question}")
+
+# Test 6: 5+ sorgudan sonra
+print("\n6️⃣ POTANSİYEL MÜŞTERİ (5+ SORGU)")
+phone5 = "+905555555555"
+for i in range(5):
+    crm.update_interaction(phone5, f"Soru {i+1}", None)
+
+should_ask, question = crm.should_ask_for_name(phone5, "Başka model var mı?")
+print(f"5+ sorgudan sonra")
+print(f"İsim sorulmalı: {should_ask}")
+if question:
+    print(f"Soru: {question}")
+
+print("\n" + "="*50)
+print("✅ Testler Tamamlandı!")
+
+# Cleanup
+if os.path.exists("test_customers.json"):
+    os.remove("test_customers.json")

test_simulate_whatsapp.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+"""Simulate a WhatsApp message for MADONE SL 6"""
+
+import sys
+import os
+sys.path.insert(0, '/home/samikoen/bf_wab_space')
+
+# Set API key if exists
+api_key = "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"
+os.environ['OPENAI_API_KEY'] = api_key
+
+print("="*60)
+print("SIMULATING WHATSAPP MESSAGE: 'madone sl 6'")
+print("="*60)
+
+from smart_warehouse_complete import get_warehouse_stock_smart_complete
+
+try:
+    print("\nCalling get_warehouse_stock_smart_complete('madone sl 6')...")
+    result = get_warehouse_stock_smart_complete("madone sl 6")
+    
+    if result:
+        print("\n✅ RESULT:")
+        for line in result:
+            print(f"  {line}")
+    else:
+        print("\n❌ No result (None returned)")
+        
+except Exception as e:
+    print(f"\n❌ ERROR: {e}")
+    import traceback
+    traceback.print_exc()

test_stock_consistency.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""
+Test Stock Consistency Algorithm
+Simulates conversation flow to ensure stock information remains consistent
+"""
+
+# Test conversation memory functions
+import sys
+sys.path.insert(0, '/home/samikoen/bf_wab_space')
+
+def test_stock_consistency():
+    print("🧪 STOK TUTARLILİK TESTİ")
+    print("="*50)
+    
+    # Simulate phone number
+    test_phone = "+905551111111"
+    
+    # Import the conversation functions
+    try:
+        from app import get_conversation_context, cache_product_info, get_cached_product_info
+        
+        # Test 1: İlk ürün araması
+        print("\n1️⃣ İLK ÜRÜN ARAMASI")
+        search_term = "FX 3 var mı"
+        product_info = """📦 FX 3 (2024) - Şehir Bisikleti
+💰 Fiyat: 73.000 TL
+🏪 Stok: İzmir Alsancak, İstanbul Ortaköy
+📏 L beden mevcut"""
+        
+        # Cache product info
+        cache_product_info(test_phone, search_term, product_info)
+        print(f"✅ Cached: {search_term}")
+        print(f"   Info: {product_info[:100]}...")
+        
+        # Test 2: İkinci mesaj - benzer sorgu
+        print("\n2️⃣ İKINCİ MESAJ - BENZERİ SORGU")
+        follow_up = "boyum 190 cm L boy olur mu"
+        
+        cached_result = get_cached_product_info(test_phone, follow_up)
+        if cached_result:
+            print(f"✅ CACHED bulundu: {follow_up}")
+            print(f"   Cached data: {cached_result[:100]}...")
+        else:
+            print(f"❌ Cache BULUNAMADI: {follow_up}")
+        
+        # Test 3: Üçüncü mesaj - aynı ürün hakkında
+        print("\n3️⃣ ÜÇÜNCÜ MESAJ - AYNI ÜRÜN")
+        third_msg = "ayırtmak istiyorum"
+        
+        cached_result = get_cached_product_info(test_phone, third_msg)
+        if cached_result:
+            print(f"✅ CACHED bulundu: {third_msg}")
+            print(f"   Cached data: {cached_result[:100]}...")
+        else:
+            print(f"❌ Cache BULUNAMADI: {third_msg}")
+            
+        # Test 4: Conversation context
+        print("\n4️⃣ CONVERSATION CONTEXT")
+        context = get_conversation_context(test_phone)
+        print(f"Context keys: {list(context.keys())}")
+        print(f"Last search term: {context.get('last_search_term')}")
+        print(f"Has product info: {'Yes' if context.get('last_product_info') else 'No'}")
+        
+        # Test 5: Farklı ürün araması
+        print("\n5️⃣ FARKLI ÜRÜN ARAMASI")
+        new_search = "Marlin 5 var mı"
+        
+        cached_result = get_cached_product_info(test_phone, new_search)
+        if cached_result:
+            print(f"⚠️  Yanlış cache bulundu (beklenmeyen): {new_search}")
+        else:
+            print(f"✅ Doğru: Farklı ürün için cache yok: {new_search}")
+            
+        # Test 6: Cache expiration (30 dakika sonrası simülasyonu)
+        print("\n6️⃣ CACHE EXPIRATION TEST")
+        import datetime
+        context = get_conversation_context(test_phone)
+        
+        # Zamanı geriye al (31 dakika önce)
+        old_time = datetime.datetime.now() - datetime.timedelta(minutes=31)
+        context["last_search_time"] = old_time
+        
+        cached_result = get_cached_product_info(test_phone, "FX 3 fiyat")
+        if cached_result:
+            print(f"❌ Cache expire olmadı (sorun)")
+        else:
+            print(f"✅ Cache doğru şekilde expire oldu")
+            
+        print("\n" + "="*50)
+        print("✅ STOK TUTARLILİK TESTİ TAMAMLANDI!")
+        
+    except ImportError as e:
+        print(f"❌ Import hatası: {e}")
+        print("Bu test app.py ile aynı dizinde çalışmalı")
+
+if __name__ == "__main__":
+    test_stock_consistency()

test_updated_warehouse.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+import requests
+import xml.etree.ElementTree as ET
+
+def get_warehouse_stock(product_name):
+    """B2B API'den mağaza stok bilgilerini çek - Final Updated Version"""
+    try:
+        import re
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml.php'
+        response = requests.get(warehouse_url, verify=False, timeout=15)
+        
+        if response.status_code != 200:
+            return None
+            
+        root = ET.fromstring(response.content)
+        
+        # Turkish character normalization function
+        turkish_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c', 'İ': 'i', 'I': 'i'}
+        
+        def normalize_turkish(text):
+            import unicodedata
+            text = unicodedata.normalize('NFD', text)
+            text = ''.join(char for char in text if unicodedata.category(char) != 'Mn')
+            for tr_char, en_char in turkish_map.items():
+                text = text.replace(tr_char, en_char)
+            return text
+        
+        # Normalize search product name
+        search_name = normalize_turkish(product_name.lower().strip())
+        search_name = search_name.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+        search_words = search_name.split()
+        
+        best_matches = []
+        exact_matches = []
+        variant_matches = []
+        candidates = []
+        
+        # Check if this is a size/color specific query (like "M Turuncu")
+        is_size_color_query = (len(search_words) <= 3 and 
+                               any(word in ['s', 'm', 'l', 'xl', 'xs', 'small', 'medium', 'large', 
+                                           'turuncu', 'siyah', 'beyaz', 'mavi', 'kirmizi', 'yesil', 
+                                           'orange', 'black', 'white', 'blue', 'red', 'green'] 
+                                   for word in search_words))
+        
+        # İlk geçiş: Variant alanında beden/renk araması
+        if is_size_color_query:
+            for product in root.findall('Product'):
+                product_name_elem = product.find('ProductName')
+                variant_elem = product.find('Variant')
+                
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
+                    
+                    # Variant field check
+                    if variant_elem is not None and variant_elem.text:
+                        variant_text = normalize_turkish(variant_elem.text.lower().replace('-', ' '))
+                        
+                        # Check if all search words are in variant field
+                        if all(word in variant_text for word in search_words):
+                            variant_matches.append((product, xml_product_name, variant_text))
+            
+            if variant_matches:
+                candidates = variant_matches
+            else:
+                # Fallback to normal product name search
+                is_size_color_query = False
+        
+        # İkinci geçiş: Normal ürün adı tam eşleşmeleri (variant match yoksa)
+        if not is_size_color_query or not candidates:
+            for product in root.findall('Product'):
+                product_name_elem = product.find('ProductName')
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
+                    normalized_xml = normalize_turkish(xml_product_name.lower())
+                    normalized_xml = normalized_xml.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+                    xml_words = normalized_xml.split()
+                    
+                    # Tam eşleşme kontrolü - ilk iki kelime tam aynı olmalı
+                    if len(search_words) >= 2 and len(xml_words) >= 2:
+                        search_key = f"{search_words[0]} {search_words[1]}"
+                        xml_key = f"{xml_words[0]} {xml_words[1]}"
+                        
+                        if search_key == xml_key:
+                            exact_matches.append((product, xml_product_name, normalized_xml))
+            
+            # Eğer variant match varsa onu kullan, yoksa exact matches kullan
+            if not candidates:
+                candidates = exact_matches if exact_matches else []
+        
+        # Eğer hala bir match yoksa, fuzzy matching yap
+        if not candidates:
+            for product in root.findall('Product'):
+                product_name_elem = product.find('ProductName')
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
+                    normalized_xml = normalize_turkish(xml_product_name.lower())
+                    normalized_xml = normalized_xml.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+                    xml_words = normalized_xml.split()
+                    
+                    # Ortak kelime sayısını hesapla
+                    common_words = set(search_words) & set(xml_words)
+                    
+                    # En az 2 ortak kelime olmalı VE ilk kelime aynı olmalı (marka kontrolü)
+                    if (len(common_words) >= 2 and 
+                        len(search_words) > 0 and len(xml_words) > 0 and 
+                        search_words[0] == xml_words[0]):
+                        best_matches.append((product, xml_product_name, normalized_xml, len(common_words)))
+            
+            # En çok ortak kelimeye sahip olanları seç
+            if best_matches:
+                max_common = max(match[3] for match in best_matches)
+                candidates = [(match[0], match[1], match[2]) for match in best_matches if match[3] == max_common]
+        
+        # Stok bilgilerini topla ve tekrarları önle
+        warehouse_stock_map = {}  # warehouse_name -> total_stock
+        
+        for product, xml_name, _ in candidates:
+            warehouses = product.find('Warehouses')
+            if warehouses is not None:
+                for warehouse in warehouses.findall('Warehouse'):
+                    name_elem = warehouse.find('Name')
+                    stock_elem = warehouse.find('Stock')
+                    
+                    if name_elem is not None and stock_elem is not None:
+                        warehouse_name = name_elem.text if name_elem.text else "Bilinmeyen"
+                        try:
+                            stock_count = int(stock_elem.text) if stock_elem.text else 0
+                            if stock_count > 0:
+                                # Aynı mağaza için stokları topla
+                                if warehouse_name in warehouse_stock_map:
+                                    warehouse_stock_map[warehouse_name] += stock_count
+                                else:
+                                    warehouse_stock_map[warehouse_name] = stock_count
+                        except (ValueError, TypeError):
+                            pass
+        
+        if warehouse_stock_map:
+            # Mağaza stoklarını liste halinde döndür
+            all_warehouse_info = []
+            for warehouse_name, total_stock in warehouse_stock_map.items():
+                all_warehouse_info.append(f"{warehouse_name}: {total_stock} adet")
+            return all_warehouse_info
+        else:
+            return ["Hiçbir mağazada stokta bulunmuyor"]
+        
+    except Exception as e:
+        print(f"Mağaza stok bilgisi çekme hatası: {e}")
+        return None
+
+if __name__ == "__main__":
+    test_cases = [
+        "M Turuncu",
+        "Marlin 6 M Turuncu",
+        "L Siyah"
+    ]
+    
+    for test_case in test_cases:
+        print(f"\n=== Testing: {test_case} ===")
+        result = get_warehouse_stock(test_case)
+        if result:
+            print("Sonuç:")
+            for item in result:
+                print(f"  • {item}")
+        else:
+            print("Sonuç bulunamadı")
+        print("-" * 50)

test_variant.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+import requests
+import xml.etree.ElementTree as ET
+
+def test_variant_search(product_name):
+    """B2B API'den variant field'ı kontrol et"""
+    try:
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml.php'
+        response = requests.get(warehouse_url, verify=False, timeout=15)
+        
+        if response.status_code != 200:
+            return None
+            
+        root = ET.fromstring(response.content)
+        
+        # Turkish character normalization function
+        turkish_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c', 'İ': 'i', 'I': 'i'}
+        
+        def normalize_turkish(text):
+            import unicodedata
+            text = unicodedata.normalize('NFD', text)
+            text = ''.join(char for char in text if unicodedata.category(char) != 'Mn')
+            for tr_char, en_char in turkish_map.items():
+                text = text.replace(tr_char, en_char)
+            return text
+        
+        # Normalize search product name
+        search_name = normalize_turkish(product_name.lower().strip())
+        search_words = search_name.split()
+        
+        print(f"DEBUG: Aranan: '{product_name}' -> normalize: '{search_name}' -> kelimeler: {search_words}")
+        
+        variant_matches = []
+        
+        # Check variant field for M-TURUNCU like patterns
+        for product in root.findall('Product'):
+            product_name_elem = product.find('ProductName')
+            variant_elem = product.find('Variant')
+            
+            if product_name_elem is not None and product_name_elem.text:
+                xml_product_name = product_name_elem.text.strip()
+                
+                # Check variant field
+                if variant_elem is not None and variant_elem.text:
+                    variant_text = variant_elem.text.strip()
+                    variant_normalized = normalize_turkish(variant_text.lower().replace('-', ' '))
+                    
+                    # Check if all search words are in variant field
+                    if all(word in variant_normalized for word in search_words):
+                        # Check for stock
+                        warehouses = product.find('Warehouses')
+                        stock_info = []
+                        if warehouses is not None:
+                            for warehouse in warehouses.findall('Warehouse'):
+                                name_elem = warehouse.find('Name')
+                                stock_elem = warehouse.find('Stock')
+                                
+                                if name_elem is not None and stock_elem is not None:
+                                    warehouse_name = name_elem.text if name_elem.text else "Bilinmeyen"
+                                    try:
+                                        stock_count = int(stock_elem.text) if stock_elem.text else 0
+                                        if stock_count > 0:
+                                            stock_info.append(f"{warehouse_name}: {stock_count}")
+                                    except (ValueError, TypeError):
+                                        pass
+                        
+                        variant_matches.append({
+                            'product_name': xml_product_name,
+                            'variant': variant_text,
+                            'variant_normalized': variant_normalized,
+                            'stock_info': stock_info
+                        })
+                        
+                        print(f"DEBUG: VARIANT MATCH - {xml_product_name}")
+                        print(f"       Variant: {variant_text} -> {variant_normalized}")
+                        if stock_info:
+                            print(f"       Stok: {', '.join(stock_info)}")
+                        else:
+                            print(f"       Stokta yok")
+        
+        return variant_matches
+        
+    except Exception as e:
+        print(f"Hata: {e}")
+        return None
+
+if __name__ == "__main__":
+    # Test different cases
+    test_cases = [
+        "M Turuncu",
+        "m turuncu", 
+        "L Siyah",
+        "S Beyaz"
+    ]
+    
+    for test_case in test_cases:
+        print(f"\n=== Testing: {test_case} ===")
+        result = test_variant_search(test_case)
+        
+        if result:
+            print(f"Toplam {len(result)} variant match bulundu:")
+            for i, match in enumerate(result, 1):
+                print(f"{i}. {match['product_name']} - {match['variant']}")
+                if match['stock_info']:
+                    print(f"   Stokta: {', '.join(match['stock_info'])}")
+                else:
+                    print(f"   Stokta değil")
+        else:
+            print("Variant match bulunamadı")
+        print("-" * 50)

test_warehouse.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+import requests
+import xml.etree.ElementTree as ET
+
+def get_warehouse_stock(product_name):
+    """B2B API'den mağaza stok bilgilerini çek - İyileştirilmiş versiyon"""
+    try:
+        import re
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml.php'
+        response = requests.get(warehouse_url, verify=False, timeout=15)
+        
+        if response.status_code != 200:
+            return None
+            
+        root = ET.fromstring(response.content)
+        
+        # Turkish character normalization function
+        turkish_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c', 'İ': 'i', 'I': 'i'}
+        
+        def normalize_turkish(text):
+            import unicodedata
+            text = unicodedata.normalize('NFD', text)
+            text = ''.join(char for char in text if unicodedata.category(char) != 'Mn')
+            for tr_char, en_char in turkish_map.items():
+                text = text.replace(tr_char, en_char)
+            return text
+        
+        # Normalize search product name
+        search_name = normalize_turkish(product_name.lower().strip())
+        search_name = search_name.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+        search_words = search_name.split()
+        
+        print(f"DEBUG: Aranan ürün: '{product_name}' -> normalize: '{search_name}' -> kelimeler: {search_words}")
+        
+        best_matches = []
+        exact_matches = []
+        
+        # İlk geçiş: Tam eşleşmeleri bul
+        for product in root.findall('Product'):
+            product_name_elem = product.find('ProductName')
+            if product_name_elem is not None and product_name_elem.text:
+                xml_product_name = product_name_elem.text.strip()
+                normalized_xml = normalize_turkish(xml_product_name.lower())
+                normalized_xml = normalized_xml.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+                xml_words = normalized_xml.split()
+                
+                # Tam eşleşme kontrolü - ilk iki kelime tam aynı olmalı
+                if len(search_words) >= 2 and len(xml_words) >= 2:
+                    search_key = f"{search_words[0]} {search_words[1]}"
+                    xml_key = f"{xml_words[0]} {xml_words[1]}"
+                    
+                    if search_key == xml_key:
+                        exact_matches.append((product, xml_product_name, normalized_xml))
+                        print(f"DEBUG: TAM EŞLEŞME bulundu: '{xml_product_name}'")
+        
+        # Eğer tam eşleşme varsa, sadece onları kullan
+        candidates = exact_matches if exact_matches else []
+        
+        # Eğer tam eşleşme yoksa, fuzzy matching yap
+        if not candidates:
+            print("DEBUG: Tam eşleşme yok, fuzzy matching yapılıyor...")
+            for product in root.findall('Product'):
+                product_name_elem = product.find('ProductName')
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
+                    normalized_xml = normalize_turkish(xml_product_name.lower())
+                    normalized_xml = normalized_xml.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+                    xml_words = normalized_xml.split()
+                    
+                    # Ortak kelime sayısını hesapla
+                    common_words = set(search_words) & set(xml_words)
+                    
+                    # En az 2 ortak kelime olmalı VE ilk kelime aynı olmalı (marka kontrolü)
+                    if (len(common_words) >= 2 and 
+                        len(search_words) > 0 and len(xml_words) > 0 and 
+                        search_words[0] == xml_words[0]):
+                        best_matches.append((product, xml_product_name, normalized_xml, len(common_words)))
+                        print(f"DEBUG: FUZZY EŞLEŞME: '{xml_product_name}' (ortak: {len(common_words)})")
+            
+            # En çok ortak kelimeye sahip olanları seç
+            if best_matches:
+                max_common = max(match[3] for match in best_matches)
+                candidates = [(match[0], match[1], match[2]) for match in best_matches if match[3] == max_common]
+        
+        print(f"DEBUG: Toplam {len(candidates)} aday ürün bulundu")
+        
+        # Stok bilgilerini topla ve tekrarları önle
+        warehouse_stock_map = {}  # warehouse_name -> total_stock
+        
+        for product, xml_name, _ in candidates:
+            warehouses = product.find('Warehouses')
+            if warehouses is not None:
+                for warehouse in warehouses.findall('Warehouse'):
+                    name_elem = warehouse.find('Name')
+                    stock_elem = warehouse.find('Stock')
+                    
+                    if name_elem is not None and stock_elem is not None:
+                        warehouse_name = name_elem.text if name_elem.text else "Bilinmeyen"
+                        try:
+                            stock_count = int(stock_elem.text) if stock_elem.text else 0
+                            if stock_count > 0:
+                                # Aynı mağaza için stokları topla
+                                if warehouse_name in warehouse_stock_map:
+                                    warehouse_stock_map[warehouse_name] += stock_count
+                                else:
+                                    warehouse_stock_map[warehouse_name] = stock_count
+                                print(f"DEBUG: STOK BULUNDU - {warehouse_name}: {stock_count} adet ({xml_name})")
+                        except (ValueError, TypeError):
+                            pass
+        
+        if warehouse_stock_map:
+            # Mağaza stoklarını liste halinde döndür
+            all_warehouse_info = []
+            for warehouse_name, total_stock in warehouse_stock_map.items():
+                all_warehouse_info.append(f"{warehouse_name}: {total_stock} adet")
+            return all_warehouse_info
+        else:
+            print("DEBUG: Hiçbir mağazada stok bulunamadı")
+            return ["Hiçbir mağazada stokta bulunmuyor"]
+        
+    except Exception as e:
+        print(f"Mağaza stok bilgisi çekme hatası: {e}")
+        return None
+
+if __name__ == "__main__":
+    # Test the function with different inputs
+    test_cases = [
+        "MARLIN 6 (2026)",
+        "Marlin 6"
+    ]
+    
+    for test_case in test_cases:
+        print(f"=== Testing: {test_case} ===")
+        result = get_warehouse_stock(test_case)
+        print(f"Result: {result}")
+        print()

warehouse_stock_finder.py

@@ -0,0 +1,91 @@
+"""Ultra simple and fast warehouse stock finder"""
+
+def get_warehouse_stock(product_name):
+    """Find warehouse stock FAST - no XML parsing, just regex"""
+    try:
+        import re
+        import requests
+        
+        # Get XML
+        url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
+        response = requests.get(url, verify=False, timeout=7)
+        xml_text = response.text
+        
+        # Turkish normalize
+        def normalize(text):
+            tr_map = {'İ': 'i', 'I': 'i', 'ı': 'i', 'Ğ': 'g', 'ğ': 'g', 'Ü': 'u', 'ü': 'u', 'Ş': 's', 'ş': 's', 'Ö': 'o', 'ö': 'o', 'Ç': 'c', 'ç': 'c'}
+            # FIRST normalize Turkish chars
+            for tr, en in tr_map.items():
+                text = text.replace(tr, en)
+            # THEN lowercase
+            text = text.lower()
+            return text
+        
+        # Parse query
+        query = normalize(product_name.strip()).replace('(2026)', '').replace('(2025)', '').strip()
+        words = query.split()
+        
+        # Find size
+        sizes = ['s', 'm', 'l', 'xl', 'xs', 'xxl', 'ml']
+        size = next((w for w in words if w in sizes), None)
+        product_words = [w for w in words if w not in sizes and w not in ['beden', 'size', 'boy']]
+        
+        # Build search pattern
+        if 'madone' in product_words and 'sl' in product_words and '6' in product_words:
+            pattern = 'MADONE SL 6 GEN 8'
+        else:
+            pattern = ' '.join(product_words).upper()
+        
+        print(f"DEBUG - Searching: {pattern}, Size: {size}")
+        
+        # Search for product + variant combo
+        if size:
+            # Direct search for product with specific size
+            size_pattern = f'{size.upper()}-'
+            
+            # Find all occurrences of the product name
+            import re
+            product_regex = f'<Product>.*?<ProductName><!\\[CDATA\\[{re.escape(pattern)}\\]\\]></ProductName>.*?<ProductVariant><!\\[CDATA\\[{size_pattern}.*?\\]\\]></ProductVariant>.*?</Product>'
+            
+            match = re.search(product_regex, xml_text, re.DOTALL)
+            
+            if match:
+                product_block = match.group(0)
+                print(f"DEBUG - Found product with {size_pattern} variant")
+                
+                # Extract warehouses
+                warehouse_info = []
+                warehouse_regex = r'<Warehouse>.*?<Name><!\\[CDATA\\[(.*?)\\]\\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
+                warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
+                
+                for wh_name, wh_stock in warehouses:
+                    try:
+                        stock = int(wh_stock.strip())
+                        if stock > 0:
+                            # Format name
+                            if "CADDEBOSTAN" in wh_name:
+                                display = "Caddebostan mağazası"
+                            elif "ORTAKÖY" in wh_name:
+                                display = "Ortaköy mağazası"
+                            elif "ALSANCAK" in wh_name:
+                                display = "İzmir Alsancak mağazası"
+                            elif "BAHCEKOY" in wh_name or "BAHÇEKÖY" in wh_name:
+                                display = "Bahçeköy mağazası"
+                            else:
+                                display = wh_name
+                            
+                            warehouse_info.append(f"{display}: Mevcut")
+                    except:
+                        pass
+                
+                return warehouse_info if warehouse_info else ["Hiçbir mağazada mevcut değil"]
+            else:
+                print(f"DEBUG - No {size_pattern} variant found for {pattern}")
+                return ["Hiçbir mağazada mevcut değil"]
+        else:
+            # No size filter - get all stock
+            return ["Beden bilgisi belirtilmedi"]
+            
+    except Exception as e:
+        print(f"Error: {e}")
+        return None

whatsapp_features.py

@@ -0,0 +1,432 @@
+# -*- coding: utf-8 -*-
+"""
+WhatsApp Trek Chatbot Enhanced Features
+1. Ürün Karşılaştırma
+2. Bütçe Önerileri  
+3. Fiyat Hesaplamaları
+WhatsApp için basitleştirilmiş versiyon - Görsel AI ve profil sistemi yok
+"""
+
+import re
+from datetime import datetime
+
+class WhatsAppProductComparison:
+    """WhatsApp için ürün karşılaştırma sistemi"""
+    
+    def __init__(self, products_data):
+        self.products = products_data
+    
+    def round_price(self, price_str):
+        """Fiyatı yuvarlama formülüne göre yuvarla"""
+        try:
+            price_float = float(price_str)
+            # Fiyat 200000 üzerindeyse en yakın 5000'lik basamağa yuvarla
+            if price_float > 200000:
+                return str(round(price_float / 5000) * 5000)
+            # Fiyat 30000 üzerindeyse en yakın 1000'lik basamağa yuvarla
+            elif price_float > 30000:
+                return str(round(price_float / 1000) * 1000)
+            # Fiyat 10000 üzerindeyse en yakın 100'lük basamağa yuvarla
+            elif price_float > 10000:
+                return str(round(price_float / 100) * 100)
+            # Diğer durumlarda en yakın 10'luk basamağa yuvarla
+            else:
+                return str(round(price_float / 10) * 10)
+        except (ValueError, TypeError):
+            return price_str
+    
+    def find_products_by_name(self, product_names):
+        """İsimlere göre ürünleri bul"""
+        found_products = []
+        used_products = set()  # Aynı ürünü iki kez eklememek için
+        
+        for name in product_names:
+            for product in self.products:
+                product_id = product[2]  # full_name'i unique id olarak kullan
+                if product_id not in used_products and name.lower() in product[2].lower():
+                    found_products.append(product)
+                    used_products.add(product_id)
+                    break
+        return found_products
+    
+    def create_comparison_whatsapp(self, product_names):
+        """WhatsApp için karşılaştırma metni oluştur"""
+        products = self.find_products_by_name(product_names)
+        
+        if len(products) < 2:
+            return "❌ Karşılaştırma için en az 2 ürün gerekli."
+        
+        # Karşılaştırma metnini hazırla
+        comparison_text = "📊 **ÜRÜN KARŞILAŞTIRMASI**\n\n"
+        
+        for i, product in enumerate(products, 1):
+            name, item_info, full_name = product
+            
+            # Ürün bilgilerini parse et
+            stock_status = item_info[0] if len(item_info) > 0 else "Bilgi yok"
+            price_raw = item_info[1] if len(item_info) > 1 and item_info[1] else "Fiyat yok"
+            product_link = item_info[2] if len(item_info) > 2 else ""
+            
+            # Fiyatı yuvarlama formülüne göre yuvarla
+            if price_raw != "Fiyat yok":
+                price = self.round_price(price_raw)
+                price_display = f"{price} TL"
+            else:
+                price_display = price_raw
+            
+            comparison_text += f"**{i}. {full_name}**\n"
+            comparison_text += f"📦 Stok: {stock_status}\n"
+            comparison_text += f"💰 Fiyat: {price_display}\n"
+            
+            # Resim URL'si varsa ekle (6. index)
+            if len(item_info) > 6 and item_info[6]:
+                comparison_text += f"🖼️ Resim: {item_info[6]}\n"
+            
+            if product_link:
+                comparison_text += f"🔗 Link: {product_link}\n"
+            
+            comparison_text += "\n" + "─" * 25 + "\n\n"
+        
+        return comparison_text
+    
+    def get_similar_products(self, product_name, category_filter=None):
+        """Benzer ürünleri bul"""
+        similar_products = []
+        base_name = product_name.lower().split()[0]  # İlk kelimeyi al
+        
+        for product in self.products:
+            product_full_name = product[2].lower()
+            if base_name in product_full_name and product_name.lower() != product_full_name:
+                if category_filter:
+                    if category_filter.lower() in product_full_name:
+                        similar_products.append(product)
+                else:
+                    similar_products.append(product)
+        
+        return similar_products[:3]  # İlk 3 benzer ürün
+
+class WhatsAppBudgetRecommendations:
+    """WhatsApp için bütçe önerileri"""
+    
+    def __init__(self, products_data):
+        self.products = products_data
+    
+    def get_budget_recommendations(self, budget_min, budget_max):
+        """Bütçeye uygun öneriler"""
+        suitable_products = []
+        
+        for product in self.products:
+            if product[1][0] == "stokta" and product[1][1]:  # Stokta ve fiyatı var
+                try:
+                    price = float(product[1][1])
+                    if budget_min <= price <= budget_max:
+                        suitable_products.append(product)
+                except (ValueError, TypeError):
+                    continue
+        
+        return suitable_products[:5]  # İlk 5 öneri
+    
+    def format_budget_recommendations_whatsapp(self, products, budget_min, budget_max):
+        """WhatsApp için bütçe önerilerini formatla"""
+        if not products:
+            if budget_min == budget_max:
+                return f"❌ {budget_min:,.0f} TL bütçenize uygun stokta ürün bulunamadı."
+            else:
+                return f"❌ {budget_min:,.0f}-{budget_max:,.0f} TL bütçenize uygun stokta ürün bulunamadı."
+        
+        if budget_min == budget_max:
+            text = f"💰 **{budget_min:,.0f} TL BÜTÇENİZE EN YAKIN ÖNERİLER**\n\n"
+        else:
+            text = f"💰 **{budget_min:,.0f}-{budget_max:,.0f} TL BÜTÇENİZE UYGUN ÖNERİLER**\n\n"
+        
+        for i, product in enumerate(products, 1):
+            name, item_info, full_name = product
+            price = item_info[1] if len(item_info) > 1 else "Fiyat yok"
+            product_link = item_info[2] if len(item_info) > 2 else ""
+            
+            text += f"**{i}. {full_name}**\n"
+            # Fiyatı formatlı göster
+            try:
+                price_float = float(price)
+                price_formatted = f"{price_float:,.0f}"
+            except:
+                price_formatted = price
+            text += f"💰 Fiyat: {price_formatted} TL\n"
+            
+            # Resim URL'si varsa ekle
+            if len(item_info) > 6 and item_info[6]:
+                text += f"🖼️ Resim: {item_info[6]}\n"
+            
+            if product_link:
+                text += f"🔗 Link: {product_link}\n"
+            
+            text += "\n"
+        
+        return text
+
+class WhatsAppCategoryRecommendations:
+    """WhatsApp için kategori bazlı öneriler"""
+    
+    def __init__(self, products_data):
+        self.products = products_data
+    
+    def get_category_products(self, category_keywords):
+        """Kategoriye göre ürünleri bul"""
+        category_products = []
+        
+        for product in self.products:
+            if product[1][0] == "stokta":  # Sadece stokta olanlar
+                product_name = product[2].lower()
+                for keyword in category_keywords:
+                    if keyword.lower() in product_name:
+                        category_products.append(product)
+                        break
+        
+        return category_products[:100]  # İlk 100 ürün - bütçe filtresi için daha fazla ürün
+    
+    def format_category_recommendations(self, category_name, products):
+        """Kategori önerilerini formatla"""
+        if not products:
+            return f"❌ {category_name} kategorisinde stokta ürün bulunamadı."
+        
+        text = f"🚲 **{category_name.upper()} KATEGORİSİ ÖNERİLERİ**\n\n"
+        
+        for i, product in enumerate(products, 1):
+            name, item_info, full_name = product
+            price = item_info[1] if len(item_info) > 1 else "Fiyat yok"
+            
+            # Fiyatı formatlı göster
+            try:
+                price_float = float(price)
+                price_formatted = f"{price_float:,.0f}"
+            except:
+                price_formatted = price
+            
+            text += f"**{i}. {full_name}**\n"
+            text += f"💰 Fiyat: {price_formatted} TL\n\n"
+        
+        return text
+
+# Global instance'lar
+whatsapp_product_comparison = None
+whatsapp_budget_recommendations = None
+whatsapp_category_recommendations = None
+
+def initialize_whatsapp_features(products_data):
+    """WhatsApp enhanced özellikleri başlat"""
+    global whatsapp_product_comparison, whatsapp_budget_recommendations, whatsapp_category_recommendations
+    
+    whatsapp_product_comparison = WhatsAppProductComparison(products_data)
+    whatsapp_budget_recommendations = WhatsAppBudgetRecommendations(products_data)
+    whatsapp_category_recommendations = WhatsAppCategoryRecommendations(products_data)
+
+def handle_whatsapp_comparison_request(user_message):
+    """WhatsApp karşılaştırma talebini işle"""
+    try:
+        if "karşılaştır" in user_message.lower() or "compare" in user_message.lower():
+            # Ürün isimlerini çıkarmaya çalış
+            words = user_message.lower().split()
+            potential_products = []
+            
+            # Bilinen model isimlerini ara - daha spesifik
+            known_models = ["émonda", "madone", "domane", "marlin", "fuel", "powerfly", "fx", "checkpoint", "procaliber", "supercaliber"]
+            
+            # Marlin 6, Marlin 7 gibi spesifik modelleri ara
+            message_lower = user_message.lower()
+            if "marlin" in message_lower:
+                import re
+                marlin_numbers = re.findall(r'marlin\s*(\d+)', message_lower)
+                if len(marlin_numbers) >= 2:
+                    # Marlin 6, Marlin 7 gibi spesifik modeller bulundu
+                    for num in marlin_numbers:
+                        potential_products.append(f"marlin {num}")
+                elif len(marlin_numbers) == 1:
+                    potential_products.append(f"marlin {marlin_numbers[0]}")
+                else:
+                    potential_products.append("marlin")
+            
+            # Diğer modelleri ara
+            for word in words:
+                for model in known_models:
+                    if model != "marlin" and model in word:  # marlin'i ayrı işliyoruz
+                        potential_products.append(model)
+            
+            # Duplicate'leri kaldır
+            potential_products = list(dict.fromkeys(potential_products))
+            
+            if len(potential_products) >= 2 and whatsapp_product_comparison:
+                comparison_result = whatsapp_product_comparison.create_comparison_whatsapp(potential_products)
+                return comparison_result
+        
+        return None
+    except Exception as e:
+        print(f"WhatsApp Comparison error: {e}")
+        return None
+
+def handle_whatsapp_price_query(user_message):
+    """WhatsApp fiyat sorgusu - 'ne kadar', 'fiyat', 'kaç para' gibi"""
+    try:
+        user_lower = user_message.lower()
+        
+        # Fiyat sorgusu anahtar kelimeleri
+        price_query_keywords = ["ne kadar", "fiyat", "kaç para", "fiyatı", "kaça", "para"]
+        if not any(keyword in user_lower for keyword in price_query_keywords):
+            return None
+        
+        # Ürün adı tespit et
+        product_keywords = ["madone", "émonda", "domane", "marlin", "fuel", "powerfly", "fx", "checkpoint", "procaliber", "supercaliber", "ds", "verve", "rail"]
+        found_product = None
+        
+        for keyword in product_keywords:
+            if keyword in user_lower:
+                found_product = keyword
+                break
+        
+        if found_product and whatsapp_budget_recommendations:
+            # Ürünü products listesinde ara
+            matching_products = []
+            for product in whatsapp_budget_recommendations.products:
+                if product[1][0] == "stokta" and found_product in product[2].lower():
+                    matching_products.append(product)
+            
+            if matching_products:
+                # İlk ürünü al (en temel model)
+                main_product = matching_products[0]
+                name, item_info, full_name = main_product
+                price = item_info[1] if len(item_info) > 1 else "Fiyat yok"
+                
+                try:
+                    price_float = float(price)
+                    price_formatted = f"{price_float:,.0f}"
+                except:
+                    price_formatted = price
+                
+                # Aynı serinin diğer modellerini bul
+                series_products = matching_products[:3]  # İlk 3 model
+                
+                response = f"🚲 **{found_product.upper()} SERİSİ FİYATLARI**\\n\\n"
+                
+                for i, product in enumerate(series_products, 1):
+                    name, item_info, full_name = product
+                    price = item_info[1] if len(item_info) > 1 else "Fiyat yok"
+                    
+                    try:
+                        price_float = float(price)
+                        price_formatted = f"{price_float:,.0f}"
+                    except:
+                        price_formatted = price
+                    
+                    response += f"**{i}. {full_name}**\\n"
+                    response += f"💰 Fiyat: {price_formatted} TL\\n\\n"
+                
+                return response
+        
+        return None
+    except Exception as e:
+        print(f"WhatsApp Price Query error: {e}")
+        return None
+
+def handle_whatsapp_budget_request(user_message):
+    """WhatsApp bütçe talebini işle"""
+    try:
+        message_lower = user_message.lower()
+        
+        # Kategori sorgusu değilse sadece bütçe sorgusuna bak
+        category_keywords = ["yol", "dağ", "şehir", "elektrikli", "gravel", "marlin", "madone", "émonda", "domane", "fuel", "powerfly", "fx", "ds", "checkpoint"]
+        has_category = any(keyword in message_lower for keyword in category_keywords)
+        
+        if has_category:
+            return None  # Kategori varsa category function'a bırak
+        
+        # Sadece sayı varsa bütçe olarak algıla
+        import re
+        numbers = re.findall(r'\d+', user_message)
+        
+        if numbers and whatsapp_budget_recommendations:
+            budget_value = int(numbers[0]) * 1000  # 350 -> 350000
+            
+            # Tüm stokta olan ürünleri al
+            all_products = []
+            for product in whatsapp_budget_recommendations.products:
+                if product[1][0] == "stokta" and product[1][1]:
+                    try:
+                        price = float(product[1][1])
+                        price_diff = abs(price - budget_value)
+                        all_products.append((product, price_diff))
+                    except:
+                        continue
+            
+            # Fiyat farkına göre sırala
+            all_products.sort(key=lambda x: x[1])
+            closest_products = [product[0] for product in all_products[:5]]  # En yakın 5 ürün
+            
+            if closest_products:
+                return f"💰 {budget_value:,} TL bütçenize en yakın öneriler:\n\n" + whatsapp_budget_recommendations.format_budget_recommendations_whatsapp(
+                    closest_products, budget_value, budget_value
+                )
+        
+        return None
+    except Exception as e:
+        print(f"WhatsApp Budget error: {e}")
+        return None
+
+def handle_whatsapp_category_request(user_message, phone_number=None):
+    """WhatsApp kategori önerisi talebini işle"""
+    try:
+        user_lower = user_message.lower()
+        
+        # Bütçe bilgisini çıkar (sadece sayı varsa)
+        budget_value = None
+        import re
+        numbers = re.findall(r'\d+', user_message)
+        if numbers:
+            budget_value = int(numbers[0]) * 1000  # 350 -> 350000
+        
+        # Kategori tespiti - basit keyword matching
+        categories = {
+            "dağ bisikleti": ["dağ", "dag", "offroad", "mountain", "marlin", "fuel", "procaliber", "supercaliber"],
+            "yol bisikleti": ["yol", "road", "hız", "yarış", "émonda", "madone", "domane", "speed"],
+            "şehir bisikleti": ["şehir", "sehir", "city", "urban", "fx", "ds", "dual sport", "verve"],
+            "elektrikli bisiklet": ["elektrikli", "electric", "e-bike", "ebike", "powerfly", "rail", "fuel exe", "domane+", "fx+", "ds+", "verve+", "townie"],
+            "gravel bisiklet": ["gravel", "çakıl", "checkpoint"]
+        }
+        
+        for category_name, keywords in categories.items():
+            if any(keyword in user_lower for keyword in keywords):
+                if whatsapp_category_recommendations:
+                    # Kategori ürünlerini al
+                    products = whatsapp_category_recommendations.get_category_products(keywords)
+                    
+                    # Bütçe varsa fiyat farkına göre sırala
+                    if budget_value is not None:
+                        products_with_price_diff = []
+                        for product in products:
+                            if product[1][0] == "stokta" and product[1][1]:
+                                try:
+                                    price = float(product[1][1])
+                                    price_diff = abs(price - budget_value)
+                                    products_with_price_diff.append((product, price_diff))
+                                except:
+                                    continue
+                        
+                        # Fiyat farkına göre sırala (en yakın fiyat önce)
+                        products_with_price_diff.sort(key=lambda x: x[1])
+                        products = [product[0] for product in products_with_price_diff[:5]]  # En yakın 5 ürün
+                    else:
+                        products = products[:5]  # Bütçe yoksa ilk 5 ürün
+                    
+                    if products:
+                        response = whatsapp_category_recommendations.format_category_recommendations(
+                            category_name, products
+                        )
+                        
+                        # Bütçe bilgisi varsa ekle
+                        if budget_value is not None:
+                            response = f"💰 {budget_value:,} TL bütçenize en yakın öneriler:\n\n" + response
+                        
+                        return response
+        
+        return None
+    except Exception as e:
+        print(f"WhatsApp Category error: {e}")
+        return None

whatsapp_improved_chatbot.py

@@ -0,0 +1,298 @@
+"""
+WhatsApp Improved Chatbot with Professional Product Search
+Optimized for mobile WhatsApp formatting
+"""
+
+from product_search import ProductSearchEngine
+import re
+from typing import List, Dict, Optional, Tuple
+
+class WhatsAppImprovedChatbot:
+    """Enhanced chatbot with intelligent product handling for WhatsApp"""
+    
+    def __init__(self, products: List[Tuple]):
+        """Initialize with product list"""
+        self.search_engine = ProductSearchEngine(products)
+        self.products = products
+        
+    def detect_product_query(self, message: str) -> bool:
+        """Detect if message is asking about products"""
+        product_keywords = [
+            'bisiklet', 'bike', 'model', 'fiyat', 'price', 'stok', 'stock',
+            'özellikleri', 'features', 'hangi', 'which', 'var mı', 'mevcut',
+            'kaç', 'how much', 'ne kadar', 'kampanya', 'indirim', 'discount',
+            'karşılaştır', 'compare', 'benzer', 'similar', 'alternatif',
+            'öneri', 'recommend', 'tavsiye', 'suggest'
+        ]
+        
+        message_lower = message.lower()
+        
+        # Check for product keywords
+        if any(keyword in message_lower for keyword in product_keywords):
+            return True
+        
+        # Check for model numbers
+        if re.search(r'\b\d+\.?\d*\b', message):
+            return True
+        
+        # Check for known product categories
+        categories = ['trek', 'marlin', 'fuel', 'slash', 'remedy', 'checkpoint', 
+                     'domane', 'madone', 'emonda', 'fx', 'dual', 'wahoo', 'powerfly']
+        if any(cat in message_lower for cat in categories):
+            return True
+        
+        return False
+    
+    def extract_query_intent(self, message: str) -> Dict:
+        """Extract the intent from user query"""
+        intent = {
+            'type': 'general',
+            'action': None,
+            'filters': {}
+        }
+        
+        message_lower = message.lower()
+        
+        # Price query
+        if any(word in message_lower for word in ['fiyat', 'price', 'kaç', 'ne kadar', 'how much']):
+            intent['type'] = 'price'
+            intent['action'] = 'get_price'
+        
+        # Stock query
+        elif any(word in message_lower for word in ['stok', 'stock', 'var mı', 'mevcut', 'available']):
+            intent['type'] = 'stock'
+            intent['action'] = 'check_stock'
+        
+        # Comparison query
+        elif any(word in message_lower for word in ['karşılaştır', 'compare', 'fark', 'difference']):
+            intent['type'] = 'comparison'
+            intent['action'] = 'compare_products'
+        
+        # Recommendation query
+        elif any(word in message_lower for word in ['öneri', 'recommend', 'tavsiye', 'suggest', 'hangi']):
+            intent['type'] = 'recommendation'
+            intent['action'] = 'recommend'
+        
+        # Feature query
+        elif any(word in message_lower for word in ['özellik', 'feature', 'spec', 'detay', 'detail']):
+            intent['type'] = 'features'
+            intent['action'] = 'get_features'
+        
+        # Extract context (size, color, type, etc.)
+        context = self.search_engine.extract_product_context(message)
+        intent['filters'] = context
+        
+        return intent
+    
+    def format_product_info_whatsapp(self, product: Tuple, intent: Dict) -> str:
+        """Format product information for WhatsApp"""
+        name = product[2]  # Full name
+        info = product[1]  # Product info array
+        
+        # Basic info
+        stock_status = info[0] if len(info) > 0 else "bilinmiyor"
+        
+        # Build response for WhatsApp (more compact format)
+        response_parts = []
+        
+        # Product name with status emoji
+        if stock_status == "stokta":
+            response_parts.append(f"🚴‍♂️ *{name}*")
+            response_parts.append("✅ *Stokta mevcut*")
+        else:
+            response_parts.append(f"🚴‍♂️ *{name}*")
+            response_parts.append("❌ *Stokta yok*")
+        
+        # Price information (only if in stock)
+        if intent['type'] in ['price', 'general'] and stock_status == "stokta" and len(info) > 1:
+            price = info[1]
+            response_parts.append(f"💰 *Fiyat:* {price} TL")
+            
+            # Campaign price if available
+            if len(info) > 4 and info[4]:
+                response_parts.append(f"🎯 *Kampanya:* {info[4]} TL")
+                
+                # Calculate discount
+                try:
+                    normal_price = float(info[1])
+                    campaign_price = float(info[4])
+                    discount = normal_price - campaign_price
+                    if discount > 0:
+                        response_parts.append(f"💸 *İndirim:* {discount:.0f} TL")
+                except:
+                    pass
+            
+            # Wire transfer price if no campaign
+            elif len(info) > 3 and info[3]:
+                response_parts.append(f"🏦 *Havale:* {info[3]} TL")
+        
+        # Product link (shortened for WhatsApp)
+        if len(info) > 2 and info[2]:
+            response_parts.append(f"🔗 Ürün sayfası: {info[2]}")
+        
+        return "\n".join(response_parts)
+    
+    def generate_product_response(self, message: str) -> str:
+        """Generate response for product queries optimized for WhatsApp"""
+        intent = self.extract_query_intent(message)
+        
+        # Search for products
+        search_results = self.search_engine.search(message)
+        
+        if not search_results:
+            # No products found - provide helpful response
+            response = self._handle_no_results_whatsapp(message)
+        elif len(search_results) == 1:
+            # Single product found
+            product = search_results[0][1]
+            response = self.format_product_info_whatsapp(product, intent)
+        elif search_results[0][0] > 0.9:
+            # Very high confidence match
+            product = search_results[0][1]
+            response = self.format_product_info_whatsapp(product, intent)
+        else:
+            # Multiple products found
+            response = self._handle_multiple_results_whatsapp(search_results[:3], intent)  # Only 3 for WhatsApp
+        
+        return response
+    
+    def _handle_no_results_whatsapp(self, query: str) -> str:
+        """Handle case when no products are found - WhatsApp format"""
+        response_parts = ["🤔 *Aradığınız ürünü bulamadım.*"]
+        
+        # Get suggestions
+        suggestions = self.search_engine.generate_suggestions(query)
+        
+        if suggestions:
+            response_parts.append("\n💡 *Belki şunları arıyor olabilirsiniz:*")
+            for i, suggestion in enumerate(suggestions[:2], 1):  # Only 2 suggestions for WhatsApp
+                response_parts.append(f"{i}. {suggestion}")
+        else:
+            response_parts.append("\n📝 *Örnek aramalar:*")
+            response_parts.append("• Marlin 5")
+            response_parts.append("• FX 3 Disc")
+            response_parts.append("• Checkpoint ALR 5")
+        
+        return "\n".join(response_parts)
+    
+    def _handle_multiple_results_whatsapp(self, results: List[Tuple[float, Tuple]], intent: Dict) -> str:
+        """Handle multiple product results - WhatsApp format"""
+        response_parts = ["📋 *Birden fazla ürün buldum:*\n"]
+        
+        for i, (score, product) in enumerate(results, 1):
+            name = product[2]
+            stock = product[1][0] if len(product[1]) > 0 else "bilinmiyor"
+            
+            # Compact info line for WhatsApp
+            if stock == "stokta":
+                status_emoji = "✅"
+                response_parts.append(f"*{i}. {name}* {status_emoji}")
+                
+                # Add price if intent is price-related
+                if intent['type'] in ['price', 'general'] and len(product[1]) > 1:
+                    price = product[1][1]
+                    response_parts.append(f"   💰 {price} TL")
+                    
+                    # Show campaign price if available
+                    if len(product[1]) > 4 and product[1][4]:
+                        response_parts.append(f"   🎯 Kampanya: {product[1][4]} TL")
+                
+                # Add product link if available
+                if len(product[1]) > 2 and product[1][2]:
+                    response_parts.append(f"   🔗 {product[1][2]}")
+            else:
+                status_emoji = "❌"
+                response_parts.append(f"*{i}. {name}* {status_emoji}")
+            
+            response_parts.append("")  # Empty line between products
+        
+        response_parts.append("💡 _Daha detaylı bilgi için ürün adını yazın_")
+        
+        return "\n".join(response_parts)
+    
+    def handle_comparison_whatsapp(self, message: str) -> Optional[str]:
+        """Handle product comparison requests - WhatsApp format"""
+        # Extract product names for comparison
+        comparison_words = ['ile', 've', 'vs', 'versus', 'karşılaştır', 'arasında']
+        
+        products_to_compare = []
+        
+        # Try to extract two product names
+        for word in comparison_words:
+            if word in message.lower():
+                parts = message.lower().split(word)
+                if len(parts) >= 2:
+                    # Search for each part
+                    for part in parts[:2]:
+                        result = self.search_engine.find_best_match(part.strip())
+                        if result:
+                            products_to_compare.append(result)
+        
+        if len(products_to_compare) < 2:
+            # Try to find products mentioned in the message
+            search_results = self.search_engine.search(message)
+            products_to_compare = [r[1] for r in search_results[:2] if r[0] > 0.6]
+        
+        if len(products_to_compare) >= 2:
+            return self._format_comparison_whatsapp(products_to_compare[:2])
+        
+        return None
+    
+    def _format_comparison_whatsapp(self, products: List[Tuple]) -> str:
+        """Format product comparison for WhatsApp"""
+        response_parts = ["📊 *Ürün Karşılaştırması*\n"]
+        
+        for i, product in enumerate(products, 1):
+            name = product[2]
+            info = product[1]
+            
+            response_parts.append(f"*{i}. {name}*")
+            
+            # Stock status
+            stock = info[0] if len(info) > 0 else "bilinmiyor"
+            if stock == "stokta":
+                response_parts.append("✅ Stokta mevcut")
+            else:
+                response_parts.append("❌ Stokta yok")
+            
+            # Price (compact for WhatsApp)
+            if stock == "stokta" and len(info) > 1:
+                price = info[1]
+                response_parts.append(f"💰 {price} TL")
+                
+                if len(info) > 4 and info[4]:
+                    response_parts.append(f"🎯 Kampanya: {info[4]} TL")
+            
+            response_parts.append("")  # Empty line
+        
+        return "\n".join(response_parts)
+    
+    def process_message(self, message: str) -> Dict:
+        """Process user message and return structured response optimized for WhatsApp"""
+        result = {
+            'is_product_query': False,
+            'response': None,
+            'products_found': [],
+            'intent': None
+        }
+        
+        # Check if it's a product query
+        if self.detect_product_query(message):
+            result['is_product_query'] = True
+            result['intent'] = self.extract_query_intent(message)
+            
+            # Check for comparison request
+            if result['intent']['type'] == 'comparison':
+                comparison_result = self.handle_comparison_whatsapp(message)
+                if comparison_result:
+                    result['response'] = comparison_result
+                    return result
+            
+            # Generate product response
+            result['response'] = self.generate_product_response(message)
+            
+            # Get found products
+            search_results = self.search_engine.search(message)
+            result['products_found'] = [r[1] for r in search_results[:2] if r[0] > 0.6]  # Limit to 2 for WhatsApp
+        
+        return result

whatsapp_passive_profiler.py

@@ -0,0 +1,368 @@
+# -*- coding: utf-8 -*-
+"""
+WhatsApp Pasif Profil Sistemi
+Kullanıcıya soru sormadan sohbet analizi ile profil oluşturur
+"""
+
+import re
+import json
+import os
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any
+
+class WhatsAppPassiveProfiler:
+    """Sohbet analizi ile kullanıcı profili çıkarır"""
+    
+    def __init__(self):
+        self.profiles_file = "user_profiles.json"
+        self.profiles = self.load_profiles()
+        
+        # Bütçe ifadeleri
+        self.budget_patterns = [
+            r'bütçem?\s*(\d+)[\s-]*(\d+)?\s*k?\s*(bin|bin tl|tl)?',
+            r'(\d+)[\s-]*(\d+)?\s*k?\s*(bin|bin tl|tl)?\s*bütçe',
+            r'(\d+)[\s-]*(\d+)?\s*k?\s*(bin|bin tl|tl)?\s*arasında',
+            r'maksimum\s*(\d+)\s*k?\s*(bin|bin tl|tl)?',
+            r'en fazla\s*(\d+)\s*k?\s*(bin|bin tl|tl)?'
+        ]
+        
+        # Kategori tercihleri
+        self.category_keywords = {
+            "dağ_bisikleti": ["dağ", "dag", "offroad", "patika", "doğa", "orman", "marlin", "fuel", "procaliber"],
+            "yol_bisikleti": ["yol", "asfalt", "hız", "yarış", "triathlon", "émonda", "madone", "domane"],
+            "şehir_bisikleti": ["şehir", "kent", "günlük", "işe gidip gelme", "fx", "ds", "verve"],
+            "elektrikli": ["elektrikli", "electric", "e-bike", "ebike", "batarya", "powerfly", "rail"],
+            "gravel": ["gravel", "çakıl", "macera", "touring", "checkpoint"]
+        }
+        
+        # Kullanım amaçları
+        self.usage_patterns = {
+            "spor": ["spor", "antrenman", "kondisyon", "fitness", "egzersiz", "yarış"],
+            "günlük": ["işe gitmek", "günlük", "şehir içi", "ulaşım", "market", "alışveriş"],
+            "hobi": ["hobi", "eğlence", "gezinti", "keyif", "hafta sonu", "macera"],
+            "profesyonel": ["profesyonel", "yarış", "müsabaka", "antrenör", "ciddi"]
+        }
+        
+        # Boy/beden işaretçileri
+        self.size_patterns = {
+            "boy": r'boyum\s*(\d+)\s*cm?|(\d+)\s*cm?\s*boy',
+            "kilo": r'kilom\s*(\d+)\s*kg?|(\d+)\s*kg?\s*kilo',
+            "beden": r'beden[im]?\s*([xsl]+)|([xsl]+)\s*beden'
+        }
+        
+    def load_profiles(self) -> Dict:
+        """Mevcut profilleri yükle"""
+        if os.path.exists(self.profiles_file):
+            try:
+                with open(self.profiles_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except Exception as e:
+                print(f"Profil yükleme hatası: {e}")
+        return {}
+    
+    def save_profiles(self):
+        """Profilleri kaydet"""
+        try:
+            with open(self.profiles_file, 'w', encoding='utf-8') as f:
+                json.dump(self.profiles, f, ensure_ascii=False, indent=2, default=str)
+        except Exception as e:
+            print(f"Profil kaydetme hatası: {e}")
+    
+    def get_or_create_profile(self, phone_number: str) -> Dict:
+        """Profil getir veya oluştur"""
+        if phone_number not in self.profiles:
+            self.profiles[phone_number] = {
+                "created_at": datetime.now(),
+                "last_updated": datetime.now(),
+                "total_messages": 0,
+                "preferences": {
+                    "budget_min": None,
+                    "budget_max": None,
+                    "categories": [],  # İlgilendiği kategoriler
+                    "usage_purpose": [],  # Kullanım amaçları
+                    "size_info": {},  # Boy, kilo, beden bilgileri
+                    "brand_preferences": [],  # Marka tercihleri
+                    "color_preferences": []  # Renk tercihleri
+                },
+                "behavior": {
+                    "price_sensitive": False,  # Fiyata duyarlı mı
+                    "tech_interested": False,  # Teknik detaylarla ilgilenir mi
+                    "comparison_lover": False,  # Karşılaştırma sever mi
+                    "quick_decider": False,  # Hızlı karar verir mi
+                    "research_oriented": False  # Araştırmacı mı
+                },
+                "interests": {
+                    "viewed_products": [],  # Baktığı ürünler
+                    "compared_products": [],  # Karşılaştırdığı ürünler
+                    "favorite_features": [],  # İlgilendiği özellikler
+                    "mentioned_brands": []  # Bahsettiği markalar
+                },
+                "statistics": {
+                    "comparison_requests": 0,
+                    "budget_queries": 0,
+                    "technical_questions": 0,
+                    "price_questions": 0,
+                    "availability_questions": 0
+                }
+            }
+        return self.profiles[phone_number]
+    
+    def analyze_message(self, phone_number: str, message: str) -> Dict:
+        """Mesajı analiz et ve profili güncelle"""
+        profile = self.get_or_create_profile(phone_number)
+        message_lower = message.lower()
+        
+        # Mesaj sayısını artır
+        profile["total_messages"] += 1
+        profile["last_updated"] = datetime.now()
+        
+        analysis_results = {
+            "budget_detected": False,
+            "category_detected": False,
+            "usage_detected": False,
+            "size_detected": False,
+            "behavior_indicators": []
+        }
+        
+        # Bütçe analizi
+        budget_info = self.extract_budget(message_lower)
+        if budget_info:
+            profile["preferences"]["budget_min"] = budget_info["min"]
+            profile["preferences"]["budget_max"] = budget_info["max"]
+            profile["statistics"]["budget_queries"] += 1
+            analysis_results["budget_detected"] = True
+        
+        # Kategori tercihi analizi
+        detected_categories = self.detect_categories(message_lower)
+        if detected_categories:
+            for category in detected_categories:
+                if category not in profile["preferences"]["categories"]:
+                    profile["preferences"]["categories"].append(category)
+            analysis_results["category_detected"] = True
+        
+        # Kullanım amacı analizi
+        usage_purposes = self.detect_usage_purpose(message_lower)
+        if usage_purposes:
+            for purpose in usage_purposes:
+                if purpose not in profile["preferences"]["usage_purpose"]:
+                    profile["preferences"]["usage_purpose"].append(purpose)
+            analysis_results["usage_detected"] = True
+        
+        # Boy/beden bilgisi analizi
+        size_info = self.extract_size_info(message_lower)
+        if size_info:
+            profile["preferences"]["size_info"].update(size_info)
+            analysis_results["size_detected"] = True
+        
+        # Davranış analizi
+        behavior_indicators = self.analyze_behavior(message_lower)
+        for behavior, detected in behavior_indicators.items():
+            if detected:
+                profile["behavior"][behavior] = True
+                analysis_results["behavior_indicators"].append(behavior)
+        
+        # İstatistik güncelleme
+        self.update_statistics(profile, message_lower)
+        
+        # Profili kaydet
+        self.save_profiles()
+        
+        return analysis_results
+    
+    def extract_budget(self, message: str) -> Optional[Dict]:
+        """Bütçe bilgisini çıkar"""
+        for pattern in self.budget_patterns:
+            match = re.search(pattern, message)
+            if match:
+                numbers = [g for g in match.groups() if g and g.isdigit()]
+                if numbers:
+                    if len(numbers) == 1:
+                        # Tek sayı - maksimum bütçe
+                        budget = int(numbers[0])
+                        if budget < 1000:  # K formatında (50k = 50000)
+                            budget *= 1000
+                        return {"min": int(budget * 0.7), "max": budget}
+                    elif len(numbers) >= 2:
+                        # Aralık - min ve max
+                        min_budget = int(numbers[0])
+                        max_budget = int(numbers[1])
+                        if min_budget < 1000:
+                            min_budget *= 1000
+                        if max_budget < 1000:
+                            max_budget *= 1000
+                        return {"min": min_budget, "max": max_budget}
+        return None
+    
+    def detect_categories(self, message: str) -> List[str]:
+        """Kategori tercihlerini tespit et"""
+        detected = []
+        for category, keywords in self.category_keywords.items():
+            if any(keyword in message for keyword in keywords):
+                detected.append(category)
+        return detected
+    
+    def detect_usage_purpose(self, message: str) -> List[str]:
+        """Kullanım amacını tespit et"""
+        detected = []
+        for purpose, keywords in self.usage_patterns.items():
+            if any(keyword in message for keyword in keywords):
+                detected.append(purpose)
+        return detected
+    
+    def extract_size_info(self, message: str) -> Dict:
+        """Boy/beden bilgisini çıkar"""
+        size_info = {}
+        
+        # Boy bilgisi
+        boy_match = re.search(self.size_patterns["boy"], message)
+        if boy_match:
+            boy = boy_match.group(1) or boy_match.group(2)
+            if boy:
+                size_info["height"] = int(boy)
+        
+        # Kilo bilgisi
+        kilo_match = re.search(self.size_patterns["kilo"], message)
+        if kilo_match:
+            kilo = kilo_match.group(1) or kilo_match.group(2)
+            if kilo:
+                size_info["weight"] = int(kilo)
+        
+        # Beden bilgisi
+        beden_match = re.search(self.size_patterns["beden"], message)
+        if beden_match:
+            beden = beden_match.group(1) or beden_match.group(2)
+            if beden:
+                size_info["size"] = beden.upper()
+        
+        return size_info
+    
+    def analyze_behavior(self, message: str) -> Dict[str, bool]:
+        """Davranış kalıplarını analiz et"""
+        behavior = {}
+        
+        # Fiyata duyarlılık
+        price_keywords = ["ucuz", "fiyat", "indirim", "kampanya", "ekonomik", "bütçe"]
+        behavior["price_sensitive"] = any(keyword in message for keyword in price_keywords)
+        
+        # Teknik ilgi
+        tech_keywords = ["teknik", "özellik", "ağırlık", "malzeme", "karbon", "alüminyum", "vites"]
+        behavior["tech_interested"] = any(keyword in message for keyword in tech_keywords)
+        
+        # Karşılaştırma sevgisi
+        comparison_keywords = ["karşılaştır", "fark", "hangisi", "arası", "seçim"]
+        behavior["comparison_lover"] = any(keyword in message for keyword in comparison_keywords)
+        
+        # Araştırmacı yapı
+        research_keywords = ["detay", "bilgi", "araştır", "inceleme", "test", "deneyim"]
+        behavior["research_oriented"] = any(keyword in message for keyword in research_keywords)
+        
+        return behavior
+    
+    def update_statistics(self, profile: Dict, message: str):
+        """İstatistikleri güncelle"""
+        if "karşılaştır" in message:
+            profile["statistics"]["comparison_requests"] += 1
+        
+        if any(word in message for word in ["fiyat", "kaç para", "ne kadar"]):
+            profile["statistics"]["price_questions"] += 1
+        
+        if any(word in message for word in ["stok", "var mı", "mevcut"]):
+            profile["statistics"]["availability_questions"] += 1
+        
+        if any(word in message for word in ["teknik", "özellik", "detay"]):
+            profile["statistics"]["technical_questions"] += 1
+    
+    def get_profile_summary(self, phone_number: str) -> Dict:
+        """Profil özetini döndür"""
+        if phone_number not in self.profiles:
+            return {"exists": False}
+        
+        profile = self.profiles[phone_number]
+        
+        # Profil güvenilirlik skoru (mesaj sayısına göre)
+        confidence = min(profile["total_messages"] / 10.0, 1.0)  # 10 mesajda %100
+        
+        summary = {
+            "exists": True,
+            "confidence": confidence,
+            "total_messages": profile["total_messages"],
+            "preferences": profile["preferences"],
+            "behavior": profile["behavior"],
+            "top_categories": profile["preferences"]["categories"][:3],
+            "is_budget_defined": profile["preferences"]["budget_min"] is not None,
+            "is_tech_savvy": profile["behavior"]["tech_interested"],
+            "is_price_conscious": profile["behavior"]["price_sensitive"],
+            "interaction_style": self.get_interaction_style(profile)
+        }
+        
+        return summary
+    
+    def get_interaction_style(self, profile: Dict) -> str:
+        """Etkileşim stilini belirle"""
+        stats = profile["statistics"]
+        behavior = profile["behavior"]
+        
+        if stats["comparison_requests"] > 2 and behavior["research_oriented"]:
+            return "analytical"  # Analitik - detaylı bilgi sever
+        elif behavior["price_sensitive"] and stats["budget_queries"] > 0:
+            return "budget_conscious"  # Bütçe odaklı
+        elif behavior["tech_interested"] and stats["technical_questions"] > 1:
+            return "technical"  # Teknik odaklı
+        elif stats["comparison_requests"] == 0 and profile["total_messages"] < 5:
+            return "decisive"  # Hızlı karar verici
+        else:
+            return "balanced"  # Dengeli
+    
+    def get_personalized_suggestions(self, phone_number: str, products_data: List) -> Dict:
+        """Kişiselleştirilmiş öneriler"""
+        profile_summary = self.get_profile_summary(phone_number)
+        
+        if not profile_summary["exists"] or profile_summary["confidence"] < 0.3:
+            return {"personalized": False, "reason": "insufficient_data"}
+        
+        suggestions = {
+            "personalized": True,
+            "user_style": profile_summary["interaction_style"],
+            "budget_aware": profile_summary["is_budget_defined"],
+            "recommendations": []
+        }
+        
+        # Bütçe filtresi
+        filtered_products = products_data
+        if profile_summary["preferences"]["budget_min"]:
+            budget_min = profile_summary["preferences"]["budget_min"]
+            budget_max = profile_summary["preferences"]["budget_max"]
+            filtered_products = [
+                p for p in products_data 
+                if p[1][0] == "stokta" and p[1][1] and 
+                budget_min <= float(p[1][1]) <= budget_max
+            ]
+        
+        # Kategori filtresi
+        if profile_summary["top_categories"]:
+            category_products = []
+            for category in profile_summary["top_categories"]:
+                category_products.extend([
+                    p for p in filtered_products 
+                    if any(keyword in p[2].lower() for keyword in self.category_keywords.get(category, []))
+                ])
+            if category_products:
+                filtered_products = category_products
+        
+        suggestions["recommendations"] = filtered_products[:5]
+        return suggestions
+
+# Global instance
+passive_profiler = WhatsAppPassiveProfiler()
+
+def analyze_user_message(phone_number: str, message: str) -> Dict:
+    """Kullanıcı mesajını analiz et ve profili güncelle"""
+    return passive_profiler.analyze_message(phone_number, message)
+
+def get_user_profile_summary(phone_number: str) -> Dict:
+    """Kullanıcı profil özetini getir"""
+    return passive_profiler.get_profile_summary(phone_number)
+
+def get_personalized_recommendations(phone_number: str, products_data: List) -> Dict:
+    """Kişiselleştirilmiş öneriler getir"""
+    return passive_profiler.get_personalized_suggestions(phone_number, products_data)

whatsapp_renderer.py

@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+"""
+WhatsApp Ürün Resimlerini ve Karşılaştırmalarını Gösterme Sistemi
+WhatsApp için basitleştirilmiş versiyon - Sadece URL paylaşımı
+"""
+
+def round_price(price_str):
+    """Fiyatı yuvarlama formülüne göre yuvarla"""
+    try:
+        # TL ve diğer karakterleri temizle
+        price_clean = price_str.replace(' TL', '').replace(',', '.')
+        price_float = float(price_clean)
+        
+        # Fiyat 200000 üzerindeyse en yakın 5000'lik basamağa yuvarla
+        if price_float > 200000:
+            return str(round(price_float / 5000) * 5000)
+        # Fiyat 30000 üzerindeyse en yakın 1000'lik basamağa yuvarla
+        elif price_float > 30000:
+            return str(round(price_float / 1000) * 1000)
+        # Fiyat 10000 üzerindeyse en yakın 100'lük basamağa yuvarla
+        elif price_float > 10000:
+            return str(round(price_float / 100) * 100)
+        # Diğer durumlarda en yakın 10'luk basamağa yuvarla
+        else:
+            return str(round(price_float / 10) * 10)
+    except (ValueError, TypeError):
+        return price_str
+
+def format_message_with_images_whatsapp(message):
+    """WhatsApp için mesajdaki resim URL'lerini formatla"""
+    if "Ürün resmi:" not in message:
+        return message
+    
+    lines = message.split('\n')
+    formatted_lines = []
+    
+    for line in lines:
+        if line.startswith("Ürün resmi:"):
+            image_url = line.replace("Ürün resmi:", "").strip()
+            if image_url:
+                # WhatsApp için sadece URL'yi ekle - WhatsApp otomatik önizleme yapar
+                formatted_lines.append(f"🖼️ Ürün Resmi: {image_url}")
+            else:
+                formatted_lines.append(line)
+        else:
+            formatted_lines.append(line)
+    
+    return '\n'.join(formatted_lines)
+
+def create_product_comparison_whatsapp(products_with_info):
+    """WhatsApp için ürün karşılaştırması oluştur"""
+    if not products_with_info:
+        return ""
+    
+    comparison_text = "📊 **ÜRÜN KARŞILAŞTIRMASI**\n\n"
+    
+    for i, product in enumerate(products_with_info, 1):
+        name = product.get('name', 'Bilinmeyen')
+        price = product.get('price', 'Fiyat yok')
+        stock = product.get('stock', 'Stok bilgisi yok')
+        product_url = product.get('product_url', '')
+        image_url = product.get('image_url', '')
+        
+        comparison_text += f"**{i}. {name}**\n"
+        comparison_text += f"💰 Fiyat: {price}\n"
+        comparison_text += f"📦 Stok: {stock}\n"
+        
+        if image_url:
+            comparison_text += f"🖼️ Resim: {image_url}\n"
+        
+        if product_url:
+            comparison_text += f"🔗 Link: {product_url}\n"
+        
+        comparison_text += "\n" + "─" * 30 + "\n\n"
+    
+    return comparison_text
+
+def extract_product_info_whatsapp(message):
+    """WhatsApp mesajından ürün bilgilerini çıkar ve formatla"""
+    # Önce resim URL'lerini formatla
+    formatted_message = format_message_with_images_whatsapp(message)
+    
+    # Karşılaştırma veya öneri mesajı ise özel formatla
+    if any(keyword in message.lower() for keyword in ["karşılaştır", "öneri", "seçenek", "alternatif", "bütçe"]):
+        # Ürün listesi var mı kontrol et
+        lines = message.split('\n')
+        products = []
+        current_product = {}
+        
+        for line in lines:
+            line = line.strip()
+            if line.startswith('•') and any(keyword in line.lower() for keyword in ['marlin', 'émonda', 'madone', 'domane', 'fuel', 'powerfly', 'fx']):
+                # Yeni ürün başladı
+                if current_product:
+                    products.append(current_product)
+                
+                # Ürün adı ve fiyatı parse et
+                parts = line.split(' - ')
+                name = parts[0].replace('•', '').strip()
+                price_raw = parts[1] if len(parts) > 1 else 'Fiyat yok'
+                
+                # Fiyatı yuvarlama formülüne göre yuvarla
+                if price_raw != 'Fiyat yok':
+                    price = round_price(price_raw) + ' TL'
+                else:
+                    price = price_raw
+                
+                current_product = {
+                    'name': name,
+                    'price': price,
+                    'stock': 'stokta',
+                    'image_url': '',
+                    'product_url': ''
+                }
+            elif "Ürün resmi:" in line and current_product:
+                current_product['image_url'] = line.replace("Ürün resmi:", "").strip()
+            elif "Ürün linki:" in line and current_product:
+                current_product['product_url'] = line.replace("Ürün linki:", "").strip()
+        
+        # Son ürünü ekle
+        if current_product:
+            products.append(current_product)
+        
+        if len(products) > 1:
+            # Çoklu ürün karşılaştırması
+            comparison = create_product_comparison_whatsapp(products)
+            # Orijinal mesajdaki resim linklerini temizle
+            cleaned_message = message
+            for line in message.split('\n'):
+                if line.startswith("Ürün resmi:") or line.startswith("Ürün linki:"):
+                    cleaned_message = cleaned_message.replace(line, "")
+            
+            return cleaned_message.strip() + "\n\n" + comparison
+    
+    return formatted_message
+
+def should_use_comparison_format_whatsapp(message):
+    """WhatsApp mesajının karşılaştırma formatı kullanması gerekip gerekmediğini kontrol et"""
+    comparison_keywords = ["karşılaştır", "öneri", "seçenek", "alternatif", "bütçe", "compare"]
+    return any(keyword in message.lower() for keyword in comparison_keywords)
+
+def format_whatsapp_product_list(products, title="Ürün Listesi"):
+    """WhatsApp için ürün listesini formatla"""
+    if not products:
+        return f"❌ {title} - Uygun ürün bulunamadı."
+    
+    text = f"🚲 **{title.upper()}**\n\n"
+    
+    for i, product in enumerate(products, 1):
+        name, item_info, full_name = product
+        price = item_info[1] if len(item_info) > 1 else "Fiyat yok"
+        product_link = item_info[2] if len(item_info) > 2 else ""
+        
+        text += f"**{i}. {full_name}**\n"
+        text += f"💰 {price} TL\n"
+        
+        # Resim URL'si varsa ekle
+        if len(item_info) > 6 and item_info[6]:
+            text += f"🖼️ {item_info[6]}\n"
+        
+        if product_link:
+            text += f"🔗 {product_link}\n"
+        
+        text += "\n"
+    
+    return text
+
+def format_whatsapp_single_product(product):
+    """WhatsApp için tek ürün formatla"""
+    if not product:
+        return "❌ Ürün bulunamadı."
+    
+    name, item_info, full_name = product
+    
+    text = f"🚲 **{full_name}**\n\n"
+    
+    # Stok durumu
+    stock_status = item_info[0] if len(item_info) > 0 else "Bilgi yok"
+    text += f"📦 Stok: {stock_status}\n"
+    
+    if stock_status == "stokta":
+        # Fiyat bilgileri
+        if len(item_info) > 1 and item_info[1]:
+            text += f"💰 Fiyat: {item_info[1]} TL\n"
+        
+        # EFT fiyatı
+        if len(item_info) > 3 and item_info[3]:
+            text += f"💳 Havale Fiyatı: {item_info[3]} TL\n"
+        
+        # Kampanyalı fiyat
+        if len(item_info) > 4 and item_info[4]:
+            text += f"🎯 Kampanyalı Fiyat: {item_info[4]} TL\n"
+        
+        # Resim
+        if len(item_info) > 6 and item_info[6]:
+            text += f"🖼️ {item_info[6]}\n"
+        
+        # Ürün linki
+        if len(item_info) > 2 and item_info[2]:
+            text += f"🔗 {item_info[2]}\n"
+    
+    return text
+
+def clean_whatsapp_message(message):
+    """WhatsApp mesajını temizle ve optimize et"""
+    # Gereksiz boşlukları temizle
+    lines = [line.strip() for line in message.split('\n') if line.strip()]
+    
+    # Aynı URL'leri tekrar eden satırları kaldır
+    seen_urls = set()
+    clean_lines = []
+    
+    for line in lines:
+        if line.startswith('🖼️') or line.startswith('🔗'):
+            url = line.split(' ', 1)[1] if ' ' in line else line
+            if url not in seen_urls:
+                seen_urls.add(url)
+                clean_lines.append(line)
+        else:
+            clean_lines.append(line)
+    
+    return '\n'.join(clean_lines)