Upload 3 files

app.py

@@ -0,0 +1,1094 @@
+import os
+import json
+import requests
+import xml.etree.ElementTree as ET
+import warnings
+import time
+import threading
+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 modüller - Basit sistem
+from prompts import get_prompt_content_only
+from whatsapp_renderer import extract_product_info_whatsapp
+from whatsapp_passive_profiler import (
+    analyze_user_message, get_user_profile_summary, get_personalized_recommendations
+)
+
+# Import improved WhatsApp search for BF space
+try:
+    from whatsapp_improved_chatbot import WhatsAppImprovedChatbot
+    USE_IMPROVED_SEARCH = True
+except ImportError:
+    print("Improved WhatsApp chatbot not available, using basic search")
+    USE_IMPROVED_SEARCH = False
+
+# LOGGING EN BAŞA EKLENDİ
+import logging
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+warnings.simplefilter('ignore')
+
+# API ayarları
+API_URL = "https://api.openai.com/v1/chat/completions"
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+logger.info(f"OpenAI API Key var mı: {'Evet' if OPENAI_API_KEY else 'Hayır'}")
+
+# Twilio WhatsApp 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")
+TWILIO_WHATSAPP_NUMBER = "whatsapp:+905332047254"
+
+logger.info(f"Twilio SID var mı: {'Evet' if TWILIO_ACCOUNT_SID else 'Hayır'}")
+logger.info(f"Twilio Auth Token var mı: {'Evet' if TWILIO_AUTH_TOKEN else 'Hayır'}")
+logger.info(f"Messaging Service SID var mı: {'Evet' if TWILIO_MESSAGING_SERVICE_SID else 'Hayır'}")
+
+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 başarıyla oluşturuldu!")
+    except Exception as e:
+        logger.error(f"❌ Twilio client hatası: {e}")
+        twilio_client = None
+
+# Trek bisiklet ürünlerini çekme - DÜZELTİLMİŞ VERSİYON
+try:
+    print("🔍 XML DEBUG TEST BAŞLADI")
+    print("========================")
+    
+    url = 'https://www.trekbisiklet.com.tr/output/8582384479'
+    print(f"📡 URL: {url}")
+    
+    print("📥 HTTP isteği gönderiliyor...")
+    response = requests.get(url, verify=False, timeout=10)
+    print(f"✅ HTTP Status: {response.status_code}")
+    print(f"📏 Content Length: {len(response.content)} bytes")
+    
+    # İlk 500 karakteri göster
+    content_preview = response.content[:500].decode('utf-8', errors='ignore')
+    print(f"📄 İlk 500 karakter:")
+    print(content_preview)
+    print("...")
+    
+    print("\n🔄 XML parsing...")
+    root = ET.fromstring(response.content)
+    print(f"✅ XML root tag: {root.tag}")
+    
+    all_items = root.findall('item')
+    print(f"📦 Toplam item sayısı: {len(all_items)}")
+    
+    # İlk birkaç item'ı incele
+    print(f"\n🔍 İlk 3 item analizi:")
+    for i, item in enumerate(all_items[:3]):
+        print(f"\n--- ITEM {i+1} ---")
+        
+        rootlabel = item.find('rootlabel')
+        if rootlabel is not None and rootlabel.text:
+            print(f"📛 Ürün: {rootlabel.text}")
+        else:
+            print("❌ rootlabel bulunamadı")
+            
+        stock = item.find('stockAmount')
+        if stock is not None and stock.text:
+            print(f"📦 Stok: {stock.text}")
+        else:
+            print("❌ stockAmount bulunamadı")
+            
+        price = item.find('priceTaxWithCur')
+        if price is not None and price.text:
+            print(f"💰 Fiyat: {price.text}")
+        else:
+            print("❌ priceTaxWithCur bulunamadı")
+    
+    # Marlin arama testi
+    print(f"\n🎯 MARLIN ARAMA TESİ:")
+    marlin_count = 0
+    products = []
+    
+    for item in all_items:
+        # Değişkenleri önceden tanımla
+        stock_number = 0
+        stock_amount = "stokta değil"
+        price = ""
+        price_eft = ""
+        product_link = ""
+        
+        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 KONTROLÜ - SAYISAL KARŞILAŞTIRMA
+        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 değil"
+            except (ValueError, TypeError):
+                stock_number = 0
+                stock_amount = "stokta değil"
+        
+        # Marlin kontrolü
+        if 'marlin' in full_name.lower():
+            marlin_count += 1
+            print(f"🎯 MARLIN BULUNDU #{marlin_count}: {full_name}")
+            print(f"   📦 Stok: {stock_number} adet")
+            print(f"   📊 Durum: {stock_amount}")
+        
+        # Stokta olan ürünler için 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 fiyatı
+            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 ""
+            
+            # Kampanya fiyatı varsa onu kullan, yoksa normal fiyatı kullan
+            final_price_str = price_str
+            if price_rebate_str:
+                try:
+                    normal_price = float(price_str)
+                    rebate_price = float(price_rebate_str)
+                    # Kampanya fiyatı normal fiyattan farklı ve düşükse kullan
+                    if rebate_price < normal_price:
+                        final_price_str = price_rebate_str
+                except (ValueError, TypeError):
+                    final_price_str = price_str
+            
+            # EFT fiyatı
+            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 ""
+            
+            # Ürün linki
+            link_element = item.find('productLink')
+            product_link = link_element.text if link_element is not None and link_element.text else ""
+            
+            # Fiyat formatting (kampanya fiyatı veya normal fiyat)
+            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 = ""
+        
+        # Ürün bilgilerini tuple olarak oluştur
+        item_info = (stock_amount, price, product_link, price_eft, str(stock_number))
+        products.append((name, item_info, full_name))
+    
+    print(f"\n📊 SONUÇ:")
+    print(f"   Toplam ürün: {len(all_items)}")
+    print(f"   Marlin ürünü: {marlin_count}")
+    print(f"   Products listesi: {len(products)} ürün")
+    
+    # Initialize improved WhatsApp chatbot for BF space
+    global improved_whatsapp_bot
+    improved_whatsapp_bot = None
+    if USE_IMPROVED_SEARCH:
+        try:
+            improved_whatsapp_bot = WhatsAppImprovedChatbot(products)
+            print("✅ BF Space: Improved WhatsApp product search initialized successfully")
+        except Exception as e:
+            print(f"❌ BF Space: Failed to initialize improved WhatsApp search: {e}")
+            USE_IMPROVED_SEARCH = False
+            improved_whatsapp_bot = None
+    
+    # Enhanced features kaldırıldı - GPT-4 doğal dil anlama kullanacak
+    print("✅ Basit sistem aktif - GPT-4 doğal dil anlama")
+    
+    if marlin_count == 0:
+        print("❌ XML'de hiç Marlin ürünü bulunamadı!")
+        print("   Muhtemelen XML'de sadece aksesuar/yedek parça var.")
+    else:
+        print("✅ Marlin ürünleri XML'de mevcut")
+        
+        # Marlin stok raporu
+        marlin_products = [p for p in products if 'marlin' in p[2].lower()]
+        marlin_in_stock = [p for p in marlin_products if p[1][0] == "stokta"]
+        marlin_out_of_stock = [p for p in marlin_products if p[1][0] == "stokta değil"]
+        
+        print(f"\n📊 MARLIN STOK RAPORU:")
+        print(f"  📦 Toplam Marlin modeli: {len(marlin_products)}")
+        print(f"  ✅ Stokta olan: {len(marlin_in_stock)}")
+        print(f"  ❌ Stokta olmayan: {len(marlin_out_of_stock)}")
+        
+        if marlin_in_stock:
+            print("\n✅ STOKTA OLAN MARLIN MODELLERİ:")
+            for product in marlin_in_stock:
+                print(f"   • {product[2]} - {product[1][1]} TL ({product[1][4]} adet)")
+        
+        if marlin_out_of_stock:
+            print("\n❌ STOKTA OLMAYAN MARLIN MODELLERİ:")
+            for product in marlin_out_of_stock:
+                print(f"   • {product[2]}")
+
+except Exception as e:
+    print(f"❌ Ürün yükleme hatası: {e}")
+    import traceback
+    traceback.print_exc()
+    products = []
+
+# ===============================
+# STOK API ENTEGRASYONU
+# ===============================
+
+STOCK_API_BASE = "https://video.trek-turkey.com/bizimhesap-proxy.php"
+
+# Stock cache (5 dakikalık cache)
+stock_cache = {}
+CACHE_DURATION = 300  # 5 dakika (saniye cinsinden)
+
+def normalize_turkish(text):
+    """Türkçe karakterleri normalize et"""
+    if not text:
+        return ""
+    replacements = {
+        'ı': 'i', 'İ': 'i', 'ş': 's', 'Ş': 's',
+        'ğ': 'g', 'Ğ': 'g', 'ü': 'u', 'Ü': 'u',
+        'ö': 'o', 'Ö': 'o', 'ç': 'c', 'Ç': 'c'
+    }
+    text = text.lower()
+    for tr_char, eng_char in replacements.items():
+        text = text.replace(tr_char, eng_char)
+    return text
+
+def fetch_warehouse_inventory(warehouse, product_name, search_terms):
+    """Tek bir mağazanın stok bilgisini al"""
+    try:
+        warehouse_id = warehouse['id']
+        warehouse_name = warehouse['title']
+        
+        # DSW'yi ayrı tut (gelecek stok için)
+        is_dsw = 'DSW' in warehouse_name or 'ÖN SİPARİŞ' in warehouse_name.upper()
+        
+        # Mağaza stoklarını 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 yanıtını kontrol et
+        if 'data' not in inventory_data or 'inventory' not in inventory_data['data']:
+            return None
+        
+        products = inventory_data['data']['inventory']
+        
+        # Beden terimleri kontrolü
+        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 mı 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
+        
+        # Eğer sadece beden sorgusu varsa (ör: "m", "xl")
+        is_only_size_query = len(search_terms) == 1 and has_size_query
+        
+        # Ürünü ara
+        warehouse_variants = []
+        dsw_stock_count = 0
+        
+        for product in products:
+            product_title = normalize_turkish(product.get('title', '')).lower()
+            original_title = product.get('title', '')
+            
+            # Eğer sadece beden sorgusu ise
+            if is_only_size_query:
+                # Beden terimini ürün başlığında ara (parantez içinde veya dışında)
+                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 ürün araması - tüm terimler eşleşmeli
+                # Ama beden terimi varsa özel kontrol yap
+                if has_size_query:
+                    # Beden hariç diğer terimleri kontrol et
+                    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)
+                    
+                    # Beden kontrolü - daha esnek
+                    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
+                            
+                            # Varyant bilgisini göster
+                            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:
+                    # Beden sorgusu yoksa normal kontrol
+                    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")
+        
+        # Sonuç döndür
+        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 gerçek zamanlı stok bilgisini çek - Paralel versiyon with cache"""
+    try:
+        # Cache kontrolü
+        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]
+            # Cache hala geçerli mi?
+            if current_time - cached_time < CACHE_DURATION:
+                logger.info(f"Cache'den döndürülüyor: {product_name}")
+                return cached_data
+        
+        # Önce mağaza 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"Mağaza listesi alınamadı: {warehouses_response.status_code}")
+            return None
+            
+        warehouses_data = warehouses_response.json()
+        
+        # API yanıtını kontrol et
+        if 'data' not in warehouses_data or 'warehouses' not in warehouses_data['data']:
+            logger.error("Mağaza verisi bulunamadı")
+            return None
+        
+        warehouses = warehouses_data['data']['warehouses']
+        
+        # Ürün adını normalize et
+        search_terms = normalize_turkish(product_name).lower().split()
+        logger.info(f"Aranan ürün: {product_name} -> {search_terms}")
+        
+        stock_info = {}
+        total_dsw_stock = 0
+        total_stock = 0
+        
+        # Paralel olarak tüm mağazaları sorgula
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            # Tüm mağazalar için görev oluştur
+            futures = {
+                executor.submit(fetch_warehouse_inventory, warehouse, product_name, search_terms): warehouse 
+                for warehouse in warehouses
+            }
+            
+            # Sonuçları topla
+            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  # En az bir mağazada var
+        
+        # Sonucu oluştur
+        if not stock_info:
+            # Mağazada yok ama DSW'de varsa
+            if total_dsw_stock > 0:
+                result = f"{product_name}: Şu anda mağazalarda stokta yok, ancak yakında gelecek. Ön sipariş verebilirsiniz."
+            else:
+                result = f"{product_name}: Şu anda hiçbir mağazada stokta bulunmuyor."
+        else:
+            # Minimal prompt oluştur - varyant detaylarıyla
+            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}")
+            
+            # Güvenlik: Toplam adet bilgisi gösterme
+            if total_stock > 0:
+                prompt_lines.append(f"✓ Ürün 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 hatası: {e}")
+        return None
+
+def is_stock_query(message):
+    """Mesajın stok sorgusu olup olmadığını kontrol et"""
+    stock_keywords = ['stok', 'stock', 'var mı', 'mevcut mu', 'kaç adet', 
+                      'kaç tane', 'bulunuyor mu', 'hangi mağaza', 
+                      'nerede var', 'beden', 'numara']
+    message_lower = message.lower()
+    return any(keyword in message_lower for keyword in stock_keywords)
+
+# Sistem mesajları - Modüler prompts'tan yükle
+def get_system_messages():
+    return get_prompt_content_only()  # prompts.py'dan yükle
+
+# ===============================
+# SOHBET HAFIZASI SİSTEMİ
+# ===============================
+
+# Sohbet hafızası için basit bir dictionary
+conversation_memory = {}
+
+def get_conversation_context(phone_number):
+    """Kullanıcının sohbet geçmişini getir"""
+    if phone_number not in conversation_memory:
+        conversation_memory[phone_number] = {
+            "messages": [],
+            "current_category": None,
+            "last_activity": None
+        }
+    return conversation_memory[phone_number]
+
+def add_to_conversation(phone_number, user_message, ai_response):
+    """Sohbet geçmişine ekle"""
+    import datetime
+    
+    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 mesajı 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):
+    """Konuşulan kategoriyi 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
+                print(f"🎯 Kategori tespit edildi: {category} ({phone_number})")
+                return category
+    
+    return context.get("current_category")
+
+def build_context_messages(phone_number, current_message):
+    """Sohbet geçmişi ile sistem mesajlarını oluştur"""
+    context = get_conversation_context(phone_number)
+    system_messages = get_system_messages()
+    
+    # Mevcut kategori varsa, sistem mesajına ekle
+    if context.get("current_category"):
+        category_msg = f"Kullanıcı şu anda {context['current_category'].upper()} kategorisi hakkında konuşuyor. Tüm cevaplarını bu kategori bağlamında ver. Kullanıcı yeni bir kategori belirtmediği sürece {context['current_category']} hakkında bilgi vermek istediğini varsay."
+        system_messages.append({"role": "system", "content": category_msg})
+    
+    # Son 3 mesaj alışverişini ekle
+    recent_messages = context["messages"][-3:] if context["messages"] else []
+    
+    all_messages = system_messages.copy()
+    
+    # Geçmiş mesajları ekle
+    for msg in recent_messages:
+        all_messages.append({"role": "user", "content": msg["user"]})
+        all_messages.append({"role": "assistant", "content": msg["ai"]})
+    
+    # Mevcut mesajı ekle
+    all_messages.append({"role": "user", "content": current_message})
+    
+    return all_messages
+
+def process_whatsapp_message_with_memory(user_message, phone_number):
+    """Hafızalı WhatsApp mesaj işleme"""
+    try:
+        # 🧠 Pasif profil analizi - kullanıcı mesajını analiz et
+        profile_analysis = analyze_user_message(phone_number, user_message)
+        logger.info(f"📊 Profil analizi: {phone_number} -> {profile_analysis}")
+        
+        # 🎯 Kişiselleştirilmiş öneriler kontrolü
+        if any(keyword in user_message.lower() for keyword in ["öneri", "öner", "tavsiye", "ne önerirsin"]):
+            personalized = get_personalized_recommendations(phone_number, products)
+            if personalized.get("personalized") and personalized.get("recommendations"):
+                # Kullanıcı profiline göre özelleştirilmiş cevap hazırla
+                profile_summary = get_user_profile_summary(phone_number)
+                custom_response = create_personalized_response(personalized, profile_summary)
+                return extract_product_info_whatsapp(custom_response)
+        
+        # Enhanced features kaldırıldı - GPT-4 doğal dil anlama kullanacak
+        
+        # STOK SORGUSU KONTROLÜ
+        if is_stock_query(user_message):
+            logger.info("Stok sorgusu algılandı, API'den veri çekiliyor...")
+            
+            # Mesajdan ürün adını çıkarmaya çalış
+            product_words = []
+            skip_words = ['stok', 'stock', 'kaç', 'adet', 'tane', 'var', 'mı', 'mi', 
+                          'mevcut', 'mu', 'bulunuyor', 'hangi', 'mağaza', 'nerede', 
+                          'durumu', 'stoklarda', 'stokta', 'için', 've', 'ile', 'toplam', 'toplamda',
+                          'fiyat', 'fiyatı', 'ne', 'nedir', 'kadar', 'beden', 'bedeni', 'bedenli']
+            
+            # Beden terimleri - bunları skip etmemeliyiz
+            size_terms = ['xs', 's', 'm', 'ml', 'l', 'xl', 'xxl', '2xl', '3xl', 'small', 'medium', 'large',
+                         '44', '46', '48', '50', '52', '54', '56', '58', '60']
+            
+            for word in user_message.lower().split():
+                if word not in skip_words:
+                    product_words.append(word)
+            
+            if product_words:
+                product_name = ' '.join(product_words)
+                
+                # Sadece beden sorgusu mu kontrol et
+                is_only_size = len(product_words) == 1 and product_words[0].lower() in size_terms
+                
+                if is_only_size:
+                    product_name = product_words[0].lower()
+                    logger.info(f"Sadece beden sorgusu: {product_name}")
+                
+                # API'den stok bilgisi al
+                stock_info = get_realtime_stock_parallel(product_name)
+                if stock_info:
+                    # WhatsApp için formatla
+                    formatted_response = extract_product_info_whatsapp(stock_info)
+                    
+                    # Sohbet geçmişine ekle
+                    add_to_conversation(phone_number, user_message, formatted_response)
+                    
+                    return formatted_response
+        
+        # Sohbet geçmişi ile sistem mesajlarını oluştur
+        messages = build_context_messages(phone_number, user_message)
+        
+        # 🎯 Profil bilgilerini sistem mesajlarına ekle
+        profile_summary = get_user_profile_summary(phone_number)
+        if profile_summary.get("exists") and profile_summary.get("confidence", 0) > 0.3:
+            profile_context = create_profile_context_message(profile_summary)
+            messages.append({"role": "system", "content": profile_context})
+        
+        # 🔍 BF Space: Use improved product search if available
+        product_found_improved = False
+        if USE_IMPROVED_SEARCH and improved_whatsapp_bot:
+            try:
+                product_result = improved_whatsapp_bot.process_message(user_message)
+                if product_result['is_product_query'] and product_result['response']:
+                    # Use improved search response directly
+                    messages.append({
+                        "role": "system",
+                        "content": f"ÜRÜN BİLGİSİ (BF Space):\n{product_result['response']}\n\nSADECE bu bilgileri kullanarak kullanıcıya yardımcı ol. Bu bilgiler dışında ek bilgi ekleme."
+                    })
+                    product_found_improved = True
+                    logger.info("✅ BF Space: Improved product search used")
+            except Exception as e:
+                logger.error(f"❌ BF Space: Improved search error: {e}")
+        
+        # Fallback to basic search if improved search didn't work
+        if not product_found_improved:
+            # Ürün bilgilerini kontrol et ve ekle (basic search)
+            input_words = user_message.lower().split()
+            for product_info in products:
+                if product_info[0] in input_words:
+                    if 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
+                        
+                        new_msg = f"{product_info[2]} {product_info[1][0]} - {price_info}"
+                    else:
+                        new_msg = f"{product_info[2]} {product_info[1][0]}"
+                    messages.append({"role": "system", "content": new_msg})
+                    break  # Avoid duplicates
+
+        if not OPENAI_API_KEY:
+            return "OpenAI API anahtarı eksik. Lütfen environment variables'ları kontrol edin."
+
+        payload = {
+            "model": "gpt-5-chat-latest",
+            "messages": messages,
+            "temperature": 0,
+            "max_tokens": 800,
+            "stream": False,
+        }
+        
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {OPENAI_API_KEY}"
+        }
+        
+        response = requests.post(API_URL, headers=headers, json=payload)
+        if response.status_code == 200:
+            result = response.json()
+            ai_response = result['choices'][0]['message']['content']
+            
+            # WhatsApp için resim URL'lerini formatla
+            formatted_response = extract_product_info_whatsapp(ai_response)
+            
+            # Sohbet geçmişine ekle
+            add_to_conversation(phone_number, user_message, formatted_response)
+            
+            return formatted_response
+        else:
+            print(f"OpenAI API Error: {response.status_code} - {response.text}")
+            return f"API hatası: {response.status_code}. Lütfen daha sonra tekrar deneyin."
+            
+    except Exception as e:
+        print(f"❌ WhatsApp mesaj işleme hatası: {e}")
+        return "Teknik bir sorun oluştu. Lütfen daha sonra tekrar deneyin."
+
+def create_profile_context_message(profile_summary):
+    """Profil bilgilerini sistem mesajına çevir"""
+    context_parts = []
+    
+    preferences = profile_summary.get("preferences", {})
+    behavior = profile_summary.get("behavior", {})
+    
+    # Bütçe bilgisi
+    if preferences.get("budget_min") and preferences.get("budget_max"):
+        budget_min = preferences["budget_min"]
+        budget_max = preferences["budget_max"]
+        context_parts.append(f"Kullanıcının bütçesi: {budget_min:,}-{budget_max:,} TL")
+    
+    # Kategori tercihleri
+    if preferences.get("categories"):
+        categories = ", ".join(preferences["categories"])
+        context_parts.append(f"İlgilendiği kategoriler: {categories}")
+    
+    # Kullanım amacı
+    if preferences.get("usage_purpose"):
+        purposes = ", ".join(preferences["usage_purpose"])
+        context_parts.append(f"Kullanım amacı: {purposes}")
+    
+    # Davranış kalıpları
+    if behavior.get("price_sensitive"):
+        context_parts.append("Fiyata duyarlı bir kullanıcı")
+    if behavior.get("tech_interested"):
+        context_parts.append("Teknik detaylarla ilgilenen bir kullanıcı")
+    if behavior.get("comparison_lover"):
+        context_parts.append("Karşılaştırma yapmayı seven bir kullanıcı")
+    
+    # Etkileşim stili
+    interaction_style = profile_summary.get("interaction_style", "balanced")
+    style_descriptions = {
+        "analytical": "Detaylı ve analitik bilgi bekleyen",
+        "budget_conscious": "Bütçe odaklı ve ekonomik seçenekleri arayan",
+        "technical": "Teknik özellikler ve spesifikasyonlarla ilgilenen",
+        "decisive": "Hızlı karar veren ve özet bilgi isteyen",
+        "balanced": "Dengeli yaklaşım sergileyen"
+    }
+    context_parts.append(f"{style_descriptions.get(interaction_style, 'balanced')} bir kullanıcı")
+    
+    if context_parts:
+        return f"Kullanıcı profili: {'. '.join(context_parts)}. Bu bilgileri göz önünde bulundurarak cevap ver."
+    return ""
+
+def create_personalized_response(personalized_data, profile_summary):
+    """Kişiselleştirilmiş öneri cevabı oluştur"""
+    response_parts = []
+    
+    # Kullanıcı stiline göre selamlama
+    interaction_style = profile_summary.get("interaction_style", "balanced")
+    if interaction_style == "analytical":
+        response_parts.append("🔍 Profilinizi analiz ederek sizin için en uygun seçenekleri belirledim:")
+    elif interaction_style == "budget_conscious":
+        response_parts.append("💰 Bütçenize uygun en iyi seçenekleri hazırladım:")
+    elif interaction_style == "technical":
+        response_parts.append("⚙️ Teknik tercihlerinize göre önerilerim:")
+    else:
+        response_parts.append("🎯 Size özel seçtiklerim:")
+    
+    # Önerileri listele
+    recommendations = personalized_data.get("recommendations", [])[:3]  # İlk 3 öneri
+    
+    if recommendations:
+        response_parts.append("\n")
+        for i, product in enumerate(recommendations, 1):
+            name, item_info, full_name = product
+            price = item_info[1] if len(item_info) > 1 else "Fiyat yok"
+            response_parts.append(f"**{i}. {full_name}**")
+            response_parts.append(f"💰 Fiyat: {price} TL")
+            response_parts.append("")
+    
+    # Profil bazlı açıklama
+    preferences = profile_summary.get("preferences", {})
+    if preferences.get("categories"):
+        category = preferences["categories"][0]
+        response_parts.append(f"Bu öneriler {category} kategorisindeki ilginizi ve tercihlerinizi dikkate alarak hazırlandı.")
+    
+    return "\n".join(response_parts)
+
+def split_long_message(message, max_length=1600):
+    """Uzun mesajları WhatsApp için uygun parçalara böler"""
+    if len(message) <= max_length:
+        return [message]
+    
+    parts = []
+    remaining = message
+    
+    while len(remaining) > max_length:
+        cut_point = max_length
+        
+        # Geriye doğru git ve uygun kesme noktası ara
+        for i in range(max_length, max_length - 200, -1):
+            if i < len(remaining) and remaining[i] in ['.', '!', '?', '\n']:
+                cut_point = i + 1
+                break
+            elif i < len(remaining) and remaining[i] in [' ', ',', ';']:
+                cut_point = i
+        
+        parts.append(remaining[:cut_point].strip())
+        remaining = remaining[cut_point:].strip()
+    
+    if remaining:
+        parts.append(remaining)
+    
+    return parts
+
+# ===============================
+# HAFIZA SİSTEMİ SONU
+# ===============================
+
+# WhatsApp mesajı işleme (eski fonksiyon - yedek için)
+def process_whatsapp_message(user_message):
+    try:
+        system_messages = get_system_messages()
+        
+        # 🔍 BF Space: Use improved product search if available (backup function)
+        product_found_improved = False
+        if USE_IMPROVED_SEARCH and improved_whatsapp_bot:
+            try:
+                product_result = improved_whatsapp_bot.process_message(user_message)
+                if product_result['is_product_query'] and product_result['response']:
+                    system_messages.append({
+                        "role": "system",
+                        "content": f"ÜRÜN BİLGİSİ (BF Space Backup):\n{product_result['response']}\n\nSADECE bu bilgileri kullanarak kullanıcıya yardımcı ol. Bu bilgiler dışında ek bilgi ekleme."
+                    })
+                    product_found_improved = True
+            except Exception as e:
+                print(f"BF Space backup: Improved search error: {e}")
+        
+        # Fallback to basic search
+        if not product_found_improved:
+            # Ürün bilgilerini kontrol et (basic search)
+            input_words = user_message.lower().split()
+            for product_info in products:
+                if product_info[0] in input_words:
+                    if 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
+                        
+                        new_msg = f"{product_info[2]} {product_info[1][0]} - {price_info}"
+                    else:
+                        new_msg = f"{product_info[2]} {product_info[1][0]}"
+                    system_messages.append({"role": "system", "content": new_msg})
+                    break
+
+        messages = system_messages + [{"role": "user", "content": user_message}]
+
+        if not OPENAI_API_KEY:
+            return "OpenAI API anahtarı eksik. Lütfen environment variables'ları kontrol edin."
+
+        payload = {
+            "model": "gpt-5-chat-latest",
+            "messages": messages,
+            "temperature": 0,
+            "max_tokens": 800,
+            "stream": False,
+        }
+        
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {OPENAI_API_KEY}"
+        }
+        
+        response = requests.post(API_URL, headers=headers, json=payload)
+        if response.status_code == 200:
+            result = response.json()
+            return result['choices'][0]['message']['content']
+        else:
+            print(f"OpenAI API Error: {response.status_code} - {response.text}")
+            return f"API hatası: {response.status_code}. Lütfen daha sonra tekrar deneyin."
+            
+    except Exception as e:
+        print(f"❌ WhatsApp mesaj işleme hatası: {e}")
+        return "Teknik bir sorun oluştu. Lütfen daha sonra tekrar deneyin."
+
+# FastAPI uygulaması
+app = FastAPI()
+
+@app.post("/whatsapp-webhook")
+async def whatsapp_webhook(request: Request):
+    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')
+        
+        print(f"📱 Webhook - From: {from_number}, Body: {message_body}, Status: {message_status}")
+        
+        # Durum güncellemelerini ignore et
+        if message_status in ['sent', 'delivered', 'read', 'failed']:
+            return {"status": "ignored", "message": f"Status: {message_status}"}
+        
+        # Giden mesajları ignore et
+        if to_number != TWILIO_WHATSAPP_NUMBER:
+            return {"status": "ignored", "message": "Outgoing message"}
+        
+        # Boş mesaj kontrolü
+        if not message_body or message_body.strip() == "":
+            return {"status": "ignored", "message": "Empty message"}
+        
+        print(f"✅ MESAJ ALINDI: {from_number} -> {message_body}")
+        
+        if not twilio_client:
+            return {"status": "error", "message": "Twilio yapılandırması eksik"}
+        
+        # HAFIZALİ MESAJ İŞLEME
+        ai_response = process_whatsapp_message_with_memory(message_body, from_number)
+        
+        # Mesajı parçalara böl
+        message_parts = split_long_message(ai_response, max_length=1600)
+        
+        sent_messages = []
+        
+        # Her parçayı sırayla gönder
+        for i, part in enumerate(message_parts):
+            if len(message_parts) > 1:
+                if i == 0:
+                    part = f"{part}\n\n(1/{len(message_parts)})"
+                elif i == len(message_parts) - 1:
+                    part = f"({i+1}/{len(message_parts)})\n\n{part}"
+                else:
+                    part = f"({i+1}/{len(message_parts)})\n\n{part}"
+            
+            # WhatsApp'a gönder
+            message = twilio_client.messages.create(
+                messaging_service_sid=TWILIO_MESSAGING_SERVICE_SID,
+                body=part,
+                to=from_number
+            )
+            
+            sent_messages.append(message.sid)
+            
+            if i < len(message_parts) - 1:
+                import time
+                time.sleep(0.5)
+        
+        print(f"✅ {len(message_parts)} PARÇA GÖNDERİLDİ")
+        
+        # Debug için mevcut kategoriyi logla
+        context = get_conversation_context(from_number)
+        if context.get("current_category"):
+            print(f"💭 Aktif kategori: {context['current_category']}")
+        
+        return {
+            "status": "success", 
+            "message_parts": len(message_parts),
+            "message_sids": sent_messages,
+            "current_category": context.get("current_category")
+        }
+        
+    except Exception as e:
+        print(f"❌ Webhook hatası: {str(e)}")
+        return {"status": "error", "message": str(e)}
+
+@app.get("/")
+async def root():
+    return {"message": "Trek WhatsApp Bot çalışıyor!", "status": "active"}
+
+# Hafızayı temizleme endpoint'i
+@app.get("/clear-memory/{phone_number}")
+async def clear_memory(phone_number: str):
+    """Belirli bir telefon numarasının hafızasını temizle"""
+    if phone_number in conversation_memory:
+        del conversation_memory[phone_number]
+        return {"status": "success", "message": f"{phone_number} hafızası temizlendi"}
+    return {"status": "info", "message": "Hafıza bulunamadı"}
+
+# Tüm hafızayı görme endpoint'i
+@app.get("/debug-memory")
+async def debug_memory():
+    """Tüm hafızay�� görüntüle (debug için)"""
+    memory_info = {}
+    for phone, context in conversation_memory.items():
+        memory_info[phone] = {
+            "current_category": context.get("current_category"),
+            "message_count": len(context.get("messages", [])),
+            "last_activity": str(context.get("last_activity"))
+        }
+    return {"conversation_memory": memory_info}
+
+# Profil bilgilerini görme endpoint'i
+@app.get("/debug-profile/{phone_number}")
+async def debug_profile(phone_number: str):
+    """Belirli kullanıcının profil bilgilerini görüntüle"""
+    profile_summary = get_user_profile_summary(phone_number)
+    return {"phone_number": phone_number, "profile": profile_summary}
+
+# Tüm profilleri görme endpoint'i
+@app.get("/debug-profiles")
+async def debug_profiles():
+    """Tüm kullanıcı profillerini görüntüle"""
+    from whatsapp_passive_profiler import passive_profiler
+    all_profiles = {}
+    for phone_number in passive_profiler.profiles.keys():
+        all_profiles[phone_number] = get_user_profile_summary(phone_number)
+    return {"profiles": all_profiles}
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "healthy",
+        "twilio_configured": twilio_client is not None,
+        "openai_configured": OPENAI_API_KEY is not None,
+        "products_loaded": len(products),
+        "webhook_endpoint": "/whatsapp-webhook"
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    print("🚀 Trek WhatsApp Bot başlatılıyor...")
+    uvicorn.run(app, host="0.0.0.0", port=7860)

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

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