Copy all essential files from BF space to BF-WAB

- Copy smart_warehouse_with_price.py (exact working version)
- Copy image_renderer.py for visual support
- Copy get_warehouse_fast.py for fast queries
- Copy warehouse_stock_finder.py
- Copy smart_warehouse.py
- Update app.py to use smart_warehouse_with_price instead of smart_warehouse_complete
- Now using exact same code as working BF space

app.py

@@ -32,9 +32,9 @@ except ImportError:
 
 # Import GPT-5 powered smart warehouse search - complete BF algorithm
 try:
-    from smart_warehouse_complete import get_warehouse_stock_smart_complete
+    from smart_warehouse_with_price import get_warehouse_stock_smart_with_price
     USE_GPT5_SEARCH = True
-    logger.info("✅ GPT-5 complete smart warehouse (BF algorithm) loaded")
+    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")
@@ -72,7 +72,7 @@ def get_warehouse_stock(product_name):
     """B2B API'den mağaza stok bilgilerini çek - GPT-5 enhanced"""
     # Try GPT-5 complete smart search (BF algorithm)
     if USE_GPT5_SEARCH:
-        gpt5_result = get_warehouse_stock_smart_complete(product_name)
+        gpt5_result = get_warehouse_stock_smart_with_price(product_name)
         if gpt5_result and isinstance(gpt5_result, list):
             # Return directly if it's already formatted strings
             if all(isinstance(item, str) for item in gpt5_result):
@@ -1319,7 +1319,7 @@ async def health():
 @app.get("/test-madone")
 async def test_madone():
     """Test MADONE search directly"""
-    from smart_warehouse_complete import get_warehouse_stock_smart_complete
+    from smart_warehouse_with_price import get_warehouse_stock_smart_with_price
     
     # Set a test API key if needed
     import os
@@ -1327,7 +1327,7 @@ async def test_madone():
         return {"error": "No OPENAI_API_KEY set"}
     
     try:
-        result = get_warehouse_stock_smart_complete("madone sl 6")
+        result = get_warehouse_stock_smart_with_price("madone sl 6")
         return {
             "query": "madone sl 6",
             "result": result if result else "No result",

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)

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_with_price.py

@@ -0,0 +1,370 @@
+"""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)
+        
+        # Normalize search terms
+        search_name = product_name.lower()
+        search_variant = variant.lower() if variant else ""
+        
+        # Turkish character normalization
+        tr_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c'}
+        for tr, en in tr_map.items():
+            search_name = search_name.replace(tr, en)
+            search_variant = search_variant.replace(tr, en)
+        
+        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_with_price(user_message, previous_result=None):
+    """Enhanced smart warehouse search with price and link info"""
+    
+    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."
+    
+    # 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}'")
+            
+            # 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}")
+            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()

warehouse_stock_finder.py

@@ -0,0 +1,89 @@
+"""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', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c', 'İ': 'i', 'I': 'i'}
+            text = text.lower()
+            for tr, en in tr_map.items():
+                text = text.replace(tr, en)
+            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