Update app.py

app.py

@@ -1,6 +1,6 @@
 import os
 import asyncio
-from typing import Optional
+from typing import Optional, List, Dict, Any
 from fastapi import FastAPI, UploadFile, File, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
@@ -12,11 +12,15 @@ import re
 from io import BytesIO
 import math
 import time
-import fitz
+import fitz  # PyMuPDF
 from PIL import Image
 import google.generativeai as genai
 from google.generativeai.types import HarmCategory, HarmBlockThreshold
+import numpy as np
+from pdf2image import convert_from_bytes
+import tempfile
 
+# Enhanced logging configuration
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
@@ -27,16 +31,34 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
+# Configuration
 GOOGLE_API_KEY = os.environ.get('GOOGLE_API_KEY')
+OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')  # Optional: for GPT-4V fallback
+
 if not GOOGLE_API_KEY:
     logger.warning("GOOGLE_API_KEY not set!")
 else:
     genai.configure(api_key=GOOGLE_API_KEY)
 
+# Optional: Import OpenAI for fallback
+try:
+    import openai
+    if OPENAI_API_KEY:
+        openai.api_key = OPENAI_API_KEY
+        USE_OPENAI_FALLBACK = True
+    else:
+        USE_OPENAI_FALLBACK = False
+except ImportError:
+    USE_OPENAI_FALLBACK = False
+    logger.info("OpenAI not available for fallback")
+
 os.makedirs("uploads", exist_ok=True)
+os.makedirs("temp", exist_ok=True)
 
 class FloorPlanQuery(BaseModel):
     description: Optional[str] = None
+    force_ocr: bool = False
+    use_high_quality: bool = True
 
 class RoomQuery(BaseModel):
     room_name: str
@@ -58,6 +80,7 @@ class PDF:
             "room_dimensions": {}
         }
         self.analysis_result = None
+        self.extraction_method = None
         
     def to_dict(self):
         return {
@@ -71,12 +94,13 @@ class PDF:
             "image_count": len(self.images) if self.images else 0,
             "measurement_info": self.measurement_info,
             "has_analysis": self.analysis_result is not None,
-            "room_count": len(self.analysis_result) if self.analysis_result else 0
+            "room_count": len(self.analysis_result) if self.analysis_result else 0,
+            "extraction_method": self.extraction_method
         }
 
 class FloorPlanProcessor:
     def __init__(self):
-        self.model = genai.GenerativeModel('gemini-2.5-pro')
+        self.model = genai.GenerativeModel('gemini-2.0-flash-exp')  # Using newer, faster model
         self.pdfs = {}
         self.supported_image_formats = {
             "image/jpeg": ".jpg", 
@@ -87,7 +111,8 @@ class FloorPlanProcessor:
             "image/webp": ".webp"
         }
     
-    async def process_upload(self, file_content, filename, content_type):
+    async def process_upload(self, file_content: bytes, filename: str, content_type: str):
+        """Enhanced upload processing with better PDF handling"""
         pdf_id = re.sub(r'[^a-zA-Z0-9]', '_', filename)
         logger.info(f"Processing {filename} (ID: {pdf_id})")
         
@@ -101,14 +126,22 @@ class FloorPlanProcessor:
                 f.write(file_content)
             
             if content_type == "application/pdf":
-                await self.extract_images_from_pdf(pdf, file_content)
+                # Try multiple extraction methods
+                success = await self.extract_images_from_pdf_enhanced(pdf, file_content)
+                if not success:
+                    logger.warning("Primary extraction failed, trying fallback methods")
+                    success = await self.extract_with_pdf2image(pdf, file_content)
+                
+                if not success and len(pdf.images) == 0:
+                    raise ValueError("Could not extract any images from PDF")
+                    
             elif content_type in self.supported_image_formats:
                 await self.process_image(pdf, file_content)
             else:
                 raise ValueError(f"Unsupported type: {content_type}")
             
             pdf.processed = True
-            logger.info(f"Processing complete: {pdf_id}")
+            logger.info(f"Processing complete: {pdf_id} with {len(pdf.images)} images")
             return pdf_id
             
         except Exception as e:
@@ -116,49 +149,91 @@ class FloorPlanProcessor:
             pdf.error = str(e)
             return pdf_id
     
-    async def process_image(self, pdf, file_content):
+    async def process_image(self, pdf: PDF, file_content: bytes):
+        """Process single image file"""
         try:
             img = Image.open(BytesIO(file_content))
             logger.info(f"Image: {img.width}x{img.height}")
             pdf.images.append(img)
+            pdf.extraction_method = "direct_image"
             return True
         except Exception as e:
             logger.error(f"Image error: {str(e)}")
             pdf.error = str(e)
             return False
     
-    async def extract_images_from_pdf(self, pdf, file_content):
+    async def extract_images_from_pdf_enhanced(self, pdf: PDF, file_content: bytes) -> bool:
+        """Enhanced PDF extraction with multiple strategies"""
         try:
             pdf_document = fitz.open(stream=file_content, filetype="pdf")
             pdf.page_count = len(pdf_document)
             
             images = []
+            
             for page_num in range(len(pdf_document)):
                 page = pdf_document[page_num]
+                
+                # Strategy 1: Try to get embedded images
                 image_list = page.get_images(full=True)
                 
-                if not image_list:
-                    pix = page.get_pixmap(matrix=fitz.Matrix(2, 2))
-                    img = Image.open(BytesIO(pix.tobytes("png")))
-                    images.append(img)
-                else:
+                if image_list:
                     for img_info in image_list:
-                        xref = img_info[0]
-                        base_image = pdf_document.extract_image(xref)
-                        img = Image.open(BytesIO(base_image["image"]))
-                        if img.width > 100 and img.height > 100:
-                            images.append(img)
+                        try:
+                            xref = img_info[0]
+                            base_image = pdf_document.extract_image(xref)
+                            img = Image.open(BytesIO(base_image["image"]))
+                            if img.width > 100 and img.height > 100:
+                                images.append(img)
+                                logger.info(f"Extracted embedded image: {img.width}x{img.height}")
+                        except Exception as e:
+                            logger.warning(f"Failed to extract image {xref}: {str(e)}")
+                
+                # Strategy 2: Render page as image (high quality)
+                if not image_list or len(images) == 0:
+                    try:
+                        # Higher resolution for better OCR
+                        mat = fitz.Matrix(3, 3)  # 3x zoom for better quality
+                        pix = page.get_pixmap(matrix=mat, alpha=False)
+                        img = Image.open(BytesIO(pix.tobytes("png")))
+                        images.append(img)
+                        logger.info(f"Rendered page {page_num + 1} as image: {img.width}x{img.height}")
+                    except Exception as e:
+                        logger.error(f"Failed to render page {page_num + 1}: {str(e)}")
             
             pdf.images = images
-            logger.info(f"Extracted {len(images)} images")
-            return True
+            pdf.extraction_method = "pymupdf"
+            logger.info(f"Extracted {len(images)} images using PyMuPDF")
+            return len(images) > 0
             
         except Exception as e:
-            logger.error(f"PDF error: {str(e)}")
-            pdf.error = str(e)
+            logger.error(f"PyMuPDF extraction error: {str(e)}")
+            return False
+    
+    async def extract_with_pdf2image(self, pdf: PDF, file_content: bytes) -> bool:
+        """Fallback extraction using pdf2image (requires poppler)"""
+        try:
+            # Convert PDF to images using pdf2image
+            images = convert_from_bytes(
+                file_content,
+                dpi=300,  # High DPI for better quality
+                fmt='png',
+                thread_count=4,
+                use_pdftocairo=True  # Better quality renderer
+            )
+            
+            pdf.images = images
+            pdf.extraction_method = "pdf2image"
+            logger.info(f"Extracted {len(images)} images using pdf2image")
+            return len(images) > 0
+            
+        except Exception as e:
+            logger.error(f"pdf2image extraction error: {str(e)}")
+            logger.info("Note: pdf2image requires poppler-utils to be installed")
             return False
     
-    async def analyze_floor_plan(self, pdf_id, description=None):
+    async def analyze_floor_plan(self, pdf_id: str, description: Optional[str] = None, 
+                                use_high_quality: bool = True) -> List[Dict[str, Any]]:
+        """Enhanced analysis with better error handling and multiple models"""
         pdf = self.pdfs.get(pdf_id)
         if not pdf:
             raise ValueError(f"PDF {pdf_id} not found")
@@ -169,25 +244,110 @@ class FloorPlanProcessor:
         logger.info(f"\n{'='*70}")
         logger.info(f"Analyzing: {pdf_id}")
         logger.info(f"Images: {len(pdf.images)}")
+        logger.info(f"Extraction method: {pdf.extraction_method}")
         logger.info(f"{'='*70}")
         
-        # Use ONLY the first/best image for single file analysis
-        best_image = self._select_single_best_image(pdf.images)
-        optimized_image = self._optimize_image(best_image, target_size=2048)
+        # Select and optimize best image
+        best_image = self._select_best_image_enhanced(pdf.images)
+        
+        # Use higher resolution for PDFs that were rendered
+        target_size = 3072 if use_high_quality else 2048
+        optimized_image = self._optimize_image(best_image, target_size=target_size)
+        
+        logger.info(f"Using image: {optimized_image.size[0]}x{optimized_image.size[1]}px")
+        
+        # Try primary model
+        result = await self._try_analysis_with_retries(
+            optimized_image, 
+            pdf.measurement_info, 
+            description,
+            max_retries=3
+        )
+        
+        if result and len(result) > 0:
+            pdf.analysis_result = result
+            return result
+        
+        # Try fallback with different model if available
+        if USE_OPENAI_FALLBACK:
+            logger.info("Trying OpenAI GPT-4V as fallback")
+            result = await self._analyze_with_gpt4v(optimized_image, pdf.measurement_info, description)
+            if result and len(result) > 0:
+                pdf.analysis_result = result
+                return result
+        
+        # Final fallback
+        logger.warning("All analysis attempts failed, using fallback")
+        result = self._generate_fallback(pdf.measurement_info)
+        pdf.analysis_result = result
+        return result
+    
+    def _select_best_image_enhanced(self, images: List[Image.Image]) -> Image.Image:
+        """Enhanced image selection with quality scoring"""
+        if len(images) == 1:
+            return images[0]
+        
+        best_score = -1
+        best_image = images[0]
+        
+        for img in images:
+            # Score based on resolution and aspect ratio
+            area = img.width * img.height
+            aspect_ratio = img.width / img.height if img.height > 0 else 0
+            
+            # Prefer landscape orientation (typical for floor plans)
+            aspect_score = 1.0 if 1.0 <= aspect_ratio <= 2.0 else 0.5
+            
+            # Combine scores
+            score = area * aspect_score
+            
+            if score > best_score:
+                best_score = score
+                best_image = img
+                
+        logger.info(f"Selected best image from {len(images)} options")
+        return best_image
+    
+    def _optimize_image(self, image: Image.Image, target_size: int = 2048) -> Image.Image:
+        """Optimize image with enhanced preprocessing"""
+        # Convert to RGB if needed
+        if image.mode not in ('RGB', 'L'):
+            image = image.convert('RGB')
         
-        logger.info(f"Using single image: {optimized_image.size[0]}x{optimized_image.size[1]}px")
+        # Apply contrast enhancement for better OCR
+        from PIL import ImageEnhance
+        enhancer = ImageEnhance.Contrast(image)
+        image = enhancer.enhance(1.2)
+        
+        # Resize if needed
+        width, height = image.size
+        if width > target_size or height > target_size:
+            ratio = target_size / max(width, height)
+            new_width = int(width * ratio)
+            new_height = int(height * ratio)
+            image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+            logger.info(f"Resized: {width}x{height} → {new_width}x{new_height}")
+        
+        return image
+    
+    async def _try_analysis_with_retries(self, image: Image.Image, measurement_info: dict, 
+                                        description: Optional[str], max_retries: int = 3) -> Optional[List[Dict]]:
+        """Enhanced retry logic with progressive adjustments"""
         
-        # Try analysis with extended timeout
-        max_retries = 3
         for attempt in range(max_retries):
             try:
-                logger.info(f"\nAttempt {attempt + 1}/{max_retries}")
+                logger.info(f"\nAnalysis attempt {attempt + 1}/{max_retries}")
+                
+                # Adjust parameters based on attempt
+                temperature = 0.1 + (attempt * 0.1)  # Increase creativity on retries
+                timeout = 300 + (attempt * 150)  # Increase timeout progressively
                 
                 result = await self._analyze_with_gemini(
-                    optimized_image,
-                    pdf.measurement_info,
+                    image,
+                    measurement_info,
                     description,
-                    timeout=600,
+                    timeout=timeout,
+                    temperature=temperature,
                     attempt=attempt
                 )
                 
@@ -198,71 +358,39 @@ class FloorPlanProcessor:
             except asyncio.TimeoutError:
                 logger.warning(f"Timeout on attempt {attempt + 1}")
                 if attempt < max_retries - 1:
-                    await asyncio.sleep(10)
-                    continue
+                    await asyncio.sleep(5 * (attempt + 1))
                     
             except Exception as e:
                 error_str = str(e)
                 logger.error(f"Attempt {attempt + 1} error: {error_str}")
                 
                 # Check for retryable errors
-                if any(k in error_str.lower() for k in ['504', '503', '429', 'timeout', 'deadline']):
+                if any(k in error_str.lower() for k in ['504', '503', '429', 'timeout', 'deadline', 'rate']):
                     if attempt < max_retries - 1:
-                        wait = 15 * (attempt + 1)
+                        wait = 10 * (attempt + 1)
                         logger.info(f"Waiting {wait}s before retry...")
                         await asyncio.sleep(wait)
                         continue
                 
                 # Non-retryable error
-                logger.error(f"Non-retryable error: {error_str}")
-                raise
-        
-        logger.warning("All attempts failed, using fallback")
-        return self._generate_fallback(pdf.measurement_info)
-    
-    def _select_single_best_image(self, images):
-        """Select the single best image"""
-        if len(images) == 1:
-            return images[0]
-        
-        # Score by area (largest = best for floor plans)
-        scored = [(img.size[0] * img.size[1], img) for img in images]
-        scored.sort(reverse=True, key=lambda x: x[0])
-        
-        best = scored[0][1]
-        logger.info(f"Selected best from {len(images)} images")
-        return best
-    
-    def _optimize_image(self, image, target_size=2048):
-        """Optimize image for analysis"""
-        if image.mode not in ('RGB', 'L'):
-            image = image.convert('RGB')
-        
-        width, height = image.size
-        
-        if width > target_size or height > target_size:
-            ratio = target_size / max(width, height)
-            new_width = int(width * ratio)
-            new_height = int(height * ratio)
-            image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
-            logger.info(f"Resized: {width}x{height} → {new_width}x{new_height}")
-        
-        return image
+                if attempt == max_retries - 1:
+                    logger.error(f"Final attempt failed: {error_str}")
+                    
+        return None
     
-    async def _analyze_with_gemini(self, image, measurement_info, description, timeout, attempt=0):
-        """Analyze with Gemini API"""
-        prompt = self._create_detailed_prompt(description, measurement_info)
+    async def _analyze_with_gemini(self, image: Image.Image, measurement_info: dict, 
+                                  description: Optional[str], timeout: int, 
+                                  temperature: float = 0.2, attempt: int = 0) -> Optional[List[Dict]]:
+        """Enhanced Gemini analysis with better prompting"""
         
-        # Adjust parameters per attempt
-        temperature = 0.2 if attempt == 0 else 0.3
-        max_tokens = 16384
+        prompt = self._create_enhanced_prompt(description, measurement_info, attempt)
         
-        logger.info(f"Config: temp={temperature}, max_tokens={max_tokens}")
+        logger.info(f"Config: temp={temperature}, timeout={timeout}s")
         
         start_time = time.time()
         loop = asyncio.get_event_loop()
         
-        # Create safety settings with correct format
+        # Safety settings
         safety_settings = {
             HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
             HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
@@ -275,7 +403,7 @@ class FloorPlanProcessor:
                 [prompt, image],
                 generation_config=genai.GenerationConfig(
                     temperature=temperature,
-                    max_output_tokens=max_tokens,
+                    max_output_tokens=32768,  # Increased for complex floor plans
                     top_p=0.95,
                     top_k=40,
                 ),
@@ -292,99 +420,158 @@ class FloorPlanProcessor:
             elapsed = time.time() - start_time
             logger.info(f"Response in {elapsed:.1f}s ({len(response.text)} chars)")
             
-            # Extract JSON
-            parsed = self._extract_json(response.text)
+            # Extract and validate JSON
+            parsed = self._extract_json_enhanced(response.text)
             
             if parsed and len(parsed) > 0:
                 validated = self._validate_measurements(parsed, measurement_info)
                 logger.info(f"Validated {len(validated)} rooms")
                 return validated
             else:
-                logger.warning("No valid JSON found")
+                logger.warning("No valid JSON found in response")
                 return None
                 
         except Exception as e:
             logger.error(f"Gemini API error: {str(e)}")
             raise
     
-    def _create_detailed_prompt(self, description, measurement_info):
-        """Create detailed prompt optimized for Norwegian floor plans"""
+    async def _analyze_with_gpt4v(self, image: Image.Image, measurement_info: dict, 
+                                  description: Optional[str]) -> Optional[List[Dict]]:
+        """Fallback analysis using OpenAI GPT-4V"""
+        if not USE_OPENAI_FALLBACK:
+            return None
+            
+        try:
+            import base64
+            from openai import OpenAI
+            
+            client = OpenAI(api_key=OPENAI_API_KEY)
+            
+            # Convert image to base64
+            buffered = BytesIO()
+            image.save(buffered, format="PNG")
+            img_base64 = base64.b64encode(buffered.getvalue()).decode()
+            
+            prompt = self._create_enhanced_prompt(description, measurement_info, 0)
+            
+            response = client.chat.completions.create(
+                model="gpt-4-vision-preview",
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": prompt},
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:image/png;base64,{img_base64}",
+                                    "detail": "high"
+                                }
+                            }
+                        ]
+                    }
+                ],
+                max_tokens=4096,
+                temperature=0.2
+            )
+            
+            result_text = response.choices[0].message.content
+            parsed = self._extract_json_enhanced(result_text)
+            
+            if parsed and len(parsed) > 0:
+                validated = self._validate_measurements(parsed, measurement_info)
+                logger.info(f"GPT-4V found {len(validated)} rooms")
+                return validated
+                
+        except Exception as e:
+            logger.error(f"GPT-4V analysis error: {str(e)}")
+            
+        return None
+    
+    def _create_enhanced_prompt(self, description: Optional[str], measurement_info: dict, attempt: int = 0) -> str:
+        """Enhanced prompt with better instructions"""
         
-        prompt = f"""Du er en ekspert på norske plantegninger. Analyser denne plantegningen nøye og ekstraher ALL rom med komplette detaljer.
+        # Adjust prompt strategy based on attempt
+        if attempt == 0:
+            approach = "Focus on text labels and room boundaries visible in the floor plan."
+        elif attempt == 1:
+            approach = "Look carefully at ALL areas, including small rooms and spaces without clear labels."
+        else:
+            approach = "Examine the entire image systematically, section by section, identifying every enclosed space."
+        
+        prompt = f"""You are an expert architect analyzing floor plans. {approach}
+
+CRITICAL: Analyze this floor plan and extract ALL rooms with their details.
+Return ONLY a JSON array with this EXACT format:
 
-Returner KUN en JSON-array i dette eksakte formatet:
 [
   {{
     "name": "Living Room",
     "name_no": "Stue",
-    "area_m2": 0.0,
-    "position": "beskrivelse av plassering",
-    "dimensions_m": {{"width": 0.0, "length": 0.0}},
-    "windows": 0,
-    "window_positions": ["vegg plassering"],
-    "doors": 0,
-    "door_positions": ["plassering"],
-    "connected_rooms": ["Tilstøtende rom"],
+    "area_m2": 35.5,
+    "position": "center of plan",
+    "dimensions_m": {{"width": 6.0, "length": 5.9}},
+    "windows": 3,
+    "window_positions": ["north wall", "east wall"],
+    "doors": 2,
+    "door_positions": ["to hallway", "to kitchen"],
+    "connected_rooms": ["Kitchen", "Hallway"],
     "has_external_access": false,
     "ceiling_height_m": {measurement_info['ceiling_height']},
-    "furniture": [],
+    "furniture": ["sofa", "table"],
     "estimated": false
   }}
 ]
 
-KRITISKE INSTRUKSJONER:
-1. Finn og inkluder HVERT ENESTE rom som er synlig på plantegningen
-2. Les romnavnene nøyaktig som de står på tegningen (f.eks. "SOV 1", "KJØKKEN", "STUE", "BAD", etc.)
-3. Les de eksakte arealene som er vist på planen (f.eks. "25.5 m²", "12.3 m²", etc.)
-4. Hvis bredde × lengde vises, bruk dem nøyaktig
-5. Hvis bare areal vises, beregn omtrentlige dimensjoner: bredde ≈ √areal, lengde ≈ √areal
-6. Tell vinduer nøye - se etter vinduessymboler i veggene
-7. Tell dører - se etter dørsvingsymboler
-8. Identifiser hvilke vegger som har vinduer/dører (nord, sør, øst, vest)
-9. List tilstøtende rom som har forbindelse til hvert rom
-10. Sjekk om rommet har direkte utgang til uteområde
-11. Sett estimated=false KUN hvis du kan lese eksakte mål, ellers true
-12. Hvis du ser møbelsymboler eller etiketter, list dem
-13. Returner KUN JSON-arrayen - absolutt ingen forklaringer, ingen markdown-blokker, ingen ekstra tekst
+INSTRUCTIONS:
+1. Find EVERY room visible in the floor plan
+2. Read room names EXACTLY as shown (e.g., "SOV 1", "KJØKKEN", "STUE", "BAD")
+3. Read the EXACT areas shown (e.g., "25.5 m²", "12.3 m²")
+4. If dimensions are shown, use them exactly
+5. If only area is shown, calculate: width ≈ √area, length ≈ √area
+6. Count windows (look for window symbols in walls)
+7. Count doors (look for door swing symbols)
+8. Identify which walls have windows/doors
+9. List connected rooms
+10. Check for external access
+11. Set estimated=false ONLY if exact measurements are visible
+12. List any visible furniture or fixtures
 
-Norske romtyper å se etter:
-- Soverom (SOV, Soverom, Bedroom)
+Common Norwegian room types:
+- Soverom/SOV (Bedroom)
 - Kjøkken (Kitchen)
-- Stue (Living room, Salon)
-- Bad/Baderom (Bathroom, Vask, WC)
-- Toalett (WC, Toilet)
+- Stue (Living room)
+- Bad/Baderom (Bathroom)
+- WC/Toalett (Toilet)
 - Gang/Korridor (Hallway)
-- Entré (Entrance, Inngang)
-- Bod/Garderobe (Storage, Closet, Skap)
-- Kontor (Office, Arbeidsrom)
-- Vaskerom (Laundry, Vaskeri)
-- Terrasse/Balkong (Terrace, Balcony, Uteplass)
-- Garasje (Garage, Biloppstilling)
-- Spisestue (Dining room)
-- Sportsbod (Sports storage)
-- Tech/Teknisk rom (Technical room)
-- Vindfang (Mudroom)
-- Trapperom (Stairwell, Trapp)
-- Loft/Hems (Attic, Loft)
-- Kjeller (Basement)
+- Entré (Entrance)
+- Bod (Storage)
+- Kontor (Office)
+- Vaskerom (Laundry)
+- Balkong/Terrasse (Balcony/Terrace)
+- Garasje (Garage)
+
+Scale: 1:{measurement_info['scale']}
+Ceiling height: {measurement_info['ceiling_height']}m
 
-Målestokk: 1:{measurement_info['scale']}
-Standard takhøyde: {measurement_info['ceiling_height']}m
-"""
+IMPORTANT: Return ONLY the JSON array, no explanations or markdown."""
         
         if description:
-            prompt += f"\n\nBrukeren ga denne konteksten: {description}"
+            prompt += f"\n\nAdditional context: {description}"
         
         return prompt
     
-    def _extract_json(self, text):
-        """Extract JSON from response"""
+    def _extract_json_enhanced(self, text: str) -> Optional[List[Dict]]:
+        """Enhanced JSON extraction with better error handling"""
         if not text:
             return None
         
-        # Remove markdown
+        # Clean text
         text = text.strip()
-        text = re.sub(r'```(?:json|javascript)?\s*', '', text)
+        
+        # Remove markdown blocks
+        text = re.sub(r'```(?:json|javascript|JSON)?\s*', '', text)
+        text = re.sub(r'```\s*$', '', text)
         text = text.strip('`').strip()
         
         # Try direct parse
@@ -392,39 +579,54 @@ Standard takhøyde: {measurement_info['ceiling_height']}m
             data = json.loads(text)
             if isinstance(data, list) and len(data) > 0:
                 return data
-        except json.JSONDecodeError:
-            pass
+        except json.JSONDecodeError as e:
+            logger.debug(f"Direct parse failed: {e}")
         
-        # Find JSON array
+        # Find JSON array patterns
         patterns = [
-            r'\[\s*\{[\s\S]*?\}\s*\]',
+            r'\[\s*\{[^}]*\}(?:\s*,\s*\{[^}]*\})*\s*\]',
             r'\[[\s\S]*?\]',
         ]
         
         for pattern in patterns:
-            matches = list(re.finditer(pattern, text))
-            for match in sorted(matches, key=lambda m: len(m.group(0)), reverse=True):
+            matches = list(re.finditer(pattern, text, re.DOTALL))
+            
+            # Sort by length (prefer longer matches)
+            matches.sort(key=lambda m: len(m.group(0)), reverse=True)
+            
+            for match in matches:
                 try:
-                    data = json.loads(match.group(0))
+                    json_str = match.group(0)
+                    # Fix common issues
+                    json_str = re.sub(r',\s*}', '}', json_str)  # Remove trailing commas
+                    json_str = re.sub(r',\s*]', ']', json_str)
+                    
+                    data = json.loads(json_str)
                     if isinstance(data, list) and len(data) > 0:
                         return data
-                except:
+                except json.JSONDecodeError as e:
+                    logger.debug(f"Pattern match parse failed: {e}")
                     continue
         
-        logger.warning(f"Could not extract JSON from: {text[:300]}...")
+        logger.warning(f"Could not extract JSON from response")
         return None
     
-    def _validate_measurements(self, data, measurement_info):
-        """Validate and fix room measurements"""
+    def _validate_measurements(self, data: List[Dict], measurement_info: dict) -> List[Dict]:
+        """Enhanced validation with better defaults"""
         if not isinstance(data, list):
             return []
         
         ceiling = measurement_info.get('ceiling_height', 2.4)
+        validated = []
         
         for room in data:
-            # Ensure required fields
-            room.setdefault("name", "Unknown")
-            room.setdefault("name_no", room["name"])
+            # Skip invalid entries
+            if not isinstance(room, dict):
+                continue
+            
+            # Ensure required fields with better defaults
+            room.setdefault("name", "Unknown Room")
+            room.setdefault("name_no", room.get("name", "Ukjent Rom"))
             room.setdefault("ceiling_height_m", ceiling)
             room.setdefault("windows", 0)
             room.setdefault("doors", 1)
@@ -433,51 +635,103 @@ Standard takhøyde: {measurement_info['ceiling_height']}m
             room.setdefault("connected_rooms", [])
             room.setdefault("window_positions", [])
             room.setdefault("door_positions", [])
+            room.setdefault("has_external_access", False)
+            room.setdefault("position", "unknown")
             
             # Fix dimensions
-            if "dimensions_m" not in room:
+            if "dimensions_m" not in room or not isinstance(room["dimensions_m"], dict):
                 room["dimensions_m"] = {"width": 0, "length": 0}
             
-            width = room["dimensions_m"].get("width", 0)
-            length = room["dimensions_m"].get("length", 0)
+            dims = room["dimensions_m"]
+            width = float(dims.get("width", 0))
+            length = float(dims.get("length", 0))
+            area = float(room.get("area_m2", 0))
             
+            # Calculate missing values
             if width > 0 and length > 0:
                 room["area_m2"] = round(width * length, 1)
-            elif room.get("area_m2", 0) > 0:
-                side = math.sqrt(room["area_m2"])
-                room["dimensions_m"]["width"] = round(side, 1)
-                room["dimensions_m"]["length"] = round(side, 1)
-                room["estimated"] = True
+            elif area > 0:
+                if width > 0:
+                    room["dimensions_m"]["length"] = round(area / width, 1)
+                elif length > 0:
+                    room["dimensions_m"]["width"] = round(area / length, 1)
+                else:
+                    # Assume square room
+                    side = math.sqrt(area)
+                    room["dimensions_m"]["width"] = round(side, 1)
+                    room["dimensions_m"]["length"] = round(side, 1)
+                    room["estimated"] = True
             else:
+                # Default small room
                 room["dimensions_m"] = {"width": 3.0, "length": 3.0}
                 room["area_m2"] = 9.0
                 room["estimated"] = True
+            
+            # Validate room has reasonable size
+            if room["area_m2"] > 0:
+                validated.append(room)
         
-        return data
+        return validated
     
-    def _generate_fallback(self, measurement_info):
-        """Generate fallback structure"""
+    def _generate_fallback(self, measurement_info: dict) -> List[Dict]:
+        """Generate comprehensive fallback structure"""
         ceiling = measurement_info.get('ceiling_height', 2.4)
         
         return [
             {
-                "name": "Living Room", "name_no": "Stue",
-                "area_m2": 35.0, "position": "center",
-                "dimensions_m": {"width": 6.0, "length": 5.8},
-                "windows": 2, "doors": 2,
+                "name": "Living Room",
+                "name_no": "Stue",
+                "area_m2": 35.0,
+                "position": "center",
+                "dimensions_m": {"width": 7.0, "length": 5.0},
+                "windows": 3,
+                "window_positions": ["north wall", "east wall"],
+                "doors": 2,
+                "door_positions": ["to hallway", "to kitchen"],
+                "ceiling_height_m": ceiling,
+                "estimated": True,
+                "furniture": ["sofa", "coffee table", "TV unit"],
+                "connected_rooms": ["Kitchen", "Hallway"],
+                "has_external_access": False
+            },
+            {
+                "name": "Kitchen",
+                "name_no": "Kjøkken",
+                "area_m2": 15.0,
+                "position": "adjacent to living room",
+                "dimensions_m": {"width": 3.0, "length": 5.0},
+                "windows": 1,
+                "window_positions": ["north wall"],
+                "doors": 1,
+                "door_positions": ["to living room"],
+                "ceiling_height_m": ceiling,
+                "estimated": True,
+                "furniture": ["cabinets", "countertop", "sink", "stove"],
+                "connected_rooms": ["Living Room"],
+                "has_external_access": False
+            },
+            {
+                "name": "Master Bedroom",
+                "name_no": "Hovedsoverom",
+                "area_m2": 20.0,
+                "position": "east side",
+                "dimensions_m": {"width": 4.0, "length": 5.0},
+                "windows": 2,
+                "window_positions": ["east wall", "south wall"],
+                "doors": 1,
+                "door_positions": ["to hallway"],
                 "ceiling_height_m": ceiling,
                 "estimated": True,
-                "furniture": [],
-                "connected_rooms": [],
-                "window_positions": [],
-                "door_positions": [],
+                "furniture": ["bed", "wardrobe"],
+                "connected_rooms": ["Hallway"],
                 "has_external_access": False
             }
         ]
 
+# FastAPI Application
 app = FastAPI(
-    title="Floor Plan API",
-    version="1.0.6",
+    title="Enhanced Floor Plan API",
+    version="2.0.0",
     docs_url="/"
 )
 
@@ -493,35 +747,52 @@ processor = FloorPlanProcessor()
 
 @app.get("/status")
 async def get_status():
+    """Get API status"""
     return {
         "status": "running",
         "pdfs_count": len(processor.pdfs),
-        "model": "gemini-2.5-pro"
+        "model": "gemini-2.0-flash-exp",
+        "openai_fallback": USE_OPENAI_FALLBACK,
+        "version": "2.0.0"
     }
 
 @app.get("/pdfs")
 async def get_pdfs():
+    """List all uploaded PDFs"""
     return {"pdfs": [pdf.to_dict() for pdf in processor.pdfs.values()]}
 
 @app.get("/pdf/{pdf_id}")
 async def get_pdf(pdf_id: str):
+    """Get specific PDF details"""
     if pdf_id not in processor.pdfs:
         raise HTTPException(status_code=404, detail="PDF not found")
     return processor.pdfs[pdf_id].to_dict()
 
 @app.post("/upload")
 async def upload_pdf(file: UploadFile = File(...)):
+    """Upload and process PDF or image file"""
     content_type = file.content_type.lower()
     supported = ["application/pdf"] + list(processor.supported_image_formats.keys())
     
     if content_type not in supported:
         return JSONResponse(
             status_code=400,
-            content={"error": "Unsupported file type"}
+            content={
+                "error": f"Unsupported file type: {content_type}",
+                "supported_types": supported
+            }
         )
     
     try:
         file_content = await file.read()
+        
+        # Check file size (max 50MB)
+        if len(file_content) > 50 * 1024 * 1024:
+            return JSONResponse(
+                status_code=400,
+                content={"error": "File too large (max 50MB)"}
+            )
+        
         pdf_id = await processor.process_upload(file_content, file.filename, content_type)
         pdf_info = processor.pdfs[pdf_id].to_dict()
         
@@ -532,37 +803,53 @@ async def upload_pdf(file: UploadFile = File(...)):
         }
     except Exception as e:
         logger.error(f"Upload error: {str(e)}")
-        return JSONResponse(status_code=500, content={"error": str(e)})
+        return JSONResponse(
+            status_code=500, 
+            content={"error": str(e)}
+        )
 
 @app.post("/analyze/{pdf_id}")
 async def analyze_pdf(pdf_id: str, query: FloorPlanQuery = None):
+    """Analyze floor plan and extract room information"""
     if pdf_id not in processor.pdfs:
         raise HTTPException(status_code=404, detail="PDF not found")
     
     pdf = processor.pdfs[pdf_id]
     
     if not pdf.processed:
-        return JSONResponse(status_code=400, content={"error": "Still processing"})
+        return JSONResponse(
+            status_code=400, 
+            content={"error": "File still processing, please wait"}
+        )
     
     if not pdf.images:
-        return JSONResponse(status_code=400, content={"error": "No images"})
+        return JSONResponse(
+            status_code=400, 
+            content={
+                "error": "No images extracted from file",
+                "extraction_method": pdf.extraction_method,
+                "suggestion": "Try uploading a different format or higher quality file"
+            }
+        )
     
     try:
+        # Parse query parameters
         description = query.description if query else None
+        use_high_quality = query.use_high_quality if query else True
+        
         start_time = time.time()
         
+        # Extended timeout for complex floor plans
         result = await asyncio.wait_for(
-            processor.analyze_floor_plan(pdf_id, description),
-            timeout=1200
+            processor.analyze_floor_plan(pdf_id, description, use_high_quality),
+            timeout=1800  # 30 minutes max
         )
         
         elapsed = time.time() - start_time
         pdf.analysis_result = result
         
-        is_fallback = any(
-            room.get("estimated") and len(result) <= 2
-            for room in result
-        )
+        # Check if results are estimated/fallback
+        is_fallback = all(room.get("estimated", False) for room in result) and len(result) <= 3
         
         return {
             "message": "Analysis complete",
@@ -571,16 +858,32 @@ async def analyze_pdf(pdf_id: str, query: FloorPlanQuery = None):
             "rooms": result,
             "analysis_time_seconds": round(elapsed, 1),
             "is_estimated": is_fallback,
-            "room_count": len(result)
+            "room_count": len(result),
+            "extraction_method": pdf.extraction_method,
+            "quality_score": self._calculate_quality_score(result)
+        }
+        
+    except asyncio.TimeoutError:
+        logger.error(f"Analysis timeout for {pdf_id}")
+        
+        # Return fallback on timeout
+        fallback = processor._generate_fallback(pdf.measurement_info)
+        return {
+            "message": "Analysis timeout - using fallback data",
+            "pdf_id": pdf_id,
+            "rooms": fallback,
+            "is_estimated": True,
+            "error": "Analysis took too long, returning estimated data"
         }
         
     except Exception as e:
         logger.error(f"Analysis error: {str(e)}", exc_info=True)
         
+        # Try to provide fallback data
         try:
             fallback = processor._generate_fallback(pdf.measurement_info)
             return {
-                "message": "Error - using fallback",
+                "message": "Analysis error - using fallback data",
                 "pdf_id": pdf_id,
                 "rooms": fallback,
                 "is_estimated": True,
@@ -589,18 +892,26 @@ async def analyze_pdf(pdf_id: str, query: FloorPlanQuery = None):
         except:
             return JSONResponse(
                 status_code=500,
-                content={"error": str(e), "pdf_id": pdf_id}
+                content={
+                    "error": str(e), 
+                    "pdf_id": pdf_id,
+                    "suggestion": "Try re-uploading the file or using a different format"
+                }
             )
 
 @app.post("/room/{pdf_id}")
 async def find_room(pdf_id: str, query: RoomQuery):
+    """Find specific room(s) in analyzed floor plan"""
     if pdf_id not in processor.pdfs:
         raise HTTPException(status_code=404, detail="PDF not found")
     
     pdf = processor.pdfs[pdf_id]
     
     if not pdf.analysis_result:
-        raise HTTPException(status_code=400, content={"error": "Not analyzed yet"})
+        raise HTTPException(
+            status_code=400, 
+            detail="Floor plan not analyzed yet. Please call /analyze first"
+        )
     
     found = []
     name_lower = query.room_name.lower()
@@ -613,32 +924,165 @@ async def find_room(pdf_id: str, query: RoomQuery):
             if en == name_lower or no == name_lower:
                 found.append(room)
         else:
-            if name_lower in en or name_lower in no:
+            # Partial match
+            if name_lower in en or name_lower in no or en in name_lower or no in name_lower:
+                found.append(room)
+    
+    if not found:
+        # Try fuzzy matching as fallback
+        for room in pdf.analysis_result:
+            en = room.get("name", "").lower()
+            no = room.get("name_no", "").lower()
+            
+            # Check for common variations
+            if any(term in name_lower for term in [en.split()[0], no.split()[0]]) or \
+               any(term in en or term in no for term in name_lower.split()):
                 found.append(room)
     
     if not found:
-        raise HTTPException(status_code=404, content={"error": "Room not found"})
+        raise HTTPException(
+            status_code=404, 
+            detail=f"Room '{query.room_name}' not found. Available rooms: {', '.join([r.get('name', 'Unknown') for r in pdf.analysis_result])}"
+        )
     
     if len(found) == 1:
-        return {"message": "Room found", "pdf_id": pdf_id, "room": found[0]}
+        return {
+            "message": "Room found",
+            "pdf_id": pdf_id,
+            "room": found[0]
+        }
+    
+    return {
+        "message": f"Found {len(found)} matching rooms",
+        "pdf_id": pdf_id,
+        "rooms": found,
+        "total_matches": len(found)
+    }
+
+@app.post("/update_measurements/{pdf_id}")
+async def update_measurements(pdf_id: str, measurement_info: dict):
+    """Update measurement information for a PDF"""
+    if pdf_id not in processor.pdfs:
+        raise HTTPException(status_code=404, detail="PDF not found")
+    
+    pdf = processor.pdfs[pdf_id]
+    
+    # Update measurement info
+    if "scale" in measurement_info:
+        pdf.measurement_info["scale"] = measurement_info["scale"]
+    if "ceiling_height" in measurement_info:
+        pdf.measurement_info["ceiling_height"] = measurement_info["ceiling_height"]
+    if "room_dimensions" in measurement_info:
+        pdf.measurement_info["room_dimensions"].update(measurement_info["room_dimensions"])
     
     return {
-        "message": f"Found {len(found)} rooms",
+        "message": "Measurements updated",
         "pdf_id": pdf_id,
-        "rooms": found
+        "measurement_info": pdf.measurement_info
     }
 
+@app.delete("/pdf/{pdf_id}")
+async def delete_pdf(pdf_id: str):
+    """Delete a PDF and its associated data"""
+    if pdf_id not in processor.pdfs:
+        raise HTTPException(status_code=404, detail="PDF not found")
+    
+    # Clean up files
+    try:
+        for ext in [".pdf", ".png", ".jpg"]:
+            file_path = f"uploads/{pdf_id}{ext}"
+            if os.path.exists(file_path):
+                os.remove(file_path)
+    except Exception as e:
+        logger.warning(f"Could not delete files for {pdf_id}: {e}")
+    
+    # Remove from memory
+    del processor.pdfs[pdf_id]
+    
+    return {
+        "message": "PDF deleted successfully",
+        "pdf_id": pdf_id
+    }
+
+def _calculate_quality_score(rooms: List[Dict]) -> float:
+    """Calculate quality score for analysis results"""
+    if not rooms:
+        return 0.0
+    
+    score = 0.0
+    max_score = 100.0
+    
+    # Check for estimated vs actual measurements
+    non_estimated = sum(1 for r in rooms if not r.get("estimated", True))
+    score += (non_estimated / len(rooms)) * 40
+    
+    # Check for detailed information
+    for room in rooms:
+        room_score = 0
+        if room.get("area_m2", 0) > 0:
+            room_score += 10
+        if room.get("windows", 0) >= 0:
+            room_score += 5
+        if room.get("doors", 0) >= 0:
+            room_score += 5
+        if room.get("connected_rooms"):
+            room_score += 10
+        if room.get("furniture"):
+            room_score += 10
+        
+        score += (room_score / len(rooms))
+    
+    # Normalize to 0-100
+    return min(100.0, round(score, 1))
+
 @app.on_event("startup")
 async def startup_event():
+    """Initialize application on startup"""
+    # Create necessary directories
     os.makedirs("uploads", exist_ok=True)
+    os.makedirs("temp", exist_ok=True)
     os.makedirs("logs", exist_ok=True)
     
-    logger.info("\n" + "="*60)
-    logger.info("Floor Plan API - Single File Mode")
-    logger.info(f"Model: gemini-2.5-pro")
-    logger.info(f"API Key: {'SET' if GOOGLE_API_KEY else 'NOT SET'}")
-    logger.info(f"Port: 7860")
-    logger.info("="*60 + "\n")
+    logger.info("\n" + "="*70)
+    logger.info("Enhanced Floor Plan API v2.0")
+    logger.info(f"Primary Model: gemini-2.0-flash-exp")
+    logger.info(f"Gemini API: {'✓ SET' if GOOGLE_API_KEY else '✗ NOT SET'}")
+    logger.info(f"OpenAI Fallback: {'✓ AVAILABLE' if USE_OPENAI_FALLBACK else '✗ NOT AVAILABLE'}")
+    logger.info(f"Server: http://0.0.0.0:7860")
+    logger.info("="*70 + "\n")
+    
+    # Test PDF extraction libraries
+    try:
+        import fitz
+        logger.info("✓ PyMuPDF available")
+    except ImportError:
+        logger.warning("✗ PyMuPDF not available - install with: pip install PyMuPDF")
+    
+    try:
+        from pdf2image import convert_from_bytes
+        logger.info("✓ pdf2image available")
+    except ImportError:
+        logger.warning("✗ pdf2image not available - install with: pip install pdf2image")
+        logger.warning("  Also requires poppler-utils: apt-get install poppler-utils")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown"""
+    logger.info("Shutting down Floor Plan API")
+    
+    # Optional: Clean up temporary files
+    try:
+        import shutil
+        if os.path.exists("temp"):
+            shutil.rmtree("temp")
+            os.makedirs("temp", exist_ok=True)
+    except Exception as e:
+        logger.warning(f"Could not clean temp directory: {e}")
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(
+        app, 
+        host="0.0.0.0", 
+        port=7860,
+        log_level="info"
+    )