Update app.py

app.py

@@ -2,6 +2,7 @@
 """
 Turbo Air Viewer - Equipment Specification Database Viewer
 Enhanced version with product image extraction and display
+Modified to work with Excel-generated database structure
 
 Required dependencies (add to requirements.txt):
 - streamlit
@@ -13,6 +14,7 @@ Required dependencies (add to requirements.txt):
 """
 
 import streamlit as st
+import streamlit.components.v1 as components
 import sqlite3
 import json
 from pathlib import Path
@@ -34,6 +36,17 @@ from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 from reportlab.lib.units import inch
 from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, Image as RLImage, PageBreak
 from reportlab.lib.enums import TA_CENTER
+import urllib.parse
+
+# Try to import openpyxl for Excel export
+try:
+    import openpyxl
+    from openpyxl.drawing.image import Image as XLImage
+    from openpyxl.styles import Alignment, Font, PatternFill
+    from openpyxl.utils import get_column_letter
+    EXCEL_AVAILABLE = True
+except ImportError:
+    EXCEL_AVAILABLE = False
 
 # Streamlit page config MUST be first
 st.set_page_config(
@@ -42,131 +55,20 @@ st.set_page_config(
     layout="wide"
 )
 
-# Configuration
-DB_FILENAME = "turbo_air_db.sqlite"
-DB_URL = "https://huggingface.co/spaces/TurboAir/turbo-air-viewer/resolve/main/turbo_air_db.sqlite"
-
-def download_database():
-    """Download database from Hugging Face if not present or invalid"""
-    if os.path.exists(DB_FILENAME):
-        # Check if existing file is valid
-        try:
-            # Check file size first
-            file_size = os.path.getsize(DB_FILENAME)
-            if file_size < 1000000:  # Less than 1MB, probably wrong
-                st.warning(f"Existing database file is too small ({file_size/1024/1024:.1f} MB), re-downloading...")
-                os.remove(DB_FILENAME)
-            else:
-                conn = sqlite3.connect(DB_FILENAME)
-                cursor = conn.cursor()
-                cursor.execute("SELECT name FROM sqlite_master WHERE type='table' LIMIT 1")
-                tables = cursor.fetchall()
-                conn.close()
-                
-                if tables:
-                    # Don't show success message - just return
-                    return DB_FILENAME  # Valid database exists
-        except:
-            st.warning("Existing database file is invalid, re-downloading...")
-            if os.path.exists(DB_FILENAME):
-                os.remove(DB_FILENAME)
-    
-    # Download the database
-    st.info("🔄 Downloading database... This is a one-time download of 279 MB.")
-    
-    try:
-        # Method 1: Try requests first
-        import requests
-        
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-        }
-        
-        response = requests.get(DB_URL, headers=headers, stream=True, timeout=30, allow_redirects=True)
-        
-        # Check if we got a valid response
-        if response.status_code == 200:
-            total_size = int(response.headers.get('content-length', 0))
-            
-            # Only proceed if file size looks right (should be ~279 MB)
-            if total_size < 10000000:  # Less than 10MB
-                st.error(f"Downloaded file too small ({total_size/1024/1024:.1f} MB). Expected ~279 MB.")
-                st.error("The database file may be a Git LFS pointer.")
-                raise Exception("File size mismatch")
-            
-            progress_bar = st.progress(0)
-            status_text = st.empty()
-            
-            with open(DB_FILENAME, 'wb') as f:
-                downloaded = 0
-                for chunk in response.iter_content(chunk_size=1024*1024):  # 1MB chunks
-                    if chunk:
-                        f.write(chunk)
-                        downloaded += len(chunk)
-                        if total_size > 0:
-                            progress = downloaded / total_size
-                            progress_bar.progress(progress)
-                            status_text.text(f"Downloaded {downloaded/1024/1024:.1f} MB / {total_size/1024/1024:.1f} MB")
-            
-            progress_bar.empty()
-            status_text.empty()
-            
-            # Verify the downloaded file
-            if os.path.getsize(DB_FILENAME) > 100000000:  # At least 100MB
-                try:
-                    conn = sqlite3.connect(DB_FILENAME)
-                    cursor = conn.cursor()
-                    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' LIMIT 1")
-                    tables = cursor.fetchall()
-                    conn.close()
-                    
-                    if tables:
-                        # Don't show success message - just return
-                        return DB_FILENAME
-                except:
-                    st.error("Downloaded file is not a valid SQLite database")
-                    
-        else:
-            st.error(f"Failed to download: HTTP {response.status_code}")
-            
-    except requests.exceptions.RequestException as e:
-        st.error(f"Download failed: {str(e)}")
-    except ImportError:
-        st.error("requests library not installed. Please add 'requests' to requirements.txt")
-    except Exception as e:
-        st.error(f"Unexpected error: {str(e)}")
-    
-    # If download failed, provide manual instructions
-    st.error("❌ Automatic download failed.")
-    st.markdown("""
-    ### Manual Download Instructions:
-    
-    1. **Download directly from this link:**
-       [Download turbo_air_db.sqlite (279 MB)](https://huggingface.co/spaces/TurboAir/turbo-air-viewer/resolve/main/turbo_air_db.sqlite)
-    
-    2. **Or use wget/curl:**
-       ```bash
-       wget https://huggingface.co/spaces/TurboAir/turbo-air-viewer/resolve/main/turbo_air_db.sqlite
-       # or
-       curl -L -o turbo_air_db.sqlite https://huggingface.co/spaces/TurboAir/turbo-air-viewer/resolve/main/turbo_air_db.sqlite
-       ```
-    
-    3. **Or clone with Git LFS:**
-       ```bash
-       git lfs install
-       git clone https://huggingface.co/spaces/TurboAir/turbo-air-viewer
-       ```
-    
-    **Note:** The database file is 279 MB. Make sure you have a stable internet connection.
-    """)
-    
-    return None
+# Configuration - MODIFIED FOR HUGGING FACE
+DB_FILENAME = "turbo_air_db_online.sqlite"  # Local database in root
+PDF_DIR = "pdfs"  # Local PDF directory
 
-# Download or verify database
-DB_PATH = download_database()
+# Create PDF directory if it doesn't exist
+if not os.path.exists(PDF_DIR):
+    os.makedirs(PDF_DIR)
+    st.info(f"Created PDF directory: {PDF_DIR}")
 
-if DB_PATH is None:
-    st.error("❌ Unable to load database. Please refresh the page to try again.")
+# Check if database exists
+if not os.path.exists(DB_FILENAME):
+    st.error(f"❌ Database file '{DB_FILENAME}' not found!")
+    st.info("Please ensure 'turbo_air_db_online.sqlite' is in the same directory as this script.")
+    st.write(f"Looking in: {os.path.abspath(DB_FILENAME)}")
     st.stop()
 
 # Product type mappings
@@ -243,6 +145,12 @@ st.markdown("""
         border-radius: 8px;
     }
     
+    /* Make PDF viewer take up more vertical space */
+    iframe[src*="pdf.js"] {
+        min-height: 85vh !important;
+        height: 85vh !important;
+    }
+    
     .main-title {
         color: #4CAF50;
         font-size: 2.5em;
@@ -291,14 +199,14 @@ st.markdown("""
         border: 1px solid #444;
     }
     
-    .bookmark-image {
+    .cart-image {
         border: 1px solid #444;
         border-radius: 4px;
         margin-bottom: 8px;
         transition: transform 0.2s ease;
     }
     
-    .bookmark-image:hover {
+    .cart-image:hover {
         transform: scale(1.05);
         border-color: #4CAF50;
     }
@@ -323,6 +231,34 @@ st.markdown("""
     .stSelectbox input {
         cursor: text !important;
     }
+    
+    .email-button {
+        width: 100%;
+        padding: 0.5rem;
+        background-color: #4CAF50;
+        color: white;
+        border: none;
+        border-radius: 5px;
+        cursor: pointer;
+        font-size: 16px;
+        text-decoration: none;
+        display: inline-block;
+        text-align: center;
+    }
+    
+    .email-button:hover {
+        background-color: #45a049;
+        color: white;
+        text-decoration: none;
+    }
+    
+    /* Left-align text in cart text-only view buttons */
+    [data-testid="stButton"][id*="select_text_"] button,
+    [data-testid="stButton"][id*="select_text_exp_"] button {
+        text-align: left !important;
+        justify-content: flex-start !important;
+        padding-left: 10px !important;
+    }
 </style>
 
 <script>
@@ -344,14 +280,61 @@ document.addEventListener('DOMContentLoaded', function() {
 # Initialize session state
 if 'selected_model' not in st.session_state:
     st.session_state.selected_model = None
-if 'bookmarked_models' not in st.session_state:
-    st.session_state.bookmarked_models = []
+if 'cart_models' not in st.session_state:
+    st.session_state.cart_models = []
 if 'text_only_view' not in st.session_state:
     st.session_state.text_only_view = False
 if 'product_images' not in st.session_state:
     st.session_state.product_images = {}
+if 'db_last_modified' not in st.session_state:
+    st.session_state.db_last_modified = None
+
+# Check if database has been modified
+def check_db_cache():
+    """Check if database has been modified and clear cache if needed"""
+    if DB_PATH and os.path.exists(DB_PATH):
+        current_mtime = os.path.getmtime(DB_PATH)
+        if st.session_state.db_last_modified is None:
+            st.session_state.db_last_modified = current_mtime
+        elif current_mtime != st.session_state.db_last_modified:
+            # Database has been modified, clear cache
+            st.session_state.product_images = {}
+            st.session_state.db_last_modified = current_mtime
+            st.cache_data.clear()
+            return True
+    return False
+
+# MODIFIED: Check for local database
+def check_database():
+    """Check if database exists locally"""
+    if os.path.exists(DB_FILENAME):
+        try:
+            conn = sqlite3.connect(DB_FILENAME)
+            cursor = conn.cursor()
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' LIMIT 1")
+            tables = cursor.fetchall()
+            conn.close()
+            
+            if tables:
+                return DB_FILENAME
+        except:
+            st.error("Database file exists but is invalid")
+            return None
+    else:
+        st.error(f"Database file '{DB_FILENAME}' not found in root directory")
+        return None
+
+# Check database
+DB_PATH = check_database()
+
+if DB_PATH is None:
+    st.error("❌ Unable to load database. Please ensure 'turbo_air_db_online.sqlite' is in the root directory.")
+    st.stop()
+
+# Check if database was modified
+check_db_cache()
 
-def extract_pdf_thumbnail(pdf_url, model_name, max_width=300, max_height=400):
+def extract_pdf_thumbnail(pdf_path, model_name, max_width=300, max_height=400):
     """Extract first page of PDF as thumbnail image"""
     cache_key = f"thumb_{model_name}"
     
@@ -360,68 +343,95 @@ def extract_pdf_thumbnail(pdf_url, model_name, max_width=300, max_height=400):
         return st.session_state.product_images[cache_key]
     
     try:
-        # Download PDF to temporary file (silently)
-        response = requests.get(pdf_url, timeout=30)
-        if response.status_code == 200:
-            with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_file:
-                tmp_file.write(response.content)
-                tmp_path = tmp_file.name
+        # Check if file exists
+        if not os.path.exists(pdf_path):
+            # Try alternate naming conventions in PDF_DIR
+            alt_paths = [
+                os.path.join(PDF_DIR, f"{model_name}.pdf"),
+                os.path.join(PDF_DIR, f"{model_name.upper()}.pdf"),
+                os.path.join(PDF_DIR, f"{model_name.lower()}.pdf"),
+                os.path.join(PDF_DIR, f"{model_name.replace('-', '_')}.pdf"),
+                os.path.join(PDF_DIR, f"{model_name.replace('-', '')}.pdf"),
+                # Also try with parentheses removed
+                os.path.join(PDF_DIR, f"{model_name.replace('(', '').replace(')', '')}.pdf"),
+                os.path.join(PDF_DIR, f"{model_name.split('(')[0].strip()}.pdf"),
+            ]
             
-            # Open PDF and extract first page
-            pdf_document = fitz.open(tmp_path)  # type: ignore
-            first_page = pdf_document[0]
+            # Debug: Show what files we're looking for
+            print(f"Looking for PDF for model {model_name}")
+            print(f"Primary path: {pdf_path}")
             
-            # Render page as image (2x resolution for better quality)
-            mat = fitz.Matrix(2, 2)
-            # Try new API first, fallback to old API
+            for alt_path in alt_paths:
+                if os.path.exists(alt_path):
+                    print(f"Found PDF at: {alt_path}")
+                    pdf_path = alt_path
+                    break
+            else:
+                print(f"No PDF found for {model_name}")
+                # List available PDFs in the directory for debugging
+                if os.path.exists(PDF_DIR):
+                    available_pdfs = [f for f in os.listdir(PDF_DIR) if f.endswith('.pdf')]
+                    print(f"Available PDFs in {PDF_DIR}: {available_pdfs[:5]}...")  # Show first 5
+                return None
+        
+        # Open PDF and extract first page
+        pdf_document = fitz.open(pdf_path)  # type: ignore
+        first_page = pdf_document[0]
+        
+        # Render page as image (2x resolution for better quality)
+        mat = fitz.Matrix(2, 2)
+        # Fixed: Use getPixmap for older PyMuPDF versions or get_pixmap for newer
+        try:
+            # Try newer API first
+            pix = first_page.get_pixmap(matrix=mat)  # type: ignore
+        except AttributeError:
             try:
-                # New PyMuPDF API
-                pix = first_page.get_pixmap(matrix=mat)
+                # Try older API with matrix parameter
+                pix = first_page.getPixmap(matrix=mat)  # type: ignore
             except:
                 try:
-                    # Alternative method
-                    pix = first_page.get_pixmap(mat)
+                    # Try older API with mat parameter
+                    pix = first_page.getPixmap(mat)  # type: ignore
                 except:
-                    # Fallback without matrix for very old versions
-                    pix = first_page.get_pixmap()
-            
-            # Convert to PIL Image
-            img_data = pix.tobytes("png")
-            img = Image.open(io.BytesIO(img_data))
-            
-            # Calculate aspect ratio and resize
-            width, height = img.size
-            aspect_ratio = width / height
-            
-            if width > max_width:
-                new_width = max_width
-                new_height = int(new_width / aspect_ratio)
-            else:
-                new_width = width
-                new_height = height
-            
-            if new_height > max_height:
-                new_height = max_height
-                new_width = int(new_height * aspect_ratio)
-            
-            img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
-            
-            # Convert to base64 for caching
-            buffered = io.BytesIO()
-            img.save(buffered, format="PNG")
-            img_base64 = base64.b64encode(buffered.getvalue()).decode()
-            
-            # Cache in session state
-            st.session_state.product_images[cache_key] = img_base64
-            
-            # Cleanup
-            pdf_document.close()
-            os.unlink(tmp_path)
-            
-            return img_base64
-            
+                    # Fallback to no matrix
+                    pix = first_page.getPixmap()  # type: ignore
+        
+        # Convert to PIL Image
+        img_data = pix.tobytes("png")
+        img = Image.open(io.BytesIO(img_data))
+        
+        # Calculate aspect ratio and resize
+        width, height = img.size
+        aspect_ratio = width / height
+        
+        if width > max_width:
+            new_width = max_width
+            new_height = int(new_width / aspect_ratio)
+        else:
+            new_width = width
+            new_height = height
+        
+        if new_height > max_height:
+            new_height = max_height
+            new_width = int(new_height * aspect_ratio)
+        
+        img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        
+        # Convert to base64 for caching
+        buffered = io.BytesIO()
+        img.save(buffered, format="PNG")
+        img_base64 = base64.b64encode(buffered.getvalue()).decode()
+        
+        # Cache in session state
+        st.session_state.product_images[cache_key] = img_base64
+        
+        # Cleanup
+        pdf_document.close()
+        
+        return img_base64
+        
     except Exception as e:
-        # Silently fail - don't show warnings
+        print(f"Error extracting thumbnail: {e}")
         return None
 
 # Cache functions
@@ -436,30 +446,11 @@ def get_all_models():
     all_models = []
     
     try:
-        # First try the model_index table (faster)
-        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='model_index'")
-        if cursor.fetchone():
-            cursor.execute("SELECT model FROM model_index ORDER BY model")
-            models = cursor.fetchall()
-            if models:
-                all_models = [m[0] for m in models]
-                conn.close()
-                return all_models
-        
-        # Fallback to scanning documents
-        cursor.execute("SELECT full_data FROM documents")
-        rows = cursor.fetchall()
-        
-        model_set = set()
-        for row in rows:
-            try:
-                data = json.loads(row[0])
-                models = data.get('models', [])
-                model_set.update(models)
-            except:
-                continue
-        
-        all_models = sorted(list(model_set))
+        # Try products table from scanner database
+        cursor.execute("SELECT model FROM products ORDER BY model")
+        models = cursor.fetchall()
+        if models:
+            all_models = [m[0] for m in models]
         
     except Exception as e:
         st.error(f"Database error: {e}")
@@ -471,38 +462,91 @@ def get_all_models():
 
 @st.cache_data
 def get_model_data(model_name):
-    """Get data for specific model - CACHED"""
+    """Get data for specific model - CACHED - MODIFIED FOR EXCEL STRUCTURE"""
     if DB_PATH is None:
         return None
     conn = sqlite3.connect(DB_PATH)
     cursor = conn.cursor()
     
     try:
-        # Search for the model in documents
-        cursor.execute("""
-        SELECT id, file_path, full_data, quality FROM documents 
-        WHERE full_data LIKE ?
-        ORDER BY import_date DESC
-        LIMIT 1
-        """, (f'%"{model_name}"%',))
-        
+        # Get from products table
+        cursor.execute("SELECT * FROM products WHERE model = ?", (model_name,))
         row = cursor.fetchone()
+        
         if row:
-            doc_id, file_path, full_data_str, quality = row
+            # Get column names
+            columns = [description[0] for description in cursor.description]
             
-            try:
-                data = json.loads(full_data_str)
-            except:
-                data = {'models': [], 'specs': {}, 'features': []}
+            # Create dictionary from row data
+            data = dict(zip(columns, row))
             
-            filename = Path(file_path).name if file_path else 'Unknown'
+            # Build file path from source_file
+            filename = 'Unknown'
+            file_path = None
+            if data.get('source_file'):
+                # Extract just the filename from the full path
+                source_path = data['source_file']
+                # Handle both Windows and Unix paths
+                filename = source_path.replace('\\', '/').split('/')[-1]
+                # Remove any file extension and add .pdf if needed
+                if not filename.lower().endswith('.pdf'):
+                    filename = filename.split('.')[0] + '.pdf'
+                file_path = filename  # Store just the filename
+            
+            # Create specs dictionary
+            specs = {
+                'voltage': data.get('Voltage', 'N/A'),  # Changed from hardcoded 'N/A'
+                'amperage': f"{data.get('amps', 'N/A')} A" if data.get('amps') else 'N/A',
+                'phase': data.get('phase', 'N/A'),  # Now available from Excel
+                'frequency': data.get('frequency', 'N/A'),  # Now available from Excel
+                'dimensions': data.get('Dimensions', 'N/A'),  # Direct from Excel
+                'weight': data.get('Weight', 'N/A'),  # Changed from weight_lbs
+                'capacity': data.get('Capacity', 'N/A'),  # Changed from capacity_cuft
+                'refrigerant': data.get('refrigerant', 'N/A'),
+                'temperature_range': data.get('temperature_range', 'N/A'),  # Now available from Excel
+                'compressor': data.get('Compressor', 'N/A'),  # Changed from hp
+                'btu': 'N/A',  # Not in products table
+                'doors': str(data.get('doors', 'N/A')) if data.get('doors') else 'N/A',
+                'shelves': str(data.get('shelves', 'N/A')) if data.get('shelves') else 'N/A',
+                'pans': str(data.get('pans', 'N/A')) if data.get('pans') else 'N/A',
+            }
+            
+            # Format dimensions properly if available from individual columns
+            if data.get('length_in') and data.get('depth_in') and data.get('height_in'):
+                specs['dimensions'] = f"{data['length_in']}\" x {data['depth_in']}\" x {data['height_in']}\""
+            
+            # Add voltage if we have plug_type and Voltage is not available
+            if specs['voltage'] == 'N/A' and data.get('plug_type'):
+                # Extract voltage from plug type (e.g., "NEMA 5-15P" might be 115V)
+                plug = str(data['plug_type'])
+                if '5-15' in plug:
+                    specs['voltage'] = '115V'
+                elif '5-20' in plug:
+                    specs['voltage'] = '115V'
+                elif '6-20' in plug:
+                    specs['voltage'] = '208-230V'
+                elif '6-30' in plug:
+                    specs['voltage'] = '208-230V'
+                elif '6-50' in plug:
+                    specs['voltage'] = '208-230V'
+                else:
+                    specs['voltage'] = 'See specifications'
             
             return {
-                'id': doc_id,
+                'id': model_name,
                 'filename': filename,
                 'file_path': file_path,
-                'data': data,
-                'quality': quality
+                'data': {
+                    'models': [model_name],
+                    'specs': specs,
+                    'features': data.get('features', '').split(', ') if data.get('features') else [],  # Now available from Excel
+                    'certifications': data.get('certifications', '').split(', ') if data.get('certifications') else [],  # Now available from Excel
+                    'description': data.get('description', ''),  # Now available from Excel
+                    'use_cases': data.get('use_cases', ''),  # Now available from Excel
+                },
+                'quality': 'good',  # Default quality since no confidence score
+                'price': data.get('Price', 'N/A'),  # Single price field from Excel
+                'model_no_dashes': model_name.replace('-', '')  # Generate on the fly
             }
             
     except Exception as e:
@@ -583,64 +627,132 @@ def format_model_option(model):
     product_type = get_product_type(model)
     return f"{model} - {product_type}"
 
-def export_bookmarked_models():
-    """Export bookmarked models to CSV"""
-    if not st.session_state.bookmarked_models:
+def export_cart_models_excel():
+    """Export cart models to Excel with thumbnail images"""
+    if not st.session_state.cart_models:
+        return None
+    
+    if not EXCEL_AVAILABLE:
+        st.error("Excel export requires openpyxl. Please ensure it's installed.")
         return None
     
-    export_data = []
-    for model in st.session_state.bookmarked_models:
+    # Create workbook and worksheet
+    wb = openpyxl.Workbook()  # type: ignore
+    ws = wb.active
+    if ws is None:  # Fixed: Check if worksheet is None
+        st.error("Failed to create Excel worksheet")
+        return None
+        
+    ws.title = "Turbo Air Equipment"
+    
+    # Set up headers
+    headers = [
+        'Image', 'Model', 'Product Type', 'Voltage', 'Amperage', 
+        'Dimensions', 'Weight', 'Capacity', 'Refrigerant', 'Compressor',
+        'Doors', 'Shelves', 'Pans', 'Price'
+    ]
+    
+    # Style for headers
+    header_font = Font(bold=True, color="FFFFFF")  # type: ignore
+    header_fill = PatternFill(start_color="4CAF50", end_color="4CAF50", fill_type="solid")  # type: ignore
+    
+    # Write headers
+    for col, header in enumerate(headers, 1):
+        cell = ws.cell(row=1, column=col, value=header)
+        cell.font = header_font
+        cell.fill = header_fill
+        cell.alignment = Alignment(horizontal='center', vertical='center')  # type: ignore
+    
+    # Process each cart model
+    progress_bar = st.progress(0)
+    status_text = st.empty()
+    
+    for idx, model in enumerate(st.session_state.cart_models):
+        # Update progress
+        progress = (idx + 1) / len(st.session_state.cart_models)
+        progress_bar.progress(progress)
+        status_text.text(f"Processing {model}... ({idx + 1}/{len(st.session_state.cart_models)})")
+        
         model_data = get_model_data(model)
-        if model_data:
-            specs = model_data['data'].get('specs', {})
-            specs = clean_spec_data(specs)
-            features = model_data['data'].get('features', [])
+        if not model_data:
+            continue
             
-            # Parse dimensions
-            dimensions = specs.get('dimensions', 'N/A')
-            width, depth, height = 'N/A', 'N/A', 'N/A'
+        row = idx + 2  # Start from row 2 (after headers)
+        specs = model_data['data'].get('specs', {})
+        specs = clean_spec_data(specs)
+        
+        # Column A: Image
+        if model_data.get('file_path'):
+            pdf_filename = model_data['file_path']
+            pdf_path = os.path.join(PDF_DIR, pdf_filename)
             
-            dim_patterns = [
-                r'(\d+\.?\d*)["\s]*[WwLl]\s*[xX×]\s*(\d+\.?\d*)["\s]*[DdWw]\s*[xX×]\s*(\d+\.?\d*)["\s]*[HhTt]',
-                r'(\d+\.?\d*)\s*[xX×]\s*(\d+\.?\d*)\s*[xX×]\s*(\d+\.?\d*)',
-                r'(\d+\.?\d*)"?\s*x\s*(\d+\.?\d*)"?\s*x\s*(\d+\.?\d*)"?'
-            ]
+            # Get or extract thumbnail
+            cache_key = f"thumb_{model}"
+            img_base64 = st.session_state.product_images.get(cache_key)
             
-            for pattern in dim_patterns:
-                dim_match = re.search(pattern, dimensions)
-                if dim_match:
-                    width = f"{dim_match.group(1)}\""
-                    depth = f"{dim_match.group(2)}\""
-                    height = f"{dim_match.group(3)}\""
-                    break
+            if not img_base64:
+                img_base64 = extract_pdf_thumbnail(pdf_path, model, max_width=150, max_height=200)
             
-            row = {
-                'Model': model,
-                'Product Type': get_product_type(model),
-                'Voltage': specs.get('voltage', 'N/A'),
-                'Amperage': specs.get('amperage', 'N/A'),
-                'Phase': specs.get('phase', 'N/A'),
-                'Frequency': specs.get('frequency', 'N/A'),
-                'Width': width,
-                'Depth': depth,
-                'Height': height,
-                'Capacity': specs.get('capacity', 'N/A'),
-                'Weight': specs.get('weight', 'N/A'),
-                'Refrigerant': specs.get('refrigerant', 'N/A'),
-                'Temperature Range': specs.get('temperature_range', 'N/A'),
-                'BTU': specs.get('btu', 'N/A'),
-                'Compressor': specs.get('compressor', 'N/A'),
-                'Features': '; '.join(features),
-                'Source File': model_data['filename']
-            }
-            export_data.append(row)
+            if img_base64:
+                # Convert base64 to image file for Excel
+                img_data = base64.b64decode(img_base64)
+                img = Image.open(io.BytesIO(img_data))
+                
+                # Save to temporary file
+                temp_img = io.BytesIO()
+                img.save(temp_img, format='PNG')
+                temp_img.seek(0)
+                
+                # Add to Excel
+                xl_img = XLImage(temp_img)  # type: ignore
+                xl_img.width = 150
+                xl_img.height = 200
+                ws.add_image(xl_img, f'A{row}')
+                
+                # Set row height to accommodate image
+                ws.row_dimensions[row].height = 150
+        
+        # Column B onwards: Data
+        ws.cell(row=row, column=2, value=model)
+        ws.cell(row=row, column=3, value=get_product_type(model))
+        ws.cell(row=row, column=4, value=specs.get('voltage', 'N/A'))
+        ws.cell(row=row, column=5, value=specs.get('amperage', 'N/A'))
+        ws.cell(row=row, column=6, value=specs.get('dimensions', 'N/A'))
+        ws.cell(row=row, column=7, value=specs.get('weight', 'N/A'))
+        ws.cell(row=row, column=8, value=specs.get('capacity', 'N/A'))
+        ws.cell(row=row, column=9, value=specs.get('refrigerant', 'N/A'))
+        ws.cell(row=row, column=10, value=specs.get('compressor', 'N/A'))
+        ws.cell(row=row, column=11, value=specs.get('doors', 'N/A'))
+        ws.cell(row=row, column=12, value=specs.get('shelves', 'N/A'))
+        ws.cell(row=row, column=13, value=specs.get('pans', 'N/A'))
+        
+        # Price information - MODIFIED FOR SINGLE PRICE
+        price = model_data.get('price', 'N/A')
+        ws.cell(row=row, column=14, value=price)
+        
+        # Center align all cells
+        for col in range(2, 15):
+            ws.cell(row=row, column=col).alignment = Alignment(vertical='center')  # type: ignore
+    
+    # Adjust column widths
+    ws.column_dimensions['A'].width = 25  # Image column
+    for col in range(2, 15):
+        ws.column_dimensions[get_column_letter(col)].width = 15  # type: ignore
+    
+    # Save to BytesIO
+    output = io.BytesIO()
+    wb.save(output)
+    output.seek(0)
     
-    df = pd.DataFrame(export_data)
-    return df.to_csv(index=False)
+    # Clear progress
+    progress_bar.empty()
+    status_text.empty()
+    
+    return output.getvalue()
 
-def export_bookmarked_models_pdf():
-    """Export bookmarked models to PDF with images and specifications"""
-    if not st.session_state.bookmarked_models:
+def export_cart_models_pdf():
+    """Export cart models to PDF with images and specifications"""
+    if not st.session_state.cart_models:
         return None
     
     # Create PDF in memory
@@ -677,8 +789,8 @@ def export_bookmarked_models_pdf():
                              styles['Normal']))
     elements.append(Spacer(1, 0.5*inch))
     
-    # Process each bookmarked model
-    for idx, model in enumerate(st.session_state.bookmarked_models):
+    # Process each cart model
+    for idx, model in enumerate(st.session_state.cart_models):
         if idx > 0:
             elements.append(PageBreak())
         
@@ -691,15 +803,15 @@ def export_bookmarked_models_pdf():
         
         # Try to get product image
         if model_data.get('file_path'):
-            pdf_filename = model_data['file_path'].replace('\\', '/').split('/')[-1]
-            pdf_url = f"https://huggingface.co/spaces/TurboAir/TurboAirViewer/resolve/main/pdfs/{pdf_filename}"
+            pdf_filename = model_data['file_path']
+            pdf_path = os.path.join(PDF_DIR, pdf_filename)
             
             # Get cached image or extract it
             cache_key = f"thumb_{model}"
             img_base64 = st.session_state.product_images.get(cache_key)
             
             if not img_base64:
-                img_base64 = extract_pdf_thumbnail(pdf_url, model, max_width=200, max_height=250)
+                img_base64 = extract_pdf_thumbnail(pdf_path, model, max_width=200, max_height=250)
             
             if img_base64:
                 # Convert base64 to image for PDF
@@ -738,6 +850,11 @@ def export_bookmarked_models_pdf():
         if specs.get('btu') and specs.get('btu') != 'N/A':
             spec_data.append(['BTU', specs['btu']])
         
+        # Add price information - MODIFIED FOR SINGLE PRICE
+        price = model_data.get('price', 'N/A')
+        if price and price != 'N/A':
+            spec_data.append(['Price', price])
+        
         if len(spec_data) > 1:
             # Create table
             spec_table = Table(spec_data, colWidths=[2.5*inch, 4*inch])
@@ -766,7 +883,7 @@ def export_bookmarked_models_pdf():
             elements.append(Spacer(1, 0.2*inch))
         
         # Source info
-        elements.append(Paragraph(f"<i>Source: {model_data['filename']}</i>", styles['Normal']))
+        elements.append(Paragraph(f"<i>Source: {model_data.get('filename', 'Unknown')}</i>", styles['Normal']))
     
     # Build PDF
     doc.build(elements)
@@ -780,7 +897,7 @@ def display_pdf_preview(file_path, model_name):
     pdf_filename = file_path.replace('\\', '/').split('/')[-1]
     
     # Create the HuggingFace Space URL for the PDF
-    pdf_url = f"https://huggingface.co/spaces/TurboAir/TurboAirViewer/resolve/main/pdfs/{pdf_filename}"
+    pdf_url = f"https://huggingface.co/spaces/redxican/TurboAirViewer2.0/resolve/main/pdfs/{pdf_filename}"
     
     # Control buttons row
     col1, col2, col3 = st.columns([2, 1, 1])
@@ -819,21 +936,20 @@ def display_pdf_preview(file_path, model_name):
     st.markdown("🔍 **Backup viewer** (if PDF doesn't display above):")
     
     # Use PDF.js viewer directly (most reliable for HuggingFace Spaces)
-    import streamlit.components.v1 as components
     components.iframe(
         src=f"https://mozilla.github.io/pdf.js/web/viewer.html?file={quote(pdf_url, safe='')}",
-        height=900,
+        height=1200,
         scrolling=True
     )
 
-def display_bookmarked_models():
-    """Display bookmarked models section with optimized toggle"""
-    if not st.session_state.bookmarked_models:
-        st.info("📌 No models bookmarked yet. Select models to create your custom list!")
+def display_cart_models():
+    """Display cart models section with optimized toggle"""
+    if not st.session_state.cart_models:
+        st.info("🛒 Your cart is empty. Add models to create your custom quote!")
         return
     
     # Collapsible header
-    with st.expander(f"📌 Bookmarked Models ({len(st.session_state.bookmarked_models)} selected)", expanded=True):
+    with st.expander(f"🛒 Shopping Cart ({len(st.session_state.cart_models)} items)", expanded=True):
         view_col1, view_col2, view_col3 = st.columns([2, 1, 1])
         
         with view_col3:
@@ -842,56 +958,56 @@ def display_bookmarked_models():
             if st.button(toggle_label, key="toggle_view", use_container_width=True):
                 st.session_state.text_only_view = not st.session_state.text_only_view
         
-        # Display bookmarked models with or without images
+        # Display cart models with or without images
         if st.session_state.text_only_view:
             # Text-only view (original compact list)
             display_limit = 5
-            for idx, model in enumerate(st.session_state.bookmarked_models[:display_limit]):
+            for idx, model in enumerate(st.session_state.cart_models[:display_limit]):
                 col_select, col_remove = st.columns([5, 1])
                 with col_select:
                     if st.button(f"• {model}", key=f"select_text_{idx}", use_container_width=True, help=f"Click to view {model}"):
                         st.session_state.selected_model = model
                         st.rerun()
                 with col_remove:
-                    if st.button("❌", key=f"remove_bookmark_list_{idx}", help=f"Remove {model}"):
-                        st.session_state.bookmarked_models.remove(model)
+                    if st.button("❌", key=f"remove_cart_list_{idx}", help=f"Remove {model} from cart"):
+                        st.session_state.cart_models.remove(model)
                         st.rerun()
             
-            if len(st.session_state.bookmarked_models) > display_limit:
-                with st.expander(f"Show all {len(st.session_state.bookmarked_models)} bookmarks"):
-                    for idx, model in enumerate(st.session_state.bookmarked_models[display_limit:], display_limit):
+            if len(st.session_state.cart_models) > display_limit:
+                with st.expander(f"Show all {len(st.session_state.cart_models)} items"):
+                    for idx, model in enumerate(st.session_state.cart_models[display_limit:], display_limit):
                         col_select, col_remove = st.columns([5, 1])
                         with col_select:
                             if st.button(f"• {model}", key=f"select_text_exp_{idx}", use_container_width=True, help=f"Click to view {model}"):
                                 st.session_state.selected_model = model
                                 st.rerun()
                         with col_remove:
-                            if st.button("❌", key=f"remove_bookmark_exp_{idx}", help=f"Remove {model}"):
-                                st.session_state.bookmarked_models.remove(model)
+                            if st.button("❌", key=f"remove_cart_exp_{idx}", help=f"Remove {model} from cart"):
+                                st.session_state.cart_models.remove(model)
                                 st.rerun()
 
-        else:  # ← THIS IS THE KEY FIX - Added else block
+        else:
             # Image view
             # Display in grid layout
             cols_per_row = 6  # Changed from 4 to 6 columns for narrower items
-            for i in range(0, len(st.session_state.bookmarked_models), cols_per_row):
+            for i in range(0, len(st.session_state.cart_models), cols_per_row):
                 cols = st.columns(cols_per_row)
                 
                 for j, col in enumerate(cols):
-                    if i + j < len(st.session_state.bookmarked_models):
-                        model = st.session_state.bookmarked_models[i + j]
+                    if i + j < len(st.session_state.cart_models):
+                        model = st.session_state.cart_models[i + j]
                         model_data = get_model_data(model)
                         
                         with col:
-                            # Container for each bookmarked item
-                            st.markdown('<div class="bookmark-item">', unsafe_allow_html=True)
+                            # Container for each cart item
+                            st.markdown('<div class="cart-item">', unsafe_allow_html=True)
                             
-                            # Container for each bookmarked item
+                            # Container for each cart item
                             with st.container():
                                 # Try to get and display thumbnail
                                 if model_data and model_data.get('file_path'):
-                                    pdf_filename = model_data['file_path'].replace('\\', '/').split('/')[-1]
-                                    pdf_url = f"https://huggingface.co/spaces/TurboAir/TurboAirViewer/resolve/main/pdfs/{pdf_filename}"
+                                    pdf_filename = model_data['file_path']
+                                    pdf_path = os.path.join(PDF_DIR, pdf_filename)
                                     
                                     # Check if image is already cached
                                     cache_key = f"thumb_{model}"
@@ -902,18 +1018,18 @@ def display_bookmarked_models():
                                         st.markdown(
                                             f'<img src="data:image/png;base64,{img_base64}" '
                                             f'style="width:100%; max-height:150px; object-fit:contain; cursor:pointer;" '
-                                            f'class="bookmark-image">',
+                                            f'class="cart-image">',
                                             unsafe_allow_html=True
                                         )
                                     else:
                                         # Extract image with minimal loading indication
-                                        img_base64 = extract_pdf_thumbnail(pdf_url, model, max_width=200, max_height=250)
+                                        img_base64 = extract_pdf_thumbnail(pdf_path, model, max_width=200, max_height=250)
                                         
                                         if img_base64:
                                             st.markdown(
                                                 f'<img src="data:image/png;base64,{img_base64}" '
                                                 f'style="width:100%; max-height:200px; object-fit:contain; cursor:pointer;" '
-                                                f'class="bookmark-image">',
+                                                f'class="cart-image">',
                                                 unsafe_allow_html=True
                                             )
                                         else:
@@ -935,44 +1051,118 @@ def display_bookmarked_models():
                                         st.rerun()
                                 with col_remove:
                                     if st.button("❌", key=f"remove_img_{i}_{j}", use_container_width=True, type="secondary"):
-                                        st.session_state.bookmarked_models.remove(model)
+                                        st.session_state.cart_models.remove(model)
                                         st.rerun()
                             
                             st.markdown('</div>', unsafe_allow_html=True)
     
-    # Export section - MOVED OUTSIDE THE IF/ELSE AND PROPERLY INDENTED
+    # Export section
     st.markdown("---")
-    export_col1, export_col2, export_col3 = st.columns(3)
-    
-    with export_col1:
-        csv_data = export_bookmarked_models()
-        if csv_data:
-            st.download_button(
-                "📥 Export CSV",
-                data=csv_data,
-                file_name=f"turbo_air_selection_{datetime.now().strftime('%Y%m%d_%H%M')}.csv",
-                mime="text/csv",
-                use_container_width=True
-            )
+    st.markdown("### 📊 Export & Share")
+    
+    # Initialize email visibility state
+    if 'show_email_form' not in st.session_state:
+        st.session_state.show_email_form = False
+    
+    # Export buttons row - all in one line
+    button_col1, button_col2, button_col3, button_col4 = st.columns([1.2, 1.2, 1.2, 1])
+    
+    with button_col1:
+        # Email toggle button (moved to first position)
+        email_btn_text = "📧 Email Excel ▲" if st.session_state.show_email_form else "📧 Email Excel ▼"
+        if st.button(email_btn_text, use_container_width=True, key="toggle_email"):
+            st.session_state.show_email_form = not st.session_state.show_email_form
+    
+    with button_col2:
+        # Excel export button
+        if EXCEL_AVAILABLE:
+            excel_data = export_cart_models_excel()
+            if excel_data:
+                st.download_button(
+                    "📊 Download Excel",
+                    data=excel_data,
+                    file_name=f"turbo_air_cart_{datetime.now().strftime('%Y%m%d_%H%M')}.xlsx",
+                    mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                    use_container_width=True,
+                    type="primary",
+                    key="download_excel_btn"
+                )
+        else:
+            st.error("Excel export unavailable - openpyxl not installed")
     
-    with export_col2:
+    with button_col3:
         # PDF export button
-        pdf_data = export_bookmarked_models_pdf()
+        pdf_data = export_cart_models_pdf()
         if pdf_data:
             st.download_button(
-                "📄 Export PDF",
+                "📄 Download PDF",
                 data=pdf_data,
                 file_name=f"turbo_air_report_{datetime.now().strftime('%Y%m%d_%H%M')}.pdf",
                 mime="application/pdf",
                 use_container_width=True,
-                type="primary"
+                key="download_pdf_btn"
             )
     
-    with export_col3:
-        if st.button("🗑️ Clear All", use_container_width=True):
-            st.session_state.bookmarked_models = []
+    with button_col4:
+        # Clear cart button (moved to last position)
+        if st.button("🗑️ Clear Cart", use_container_width=True):
+            st.session_state.cart_models = []
             st.session_state.product_images = {}  # Clear image cache too
             st.rerun()
+    
+    # Email form (only shown when toggled)
+    if st.session_state.show_email_form:
+        st.markdown("---")
+        
+        # Initialize session state for download tracking
+        if 'excel_downloaded' not in st.session_state:
+            st.session_state.excel_downloaded = False
+        
+        # Email form
+        email_col1, email_col2, email_col3 = st.columns([3, 1, 1])
+        
+        with email_col1:
+            receiver_email = st.text_input("To:", placeholder="Customer email address", key="receiver_email", label_visibility="collapsed")
+        
+        if receiver_email and EXCEL_AVAILABLE:
+            excel_data = export_cart_models_excel()
+            if excel_data:
+                filename = f"turbo_air_cart_{datetime.now().strftime('%Y%m%d_%H%M')}.xlsx"
+                
+                with email_col2:
+                    # Step 1: Download Excel
+                    downloaded = st.download_button(
+                        label="📥 Step 1: Download",
+                        data=excel_data,
+                        file_name=filename,
+                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                        use_container_width=True,
+                        key="download_excel_for_email"
+                    )
+                    if downloaded:
+                        st.session_state.excel_downloaded = True
+                
+                with email_col3:
+                    # Step 2: Open Email (only enabled after download)
+                    mailto_link = f"mailto:{receiver_email}"
+                    
+                    if st.session_state.excel_downloaded:
+                        st.markdown(f'''
+                        <a href="{mailto_link}" class="email-button" target="_blank" style="width: 100%; padding: 0.5rem; display: inline-block; text-align: center;">
+                            📧 Step 2: Email
+                        </a>
+                        ''', unsafe_allow_html=True)
+                    else:
+                        st.button("📧 Step 2: Email", use_container_width=True, disabled=True, key="email_disabled")
+                
+                # Instructions
+                if st.session_state.excel_downloaded:
+                    st.info(f"✅ File downloaded: **{filename}** → Now click 'Step 2: Email' to compose your message and attach the file from your Downloads folder.")
+        else:
+            with email_col2:
+                st.button("📥 Step 1: Download", use_container_width=True, disabled=True)
+            with email_col3:
+                st.button("📧 Step 2: Email", use_container_width=True, disabled=True)
 
 # MAIN UI
 st.title("❄️ Turbo Air Equipment Viewer")
@@ -982,14 +1172,14 @@ st.caption("Professional Equipment Specification Database")
 all_models = get_all_models()
 
 if not all_models:
-    st.error("⚠️ No data found in database. Please ensure turbo_air_db.sqlite is available.")
+    st.error("⚠️ No data found in database. Please ensure turbo_air_db_online.sqlite is available.")
     st.stop()
 
-# Bookmarks section
-if st.session_state.bookmarked_models:
-    display_bookmarked_models()
+# Cart section
+if st.session_state.cart_models:
+    display_cart_models()
 else:
-    st.info("📌 No models bookmarked yet. Select models to create your custom list!")
+    st.info("🛒 Your cart is empty. Add models to create your custom quote!")
 
 # Main content area
 col1, col2 = st.columns([1, 3])
@@ -997,28 +1187,22 @@ col1, col2 = st.columns([1, 3])
 with col1:
     st.markdown("### 💡 Quick Tips")
     st.write("• View PDF spec sheets")
-    st.write("• Bookmark models for lists")
+    st.write("• Add models to cart")
     st.write("• Toggle image/text view")
-    st.write("• Export to CSV or PDF")
+    st.write("• Export to Excel with images")
+    st.write("• Export to PDF report")
+    st.write("• Email quotes to customers")
     st.write("• Google search finds prices")
 
 with col2:
     st.markdown('### 🔍 Model Search')
     st.caption("Start typing the model number or browse all models")
     
-    # Group models by product type
-    grouped_models = {}
-    for model in all_models:
-        product_type = get_product_type(model)
-        if product_type not in grouped_models:
-            grouped_models[product_type] = []
-        grouped_models[product_type].append(model)
-    
     # Create formatted options with empty first option for easy typing
     formatted_options = ['']  # Empty first option
-    for product_type in sorted(grouped_models.keys()):
-        for model in sorted(grouped_models[product_type]):
-            formatted_options.append(model)
+    # Add all models sorted alphabetically
+    for model in sorted(all_models):
+        formatted_options.append(model)
     
     # Search selectbox with clear typing experience
     if st.session_state.selected_model and st.session_state.selected_model in formatted_options:
@@ -1029,7 +1213,7 @@ with col2:
     selected = st.selectbox(
         "Select or type a model number:",
         options=formatted_options,
-        format_func=lambda x: format_model_option(x) if x else "↓ Click here and start typing model number...",
+        format_func=lambda x: x if x else "↓ Click here and start typing model number...",
         key="model_search",
         index=default_index,
         help="Click and start typing to search models"
@@ -1045,33 +1229,30 @@ if st.session_state.selected_model and st.session_state.selected_model != '':
     model_data = get_model_data(st.session_state.selected_model)
     
     if model_data:
-        # Model header with bookmark
+        # Model header with cart button
         col1, col2 = st.columns([4, 1])
         with col1:
             st.markdown(f"## {st.session_state.selected_model}")
             st.caption(f"Product Type: {get_product_type(st.session_state.selected_model)}")
-            if model_data.get('quality'):
-                quality_class = f"quality-{model_data['quality']}"
-                st.markdown(f'<span class="quality-badge {quality_class}">Data Quality: {model_data["quality"].title()}</span>', 
-                          unsafe_allow_html=True)
+            # Removed quality badge display since no confidence score
         
         with col2:
-            is_bookmarked = st.session_state.selected_model in st.session_state.bookmarked_models
-            bookmark_label = "❌ Remove" if is_bookmarked else "📌 Bookmark"
-            if st.button(bookmark_label, key=f"bookmark_{st.session_state.selected_model}", use_container_width=True):
-                if is_bookmarked:
-                    st.session_state.bookmarked_models.remove(st.session_state.selected_model)
-                    st.success("Bookmark removed!")
+            is_in_cart = st.session_state.selected_model in st.session_state.cart_models
+            cart_label = "❌ Remove from Cart" if is_in_cart else "🛒 Add to Cart"
+            if st.button(cart_label, key=f"cart_{st.session_state.selected_model}", use_container_width=True):
+                if is_in_cart:
+                    st.session_state.cart_models.remove(st.session_state.selected_model)
+                    st.success("Removed from cart!")
                 else:
-                    st.session_state.bookmarked_models.append(st.session_state.selected_model)
-                    st.success("Model bookmarked!")
+                    st.session_state.cart_models.append(st.session_state.selected_model)
+                    st.success("Added to cart!")
                 time.sleep(0.5)
                 st.rerun()
         
         # Display product image if available
         if model_data.get('file_path'):
-            pdf_filename = model_data['file_path'].replace('\\', '/').split('/')[-1]
-            pdf_url = f"https://huggingface.co/spaces/TurboAir/TurboAirViewer/resolve/main/pdfs/{pdf_filename}"
+            pdf_filename = model_data['file_path']
+            pdf_path = os.path.join(PDF_DIR, pdf_filename)
             
             # Create columns for image and specifications
             img_col, _, spec_col = st.columns([1, 0.1, 2])
@@ -1085,7 +1266,7 @@ if st.session_state.selected_model and st.session_state.selected_model != '':
                 if not img_base64:
                     # Extract image if not cached
                     with st.spinner("Loading product image..."):
-                        img_base64 = extract_pdf_thumbnail(pdf_url, st.session_state.selected_model, max_width=400, max_height=500)
+                        img_base64 = extract_pdf_thumbnail(pdf_path, st.session_state.selected_model, max_width=400, max_height=500)
                 
                 if img_base64:
                     st.markdown(
@@ -1096,6 +1277,11 @@ if st.session_state.selected_model and st.session_state.selected_model != '':
                     )
                 else:
                     st.info("📄 No preview available")
+                    # Show debug info in expander
+                    with st.expander("Debug Info"):
+                        st.write(f"PDF filename: {pdf_filename}")
+                        st.write(f"Looking for: {pdf_path}")
+                        st.write(f"File exists: {os.path.exists(pdf_path)}")
             
             with spec_col:
                 # Specifications
@@ -1132,6 +1318,26 @@ if st.session_state.selected_model and st.session_state.selected_model != '':
                         st.write(f"BTU: {specs['btu']}")
                     if specs.get('capacity') and specs.get('capacity') != 'N/A':
                         st.write(f"Capacity: {specs['capacity']}")
+                    
+                    # Configuration details
+                    config_items = []
+                    if specs.get('doors') and specs.get('doors') != 'N/A':
+                        config_items.append(f"Doors: {specs['doors']}")
+                    if specs.get('shelves') and specs.get('shelves') != 'N/A':
+                        config_items.append(f"Shelves: {specs['shelves']}")
+                    if specs.get('pans') and specs.get('pans') != 'N/A':
+                        config_items.append(f"Pans: {specs['pans']}")
+                    
+                    if config_items:
+                        st.markdown("**Configuration:**")
+                        for item in config_items:
+                            st.write(f"{item}")
+                    
+                    # Price information - MODIFIED FOR SINGLE PRICE
+                    price = model_data.get('price', 'N/A')
+                    if price and price != 'N/A':
+                        st.markdown("### Price")
+                        st.markdown(f'<p style="font-size: 1.2em; color: #ff0000; font-weight: bold; margin: 0;">{price}</p>', unsafe_allow_html=True)
         else:
             # No file path - show specifications in original two-column layout
             specs = model_data['data'].get('specs', {})
@@ -1171,6 +1377,12 @@ if st.session_state.selected_model and st.session_state.selected_model != '':
                         st.write(f"BTU: {specs['btu']}")
                     if specs.get('capacity') and specs.get('capacity') != 'N/A':
                         st.write(f"Capacity: {specs['capacity']}")
+                    
+                    # Price information - MODIFIED FOR SINGLE PRICE
+                    price = model_data.get('price', 'N/A')
+                    if price and price != 'N/A':
+                        st.markdown("### Price")
+                        st.markdown(f'<p style="font-size: 1.2em; color: #ff0000; font-weight: bold; margin: 0;">{price}</p>', unsafe_allow_html=True)
         
         # Features
         features = model_data['data'].get('features', [])
@@ -1211,8 +1423,9 @@ if st.session_state.selected_model and st.session_state.selected_model != '':
                 st.session_state[pdf_key] = not st.session_state.get(pdf_key, False)
         
         with action_col2:
-            # Google search button
-            google_search = f"https://www.google.com/search?q=turboair+{st.session_state.selected_model.replace(' ', '+')}+price"
+            # Google search button - use model_no_dashes from database
+            search_model = model_data.get('model_no_dashes', st.session_state.selected_model.replace(' ', '+'))
+            google_search = f"https://www.google.com/search?q=turboair+{search_model}+price"
             st.markdown(f'''
             <a href="{google_search}" target="_blank" style="text-decoration: none;">
                 <button class="google-search-button">
@@ -1258,18 +1471,26 @@ with col1:
 
 with col2:
     st.markdown("### Database Info")
-    try:
-        conn = sqlite3.connect(DB_PATH)
-        cursor = conn.cursor()
-        cursor.execute("SELECT COUNT(*) FROM documents")
-        doc_count = cursor.fetchone()[0]
-        conn.close()
-        
-        st.write(f"• Total Documents: {doc_count}")
-        st.write(f"• Total Models: {len(all_models)}")
-        st.write(f"• Database Size: {Path(DB_PATH).stat().st_size/1024/1024:.1f} MB")
-    except:
-        st.write("• Database info unavailable")
+    if DB_PATH:
+        try:
+            conn = sqlite3.connect(DB_PATH)
+            cursor = conn.cursor()
+            cursor.execute("SELECT COUNT(*) FROM products")
+            product_count = cursor.fetchone()[0]
+            
+            # Get products with prices - MODIFIED FOR SINGLE PRICE FIELD
+            cursor.execute("SELECT COUNT(*) FROM products WHERE Price IS NOT NULL AND Price != 'N/A'")
+            priced_count = cursor.fetchone()[0]
+            
+            conn.close()
+            
+            st.write(f"• Total Products: {product_count}")
+            st.write(f"• Products with Prices: {priced_count}")
+            st.write(f"• Database Size: {Path(DB_PATH).stat().st_size/1024/1024:.1f} MB")
+        except:
+            st.write("• Database info unavailable")
+    else:
+        st.write("• Database not loaded")
 
 # Footer
 st.markdown("---")