Update app.py

app.py

@@ -1,19 +1,21 @@
-# app.py
+# app.py - Updated Backend with Job-based API and Coordinate Support
 import os
 import io
 import json
+import uuid
+import time
 import datetime
 import requests
-
+import threading
+from typing import Dict, Any, Optional
 from flask import Flask, request, jsonify, send_file, abort
 from flask_cors import CORS
 from reportlab.lib.pagesizes import A4
 from reportlab.lib.units import mm
-from reportlab.lib import styles
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
 from reportlab.lib.enums import TA_LEFT
-from reportlab.lib.styles import ParagraphStyle
-from reportlab.lib.colors import HexColor, black, white
+from reportlab.lib.colors import HexColor, black
 
 # Configuration
 HF_API_URL = "https://router.huggingface.co/v1/chat/completions"
@@ -23,247 +25,593 @@ MODEL = "deepseek-ai/DeepSeek-V3.2:novita"
 if not HF_TOKEN:
     raise RuntimeError("HF_TOKEN environment variable is required")
 
+# In-memory job store (in production, use Redis or database)
+jobs_store: Dict[str, Dict] = {}
+jobs_lock = threading.Lock()
+
+# Extended SYSTEM_PROMPT with coordinate support
 SYSTEM_PROMPT = """
-You are EcoScan AI, a smart AI tool for environmental risk assessment in Nigeria.
+You are EcoScan AI, a smart AI tool for environmental risk assessment in Nigeria and other locations.
 You analyze proposed project locations using satellite imagery and scientific data to assess risks in:
 - Soil Erosion (score 0-10, higher = higher risk)
 - Slope Stability (score 0-10, higher = higher risk)
 - Flooding (score 0-10, higher = higher risk)
 - Biodiversity (score 0-10, higher = higher impact/risk to biodiversity)
 
-For a given location in Nigeria, generate a realistic, concise assessment based on general knowledge of Nigerian geography, climate, and environmental data.
+For a given location (place name or coordinates like "9.0820° N, 8.6753° E"), generate a realistic, detailed assessment based on geography, climate, and environmental data.
 
-**IMPORTANT**: Output ONLY a single valid JSON object and nothing else. The JSON object must follow exactly this structure (fields and nesting):
+**IMPORTANT**: Output ONLY a single valid JSON object and nothing else. The JSON object must follow exactly this structure:
 
 {
-  "erosion": {"score": float, "description": "brief explanation"},
-  "slope_stability": {"score": float, "description": "brief explanation"},
-  "flooding": {"score": float, "description": "brief explanation"},
-  "biodiversity": {"score": float, "description": "brief explanation"},
-  "overall_report": "A comprehensive paragraph summarizing the risks and mitigation recommendations."
+  "location": {
+    "name": "extracted location name",
+    "coordinates": "latitude, longitude if available",
+    "region": "geographic region"
+  },
+  "erosion": {
+    "score": float,
+    "description": "detailed explanation of erosion risk",
+    "factors": ["factor1", "factor2", "factor3"],
+    "mitigation": "recommended mitigation measures"
+  },
+  "slope_stability": {
+    "score": float,
+    "description": "detailed explanation of slope stability",
+    "factors": ["factor1", "factor2", "factor3"],
+    "mitigation": "recommended mitigation measures"
+  },
+  "flooding": {
+    "score": float,
+    "description": "detailed explanation of flooding risk",
+    "factors": ["factor1", "factor2", "factor3"],
+    "mitigation": "recommended mitigation measures"
+  },
+  "biodiversity": {
+    "score": float,
+    "description": "detailed explanation of biodiversity impact",
+    "factors": ["factor1", "factor2", "factor3"],
+    "mitigation": "recommended mitigation measures"
+  },
+  "overall_report": "A comprehensive 3-5 sentence paragraph summarizing all risks and specific mitigation recommendations.",
+  "assessment_date": "current date in YYYY-MM-DD format"
 }
 
 - Scores must be numeric (float) between 0.0 and 10.0 (one decimal place preferred).
-- Descriptions should be a single sentence (brief).
-- overall_report should be one paragraph (2-5 sentences) with specific mitigation recommendations.
-- Do not include any additional text, commentary, markdown, or trailing characters outside the JSON.
+- Descriptions should be 2-3 sentences with specific details.
+- Provide 2-3 factors for each category.
+- Mitigation should be practical, actionable recommendations.
+- Do not include any additional text outside the JSON.
 """
 
 # Flask app
 app = Flask(__name__)
 CORS(app)
 
-
-def call_hf_chat(location_text: str, timeout: int = 30) -> str:
-    """
-    Call the Hugging Face chat completions endpoint and return the model's text content.
-    """
+def extract_coordinates(location_text: str) -> Dict[str, Any]:
+    """Extract coordinates from location text if present."""
+    import re
+    
+    # Pattern for coordinates like "9.0820° N, 8.6753° E" or "9.0820, 8.6753"
+    patterns = [
+        r'([-+]?\d+\.\d+)[°\s]*([NS]?)[,\s]*([-+]?\d+\.\d+)[°\s]*([EW]?)',
+        r'lat[:\s]*([-+]?\d+\.\d+)[,\s]*lon[:\s]*([-+]?\d+\.\d+)',
+        r'([-+]?\d+\.\d+)[,\s]+([-+]?\d+\.\d+)'
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, location_text, re.IGNORECASE)
+        if match:
+            groups = match.groups()
+            if len(groups) >= 2:
+                lat = float(groups[0])
+                lon = float(groups[1])
+                # Handle N/S, E/W notation
+                if len(groups) > 2 and groups[2] == 'S':
+                    lat = -lat
+                if len(groups) > 3 and groups[3] == 'W':
+                    lon = -lon
+                return {
+                    "latitude": lat,
+                    "longitude": lon,
+                    "coordinates": f"{lat:.4f}, {lon:.4f}"
+                }
+    
+    return {"coordinates": None, "latitude": None, "longitude": None}
+
+def call_hf_chat(location_text: str) -> str:
+    """Call the Hugging Face chat completions endpoint."""
     headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+    
+    # Add coordinate context if available
+    user_prompt = f"Assess the following location: {location_text}\n"
+    coords = extract_coordinates(location_text)
+    if coords["coordinates"]:
+        user_prompt += f"Coordinates: {coords['coordinates']}\n"
+    user_prompt += "Return output exactly in the required JSON format."
+    
     payload = {
         "model": MODEL,
         "messages": [
             {"role": "system", "content": SYSTEM_PROMPT},
-            {
-                "role": "user",
-                "content": f"Assess the following location in Nigeria: {location_text}\nReturn output exactly in the required JSON format."
-            }
+            {"role": "user", "content": user_prompt}
         ],
-        "max_tokens": 512,
-        "temperature": 0.3,
+        "max_tokens": 1024,
+        "temperature": 0.2,
     }
 
-    r = requests.post(HF_API_URL, headers=headers, json=payload, timeout=timeout)
     try:
+        r = requests.post(HF_API_URL, headers=headers, json=payload, timeout=45)
         r.raise_for_status()
-    except requests.HTTPError as e:
-        raise RuntimeError(f"HuggingFace API error: {e}, response: {r.text}")
-
-    data = r.json()
-    # Expecting structure similar to OpenAI-like chat completions:
-    # {"choices":[{"message":{"role":"assistant","content":"{...}"}}], ...}
-    try:
-        content = data["choices"][0]["message"]["content"]
+        data = r.json()
+        return data["choices"][0]["message"]["content"]
     except Exception as e:
-        raise RuntimeError(f"Unexpected HF response structure: {e} | full response: {data}")
-
-    return content
-
-
-def sanitize_and_parse_json(text: str) -> dict:
-    """
-    Try to parse model output as JSON. If model included noise, attempt to extract JSON substring.
-    """
-    # First try direct load
+        raise RuntimeError(f"HuggingFace API error: {e}")
+
+def sanitize_and_parse_json(text: str) -> Dict:
+    """Parse model output as JSON, handling noise."""
+    import re
+    
+    # Clean the text
+    text = text.strip()
+    
+    # Find JSON object
+    json_match = re.search(r'\{.*\}', text, re.DOTALL)
+    if json_match:
+        text = json_match.group(0)
+    
     try:
         return json.loads(text)
-    except Exception:
-        pass
-
-    # Try to find the first '{' and last '}' and load substring
-    first = text.find("{")
-    last = text.rfind("}")
-    if first != -1 and last != -1 and last > first:
-        candidate = text[first : last + 1]
+    except json.JSONDecodeError:
+        # Try to fix common issues
+        text = re.sub(r',\s*}', '}', text)
+        text = re.sub(r',\s*]', ']', text)
         try:
-            return json.loads(candidate)
-        except Exception:
-            pass
-
-    raise ValueError("Unable to parse JSON from model output")
-
-
-def format_scores_and_validate(d: dict) -> dict:
-    """
-    Ensure numeric scores, clamp to 0-10, round to 1 decimal, and provide minimal validation.
-    """
-    keys = ["erosion", "slope_stability", "flooding", "biodiversity", "overall_report"]
-    for k in keys:
-        if k not in d:
-            raise ValueError(f"Missing required key in model output: {k}")
-
+            return json.loads(text)
+        except:
+            raise ValueError(f"Unable to parse JSON: {text[:200]}...")
+
+def validate_and_enrich_assessment(assessment: Dict, location_text: str) -> Dict:
+    """Validate and enrich assessment with additional data."""
+    required_keys = ["erosion", "slope_stability", "flooding", "biodiversity", "overall_report"]
+    
+    # Ensure all required keys exist
+    for key in required_keys:
+        if key not in assessment:
+            if key != "overall_report":
+                assessment[key] = {"score": 0.0, "description": "Data not available"}
+            else:
+                assessment[key] = "Assessment data not available."
+    
+    # Add location information
+    if "location" not in assessment:
+        coords = extract_coordinates(location_text)
+        assessment["location"] = {
+            "name": location_text,
+            "coordinates": coords.get("coordinates"),
+            "region": "Unknown"
+        }
+    
+    # Ensure scores are valid
     for metric in ["erosion", "slope_stability", "flooding", "biodiversity"]:
-        entry = d.get(metric)
-        if not isinstance(entry, dict) or "score" not in entry or "description" not in entry:
-            raise ValueError(f"Invalid structure for {metric}")
-        # Try convert score to float
-        try:
-            score = float(entry["score"])
-        except Exception:
-            raise ValueError(f"Non-numeric score for {metric}")
-        # clamp and round
-        score = max(0.0, min(10.0, score))
-        entry["score"] = round(score, 1)
-        entry["description"] = str(entry["description"]).strip()
-
-    # overall_report must be string
-    d["overall_report"] = str(d["overall_report"]).strip()
-    return d
-
+        if metric in assessment:
+            entry = assessment[metric]
+            if isinstance(entry, dict):
+                # Ensure score is float between 0-10
+                if "score" in entry:
+                    try:
+                        score = float(entry["score"])
+                        entry["score"] = max(0.0, min(10.0, round(score, 1)))
+                    except:
+                        entry["score"] = 5.0
+                else:
+                    entry["score"] = 5.0
+                
+                # Ensure description exists
+                if "description" not in entry:
+                    entry["description"] = "Risk assessment data."
+                
+                # Add factors if missing
+                if "factors" not in entry:
+                    entry["factors"] = ["Soil type", "Vegetation cover", "Rainfall pattern"]
+                
+                # Add mitigation if missing
+                if "mitigation" not in entry:
+                    entry["mitigation"] = "Implement standard mitigation measures."
+    
+    # Add assessment date
+    assessment["assessment_date"] = datetime.datetime.now().strftime("%Y-%m-%d")
+    
+    return assessment
+
+def process_assessment_job(job_id: str, location: str):
+    """Background job processor for assessments."""
+    with jobs_lock:
+        jobs_store[job_id]["status"] = "processing"
+        jobs_store[job_id]["progress"] = 0.1
+        jobs_store[job_id]["message"] = "Starting analysis..."
+    
+    try:
+        # Step 1: Extract coordinates
+        with jobs_lock:
+            jobs_store[job_id]["progress"] = 0.2
+            jobs_store[job_id]["message"] = "Extracting location data..."
+        
+        coords = extract_coordinates(location)
+        
+        # Step 2: Call AI model
+        with jobs_lock:
+            jobs_store[job_id]["progress"] = 0.4
+            jobs_store[job_id]["message"] = "Analyzing environmental data..."
+        
+        model_output = call_hf_chat(location)
+        
+        # Step 3: Parse response
+        with jobs_lock:
+            jobs_store[job_id]["progress"] = 0.7
+            jobs_store[job_id]["message"] = "Processing assessment results..."
+        
+        assessment = sanitize_and_parse_json(model_output)
+        
+        # Step 4: Validate and enrich
+        assessment = validate_and_enrich_assessment(assessment, location)
+        
+        # Add coordinate data
+        if coords["coordinates"]:
+            assessment["location"]["coordinates"] = coords["coordinates"]
+            assessment["location"]["latitude"] = coords["latitude"]
+            assessment["location"]["longitude"] = coords["longitude"]
+        
+        # Step 5: Complete
+        with jobs_lock:
+            jobs_store[job_id]["status"] = "done"
+            jobs_store[job_id]["progress"] = 1.0
+            jobs_store[job_id]["message"] = "Assessment complete"
+            jobs_store[job_id]["result"] = assessment
+            jobs_store[job_id]["completed_at"] = time.time()
+    
+    except Exception as e:
+        with jobs_lock:
+            jobs_store[job_id]["status"] = "error"
+            jobs_store[job_id]["message"] = str(e)
+            jobs_store[job_id]["error"] = str(e)
+
+def process_pdf_job(job_id: str, location: str, assessment: Dict):
+    """Background job processor for PDF generation."""
+    with jobs_lock:
+        jobs_store[job_id]["progress"] = 0.3
+        jobs_store[job_id]["message"] = "Generating PDF report..."
+    
+    try:
+        pdf_bytes = generate_pdf_bytes(location, assessment)
+        
+        with jobs_lock:
+            jobs_store[job_id]["status"] = "done"
+            jobs_store[job_id]["progress"] = 1.0
+            jobs_store[job_id]["message"] = "PDF generated"
+            jobs_store[job_id]["result"] = pdf_bytes
+            jobs_store[job_id]["completed_at"] = time.time()
+    
+    except Exception as e:
+        with jobs_lock:
+            jobs_store[job_id]["status"] = "error"
+            jobs_store[job_id]["message"] = str(e)
+            jobs_store[job_id]["error"] = str(e)
 
-def generate_pdf_bytes(location: str, assessment: dict) -> bytes:
-    """
-    Create a simple, clean PDF summary resembling the frontend layout.
-    Returns PDF bytes.
-    """
+def generate_pdf_bytes(location: str, assessment: Dict) -> bytes:
+    """Create a professional PDF report."""
     buffer = io.BytesIO()
-    doc = SimpleDocTemplate(buffer, pagesize=A4, leftMargin=18 * mm, rightMargin=18 * mm, topMargin=18 * mm, bottomMargin=18 * mm)
+    doc = SimpleDocTemplate(buffer, pagesize=A4, 
+                          leftMargin=20*mm, rightMargin=20*mm,
+                          topMargin=20*mm, bottomMargin=20*mm)
     story = []
-
+    
     # Styles
-    stylesheet = styles.getSampleStyleSheet()
+    styles = getSampleStyleSheet()
+    
+    # Title
     title_style = ParagraphStyle(
-        "Title",
-        parent=stylesheet["Heading1"],
-        alignment=TA_LEFT,
-        fontSize=20,
-        leading=24,
-        spaceAfter=6,
+        'Title',
+        parent=styles['Heading1'],
+        fontSize=24,
+        textColor=HexColor('#16a34a'),
+        spaceAfter=6
     )
-    meta_style = ParagraphStyle("Meta", parent=stylesheet["Normal"], fontSize=9, leading=11, textColor=HexColor("#666666"))
-    heading_style = ParagraphStyle("Heading", parent=stylesheet["Heading2"], fontSize=14, leading=16, spaceBefore=10, spaceAfter=6)
-    normal_style = ParagraphStyle("Normal", parent=stylesheet["BodyText"], fontSize=11, leading=14)
-
-    # Header
-    story.append(Paragraph("EcoScan AI — Environmental Risk Assessment", title_style))
-    story.append(Paragraph(f"Location: {location}", meta_style))
-    story.append(Paragraph(f"Generated: {datetime.datetime.utcnow().isoformat()} UTC", meta_style))
-    story.append(Spacer(1, 8))
-
-    # Risk analysis heading
-    story.append(Paragraph("Risk Analysis (0 = low, 10 = high)", heading_style))
-
-    # Table of metrics
-    table_data = [["Metric", "Score", "Brief description"]]
-    for metric_key, pretty in [
-        ("erosion", "Soil Erosion"),
-        ("slope_stability", "Slope Stability"),
-        ("flooding", "Flooding"),
-        ("biodiversity", "Biodiversity"),
-    ]:
-        entry = assessment[metric_key]
-        table_data.append([pretty, f"{entry['score']:.1f}", entry["description"]])
-
-    tbl = Table(table_data, colWidths=[60 * mm, 25 * mm, 90 * mm], hAlign="LEFT")
-    tbl.setStyle(
-        TableStyle(
-            [
-                ("BACKGROUND", (0, 0), (-1, 0), HexColor("#f0f6f2")),
-                ("TEXTCOLOR", (0, 0), (-1, 0), black),
-                ("FONTNAME", (0, 0), (-1, -1), "Helvetica"),
-                ("FONTSIZE", (0, 0), (-1, -1), 10),
-                ("GRID", (0, 0), (-1, -1), 0.25, HexColor("#e0e0e0")),
-                ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
-                ("LEFTPADDING", (0, 0), (-1, -1), 6),
-                ("RIGHTPADDING", (0, 0), (-1, -1), 6),
-                ("TOPPADDING", (0, 0), (-1, -1), 4),
-                ("BOTTOMPADDING", (0, 0), (-1, -1), 4),
-            ]
-        )
+    
+    subtitle_style = ParagraphStyle(
+        'Subtitle',
+        parent=styles['Heading2'],
+        fontSize=16,
+        textColor=HexColor('#4b5563'),
+        spaceAfter=24
+    )
+    
+    heading_style = ParagraphStyle(
+        'Heading',
+        parent=styles['Heading2'],
+        fontSize=14,
+        textColor=HexColor('#1f2937'),
+        spaceAfter=12
+    )
+    
+    normal_style = ParagraphStyle(
+        'Normal',
+        parent=styles['BodyText'],
+        fontSize=11,
+        leading=14,
+        spaceAfter=6
+    )
+    
+    small_style = ParagraphStyle(
+        'Small',
+        parent=styles['BodyText'],
+        fontSize=9,
+        textColor=HexColor('#6b7280'),
+        spaceAfter=2
     )
-    story.append(tbl)
+    
+    # Header
+    story.append(Paragraph("EcoScan AI", title_style))
+    story.append(Paragraph("Environmental Risk Assessment Report", subtitle_style))
     story.append(Spacer(1, 12))
-
-    # Mitigation / overall report
-    story.append(Paragraph("Overall Assessment & Mitigation Recommendations", heading_style))
-    story.append(Paragraph(assessment.get("overall_report", ""), normal_style))
-
+    
+    # Location and date
+    location_text = f"<b>Location:</b> {location}"
+    if assessment.get('location', {}).get('coordinates'):
+        location_text += f" ({assessment['location']['coordinates']})"
+    
+    story.append(Paragraph(location_text, normal_style))
+    story.append(Paragraph(f"<b>Assessment Date:</b> {assessment.get('assessment_date', 'N/A')}", normal_style))
+    story.append(Paragraph(f"<b>Report ID:</b> {str(uuid.uuid4())[:8]}", small_style))
+    story.append(Spacer(1, 24))
+    
+    # Risk Scores Summary
+    story.append(Paragraph("Risk Analysis Summary", heading_style))
+    
+    # Table data
+    table_data = [
+        ["Risk Factor", "Score (0-10)", "Description"]
+    ]
+    
+    metrics = [
+        ("Erosion", assessment.get('erosion', {})),
+        ("Slope Stability", assessment.get('slope_stability', {})),
+        ("Flooding", assessment.get('flooding', {})),
+        ("Biodiversity", assessment.get('biodiversity', {}))
+    ]
+    
+    for name, data in metrics:
+        score = data.get('score', 0)
+        desc = data.get('description', 'No description available')
+        # Truncate description for table
+        if len(desc) > 80:
+            desc = desc[:80] + "..."
+        table_data.append([name, f"{score:.1f}", desc])
+    
+    # Create table
+    table = Table(table_data, colWidths=[60*mm, 30*mm, 80*mm])
+    table.setStyle(TableStyle([
+        ('BACKGROUND', (0, 0), (-1, 0), HexColor('#f0f9ff')),
+        ('TEXTCOLOR', (0, 0), (-1, 0), HexColor('#1e40af')),
+        ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+        ('ALIGN', (1, 1), (1, -1), 'CENTER'),
+        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+        ('FONTSIZE', (0, 0), (-1, -1), 10),
+        ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+        ('GRID', (0, 0), (-1, -1), 0.5, HexColor('#e5e7eb')),
+        ('ROWBACKGROUNDS', (0, 1), (-1, -1), [HexColor('#ffffff'), HexColor('#f9fafb')]),
+    ]))
+    
+    story.append(table)
+    story.append(Spacer(1, 24))
+    
+    # Detailed Assessment
+    story.append(Paragraph("Detailed Assessment", heading_style))
+    
+    for name, data in metrics:
+        story.append(Paragraph(f"<b>{name}</b>", normal_style))
+        story.append(Paragraph(f"Score: {data.get('score', 0):.1f}/10", small_style))
+        story.append(Paragraph(data.get('description', ''), normal_style))
+        
+        # Factors
+        factors = data.get('factors', [])
+        if factors:
+            factors_text = "<b>Key Factors:</b> " + ", ".join(factors)
+            story.append(Paragraph(factors_text, small_style))
+        
+        # Mitigation
+        mitigation = data.get('mitigation', '')
+        if mitigation:
+            story.append(Paragraph(f"<b>Mitigation:</b> {mitigation}", small_style))
+        
+        story.append(Spacer(1, 12))
+    
+    # Overall Report
+    story.append(Paragraph("Overall Assessment & Recommendations", heading_style))
+    story.append(Paragraph(assessment.get('overall_report', ''), normal_style))
+    story.append(Spacer(1, 24))
+    
+    # Footer
+    story.append(Paragraph("Generated by EcoScan AI Environmental Risk Assessment System", 
+                         ParagraphStyle('Footer', parent=styles['BodyText'], fontSize=8, 
+                                      textColor=HexColor('#9ca3af'))))
+    
+    # Build PDF
     doc.build(story)
     buffer.seek(0)
     return buffer.read()
 
-
+# API Endpoints
 @app.route("/health", methods=["GET"])
 def health():
-    return jsonify({"status": "ok"})
-
-
-@app.route("/assess", methods=["POST", "GET"])
-def assess():
-    """
-    POST JSON: { "location": "<location description or lat,lon>" }
-    Query param (optional): ?download=1 to get PDF as attachment instead of raw JSON.
-    GET with ?location=... also supported (returns JSON by default).
-    """
-    if request.method == "POST":
-        body = request.get_json(silent=True)
-        if not body or "location" not in body:
-            return jsonify({"error": "POST body must be JSON with 'location' field"}), 400
-        location = body["location"]
+    return jsonify({"status": "ok", "service": "EcoScan AI"})
+
+@app.route("/assess_job", methods=["POST"])
+def create_assessment_job():
+    """Create a new assessment job."""
+    data = request.get_json()
+    if not data or "location" not in data:
+        return jsonify({"error": "Missing 'location' in request body"}), 400
+    
+    job_id = str(uuid.uuid4())
+    
+    with jobs_lock:
+        jobs_store[job_id] = {
+            "job_id": job_id,
+            "type": "assessment",
+            "status": "pending",
+            "progress": 0.0,
+            "message": "Job created",
+            "location": data["location"],
+            "created_at": time.time(),
+            "result": None,
+            "error": None
+        }
+    
+    # Start processing in background
+    thread = threading.Thread(target=process_assessment_job, args=(job_id, data["location"]))
+    thread.daemon = True
+    thread.start()
+    
+    return jsonify({"job_id": job_id, "status": "pending"})
+
+@app.route("/assess_job/status/<job_id>", methods=["GET"])
+def get_assessment_status(job_id):
+    """Get status of an assessment job."""
+    with jobs_lock:
+        job = jobs_store.get(job_id)
+    
+    if not job:
+        return jsonify({"error": "Job not found"}), 404
+    
+    return jsonify({
+        "job_id": job_id,
+        "status": job["status"],
+        "progress": job["progress"],
+        "message": job["message"],
+        "error": job.get("error")
+    })
+
+@app.route("/assess_job/result/<job_id>", methods=["GET"])
+def get_assessment_result(job_id):
+    """Get result of a completed assessment job."""
+    with jobs_lock:
+        job = jobs_store.get(job_id)
+    
+    if not job:
+        return jsonify({"error": "Job not found"}), 404
+    
+    if job["status"] != "done":
+        return jsonify({"error": "Job not completed yet"}), 400
+    
+    return jsonify(job["result"])
+
+@app.route("/pdf_job", methods=["POST"])
+def create_pdf_job():
+    """Create a new PDF generation job."""
+    data = request.get_json()
+    if not data or "location" not in data:
+        return jsonify({"error": "Missing 'location' in request body"}), 400
+    
+    # First get or create assessment
+    location = data["location"]
+    
+    # Check if we have assessment data in request
+    if "assessment" in data:
+        assessment = data["assessment"]
     else:
-        location = request.args.get("location", "")
-        if not location:
-            return jsonify({"error": "GET requires ?location=..."}), 400
-
-    download = request.args.get("download", "0") in ("1", "true", "True", "yes")
-
-    try:
-        model_text = call_hf_chat(location)
-    except Exception as e:
-        return jsonify({"error": str(e)}), 502
-
-    try:
-        parsed = sanitize_and_parse_json(model_text)
-        validated = format_scores_and_validate(parsed)
-    except Exception as e:
-        # Return raw model text for debugging (but still JSON-wrapped)
-        return jsonify({"error": "Failed to parse/validate model output", "model_output": model_text, "details": str(e)}), 500
-
-    if download:
+        # Generate assessment first
         try:
-            pdf_bytes = generate_pdf_bytes(location, validated)
-            pdf_filename = f"ecoscan_assessment_{datetime.datetime.utcnow().strftime('%Y%m%dT%H%M%SZ')}.pdf"
-            return send_file(
-                io.BytesIO(pdf_bytes),
-                mimetype="application/pdf",
-                as_attachment=True,
-                download_name=pdf_filename,
-            )
+            model_output = call_hf_chat(location)
+            assessment = sanitize_and_parse_json(model_output)
+            assessment = validate_and_enrich_assessment(assessment, location)
         except Exception as e:
-            return jsonify({"error": f"Failed to generate PDF: {e}"}), 500
-
-    return jsonify(validated)
+            return jsonify({"error": f"Failed to generate assessment: {str(e)}"}), 500
+    
+    job_id = str(uuid.uuid4())
+    
+    with jobs_lock:
+        jobs_store[job_id] = {
+            "job_id": job_id,
+            "type": "pdf",
+            "status": "pending",
+            "progress": 0.0,
+            "message": "Job created",
+            "location": location,
+            "created_at": time.time(),
+            "result": None,
+            "error": None
+        }
+    
+    # Start processing in background
+    thread = threading.Thread(target=process_pdf_job, args=(job_id, location, assessment))
+    thread.daemon = True
+    thread.start()
+    
+    return jsonify({"job_id": job_id, "status": "pending"})
+
+@app.route("/pdf_job/status/<job_id>", methods=["GET"])
+def get_pdf_status(job_id):
+    """Get status of a PDF job."""
+    with jobs_lock:
+        job = jobs_store.get(job_id)
+    
+    if not job:
+        return jsonify({"error": "Job not found"}), 404
+    
+    return jsonify({
+        "job_id": job_id,
+        "status": job["status"],
+        "progress": job["progress"],
+        "message": job["message"],
+        "error": job.get("error")
+    })
+
+@app.route("/pdf_job/result/<job_id>", methods=["GET"])
+def get_pdf_result(job_id):
+    """Get PDF result."""
+    with jobs_lock:
+        job = jobs_store.get(job_id)
+    
+    if not job:
+        return jsonify({"error": "Job not found"}), 404
+    
+    if job["status"] != "done":
+        return jsonify({"error": "Job not completed yet"}), 400
+    
+    pdf_bytes = job["result"]
+    
+    # Create response
+    buffer = io.BytesIO(pdf_bytes)
+    filename = f"EcoScan_Report_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+    
+    return send_file(
+        buffer,
+        mimetype='application/pdf',
+        as_attachment=True,
+        download_name=filename
+    )
 
+# Clean up old jobs periodically
+def cleanup_old_jobs():
+    """Remove jobs older than 1 hour."""
+    current_time = time.time()
+    with jobs_lock:
+        to_delete = []
+        for job_id, job in jobs_store.items():
+            if current_time - job.get("created_at", 0) > 3600:  # 1 hour
+                to_delete.append(job_id)
+        
+        for job_id in to_delete:
+            del jobs_store[job_id]
+
+# Schedule cleanup every 30 minutes
+import atexit
+from apscheduler.schedulers.background import BackgroundScheduler
+
+scheduler = BackgroundScheduler()
+scheduler.add_job(func=cleanup_old_jobs, trigger="interval", minutes=30)
+scheduler.start()
+atexit.register(lambda: scheduler.shutdown())
 
 if __name__ == "__main__":
-    # For local testing only. Production should use a WSGI server.
     app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))