Update app.py

app.py

@@ -1,307 +1,307 @@
-from flask import Flask, request, jsonify, render_template
-import json
-import requests
-import random
-import math
-import os
-from dotenv import load_dotenv
-
-load_dotenv()  # Load environment variables from .env file
-
-app = Flask(__name__)
-
-GEMINI_API_KEY = "AIzaSyDkiYr-eSkqIXpZ1fHlik_YFsFtfQoFi0w"
-NOMINATIM_USER_AGENT = "GeoSafeConstruct/1.0 ([email protected])"  # IMPORTANT: Change to your app name and contact email
-
-
-# --- Nominatim API Functions ---
-def get_location_name_from_coords(lat, lon):
-    """Fetches a location name/address from coordinates using Nominatim."""
-    headers = {"User-Agent": NOMINATIM_USER_AGENT}
-    url = f"https://nominatim.openstreetmap.org/reverse?format=json&lat={lat}&lon={lon}&zoom=16&addressdetails=1"
-    try:
-        response = requests.get(url, headers=headers, timeout=10)
-        response.raise_for_status()
-        data = response.json()
-        # Construct a readable address, prioritizing certain fields
-        address = data.get('address', {})
-        parts = [
-            address.get('road'), address.get('neighbourhood'), address.get('suburb'),
-            address.get('city_district'), address.get('city'), address.get('town'),
-            address.get('village'), address.get('county'), address.get('state'),
-            address.get('postcode'), address.get('country')
-        ]
-        # Filter out None values and join
-        display_name = data.get('display_name', "Unknown Location")
-        filtered_parts = [part for part in parts if part]
-        if len(filtered_parts) > 3:  # If many parts, use display_name for brevity
-            return display_name
-        elif filtered_parts:
-            return ", ".join(filtered_parts[:3])  # Take first few relevant parts
-        return display_name  # Fallback to full display_name
-    except requests.exceptions.RequestException as e:
-        print(f"Nominatim reverse geocoding error: {e}")
-        return f"Area around {lat:.3f}, {lon:.3f}"
-    except (json.JSONDecodeError, KeyError) as e:
-        print(f"Nominatim response parsing error: {e}")
-        return f"Area around {lat:.3f}, {lon:.3f}"
-
-
-def get_coords_from_location_name(query):
-    """Fetches coordinates from a location name/address using Nominatim."""
-    headers = {"User-Agent": NOMINATIM_USER_AGENT}
-    url = f"https://nominatim.openstreetmap.org/search?q={requests.utils.quote(query)}&format=json&limit=1"
-    try:
-        response = requests.get(url, headers=headers, timeout=10)
-        response.raise_for_status()
-        data = response.json()
-        if data and isinstance(data, list) and len(data) > 0:
-            return {
-                "latitude": float(data[0].get("lat")),
-                "longitude": float(data[0].get("lon")),
-                "display_name": data[0].get("display_name")
-            }
-        return None
-    except requests.exceptions.RequestException as e:
-        print(f"Nominatim geocoding error: {e}")
-        return None
-    except (json.JSONDecodeError, KeyError, IndexError) as e:
-        print(f"Nominatim geocoding response parsing error: {e}")
-        return None
-
-
-# --- Gemini API Functions ---
-def call_gemini_api(prompt_text):
-    """Generic function to call Gemini API."""
-    if not GEMINI_API_KEY:
-        print("GEMINI_API_KEY not found in environment variables.")
-        return None, "Gemini API key not configured."
-
-    url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent"
-    headers = {
-        "Content-Type": "application/json",
-        "x-goog-api-key": GEMINI_API_KEY
-    }
-    payload = {
-        "contents": [{"parts": [{"text": prompt_text}]}],
-        "generationConfig": {
-            "response_mime_type": "application/json",
-            "temperature": 0.6,  # Adjust for creativity vs. factuality
-            "topP": 0.9,
-            "topK": 40
-        },
-        "safetySettings": [  # Add safety settings if needed
-            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"}
-        ]
-    }
-
-    try:
-        response = requests.post(url, json=payload, headers=headers, timeout=60)  # Increased timeout
-        response.raise_for_status()
-        gemini_response_data = response.json()
-
-        if 'candidates' not in gemini_response_data or not gemini_response_data['candidates']:
-            print("Gemini API Error: No candidates in response.")
-            print("Full Gemini Response:", gemini_response_data)
-            if 'promptFeedback' in gemini_response_data and 'blockReason' in gemini_response_data['promptFeedback']:
-                return None, f"Content blocked by API: {gemini_response_data['promptFeedback']['blockReason']}"
-            return None, "Gemini API returned no content."
-
-        json_text_content = gemini_response_data['candidates'][0]['content']['parts'][0]['text']
-
-        # Attempt to clean JSON string if it's wrapped in markdown
-        if json_text_content.strip().startswith("```json"):
-            json_text_content = json_text_content.strip()[7:]
-        if json_text_content.strip().endswith("```"):
-            json_text_content = json_text_content.strip()[:-3]
-
-        return json.loads(json_text_content.strip()), None
-    except requests.exceptions.Timeout:
-        print("Gemini API call timed out.")
-        return None, "Analysis request timed out. Please try again."
-    except requests.exceptions.RequestException as e:
-        print(f"Error calling Gemini API (RequestException): {e}")
-        return None, f"Could not connect to analysis service: {e}"
-    except json.JSONDecodeError as e:
-        print(f"Error decoding JSON from Gemini API: {e}")
-        print(f"Received text for JSON parsing: {json_text_content if 'json_text_content' in locals() else 'N/A'}")
-        return None, "AI returned an invalid response format. Please try again."
-    except (KeyError, IndexError) as e:
-        print(f"Error parsing Gemini API response structure: {e}")
-        print(f"Gemini response: {gemini_response_data if 'gemini_response_data' in locals() else 'N/A'}")
-        return None, "AI returned an unexpected response structure."
-    except Exception as e:
-        print(f"An unexpected error occurred during Gemini call: {e}")
-        return None, f"An unexpected error occurred: {e}"
-
-
-def get_safety_analysis_with_gemini(latitude, longitude, location_address):
-    """
-    Calls Gemini API to analyze construction safety.
-    """
-    prompt = f"""
-    **Objective:** Provide a detailed and realistic construction site safety analysis for the location: {location_address} (Latitude: {latitude}, Longitude: {longitude}).
-
-    **Output Format:** STRICTLY JSON. Do NOT include any text outside the JSON structure (e.g., no '```json' or '```' wrappers).
-
-    **JSON Structure:**
-    {{
-        "location_name": "{location_address}", // Use the provided address
-        "safety_score": "integer (0-100, overall safety score, be critical and realistic)",
-        "suitability_statement": "string (e.g., 'Generally Suitable with Mitigations', 'High Caution Advised', 'Not Recommended without Major Intervention')",
-        "summary_assessment": "string (3-4 sentences summarizing key findings, suitability, and major concerns. Be specific.)",
-        "geological_risks": {{
-            "earthquake_risk": {{
-                "level": "string ('Low', 'Medium', 'High', 'Very High', 'Not Assessed')",
-                "details": "string (Specifics like proximity to faults, historical activity, soil liquefaction potential if known. If not assessed, state why.)"
-            }},
-            "landslide_risk": {{
-                "level": "string ('Low', 'Medium', 'High', 'Very High', 'Not Assessed')",
-                "details": "string (Slope stability, soil type, vegetation, historical incidents. If not assessed, state why.)"
-            }},
-            "soil_stability": {{
-                "type": "string ('Stable', 'Moderately Stable', 'Unstable', 'Variable', 'Requires Investigation')",
-                "concerns": ["string array (e.g., 'Expansive clays present', 'High water table', 'Poor drainage', 'Subsidence risk')"]
-            }}
-        }},
-        "hydrological_risks": {{
-            "flood_risk": {{
-                "level": "string ('Low', 'Medium', 'High', 'Very High', 'Not Assessed')",
-                "details": "string (Proximity to water bodies, floodplain maps, historical flooding, drainage issues. If not assessed, state why.)"
-            }},
-            "tsunami_risk": {{ // Only include if geographically relevant (coastal)
-                "level": "string ('Negligible', 'Low', 'Medium', 'High')",
-                "details": "string (Distance from coast, elevation, historical data.)"
-            }}
-        }},
-        "other_environmental_risks": [ // Array of objects, include if relevant
-            {{ "type": "Wildfire", "level": "string ('Low', 'Medium', 'High')", "details": "string (Vegetation, climate, fire history)" }},
-            {{ "type": "Extreme Weather (Hurricanes/Tornadoes/High Winds)", "level": "string ('Low', 'Medium', 'High')", "details": "string (Regional patterns, building code requirements)" }},
-            {{ "type": "Industrial Hazards", "level": "string ('Low', 'Medium', 'High')", "details": "string (Proximity to industrial plants, pipelines, hazardous material routes)" }}
-        ],
-        "key_risk_factors_summary": ["string array (Bulleted list of 3-5 most critical risk factors for this specific site)"],
-        "mitigation_recommendations": ["string array (Actionable, specific recommendations, e.g., 'Conduct Level 2 Geotechnical Survey focusing on shear strength', 'Implement earthquake-resistant design to Zone IV standards', 'Elevate foundation by 1.5m above base flood elevation')"],
-        "further_investigations_needed": ["string array (e.g., 'Detailed hydrological study', 'Environmental Impact Assessment', 'Traffic impact study')"],
-        "alternative_locations_analysis": [ // Up to 2-3 alternatives. If none are significantly better, state that.
-            {{
-                "name_suggestion": "string (Suggest a conceptual name like 'North Ridge Site' or 'Valley View Plot')",
-                "latitude": "float (as string, e.g., '18.5234')",
-                "longitude": "float (as string, e.g., '73.8567')",
-                "estimated_distance_km": "float (as string, e.g., '8.5')",
-                "brief_justification": "string (Why is this a potential alternative? E.g., 'Appears to be on more stable ground', 'Further from flood plain')",
-                "potential_pros": ["string array"],
-                "potential_cons": ["string array"],
-                "comparative_safety_score_estimate": "integer (0-100, relative to primary site)"
-            }}
-        ],
-        "data_confidence_level": "string ('Low', 'Medium', 'High' - based on assumed availability of public data for this general region, not specific site data which is unknown to you)",
-        "disclaimer": "This AI-generated analysis is for preliminary informational purposes only and not a substitute for professional engineering, geological, and environmental assessments. On-site investigations are crucial."
-    }}
-
-    **Guidelines for Content:**
-    - make sumre rnaodmness in score generation not same view ppijn t everytime
-    - Be realistic. If data for a specific risk is unlikely to be publicly available for a random coordinate, mark it 'Not Assessed' and explain.
-    - Focus on actionable insights.
-    - For alternative locations, provide *different* lat/lon coordinates that are plausibly nearby (within 5-20km).
-    - Ensure all string values are properly quoted. Ensure latitudes and longitudes for alternatives are strings representing floats.
-    - The safety_score should reflect a comprehensive evaluation of all risks.
-    - proper spacing and upo down margins shoudl be there
-    """
-    return call_gemini_api(prompt)
-
-
-# --- Flask Routes ---
-@app.route('/')
-def index():
-    return render_template('index.html')
-
-
-@app.route('/api/geocode', methods=['POST'])
-def geocode_location():
-    data = request.json
-    query = data.get('query')
-    if not query:
-        return jsonify({"error": "Query parameter is required."}), 400
-
-    coords_data = get_coords_from_location_name(query)
-    if coords_data:
-        return jsonify(coords_data), 200
-    else:
-        return jsonify({"error": "Location not found or geocoding failed."}), 404
-
-
-@app.route('/api/analyze_location', methods=['POST'])
-def analyze_location_route():
-    data = request.json
-    try:
-        latitude = float(data.get('latitude'))
-        longitude = float(data.get('longitude'))
-    except (TypeError, ValueError):
-        return jsonify({"error": "Invalid latitude or longitude provided."}), 400
-
-    # Get a human-readable name for the primary location
-    primary_location_address = get_location_name_from_coords(latitude, longitude)
-
-    # Call Gemini for the main analysis
-    analysis_data, error = get_safety_analysis_with_gemini(latitude, longitude, primary_location_address)
-
-    if error:
-        # Fallback to a simpler mock-like structure if Gemini fails critically
-        return jsonify({
-            "error_message": error,
-            "location_name": primary_location_address,
-            "safety_score": random.randint(20, 50),  # Low score to indicate issue
-            "summary_assessment": f"Could not perform detailed analysis due to: {error}. Basic location: {primary_location_address}.",
-            "suitability_statement": "Analysis Incomplete",
-            "geological_risks": {"earthquake_risk": {"level": "Not Assessed", "details": error}},
-            "hydrological_risks": {"flood_risk": {"level": "Not Assessed", "details": error}},
-            "disclaimer": "A technical issue prevented full analysis."
-        }), 500
-
-    # Post-process alternative locations to get their names
-    if analysis_data.get("alternative_locations_analysis"):
-        for alt_loc in analysis_data["alternative_locations_analysis"]:
-            try:
-                alt_lat = float(alt_loc.get("latitude"))
-                alt_lon = float(alt_loc.get("longitude"))
-                alt_loc["actual_name"] = get_location_name_from_coords(alt_lat, alt_lon)
-                # Ensure distance is calculated if not provided by Gemini or if it's nonsensical
-                if not alt_loc.get("estimated_distance_km") or float(alt_loc.get("estimated_distance_km", 0)) == 0:
-                    alt_loc["estimated_distance_km"] = str(
-                        calculate_haversine_distance(latitude, longitude, alt_lat, alt_lon))
-
-            except (TypeError, ValueError, KeyError) as e:
-                print(f"Error processing alternative location coords: {e}, data: {alt_loc}")
-                alt_loc["actual_name"] = "Nearby Area (details unavailable)"
-                # Fallback if lat/lon are missing or invalid for an alternative
-                if "latitude" not in alt_loc or "longitude" not in alt_loc:
-                    alt_loc["latitude"] = str(latitude + (random.random() - 0.5) * 0.05)  # Small offset
-                    alt_loc["longitude"] = str(longitude + (random.random() - 0.5) * 0.05)
-
-    return jsonify(analysis_data), 200
-
-
-def calculate_haversine_distance(lat1, lon1, lat2, lon2):
-    R = 6371  # Radius of Earth in kilometers
-    try:
-        lat1_rad, lon1_rad = math.radians(float(lat1)), math.radians(float(lon1))
-        lat2_rad, lon2_rad = math.radians(float(lat2)), math.radians(float(lon2))
-    except (ValueError, TypeError):
-        print(f"Error converting lat/lon to float for Haversine: {lat1}, {lon1}, {lat2}, {lon2}")
-        return 0.0  # Fallback
-    dlon = lon2_rad - lon1_rad
-    dlat = lat2_rad - lat1_rad
-    a = math.sin(dlat / 2) ** 2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(dlon / 2) ** 2
-    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
-    distance = R * c
-    return round(distance, 1)
-
-
-if __name__ == '__main__':
-    if not GEMINI_API_KEY:
-        print("CRITICAL ERROR: GEMINI_API_KEY is not set in the environment.")
-        print("Please create a .env file with GEMINI_API_KEY=YOUR_API_KEY or set it as an environment variable.")
+from flask import Flask, request, jsonify, render_template
+import json
+import requests
+import random
+import math
+import os
+from dotenv import load_dotenv
+
+load_dotenv()  # Load environment variables from .env file
+
+app = Flask(__name__)
+
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
+NOMINATIM_USER_AGENT = "GeoSafeConstruct/1.0 ([email protected])"  # IMPORTANT: Change to your app name and contact email
+
+
+# --- Nominatim API Functions ---
+def get_location_name_from_coords(lat, lon):
+    """Fetches a location name/address from coordinates using Nominatim."""
+    headers = {"User-Agent": NOMINATIM_USER_AGENT}
+    url = f"https://nominatim.openstreetmap.org/reverse?format=json&lat={lat}&lon={lon}&zoom=16&addressdetails=1"
+    try:
+        response = requests.get(url, headers=headers, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        # Construct a readable address, prioritizing certain fields
+        address = data.get('address', {})
+        parts = [
+            address.get('road'), address.get('neighbourhood'), address.get('suburb'),
+            address.get('city_district'), address.get('city'), address.get('town'),
+            address.get('village'), address.get('county'), address.get('state'),
+            address.get('postcode'), address.get('country')
+        ]
+        # Filter out None values and join
+        display_name = data.get('display_name', "Unknown Location")
+        filtered_parts = [part for part in parts if part]
+        if len(filtered_parts) > 3:  # If many parts, use display_name for brevity
+            return display_name
+        elif filtered_parts:
+            return ", ".join(filtered_parts[:3])  # Take first few relevant parts
+        return display_name  # Fallback to full display_name
+    except requests.exceptions.RequestException as e:
+        print(f"Nominatim reverse geocoding error: {e}")
+        return f"Area around {lat:.3f}, {lon:.3f}"
+    except (json.JSONDecodeError, KeyError) as e:
+        print(f"Nominatim response parsing error: {e}")
+        return f"Area around {lat:.3f}, {lon:.3f}"
+
+
+def get_coords_from_location_name(query):
+    """Fetches coordinates from a location name/address using Nominatim."""
+    headers = {"User-Agent": NOMINATIM_USER_AGENT}
+    url = f"https://nominatim.openstreetmap.org/search?q={requests.utils.quote(query)}&format=json&limit=1"
+    try:
+        response = requests.get(url, headers=headers, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        if data and isinstance(data, list) and len(data) > 0:
+            return {
+                "latitude": float(data[0].get("lat")),
+                "longitude": float(data[0].get("lon")),
+                "display_name": data[0].get("display_name")
+            }
+        return None
+    except requests.exceptions.RequestException as e:
+        print(f"Nominatim geocoding error: {e}")
+        return None
+    except (json.JSONDecodeError, KeyError, IndexError) as e:
+        print(f"Nominatim geocoding response parsing error: {e}")
+        return None
+
+
+# --- Gemini API Functions ---
+def call_gemini_api(prompt_text):
+    """Generic function to call Gemini API."""
+    if not GEMINI_API_KEY:
+        print("GEMINI_API_KEY not found in environment variables.")
+        return None, "Gemini API key not configured."
+
+    url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent"
+    headers = {
+        "Content-Type": "application/json",
+        "x-goog-api-key": GEMINI_API_KEY
+    }
+    payload = {
+        "contents": [{"parts": [{"text": prompt_text}]}],
+        "generationConfig": {
+            "response_mime_type": "application/json",
+            "temperature": 0.6,  # Adjust for creativity vs. factuality
+            "topP": 0.9,
+            "topK": 40
+        },
+        "safetySettings": [  # Add safety settings if needed
+            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"}
+        ]
+    }
+
+    try:
+        response = requests.post(url, json=payload, headers=headers, timeout=60)  # Increased timeout
+        response.raise_for_status()
+        gemini_response_data = response.json()
+
+        if 'candidates' not in gemini_response_data or not gemini_response_data['candidates']:
+            print("Gemini API Error: No candidates in response.")
+            print("Full Gemini Response:", gemini_response_data)
+            if 'promptFeedback' in gemini_response_data and 'blockReason' in gemini_response_data['promptFeedback']:
+                return None, f"Content blocked by API: {gemini_response_data['promptFeedback']['blockReason']}"
+            return None, "Gemini API returned no content."
+
+        json_text_content = gemini_response_data['candidates'][0]['content']['parts'][0]['text']
+
+        # Attempt to clean JSON string if it's wrapped in markdown
+        if json_text_content.strip().startswith("```json"):
+            json_text_content = json_text_content.strip()[7:]
+        if json_text_content.strip().endswith("```"):
+            json_text_content = json_text_content.strip()[:-3]
+
+        return json.loads(json_text_content.strip()), None
+    except requests.exceptions.Timeout:
+        print("Gemini API call timed out.")
+        return None, "Analysis request timed out. Please try again."
+    except requests.exceptions.RequestException as e:
+        print(f"Error calling Gemini API (RequestException): {e}")
+        return None, f"Could not connect to analysis service: {e}"
+    except json.JSONDecodeError as e:
+        print(f"Error decoding JSON from Gemini API: {e}")
+        print(f"Received text for JSON parsing: {json_text_content if 'json_text_content' in locals() else 'N/A'}")
+        return None, "AI returned an invalid response format. Please try again."
+    except (KeyError, IndexError) as e:
+        print(f"Error parsing Gemini API response structure: {e}")
+        print(f"Gemini response: {gemini_response_data if 'gemini_response_data' in locals() else 'N/A'}")
+        return None, "AI returned an unexpected response structure."
+    except Exception as e:
+        print(f"An unexpected error occurred during Gemini call: {e}")
+        return None, f"An unexpected error occurred: {e}"
+
+
+def get_safety_analysis_with_gemini(latitude, longitude, location_address):
+    """
+    Calls Gemini API to analyze construction safety.
+    """
+    prompt = f"""
+    **Objective:** Provide a detailed and realistic construction site safety analysis for the location: {location_address} (Latitude: {latitude}, Longitude: {longitude}).
+
+    **Output Format:** STRICTLY JSON. Do NOT include any text outside the JSON structure (e.g., no '```json' or '```' wrappers).
+
+    **JSON Structure:**
+    {{
+        "location_name": "{location_address}", // Use the provided address
+        "safety_score": "integer (0-100, overall safety score, be critical and realistic)",
+        "suitability_statement": "string (e.g., 'Generally Suitable with Mitigations', 'High Caution Advised', 'Not Recommended without Major Intervention')",
+        "summary_assessment": "string (3-4 sentences summarizing key findings, suitability, and major concerns. Be specific.)",
+        "geological_risks": {{
+            "earthquake_risk": {{
+                "level": "string ('Low', 'Medium', 'High', 'Very High', 'Not Assessed')",
+                "details": "string (Specifics like proximity to faults, historical activity, soil liquefaction potential if known. If not assessed, state why.)"
+            }},
+            "landslide_risk": {{
+                "level": "string ('Low', 'Medium', 'High', 'Very High', 'Not Assessed')",
+                "details": "string (Slope stability, soil type, vegetation, historical incidents. If not assessed, state why.)"
+            }},
+            "soil_stability": {{
+                "type": "string ('Stable', 'Moderately Stable', 'Unstable', 'Variable', 'Requires Investigation')",
+                "concerns": ["string array (e.g., 'Expansive clays present', 'High water table', 'Poor drainage', 'Subsidence risk')"]
+            }}
+        }},
+        "hydrological_risks": {{
+            "flood_risk": {{
+                "level": "string ('Low', 'Medium', 'High', 'Very High', 'Not Assessed')",
+                "details": "string (Proximity to water bodies, floodplain maps, historical flooding, drainage issues. If not assessed, state why.)"
+            }},
+            "tsunami_risk": {{ // Only include if geographically relevant (coastal)
+                "level": "string ('Negligible', 'Low', 'Medium', 'High')",
+                "details": "string (Distance from coast, elevation, historical data.)"
+            }}
+        }},
+        "other_environmental_risks": [ // Array of objects, include if relevant
+            {{ "type": "Wildfire", "level": "string ('Low', 'Medium', 'High')", "details": "string (Vegetation, climate, fire history)" }},
+            {{ "type": "Extreme Weather (Hurricanes/Tornadoes/High Winds)", "level": "string ('Low', 'Medium', 'High')", "details": "string (Regional patterns, building code requirements)" }},
+            {{ "type": "Industrial Hazards", "level": "string ('Low', 'Medium', 'High')", "details": "string (Proximity to industrial plants, pipelines, hazardous material routes)" }}
+        ],
+        "key_risk_factors_summary": ["string array (Bulleted list of 3-5 most critical risk factors for this specific site)"],
+        "mitigation_recommendations": ["string array (Actionable, specific recommendations, e.g., 'Conduct Level 2 Geotechnical Survey focusing on shear strength', 'Implement earthquake-resistant design to Zone IV standards', 'Elevate foundation by 1.5m above base flood elevation')"],
+        "further_investigations_needed": ["string array (e.g., 'Detailed hydrological study', 'Environmental Impact Assessment', 'Traffic impact study')"],
+        "alternative_locations_analysis": [ // Up to 2-3 alternatives. If none are significantly better, state that.
+            {{
+                "name_suggestion": "string (Suggest a conceptual name like 'North Ridge Site' or 'Valley View Plot')",
+                "latitude": "float (as string, e.g., '18.5234')",
+                "longitude": "float (as string, e.g., '73.8567')",
+                "estimated_distance_km": "float (as string, e.g., '8.5')",
+                "brief_justification": "string (Why is this a potential alternative? E.g., 'Appears to be on more stable ground', 'Further from flood plain')",
+                "potential_pros": ["string array"],
+                "potential_cons": ["string array"],
+                "comparative_safety_score_estimate": "integer (0-100, relative to primary site)"
+            }}
+        ],
+        "data_confidence_level": "string ('Low', 'Medium', 'High' - based on assumed availability of public data for this general region, not specific site data which is unknown to you)",
+        "disclaimer": "This AI-generated analysis is for preliminary informational purposes only and not a substitute for professional engineering, geological, and environmental assessments. On-site investigations are crucial."
+    }}
+
+    **Guidelines for Content:**
+    - make sumre rnaodmness in score generation not same view ppijn t everytime
+    - Be realistic. If data for a specific risk is unlikely to be publicly available for a random coordinate, mark it 'Not Assessed' and explain.
+    - Focus on actionable insights.
+    - For alternative locations, provide *different* lat/lon coordinates that are plausibly nearby (within 5-20km).
+    - Ensure all string values are properly quoted. Ensure latitudes and longitudes for alternatives are strings representing floats.
+    - The safety_score should reflect a comprehensive evaluation of all risks.
+    - proper spacing and upo down margins shoudl be there
+    """
+    return call_gemini_api(prompt)
+
+
+# --- Flask Routes ---
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+
+@app.route('/api/geocode', methods=['POST'])
+def geocode_location():
+    data = request.json
+    query = data.get('query')
+    if not query:
+        return jsonify({"error": "Query parameter is required."}), 400
+
+    coords_data = get_coords_from_location_name(query)
+    if coords_data:
+        return jsonify(coords_data), 200
+    else:
+        return jsonify({"error": "Location not found or geocoding failed."}), 404
+
+
+@app.route('/api/analyze_location', methods=['POST'])
+def analyze_location_route():
+    data = request.json
+    try:
+        latitude = float(data.get('latitude'))
+        longitude = float(data.get('longitude'))
+    except (TypeError, ValueError):
+        return jsonify({"error": "Invalid latitude or longitude provided."}), 400
+
+    # Get a human-readable name for the primary location
+    primary_location_address = get_location_name_from_coords(latitude, longitude)
+
+    # Call Gemini for the main analysis
+    analysis_data, error = get_safety_analysis_with_gemini(latitude, longitude, primary_location_address)
+
+    if error:
+        # Fallback to a simpler mock-like structure if Gemini fails critically
+        return jsonify({
+            "error_message": error,
+            "location_name": primary_location_address,
+            "safety_score": random.randint(20, 50),  # Low score to indicate issue
+            "summary_assessment": f"Could not perform detailed analysis due to: {error}. Basic location: {primary_location_address}.",
+            "suitability_statement": "Analysis Incomplete",
+            "geological_risks": {"earthquake_risk": {"level": "Not Assessed", "details": error}},
+            "hydrological_risks": {"flood_risk": {"level": "Not Assessed", "details": error}},
+            "disclaimer": "A technical issue prevented full analysis."
+        }), 500
+
+    # Post-process alternative locations to get their names
+    if analysis_data.get("alternative_locations_analysis"):
+        for alt_loc in analysis_data["alternative_locations_analysis"]:
+            try:
+                alt_lat = float(alt_loc.get("latitude"))
+                alt_lon = float(alt_loc.get("longitude"))
+                alt_loc["actual_name"] = get_location_name_from_coords(alt_lat, alt_lon)
+                # Ensure distance is calculated if not provided by Gemini or if it's nonsensical
+                if not alt_loc.get("estimated_distance_km") or float(alt_loc.get("estimated_distance_km", 0)) == 0:
+                    alt_loc["estimated_distance_km"] = str(
+                        calculate_haversine_distance(latitude, longitude, alt_lat, alt_lon))
+
+            except (TypeError, ValueError, KeyError) as e:
+                print(f"Error processing alternative location coords: {e}, data: {alt_loc}")
+                alt_loc["actual_name"] = "Nearby Area (details unavailable)"
+                # Fallback if lat/lon are missing or invalid for an alternative
+                if "latitude" not in alt_loc or "longitude" not in alt_loc:
+                    alt_loc["latitude"] = str(latitude + (random.random() - 0.5) * 0.05)  # Small offset
+                    alt_loc["longitude"] = str(longitude + (random.random() - 0.5) * 0.05)
+
+    return jsonify(analysis_data), 200
+
+
+def calculate_haversine_distance(lat1, lon1, lat2, lon2):
+    R = 6371  # Radius of Earth in kilometers
+    try:
+        lat1_rad, lon1_rad = math.radians(float(lat1)), math.radians(float(lon1))
+        lat2_rad, lon2_rad = math.radians(float(lat2)), math.radians(float(lon2))
+    except (ValueError, TypeError):
+        print(f"Error converting lat/lon to float for Haversine: {lat1}, {lon1}, {lat2}, {lon2}")
+        return 0.0  # Fallback
+    dlon = lon2_rad - lon1_rad
+    dlat = lat2_rad - lat1_rad
+    a = math.sin(dlat / 2) ** 2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(dlon / 2) ** 2
+    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+    distance = R * c
+    return round(distance, 1)
+
+
+if __name__ == '__main__':
+    if not GEMINI_API_KEY:
+        print("CRITICAL ERROR: GEMINI_API_KEY is not set in the environment.")
+        print("Please create a .env file with GEMINI_API_KEY=YOUR_API_KEY or set it as an environment variable.")
     app.run(debug=True, port=5000)