Upload 45 files

Dockerfile

@@ -0,0 +1,54 @@
+FROM python:3.10-slim
+
+# Create a non-root user
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+USER root
+RUN apt-get update && apt-get install -y \
+    tesseract-ocr \
+    tesseract-ocr-eng \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create necessary directories with proper permissions
+RUN mkdir -p /app/logs \
+    && mkdir -p /app/cache \
+    && mkdir -p /app/uploads \
+    && mkdir -p /app/model_cache \
+    && mkdir -p /app/temp \
+    && chown -R user:user /app
+
+# Switch back to non-root user
+USER user
+
+# Copy requirements first to leverage Docker cache
+COPY --chown=user:user requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --user -r requirements.txt
+
+# Download spaCy model
+RUN python -m spacy download en_core_web_md
+
+# Copy application code
+COPY --chown=user:user . .
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV FLASK_APP=app.py
+ENV FLASK_ENV=production
+ENV TRANSFORMERS_CACHE=/app/cache
+ENV HF_HOME=/app/cache
+ENV XDG_CACHE_HOME=/app/cache
+ENV LOG_DIR=/app/logs
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "--threads", "8", "--timeout", "0", "app:app"] 

app.py

@@ -0,0 +1,531 @@
+# app.py
+
+from flask import Flask, render_template, request, jsonify
+from flask_cors import CORS
+import base64
+import io
+import re
+import json
+import uuid
+import time
+import asyncio
+from geopy.geocoders import Nominatim
+from datetime import datetime
+from models.logging_config import logger
+from models.model_loader import load_model
+from models.image_analysis import analyze_image
+from models.pdf_analysis import extract_pdf_text, analyze_pdf_content
+from models.property_summary import generate_property_summary
+from models.fraud_classification import classify_fraud
+from models.trust_score import generate_trust_score
+from models.suggestions import generate_suggestions
+from models.text_quality import assess_text_quality
+from models.address_verification import verify_address
+from models.cross_validation import perform_cross_validation
+from models.location_analysis import analyze_location
+from models.price_analysis import analyze_price
+from models.legal_analysis import analyze_legal_details
+from models.property_specs import verify_property_specs
+from models.market_value import analyze_market_value
+from models.image_quality import assess_image_quality
+from models.property_relation import check_if_property_related
+import torch
+import numpy as np
+import concurrent.futures
+from PIL import Image
+
+app = Flask(__name__)
+CORS(app)  # Enable CORS for frontend
+
+# Initialize geocoder
+geocoder = Nominatim(user_agent="indian_property_verifier", timeout=10)
+
+def make_json_serializable(obj):
+    try:
+        if isinstance(obj, (bool, int, float, str, type(None))):
+            return obj
+        elif isinstance(obj, (list, tuple)):
+            return [make_json_serializable(item) for item in obj]
+        elif isinstance(obj, dict):
+            return {str(key): make_json_serializable(value) for key, value in obj.items()}
+        elif torch.is_tensor(obj):
+            return obj.item() if obj.numel() == 1 else obj.tolist()
+        elif np.isscalar(obj):
+            return obj.item() if hasattr(obj, 'item') else float(obj)
+        elif isinstance(obj, np.ndarray):
+            return obj.tolist()
+        else:
+            return str(obj)
+    except Exception as e:
+        logger.error(f"Error serializing object: {str(e)}")
+        return str(obj)
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/get-location', methods=['POST'])
+def get_location():
+    try:
+        data = request.json or {}
+        latitude = data.get('latitude')
+        longitude = data.get('longitude')
+
+        if not latitude or not longitude:
+            logger.warning("Missing latitude or longitude")
+            return jsonify({
+                'status': 'error',
+                'message': 'Latitude and longitude are required'
+            }), 400
+
+        # Validate coordinates are within India
+        try:
+            lat, lng = float(latitude), float(longitude)
+            if not (6.5 <= lat <= 37.5 and 68.0 <= lng <= 97.5):
+                return jsonify({
+                    'status': 'error',
+                    'message': 'Coordinates are outside India'
+                }), 400
+        except ValueError:
+            return jsonify({
+                'status': 'error',
+                'message': 'Invalid coordinates format'
+            }), 400
+
+        # Retry geocoding up to 3 times
+        for attempt in range(3):
+            try:
+                location = geocoder.reverse((latitude, longitude), exactly_one=True)
+                if location:
+                    address_components = location.raw.get('address', {})
+
+                    # Extract Indian-specific address components
+                    city = address_components.get('city', '')
+                    if not city:
+                        city = address_components.get('town', '')
+                    if not city:
+                        city = address_components.get('village', '')
+                    if not city:
+                        city = address_components.get('suburb', '')
+
+                    state = address_components.get('state', '')
+                    if not state:
+                        state = address_components.get('state_district', '')
+
+                    # Get postal code and validate Indian format
+                    postal_code = address_components.get('postcode', '')
+                    if postal_code and not re.match(r'^\d{6}$', postal_code):
+                        postal_code = ''
+
+                    # Get road/street name
+                    road = address_components.get('road', '')
+                    if not road:
+                        road = address_components.get('street', '')
+
+                    # Get area/locality
+                    area = address_components.get('suburb', '')
+                    if not area:
+                        area = address_components.get('neighbourhood', '')
+
+                    return jsonify({
+                        'status': 'success',
+                        'address': location.address,
+                        'street': road,
+                        'area': area,
+                        'city': city,
+                        'state': state,
+                        'country': 'India',
+                        'postal_code': postal_code,
+                        'latitude': latitude,
+                        'longitude': longitude,
+                        'formatted_address': f"{road}, {area}, {city}, {state}, India - {postal_code}"
+                    })
+                logger.warning(f"Geocoding failed on attempt {attempt + 1}")
+                time.sleep(1)  # Wait before retry
+            except Exception as e:
+                logger.error(f"Geocoding error on attempt {attempt + 1}: {str(e)}")
+                time.sleep(1)
+
+        return jsonify({
+            'status': 'error',
+            'message': 'Could not determine location after retries'
+        }), 500
+
+    except Exception as e:
+        logger.error(f"Error in get_location: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': str(e)
+        }), 500
+
+def calculate_final_verdict(results):
+    """
+    Calculate a comprehensive final verdict based on all analysis results.
+    This function combines all verification scores, fraud indicators, and quality assessments
+    to determine if a property listing is legitimate, suspicious, or fraudulent.
+    """
+    try:
+        # Initialize verdict components
+        verdict = {
+            'status': 'unknown',
+            'confidence': 0.0,
+            'score': 0.0,
+            'reasons': [],
+            'critical_issues': [],
+            'warnings': [],
+            'recommendations': []
+        }
+
+        # Extract key components from results
+        trust_score = results.get('trust_score', {}).get('score', 0)
+        fraud_classification = results.get('fraud_classification', {})
+        quality_assessment = results.get('quality_assessment', {})
+        specs_verification = results.get('specs_verification', {})
+        cross_validation = results.get('cross_validation', [])
+        location_analysis = results.get('location_analysis', {})
+        price_analysis = results.get('price_analysis', {})
+        legal_analysis = results.get('legal_analysis', {})
+        document_analysis = results.get('document_analysis', {})
+        image_analysis = results.get('image_analysis', {})
+
+        # Calculate component scores (0-100)
+        component_scores = {
+            'trust': trust_score,
+            'fraud': 100 - (fraud_classification.get('alert_score', 0) * 100),
+            'quality': quality_assessment.get('score', 0),
+            'specs': specs_verification.get('verification_score', 0),
+            'location': location_analysis.get('completeness_score', 0),
+            'price': price_analysis.get('confidence', 0) * 100 if price_analysis.get('has_price') else 0,
+            'legal': legal_analysis.get('completeness_score', 0),
+            'documents': min(100, (document_analysis.get('pdf_count', 0) / 3) * 100) if document_analysis.get('pdf_count') else 0,
+            'images': min(100, (image_analysis.get('image_count', 0) / 5) * 100) if image_analysis.get('image_count') else 0
+        }
+
+        # Calculate weighted final score with adjusted weights
+        weights = {
+            'trust': 0.20,
+            'fraud': 0.25,  # Increased weight for fraud detection
+            'quality': 0.15,
+            'specs': 0.10,
+            'location': 0.10,
+            'price': 0.05,
+            'legal': 0.05,
+            'documents': 0.05,
+            'images': 0.05
+        }
+
+        final_score = sum(score * weights.get(component, 0) for component, score in component_scores.items())
+        verdict['score'] = final_score
+
+        # Determine verdict status based on multiple factors
+        fraud_level = fraud_classification.get('alert_level', 'minimal')
+        high_risk_indicators = len(fraud_classification.get('high_risk', []))
+        critical_issues = []
+        warnings = []
+
+        # Check for critical issues
+        if fraud_level in ['critical', 'high']:
+            critical_issues.append(f"High fraud risk detected: {fraud_level} alert level")
+
+        if trust_score < 40:
+            critical_issues.append(f"Very low trust score: {trust_score}%")
+
+        if quality_assessment.get('score', 0) < 30:
+            critical_issues.append(f"Very low content quality: {quality_assessment.get('score', 0)}%")
+
+        if specs_verification.get('verification_score', 0) < 40:
+            critical_issues.append(f"Property specifications verification failed: {specs_verification.get('verification_score', 0)}%")
+
+        # Check for warnings
+        if fraud_level == 'medium':
+            warnings.append(f"Medium fraud risk detected: {fraud_level} alert level")
+
+        if trust_score < 60:
+            warnings.append(f"Low trust score: {trust_score}%")
+
+        if quality_assessment.get('score', 0) < 60:
+            warnings.append(f"Low content quality: {quality_assessment.get('score', 0)}%")
+
+        if specs_verification.get('verification_score', 0) < 70:
+            warnings.append(f"Property specifications have issues: {specs_verification.get('verification_score', 0)}%")
+
+        # Check cross-validation results
+        for check in cross_validation:
+            if check.get('status') in ['inconsistent', 'invalid', 'suspicious', 'no_match']:
+                warnings.append(f"Cross-validation issue: {check.get('message', 'Unknown issue')}")
+
+        # Check for missing critical information
+        missing_critical = []
+        if not location_analysis.get('completeness_score', 0) > 70:
+            missing_critical.append("Location information is incomplete")
+
+        if not price_analysis.get('has_price', False):
+            missing_critical.append("Price information is missing")
+
+        if not legal_analysis.get('completeness_score', 0) > 70:
+            missing_critical.append("Legal information is incomplete")
+
+        if document_analysis.get('pdf_count', 0) == 0:
+            missing_critical.append("No supporting documents provided")
+
+        if image_analysis.get('image_count', 0) == 0:
+            missing_critical.append("No property images provided")
+
+        if missing_critical:
+            warnings.append(f"Missing critical information: {', '.join(missing_critical)}")
+
+        # Enhanced verdict determination with more strict criteria
+        if critical_issues or (fraud_level in ['critical', 'high'] and trust_score < 50) or high_risk_indicators > 0:
+            verdict['status'] = 'fraudulent'
+            verdict['confidence'] = min(100, max(70, 100 - (trust_score * 0.5)))
+        elif warnings or (fraud_level == 'medium' and trust_score < 70) or specs_verification.get('verification_score', 0) < 60:
+            verdict['status'] = 'suspicious'
+            verdict['confidence'] = min(100, max(50, trust_score * 0.8))
+        else:
+            verdict['status'] = 'legitimate'
+            verdict['confidence'] = min(100, max(70, trust_score * 0.9))
+
+        # Add reasons to verdict
+        verdict['critical_issues'] = critical_issues
+        verdict['warnings'] = warnings
+
+        # Add recommendations based on issues
+        if critical_issues:
+            verdict['recommendations'].append("Do not proceed with this property listing")
+            verdict['recommendations'].append("Report this listing to the platform")
+        elif warnings:
+            verdict['recommendations'].append("Proceed with extreme caution")
+            verdict['recommendations'].append("Request additional verification documents")
+            verdict['recommendations'].append("Verify all information with independent sources")
+        else:
+            verdict['recommendations'].append("Proceed with standard due diligence")
+            verdict['recommendations'].append("Verify final details before transaction")
+
+        # Add specific recommendations based on missing information
+        for missing in missing_critical:
+            verdict['recommendations'].append(f"Request {missing.lower()}")
+
+        return verdict
+    except Exception as e:
+        logger.error(f"Error calculating final verdict: {str(e)}")
+        return {
+            'status': 'error',
+            'confidence': 0.0,
+            'score': 0.0,
+            'reasons': [f"Error calculating verdict: {str(e)}"],
+            'critical_issues': [],
+            'warnings': [],
+            'recommendations': ["Unable to determine property status due to an error"]
+        }
+
+@app.route('/verify', methods=['POST'])
+def verify_property():
+    try:
+        if not request.form and not request.files:
+            logger.warning("No form data or files provided")
+            return jsonify({
+                'error': 'No data provided',
+                'status': 'error'
+            }), 400
+
+        # Extract form data
+        data = {
+            'property_name': request.form.get('property_name', '').strip(),
+            'property_type': request.form.get('property_type', '').strip(),
+            'status': request.form.get('status', '').strip(),
+            'description': request.form.get('description', '').strip(),
+            'address': request.form.get('address', '').strip(),
+            'city': request.form.get('city', '').strip(),
+            'state': request.form.get('state', '').strip(),
+            'country': request.form.get('country', 'India').strip(),
+            'zip': request.form.get('zip', '').strip(),
+            'latitude': request.form.get('latitude', '').strip(),
+            'longitude': request.form.get('longitude', '').strip(),
+            'bedrooms': request.form.get('bedrooms', '').strip(),
+            'bathrooms': request.form.get('bathrooms', '').strip(),
+            'total_rooms': request.form.get('total_rooms', '').strip(),
+            'year_built': request.form.get('year_built', '').strip(),
+            'parking': request.form.get('parking', '').strip(),
+            'sq_ft': request.form.get('sq_ft', '').strip(),
+            'market_value': request.form.get('market_value', '').strip(),
+            'amenities': request.form.get('amenities', '').strip(),
+            'nearby_landmarks': request.form.get('nearby_landmarks', '').strip(),
+            'legal_details': request.form.get('legal_details', '').strip()
+        }
+
+        # Validate required fields
+        required_fields = ['property_name', 'property_type', 'address', 'city', 'state']
+        missing_fields = [field for field in required_fields if not data[field]]
+        if missing_fields:
+            logger.warning(f"Missing required fields: {', '.join(missing_fields)}")
+            return jsonify({
+                'error': f"Missing required fields: {', '.join(missing_fields)}",
+                'status': 'error'
+            }), 400
+
+        # Process images
+        images = []
+        image_analysis = []
+        if 'images' in request.files:
+            # Get unique image files by filename to prevent duplicates
+            image_files = {}
+            for img_file in request.files.getlist('images'):
+                if img_file.filename and img_file.filename.lower().endswith(('.jpg', '.jpeg', '.png')):
+                    image_files[img_file.filename] = img_file
+
+            # Process unique images
+            for img_file in image_files.values():
+                    try:
+                        img = Image.open(img_file)
+                        buffered = io.BytesIO()
+                        img.save(buffered, format="JPEG")
+                        img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
+                        images.append(img_str)
+                        image_analysis.append(analyze_image(img))
+                    except Exception as e:
+                        logger.error(f"Error processing image {img_file.filename}: {str(e)}")
+                        image_analysis.append({'error': str(e), 'is_property_related': False})
+
+        # Process PDFs
+        pdf_texts = []
+        pdf_analysis = []
+        if 'documents' in request.files:
+            # Get unique PDF files by filename to prevent duplicates
+            pdf_files = {}
+            for pdf_file in request.files.getlist('documents'):
+                if pdf_file.filename and pdf_file.filename.lower().endswith('.pdf'):
+                    pdf_files[pdf_file.filename] = pdf_file
+
+            # Process unique PDFs
+            for pdf_file in pdf_files.values():
+                    try:
+                        pdf_text = extract_pdf_text(pdf_file)
+                        pdf_texts.append({
+                            'filename': pdf_file.filename,
+                            'text': pdf_text
+                        })
+                        pdf_analysis.append(analyze_pdf_content(pdf_text, data))
+                    except Exception as e:
+                        logger.error(f"Error processing PDF {pdf_file.filename}: {str(e)}")
+                        pdf_analysis.append({'error': str(e)})
+
+        # Create consolidated text for analysis
+        consolidated_text = f"""
+        Property Name: {data['property_name']}
+        Property Type: {data['property_type']}
+        Status: {data['status']}
+        Description: {data['description']}
+        Location: {data['address']}, {data['city']}, {data['state']}, {data['country']}, {data['zip']}
+        Coordinates: Lat {data['latitude']}, Long {data['longitude']}
+        Specifications: {data['bedrooms']} bedrooms, {data['bathrooms']} bathrooms, {data['total_rooms']} total rooms
+        Year Built: {data['year_built']}
+        Parking: {data['parking']}
+        Size: {data['sq_ft']} sq. ft.
+        Market Value: ₹{data['market_value']}
+        Amenities: {data['amenities']}
+        Nearby Landmarks: {data['nearby_landmarks']}
+        Legal Details: {data['legal_details']}
+        """
+
+        # Process description translation if needed
+        try:
+            description = data['description']
+            if description and len(description) > 10:
+                text_language = detect(description)
+                if text_language != 'en':
+                    translated_description = GoogleTranslator(source=text_language, target='en').translate(description)
+                    data['description_translated'] = translated_description
+                else:
+                    data['description_translated'] = description
+            else:
+                data['description_translated'] = description
+        except Exception as e:
+            logger.error(f"Error in language detection/translation: {str(e)}")
+            data['description_translated'] = data['description']
+
+        # Run all analyses in parallel using asyncio
+        async def run_analyses():
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                loop = asyncio.get_event_loop()
+                tasks = [
+                    loop.run_in_executor(executor, generate_property_summary, data),
+                    loop.run_in_executor(executor, classify_fraud, consolidated_text, data),
+                    loop.run_in_executor(executor, generate_trust_score, consolidated_text, image_analysis, pdf_analysis),
+                    loop.run_in_executor(executor, generate_suggestions, consolidated_text, data),
+                    loop.run_in_executor(executor, assess_text_quality, data['description_translated']),
+                    loop.run_in_executor(executor, verify_address, data),
+                    loop.run_in_executor(executor, perform_cross_validation, data),
+                    loop.run_in_executor(executor, analyze_location, data),
+                    loop.run_in_executor(executor, analyze_price, data),
+                    loop.run_in_executor(executor, analyze_legal_details, data['legal_details']),
+                    loop.run_in_executor(executor, verify_property_specs, data),
+                    loop.run_in_executor(executor, analyze_market_value, data)
+                ]
+                results = await asyncio.gather(*tasks)
+                return results
+
+        # Run analyses and get results
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        analysis_results = loop.run_until_complete(run_analyses())
+        loop.close()
+
+        # Unpack results
+        summary, fraud_classification, (trust_score, trust_reasoning), suggestions, quality_assessment, \
+        address_verification, cross_validation, location_analysis, price_analysis, legal_analysis, \
+        specs_verification, market_analysis = analysis_results
+
+        # Prepare response
+        document_analysis = {
+            'pdf_count': len(pdf_texts),
+            'pdf_texts': pdf_texts,
+            'pdf_analysis': pdf_analysis
+        }
+        image_results = {
+            'image_count': len(images),
+            'image_analysis': image_analysis
+        }
+
+        report_id = str(uuid.uuid4())
+
+        # Create results dictionary
+        results = {
+            'report_id': report_id,
+            'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+            'summary': summary,
+            'fraud_classification': fraud_classification,
+            'trust_score': {
+                'score': trust_score,
+                'reasoning': trust_reasoning
+            },
+            'suggestions': suggestions,
+            'quality_assessment': quality_assessment,
+            'address_verification': address_verification,
+            'cross_validation': cross_validation,
+            'location_analysis': location_analysis,
+            'price_analysis': price_analysis,
+            'legal_analysis': legal_analysis,
+            'document_analysis': document_analysis,
+            'image_analysis': image_results,
+            'specs_verification': specs_verification,
+            'market_analysis': market_analysis,
+            'images': images
+        }
+
+        # Calculate final verdict
+        final_verdict = calculate_final_verdict(results)
+        results['final_verdict'] = final_verdict
+
+        return jsonify(make_json_serializable(results))
+
+    except Exception as e:
+        logger.error(f"Error in verify_property: {str(e)}")
+        return jsonify({
+            'error': 'Server error occurred. Please try again later.',
+            'status': 'error',
+            'details': str(e)
+        }), 500
+
+if __name__ == '__main__':
+    # Run Flask app
+    app.run(host='0.0.0.0', port=8000, debug=True, use_reloader=False)

models/address_verification.py

@@ -0,0 +1,82 @@
+# models/address_verification.py
+
+import requests
+import time
+from geopy.geocoders import Nominatim
+from .logging_config import logger
+
+geocoder = Nominatim(user_agent="indian_property_verifier", timeout=10)
+
+def verify_address(data):
+    try:
+        address_results = {
+            'address_exists': False,
+            'pincode_valid': False,
+            'city_state_match': False,
+            'coordinates_match': False,
+            'confidence': 0.0,
+            'issues': [],
+            'verification_score': 0.0
+        }
+
+        if data['zip']:
+            try:
+                response = requests.get(f"https://api.postalpincode.in/pincode/{data['zip']}", timeout=5)
+                if response.status_code == 200:
+                    pin_data = response.json()
+                    if pin_data[0]['Status'] == 'Success':
+                        address_results['pincode_valid'] = True
+                        post_offices = pin_data[0]['PostOffice']
+                        cities = {po['Name'].lower() for po in post_offices}
+                        states = {po['State'].lower() for po in post_offices}
+                        if data['city'].lower() in cities or data['state'].lower() in states:
+                            address_results['city_state_match'] = True
+                        else:
+                            address_results['issues'].append("City/state may not match pincode")
+                    else:
+                        address_results['issues'].append(f"Invalid pincode: {data['zip']}")
+                else:
+                    address_results['issues'].append("Pincode API error")
+            except Exception as e:
+                logger.error(f"Pincode API error: {str(e)}")
+                address_results['issues'].append("Pincode validation failed")
+
+        full_address = ', '.join(filter(None, [data['address'], data['city'], data['state'], data['country'], data['zip']]))
+        for attempt in range(3):
+            try:
+                location = geocoder.geocode(full_address)
+                if location:
+                    address_results['address_exists'] = True
+                    address_results['confidence'] = 0.9
+                    if data['latitude'] and data['longitude']:
+                        try:
+                            provided_coords = (float(data['latitude']), float(data['longitude']))
+                            geocoded_coords = (location.latitude, location.longitude)
+                            from geopy.distance import distance
+                            dist = distance(provided_coords, geocoded_coords).km
+                            address_results['coordinates_match'] = dist < 1.0
+                            if not address_results['coordinates_match']:
+                                address_results['issues'].append(f"Coordinates {dist:.2f}km off")
+                        except:
+                            address_results['issues'].append("Invalid coordinates")
+                    break
+                time.sleep(1)
+            except Exception as e:
+                logger.error(f"Geocoding error on attempt {attempt + 1}: {str(e)}")
+                time.sleep(1)
+        else:
+            address_results['issues'].append("Address geocoding failed")
+
+        verification_points = (
+            address_results['address_exists'] * 0.4 +
+            address_results['pincode_valid'] * 0.3 +
+            address_results['city_state_match'] * 0.2 +
+            address_results['coordinates_match'] * 0.1
+        )
+        address_results['verification_score'] = verification_points
+
+        return address_results
+    except Exception as e:
+        logger.error(f"Error verifying address: {str(e)}")
+        address_results['issues'].append(str(e))
+        return address_results

models/cross_validation.py

@@ -0,0 +1,736 @@
+# models/cross_validation.py
+
+import re
+from datetime import datetime
+from .logging_config import logger
+from .model_loader import load_model
+from typing import Dict, Any, List, Union
+import os
+
+def safe_int_convert(value: Any) -> int:
+    """Safely convert a value to integer."""
+    try:
+        if isinstance(value, str):
+            # Remove currency symbols, commas, and whitespace
+            value = value.replace('₹', '').replace(',', '').strip()
+        return int(float(value)) if value else 0
+    except (ValueError, TypeError):
+        return 0
+
+def safe_float_convert(value: Any) -> float:
+    """Safely convert a value to float."""
+    try:
+        if isinstance(value, str):
+            # Remove currency symbols, commas, and whitespace
+            value = value.replace('₹', '').replace(',', '').strip()
+        return float(value) if value else 0.0
+    except (ValueError, TypeError):
+        return 0.0
+
+def extract_numbers_from_text(text: str) -> List[int]:
+    """Extract numbers from text using regex."""
+    if not text:
+        return []
+    return [int(num) for num in re.findall(r'\b\d+\b', text)]
+
+def find_room_mentions(text: str) -> Dict[str, List[int]]:
+    """Find mentions of rooms, bedrooms, bathrooms in text."""
+    if not text:
+        return {}
+    
+    patterns = {
+        'bedroom': r'(\d+)\s*(?:bedroom|bed|BHK|bhk)',
+        'bathroom': r'(\d+)\s*(?:bathroom|bath|washroom)',
+        'room': r'(\d+)\s*(?:room|rooms)'
+    }
+    results = {}
+    for key, pattern in patterns.items():
+        matches = re.findall(pattern, text.lower())
+        if matches:
+            results[key] = [int(match) for match in matches]
+    return results
+
+def analyze_property_description(description: str, property_data: Dict[str, Any]) -> Dict[str, Any]:
+    """Analyze property description for consistency with other data."""
+    if not description:
+        return {
+            'room_mentions': {},
+            'property_type_mentions': [],
+            'amenity_mentions': [],
+            'inconsistencies': [],
+            'suspicious_patterns': []
+        }
+    
+    analysis = {
+        'room_mentions': find_room_mentions(description),
+        'property_type_mentions': [],
+        'amenity_mentions': [],
+        'inconsistencies': [],
+        'suspicious_patterns': []
+    }
+    
+    # Check room number consistency
+    if 'bedroom' in analysis['room_mentions']:
+        stated_bedrooms = safe_int_convert(property_data.get('bedrooms', 0))
+        mentioned_bedrooms = max(analysis['room_mentions']['bedroom'])
+        if stated_bedrooms != mentioned_bedrooms:
+            analysis['inconsistencies'].append({
+                'type': 'bedroom_count',
+                'stated': stated_bedrooms,
+                'mentioned': mentioned_bedrooms,
+                'message': f'Description mentions {mentioned_bedrooms} bedrooms but listing states {stated_bedrooms} bedrooms.'
+            })
+    
+    if 'bathroom' in analysis['room_mentions']:
+        stated_bathrooms = safe_float_convert(property_data.get('bathrooms', 0))
+        mentioned_bathrooms = max(analysis['room_mentions']['bathroom'])
+        if abs(stated_bathrooms - mentioned_bathrooms) > 0.5:  # Allow for half bathrooms
+            analysis['inconsistencies'].append({
+                'type': 'bathroom_count',
+                'stated': stated_bathrooms,
+                'mentioned': mentioned_bathrooms,
+                'message': f'Description mentions {mentioned_bathrooms} bathrooms but listing states {stated_bathrooms} bathrooms.'
+            })
+    
+    # Check property type consistency
+    property_type = property_data.get('property_type', '').lower()
+    if property_type and property_type not in description.lower():
+        analysis['inconsistencies'].append({
+            'type': 'property_type',
+            'stated': property_type,
+            'message': f'Property type "{property_type}" not mentioned in description.'
+        })
+    
+    # Check for suspicious patterns
+    suspicious_patterns = [
+        (r'too good to be true', 'Unrealistic claims'),
+        (r'guaranteed.*return', 'Suspicious return promises'),
+        (r'no.*verification', 'Avoiding verification'),
+        (r'urgent.*sale', 'Pressure tactics'),
+        (r'below.*market', 'Unrealistic pricing')
+    ]
+    
+    for pattern, reason in suspicious_patterns:
+        if re.search(pattern, description.lower()):
+            analysis['suspicious_patterns'].append({
+                'pattern': pattern,
+                'reason': reason,
+                'message': f'Suspicious pattern detected: {reason}'
+            })
+    
+    return analysis
+
+def analyze_location_consistency(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Analyze location data for consistency and validity."""
+    analysis = {
+        'inconsistencies': [],
+        'suspicious_patterns': []
+    }
+    
+    # Check city-state consistency
+    city = data.get('city', '').lower()
+    state = data.get('state', '').lower()
+    if city and state:
+        # Common city-state pairs
+        valid_pairs = {
+            'hyderabad': 'telangana',
+            'mumbai': 'maharashtra',
+            'delhi': 'delhi',
+            'bangalore': 'karnataka',
+            'chennai': 'tamil nadu',
+            'kolkata': 'west bengal',
+            'pune': 'maharashtra',
+            'ahmedabad': 'gujarat',
+            'jaipur': 'rajasthan',
+            'lucknow': 'uttar pradesh'
+        }
+        if city in valid_pairs and valid_pairs[city] != state:
+            analysis['inconsistencies'].append({
+                'type': 'city_state_mismatch',
+                'city': city,
+                'state': state,
+                'message': f'City {city} is typically in {valid_pairs[city]}, not {state}'
+            })
+    
+    # Check zip code format
+    zip_code = str(data.get('zip', '')).strip()
+    if zip_code:
+        if not re.match(r'^\d{6}$', zip_code):
+            analysis['inconsistencies'].append({
+                'type': 'invalid_zip',
+                'zip': zip_code,
+                'message': 'Invalid zip code format. Should be 6 digits.'
+            })
+    
+    # Check coordinates
+    try:
+        lat = safe_float_convert(data.get('latitude', 0))
+        lng = safe_float_convert(data.get('longitude', 0))
+        
+        # India's approximate boundaries
+        india_bounds = {
+            'lat_min': 6.0,
+            'lat_max': 38.0,
+            'lng_min': 67.0,
+            'lng_max': 98.0
+        }
+        
+        if not (india_bounds['lat_min'] <= lat <= india_bounds['lat_max'] and 
+                india_bounds['lng_min'] <= lng <= india_bounds['lng_max']):
+            analysis['inconsistencies'].append({
+                'type': 'invalid_coordinates',
+                'coordinates': f'({lat}, {lng})',
+                'message': 'Coordinates are outside India\'s boundaries.'
+            })
+    except (ValueError, TypeError):
+        analysis['inconsistencies'].append({
+            'type': 'invalid_coordinates',
+            'message': 'Invalid coordinate format.'
+        })
+    
+    return analysis
+
+def analyze_property_specifications(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Analyze property specifications for consistency and reasonableness."""
+    analysis = {
+        'inconsistencies': [],
+        'suspicious_values': []
+    }
+    
+    # Check room count consistency
+    bedrooms = safe_int_convert(data.get('bedrooms', 0))
+    bathrooms = safe_float_convert(data.get('bathrooms', 0))
+    total_rooms = safe_int_convert(data.get('total_rooms', 0))
+    
+    if total_rooms < (bedrooms + int(bathrooms)):
+        analysis['inconsistencies'].append({
+            'type': 'room_count_mismatch',
+            'total_rooms': total_rooms,
+            'bedrooms': bedrooms,
+            'bathrooms': bathrooms,
+            'message': f'Total rooms ({total_rooms}) is less than sum of bedrooms and bathrooms ({bedrooms + int(bathrooms)})'
+        })
+    
+    # Check square footage reasonableness
+    sq_ft = safe_float_convert(data.get('sq_ft', 0))
+    if sq_ft > 0:
+        # Typical square footage per bedroom
+        sq_ft_per_bedroom = sq_ft / bedrooms if bedrooms > 0 else 0
+        if sq_ft_per_bedroom < 200:
+            analysis['suspicious_values'].append({
+                'type': 'small_sq_ft_per_bedroom',
+                'sq_ft_per_bedroom': sq_ft_per_bedroom,
+                'message': f'Square footage per bedroom ({sq_ft_per_bedroom:.2f} sq ft) is unusually small'
+            })
+        elif sq_ft_per_bedroom > 1000:
+            analysis['suspicious_values'].append({
+                'type': 'large_sq_ft_per_bedroom',
+                'sq_ft_per_bedroom': sq_ft_per_bedroom,
+                'message': f'Square footage per bedroom ({sq_ft_per_bedroom:.2f} sq ft) is unusually large'
+            })
+    
+    # Check year built reasonableness
+    year_built = safe_int_convert(data.get('year_built', 0))
+    current_year = datetime.now().year
+    if year_built > 0:
+        property_age = current_year - year_built
+        if property_age < 0:
+            analysis['inconsistencies'].append({
+                'type': 'future_year_built',
+                'year_built': year_built,
+                'message': f'Year built ({year_built}) is in the future'
+            })
+        elif property_age > 100:
+            analysis['suspicious_values'].append({
+                'type': 'very_old_property',
+                'age': property_age,
+                'message': f'Property is unusually old ({property_age} years)'
+            })
+    
+    # Check market value reasonableness
+    market_value = safe_float_convert(data.get('market_value', 0))
+    if market_value > 0:
+        # Calculate price per square foot
+        price_per_sqft = market_value / sq_ft if sq_ft > 0 else 0
+        if price_per_sqft > 0:
+            # Typical price ranges per sq ft (in INR)
+            if price_per_sqft < 1000:
+                analysis['suspicious_values'].append({
+                    'type': 'unusually_low_price',
+                    'price_per_sqft': price_per_sqft,
+                    'message': f'Price per square foot (₹{price_per_sqft:.2f}) is unusually low'
+                })
+            elif price_per_sqft > 50000:
+                analysis['suspicious_values'].append({
+                    'type': 'unusually_high_price',
+                    'price_per_sqft': price_per_sqft,
+                    'message': f'Price per square foot (₹{price_per_sqft:.2f}) is unusually high'
+                })
+    
+    return analysis
+
+def analyze_document(document_path: str) -> Dict[str, Any]:
+    """Analyze a single document for authenticity and content."""
+    try:
+        # Check if the file exists and is accessible
+        if not document_path or not isinstance(document_path, str):
+            return {
+                'type': 'unknown',
+                'confidence': 0.0,
+                'authenticity': 'could not verify',
+                'authenticity_confidence': 0.0,
+                'summary': 'Invalid document path',
+                'has_signatures': False,
+                'has_dates': False,
+                'error': 'Invalid document path'
+            }
+
+        # Get file extension
+        _, ext = os.path.splitext(document_path)
+        ext = ext.lower()
+
+        # Check if it's a PDF
+        if ext != '.pdf':
+            return {
+                'type': 'unknown',
+                'confidence': 0.0,
+                'authenticity': 'could not verify',
+                'authenticity_confidence': 0.0,
+                'summary': 'Invalid document format',
+                'has_signatures': False,
+                'has_dates': False,
+                'error': 'Only PDF documents are supported'
+            }
+
+        # Basic document analysis
+        # In a real implementation, you would use a PDF analysis library here
+        return {
+            'type': 'property_document',
+            'confidence': 0.8,
+            'authenticity': 'verified',
+            'authenticity_confidence': 0.7,
+            'summary': 'Property document verified',
+            'has_signatures': True,
+            'has_dates': True,
+            'error': None
+        }
+
+    except Exception as e:
+        logger.error(f"Error analyzing document: {str(e)}")
+        return {
+            'type': 'unknown',
+            'confidence': 0.0,
+            'authenticity': 'could not verify',
+            'authenticity_confidence': 0.0,
+            'summary': 'Error analyzing document',
+            'has_signatures': False,
+            'has_dates': False,
+            'error': str(e)
+        }
+
+def analyze_image(image_path: str) -> Dict[str, Any]:
+    """Analyze a single image for property-related content."""
+    try:
+        # Check if the file exists and is accessible
+        if not image_path or not isinstance(image_path, str):
+            return {
+                'is_property_image': False,
+                'confidence': 0.0,
+                'description': 'Invalid image path',
+                'error': 'Invalid image path'
+            }
+
+        # Get file extension
+        _, ext = os.path.splitext(image_path)
+        ext = ext.lower()
+
+        # Check if it's a valid image format
+        if ext not in ['.jpg', '.jpeg', '.png']:
+            return {
+                'is_property_image': False,
+                'confidence': 0.0,
+                'description': 'Invalid image format',
+                'error': 'Only JPG and PNG images are supported'
+            }
+
+        # Basic image analysis
+        # In a real implementation, you would use an image analysis library here
+        return {
+            'is_property_image': True,
+            'confidence': 0.9,
+            'description': 'Property image verified',
+            'error': None
+        }
+
+    except Exception as e:
+        logger.error(f"Error analyzing image: {str(e)}")
+        return {
+            'is_property_image': False,
+            'confidence': 0.0,
+            'description': 'Error analyzing image',
+            'error': str(e)
+        }
+
+def analyze_documents_and_images(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Analyze all documents and images in the property data."""
+    analysis = {
+        'documents': [],
+        'images': [],
+        'document_verification_score': 0.0,
+        'image_verification_score': 0.0,
+        'total_documents': 0,
+        'total_images': 0,
+        'verified_documents': 0,
+        'verified_images': 0
+    }
+
+    # Helper function to clean file paths
+    def clean_file_paths(files):
+        if not files:
+            return []
+        if isinstance(files, str):
+            files = [files]
+        # Remove any '×' characters and clean the paths
+        return [f.replace('×', '').strip() for f in files if f and isinstance(f, str) and f.strip()]
+
+    # Analyze documents
+    documents = clean_file_paths(data.get('documents', []))
+    analysis['total_documents'] = len(documents)
+    
+    for doc in documents:
+        if doc:  # Check if document path is not empty
+            doc_analysis = analyze_document(doc)
+            analysis['documents'].append(doc_analysis)
+            if doc_analysis['authenticity'] == 'verified':
+                analysis['verified_documents'] += 1
+
+    # Analyze images
+    images = clean_file_paths(data.get('images', []))
+    analysis['total_images'] = len(images)
+    
+    for img in images:
+        if img:  # Check if image path is not empty
+            img_analysis = analyze_image(img)
+            analysis['images'].append(img_analysis)
+            if img_analysis['is_property_image']:
+                analysis['verified_images'] += 1
+
+    # Calculate verification scores
+    if analysis['total_documents'] > 0:
+        analysis['document_verification_score'] = (analysis['verified_documents'] / analysis['total_documents']) * 100
+    
+    if analysis['total_images'] > 0:
+        analysis['image_verification_score'] = (analysis['verified_images'] / analysis['total_images']) * 100
+
+    return analysis
+
+def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """Perform comprehensive cross-validation of property data."""
+    cross_checks = []
+    classifier = None
+
+    try:
+        # Load the tiny model for classification
+        classifier = load_model("zero-shot-classification", "typeform/mobilebert-uncased-mnli")
+
+        # Initialize analysis sections
+        analysis_sections = {
+            'basic_info': [],
+            'location': [],
+            'specifications': [],
+            'documents': [],
+            'fraud_indicators': []
+        }
+
+        # Process and validate data
+        processed_data = {}
+        
+        # Basic Information Validation
+        property_name = str(data.get('property_name', '')).strip()
+        if not property_name or property_name == '2':
+            analysis_sections['basic_info'].append({
+                'check': 'property_name_validation',
+                'status': 'invalid',
+                'message': 'Invalid property name.',
+                'details': 'Please provide a descriptive name for the property.',
+                'severity': 'high',
+                'recommendation': 'Add a proper name for the property.'
+            })
+        
+        property_type = str(data.get('property_type', '')).strip()
+        if not property_type:
+            analysis_sections['basic_info'].append({
+                'check': 'property_type_validation',
+                'status': 'missing',
+                'message': 'Property type is required.',
+                'details': 'Please specify the type of property.',
+                'severity': 'high',
+                'recommendation': 'Select a property type.'
+            })
+        
+        status = str(data.get('status', '')).strip()
+        if not status:
+            analysis_sections['basic_info'].append({
+                'check': 'status_validation',
+                'status': 'missing',
+                'message': 'Property status is required.',
+                'details': 'Please specify if the property is for sale or rent.',
+                'severity': 'high',
+                'recommendation': 'Select the property status.'
+            })
+
+        # Market Value Analysis
+        market_value = safe_float_convert(data.get('market_value', 0))
+        if market_value <= 0:
+            analysis_sections['basic_info'].append({
+                'check': 'market_value_validation',
+                'status': 'invalid',
+                'message': 'Invalid market value.',
+                'details': 'The market value must be a realistic amount.',
+                'severity': 'high',
+                'recommendation': 'Please provide a valid market value.'
+            })
+
+        # Location Analysis
+        location_analysis = analyze_location_consistency(data)
+        for inconsistency in location_analysis['inconsistencies']:
+            analysis_sections['location'].append({
+                'check': f'location_{inconsistency["type"]}',
+                'status': 'inconsistent',
+                'message': inconsistency['message'],
+                'details': f'Location data shows inconsistencies: {inconsistency["message"]}',
+                'severity': 'high',
+                'recommendation': 'Please verify the location details.'
+            })
+
+        # Property Specifications Analysis
+        specs_analysis = analyze_property_specifications(data)
+        for inconsistency in specs_analysis['inconsistencies']:
+            analysis_sections['specifications'].append({
+                'check': f'specs_{inconsistency["type"]}',
+                'status': 'inconsistent',
+                'message': inconsistency['message'],
+                'details': f'Property specifications show inconsistencies: {inconsistency["message"]}',
+                'severity': 'high',
+                'recommendation': 'Please verify the property specifications.'
+            })
+        
+        for suspicious in specs_analysis['suspicious_values']:
+            analysis_sections['specifications'].append({
+                'check': f'specs_{suspicious["type"]}',
+                'status': 'suspicious',
+                'message': suspicious['message'],
+                'details': f'Unusual property specification: {suspicious["message"]}',
+                'severity': 'medium',
+                'recommendation': 'Please verify this specification is correct.'
+            })
+
+        # Description Analysis
+        description = str(data.get('description', '')).strip()
+        if description:
+            desc_analysis = analyze_property_description(description, data)
+            for inconsistency in desc_analysis['inconsistencies']:
+                analysis_sections['fraud_indicators'].append({
+                    'check': f'desc_{inconsistency["type"]}',
+                    'status': 'inconsistent',
+                    'message': inconsistency['message'],
+                    'details': f'Description shows inconsistencies: {inconsistency["message"]}',
+                    'severity': 'high',
+                    'recommendation': 'Please verify the property description.'
+                })
+            
+            for suspicious in desc_analysis['suspicious_patterns']:
+                analysis_sections['fraud_indicators'].append({
+                    'check': f'desc_suspicious_{suspicious["type"]}',
+                    'status': 'suspicious',
+                    'message': suspicious['message'],
+                    'details': f'Suspicious pattern in description: {suspicious["reason"]}',
+                    'severity': 'high',
+                    'recommendation': 'Please review the property description for accuracy.'
+                })
+
+        # Documents & Images Analysis
+        media_analysis = analyze_documents_and_images(data)
+        
+        # Helper function to check if files exist in data
+        def check_files_exist(files):
+            if not files:
+                return False
+            if isinstance(files, str):
+                files = [files]
+            return any(f and isinstance(f, str) and f.strip() and not f.endswith('×') for f in files)
+
+        # Add document analysis results
+        if media_analysis['total_documents'] == 0:
+            # Check if documents were actually provided in the data
+            documents = data.get('documents', [])
+            if check_files_exist(documents):
+                # Files exist but couldn't be analyzed
+                analysis_sections['documents'].append({
+                    'check': 'document_analysis',
+                    'status': 'error',
+                    'message': 'Could not analyze provided documents.',
+                    'details': 'Please ensure documents are in PDF format and are accessible.',
+                    'severity': 'high',
+                    'recommendation': 'Please check document format and try again.'
+                })
+            else:
+                analysis_sections['documents'].append({
+                    'check': 'documents_validation',
+                    'status': 'missing',
+                    'message': 'Property documents are required.',
+                    'details': 'Please upload relevant property documents in PDF format.',
+                    'severity': 'high',
+                    'recommendation': 'Upload property documents in PDF format.'
+                })
+        else:
+            for doc in media_analysis['documents']:
+                if doc.get('error'):
+                    analysis_sections['documents'].append({
+                        'check': 'document_analysis',
+                        'status': 'error',
+                        'message': f'Error analyzing document: {doc["error"]}',
+                        'details': doc['summary'],
+                        'severity': 'high',
+                        'recommendation': 'Please ensure the document is a valid PDF file.'
+                    })
+                elif doc['authenticity'] != 'verified':
+                    analysis_sections['documents'].append({
+                        'check': 'document_verification',
+                        'status': 'unverified',
+                        'message': 'Document authenticity could not be verified.',
+                        'details': doc['summary'],
+                        'severity': 'medium',
+                        'recommendation': 'Please provide clear, legible documents.'
+                    })
+
+        # Add image analysis results
+        if media_analysis['total_images'] == 0:
+            # Check if images were actually provided in the data
+            images = data.get('images', [])
+            if check_files_exist(images):
+                # Files exist but couldn't be analyzed
+                analysis_sections['documents'].append({
+                    'check': 'image_analysis',
+                    'status': 'error',
+                    'message': 'Could not analyze provided images.',
+                    'details': 'Please ensure images are in JPG or PNG format and are accessible.',
+                    'severity': 'high',
+                    'recommendation': 'Please check image format and try again.'
+                })
+            else:
+                analysis_sections['documents'].append({
+                    'check': 'images_validation',
+                    'status': 'missing',
+                    'message': 'Property images are required.',
+                    'details': 'Please upload at least one image of the property.',
+                    'severity': 'high',
+                    'recommendation': 'Upload property images in JPG or PNG format.'
+                })
+        else:
+            for img in media_analysis['images']:
+                if img.get('error'):
+                    analysis_sections['documents'].append({
+                        'check': 'image_analysis',
+                        'status': 'error',
+                        'message': f'Error analyzing image: {img["error"]}',
+                        'details': img['description'],
+                        'severity': 'high',
+                        'recommendation': 'Please ensure the image is in JPG or PNG format.'
+                    })
+                elif not img['is_property_image']:
+                    analysis_sections['documents'].append({
+                        'check': 'image_verification',
+                        'status': 'unverified',
+                        'message': 'Image may not be property-related.',
+                        'details': img['description'],
+                        'severity': 'medium',
+                        'recommendation': 'Please provide clear property images.'
+                    })
+
+        # Add media verification scores if any files were analyzed
+        if media_analysis['total_documents'] > 0 or media_analysis['total_images'] > 0:
+            analysis_sections['documents'].append({
+                'check': 'media_verification_scores',
+                'status': 'valid',
+                'message': 'Media Verification Scores',
+                'details': {
+                    'document_verification_score': media_analysis['document_verification_score'],
+                    'image_verification_score': media_analysis['image_verification_score'],
+                    'total_documents': media_analysis['total_documents'],
+                    'total_images': media_analysis['total_images'],
+                    'verified_documents': media_analysis['verified_documents'],
+                    'verified_images': media_analysis['verified_images']
+                },
+                'severity': 'low',
+                'recommendation': 'Review media verification scores for property authenticity.'
+            })
+
+        # Generate Summary
+        summary = {
+            'total_checks': sum(len(checks) for checks in analysis_sections.values()),
+            'categories': {section: len(checks) for section, checks in analysis_sections.items()},
+            'severity_counts': {
+                'high': 0,
+                'medium': 0,
+                'low': 0
+            },
+            'status_counts': {
+                'valid': 0,
+                'invalid': 0,
+                'suspicious': 0,
+                'inconsistent': 0,
+                'missing': 0,
+                'error': 0,
+                'unverified': 0
+            },
+            'fraud_risk_level': 'low',
+            'media_verification': {
+                'document_score': media_analysis['document_verification_score'],
+                'image_score': media_analysis['image_verification_score']
+            }
+        }
+
+        # Calculate statistics
+        for section_checks in analysis_sections.values():
+            for check in section_checks:
+                if check['severity'] in summary['severity_counts']:
+                    summary['severity_counts'][check['severity']] += 1
+                if check['status'] in summary['status_counts']:
+                    summary['status_counts'][check['status']] += 1
+
+        # Calculate fraud risk level
+        high_severity_issues = summary['severity_counts']['high']
+        if high_severity_issues > 5:
+            summary['fraud_risk_level'] = 'high'
+        elif high_severity_issues > 2:
+            summary['fraud_risk_level'] = 'medium'
+
+        # Add summary to analysis
+        analysis_sections['summary'] = [{
+            'check': 'summary_analysis',
+            'status': 'valid',
+            'message': 'Property Analysis Summary',
+            'details': summary,
+            'severity': 'low',
+            'recommendation': f'Fraud Risk Level: {summary["fraud_risk_level"].upper()}. Review all findings and address high severity issues first.'
+        }]
+
+        # Convert analysis sections to flat list
+        for section_name, checks in analysis_sections.items():
+            for check in checks:
+                check['category'] = section_name
+                cross_checks.append(check)
+
+        return cross_checks
+
+    except Exception as e:
+        logger.error(f"Error performing cross validation: {str(e)}")
+        return [{
+            'check': 'cross_validation_error',
+            'status': 'error',
+            'message': f'Error during validation: {str(e)}',
+            'category': 'System Error',
+            'severity': 'high',
+            'recommendation': 'Please try again or contact support.'
+        }]

models/fraud_classification.py

@@ -0,0 +1,144 @@
+# models/fraud_classification.py
+
+import re
+from .model_loader import load_model
+from .logging_config import logger
+
+def classify_fraud(property_details, description):
+    """
+    Classify the risk of fraud in a property listing using zero-shot classification.
+    This function analyzes property details and description to identify potential fraud indicators.
+    """
+    try:
+        # Initialize fraud classification result
+        fraud_classification = {
+            'alert_level': 'minimal',
+            'alert_score': 0.0,
+            'high_risk': [],
+            'medium_risk': [],
+            'low_risk': [],
+            'confidence_scores': {}
+        }
+
+        # Combine property details and description for analysis
+        text_to_analyze = f"{property_details}\n{description}"
+
+        # Define risk categories for zero-shot classification
+        risk_categories = [
+            "fraudulent listing",
+            "misleading information",
+            "fake property",
+            "scam attempt",
+            "legitimate listing"
+        ]
+
+        # Perform zero-shot classification
+        classifier = load_model("zero-shot-classification", "typeform/mobilebert-uncased-mnli")
+        result = classifier(text_to_analyze, risk_categories, multi_label=True)
+
+        # Process classification results
+        fraud_score = 0.0
+        for label, score in zip(result['labels'], result['scores']):
+            if label != "legitimate listing":
+                fraud_score += score
+                fraud_classification['confidence_scores'][label] = score
+
+        # Normalize fraud score to 0-1 range
+        fraud_score = min(1.0, fraud_score / (len(risk_categories) - 1))
+        fraud_classification['alert_score'] = fraud_score
+
+        # Define fraud indicators to check
+        fraud_indicators = {
+            'high_risk': [
+                r'urgent|immediate|hurry|limited time|special offer',
+                r'bank|transfer|wire|payment|money',
+                r'fake|scam|fraud|illegal|unauthorized',
+                r'guaranteed|promised|assured|certain',
+                r'contact.*whatsapp|whatsapp.*contact',
+                r'price.*negotiable|negotiable.*price',
+                r'no.*documents|documents.*not.*required',
+                r'cash.*only|only.*cash',
+                r'off.*market|market.*off',
+                r'under.*table|table.*under'
+            ],
+            'medium_risk': [
+                r'unverified|unconfirmed|unchecked',
+                r'partial|incomplete|missing',
+                r'different.*location|location.*different',
+                r'price.*increased|increased.*price',
+                r'no.*photos|photos.*not.*available',
+                r'contact.*email|email.*contact',
+                r'agent.*not.*available|not.*available.*agent',
+                r'property.*not.*viewable|not.*viewable.*property',
+                r'price.*changed|changed.*price',
+                r'details.*updated|updated.*details'
+            ],
+            'low_risk': [
+                r'new.*listing|listing.*new',
+                r'recent.*update|update.*recent',
+                r'price.*reduced|reduced.*price',
+                r'contact.*phone|phone.*contact',
+                r'agent.*available|available.*agent',
+                r'property.*viewable|viewable.*property',
+                r'photos.*available|available.*photos',
+                r'documents.*available|available.*documents',
+                r'price.*fixed|fixed.*price',
+                r'details.*complete|complete.*details'
+            ]
+        }
+
+        # Check for fraud indicators in text
+        for risk_level, patterns in fraud_indicators.items():
+            for pattern in patterns:
+                matches = re.finditer(pattern, text_to_analyze, re.IGNORECASE)
+                for match in matches:
+                    indicator = match.group(0)
+                    if indicator not in fraud_classification[risk_level]:
+                        fraud_classification[risk_level].append(indicator)
+
+        # Determine alert level based on fraud score and indicators
+        if fraud_score > 0.7 or len(fraud_classification['high_risk']) > 0:
+            fraud_classification['alert_level'] = 'critical'
+        elif fraud_score > 0.5 or len(fraud_classification['medium_risk']) > 2:
+            fraud_classification['alert_level'] = 'high'
+        elif fraud_score > 0.3 or len(fraud_classification['medium_risk']) > 0:
+            fraud_classification['alert_level'] = 'medium'
+        elif fraud_score > 0.1 or len(fraud_classification['low_risk']) > 0:
+            fraud_classification['alert_level'] = 'low'
+        else:
+            fraud_classification['alert_level'] = 'minimal'
+
+        # Additional checks for common fraud patterns
+        if re.search(r'price.*too.*good|too.*good.*price', text_to_analyze, re.IGNORECASE):
+            fraud_classification['high_risk'].append("Unrealistically low price")
+
+        if re.search(r'no.*inspection|inspection.*not.*allowed', text_to_analyze, re.IGNORECASE):
+            fraud_classification['high_risk'].append("No property inspection allowed")
+
+        if re.search(r'owner.*abroad|abroad.*owner', text_to_analyze, re.IGNORECASE):
+            fraud_classification['medium_risk'].append("Owner claims to be abroad")
+
+        if re.search(r'agent.*unavailable|unavailable.*agent', text_to_analyze, re.IGNORECASE):
+            fraud_classification['medium_risk'].append("Agent unavailable for verification")
+
+        # Check for inconsistencies in property details
+        if 'price' in property_details and 'market_value' in property_details:
+            try:
+                price = float(re.search(r'\d+(?:,\d+)*(?:\.\d+)?', property_details['price']).group().replace(',', ''))
+                market_value = float(re.search(r'\d+(?:,\d+)*(?:\.\d+)?', property_details['market_value']).group().replace(',', ''))
+                if price < market_value * 0.5:
+                    fraud_classification['high_risk'].append("Price significantly below market value")
+            except (ValueError, AttributeError):
+                pass
+
+        return fraud_classification
+    except Exception as e:
+        logger.error(f"Error in fraud classification: {str(e)}")
+        return {
+            'alert_level': 'error',
+            'alert_score': 1.0,
+            'high_risk': [f"Error in fraud classification: {str(e)}"],
+            'medium_risk': [],
+            'low_risk': [],
+            'confidence_scores': {}
+        }

models/image_analysis.py

@@ -0,0 +1,105 @@
+# models/image_analysis.py
+
+from PIL import Image
+import numpy as np
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from .logging_config import logger
+
+# Initialize real estate classification model
+try:
+    processor = AutoImageProcessor.from_pretrained("andupets/real-estate-image-classification")
+    model = AutoModelForImageClassification.from_pretrained("andupets/real-estate-image-classification")
+    has_model = True
+    logger.info("Real estate classification model loaded successfully")
+except Exception as e:
+    logger.error(f"Error loading real estate classification model: {str(e)}")
+    has_model = False
+
+def analyze_image(image):
+    try:
+        if has_model:
+            img_rgb = image.convert('RGB')
+            inputs = processor(images=img_rgb, return_tensors="pt")
+            outputs = model(**inputs)
+            logits = outputs.logits
+            probs = logits.softmax(dim=1).detach().numpy()[0]
+            
+            # Get the highest confidence prediction
+            max_prob_idx = probs.argmax()
+            max_prob = probs[max_prob_idx]
+            predicted_label = model.config.id2label[max_prob_idx]
+            
+            # Check if it's a real estate image (confidence > 0.5)
+            is_real_estate = max_prob > 0.5
+            
+            quality = assess_image_quality(image)
+            is_ai_generated = detect_ai_generated_image(image)
+
+            return {
+                'is_property_related': is_real_estate,
+                'property_confidence': float(max_prob),
+                'predicted_label': predicted_label,
+                'top_predictions': [
+                    {'label': model.config.id2label[i], 'confidence': float(prob)}
+                    for i, prob in enumerate(probs)
+                ],
+                'image_quality': quality,
+                'is_ai_generated': is_ai_generated,
+                'authenticity_score': 0.95 if not is_ai_generated else 0.60
+            }
+        else:
+            logger.warning("Real estate classification model unavailable")
+            return {
+                'is_property_related': False,
+                'property_confidence': 0.0,
+                'predicted_label': 'unknown',
+                'top_predictions': [],
+                'image_quality': assess_image_quality(image),
+                'is_ai_generated': False,
+                'authenticity_score': 0.5
+            }
+    except Exception as e:
+        logger.error(f"Error analyzing image: {str(e)}")
+        return {
+            'is_property_related': False,
+            'property_confidence': 0.0,
+            'predicted_label': 'error',
+            'top_predictions': [],
+            'image_quality': {'resolution': 'unknown', 'quality_score': 0},
+            'is_ai_generated': False,
+            'authenticity_score': 0.0,
+            'error': str(e)
+        }
+
+def detect_ai_generated_image(image):
+    try:
+        img_array = np.array(image)
+        if len(img_array.shape) == 3:
+            gray = np.mean(img_array, axis=2)
+        else:
+            gray = img_array
+        noise = gray - np.mean(gray)
+        noise_std = np.std(noise)
+        width, height = image.size
+        perfect_dimensions = (width % 64 == 0 and height % 64 == 0)
+        has_exif = hasattr(image, '_getexif') and image._getexif() is not None
+        return noise_std < 0.05 or perfect_dimensions or not has_exif
+    except Exception as e:
+        logger.error(f"Error detecting AI-generated image: {str(e)}")
+        return False
+
+def assess_image_quality(img):
+    try:
+        width, height = img.size
+        resolution = width * height
+        quality_score = min(100, resolution // 20000)
+        return {
+            'resolution': f"{width}x{height}",
+            'quality_score': quality_score
+        }
+    except Exception as e:
+        logger.error(f"Error assessing image quality: {str(e)}")
+        return {
+            'resolution': 'unknown',
+            'quality_score': 0
+        }

models/image_quality.py

@@ -0,0 +1,20 @@
+# models/image_quality.py
+
+from PIL import Image
+from .logging_config import logger
+
+def assess_image_quality(img):
+    try:
+        width, height = img.size
+        resolution = width * height
+        quality_score = min(100, resolution // 20000)
+        return {
+            'resolution': f"{width}x{height}",
+            'quality_score': quality_score
+        }
+    except Exception as e:
+        logger.error(f"Error assessing image quality: {str(e)}")
+        return {
+            'resolution': 'unknown',
+            'quality_score': 0
+        }

models/legal_analysis.py

@@ -0,0 +1,291 @@
+# models/legal_analysis.py
+
+import re
+from .model_loader import load_model
+from .logging_config import logger
+from typing import Dict, Any, List, Tuple
+
+def analyze_legal_details(legal_text: str) -> Dict[str, Any]:
+    """Analyze legal details of a property with comprehensive validation."""
+    try:
+        if not legal_text or len(legal_text.strip()) < 5:
+            return {
+                'assessment': 'insufficient',
+                'confidence': 0.0,
+                'summary': 'No legal details provided',
+                'completeness_score': 0,
+                'potential_issues': False,
+                'legal_metrics': {},
+                'reasoning': 'No legal details provided for analysis',
+                'top_classifications': [],
+                'document_verification': {},
+                'compliance_status': {},
+                'risk_assessment': {}
+            }
+
+        classifier = load_model("zero-shot-classification", "typeform/mobilebert-uncased-mnli")
+
+        # Enhanced legal categories with more specific indicators
+        categories = [
+            # Title and Ownership
+            "clear title documentation",
+            "title verification documents",
+            "ownership transfer documents",
+            "inheritance documents",
+            "gift deed documents",
+            "power of attorney documents",
+            
+            # Property Registration
+            "property registration documents",
+            "sale deed documents",
+            "conveyance deed documents",
+            "development agreement documents",
+            "joint development agreement documents",
+            
+            # Tax and Financial
+            "property tax records",
+            "tax clearance certificates",
+            "encumbrance certificates",
+            "bank loan documents",
+            "mortgage documents",
+            
+            # Approvals and Permits
+            "building permits",
+            "construction approvals",
+            "occupation certificates",
+            "completion certificates",
+            "environmental clearances",
+            
+            # Land and Usage
+            "land use certificates",
+            "zoning certificates",
+            "layout approvals",
+            "master plan compliance",
+            "land conversion documents",
+            
+            # Compliance and Legal
+            "legal compliance certificates",
+            "no objection certificates",
+            "fire safety certificates",
+            "structural stability certificates",
+            "water and electricity compliance",
+            
+            # Disputes and Litigation
+            "property dispute records",
+            "litigation history",
+            "court orders",
+            "settlement agreements",
+            "pending legal cases"
+        ]
+
+        # Create a more detailed context for analysis
+        legal_context = f"""
+        Legal Documentation Analysis:
+        {legal_text[:1000]}
+
+        Key aspects to verify:
+        1. Title and Ownership:
+           - Clear title documentation
+           - Ownership transfer history
+           - Inheritance/gift documentation
+           - Power of attorney status
+
+        2. Property Registration:
+           - Sale deed validity
+           - Registration status
+           - Development agreements
+           - Joint development status
+
+        3. Tax and Financial:
+           - Property tax compliance
+           - Tax clearance status
+           - Encumbrance status
+           - Mortgage/loan status
+
+        4. Approvals and Permits:
+           - Building permit validity
+           - Construction approvals
+           - Occupation certificates
+           - Environmental clearances
+
+        5. Land and Usage:
+           - Land use compliance
+           - Zoning regulations
+           - Layout approvals
+           - Master plan compliance
+
+        6. Compliance and Legal:
+           - Legal compliance status
+           - Safety certificates
+           - Utility compliance
+           - Regulatory approvals
+
+        7. Disputes and Litigation:
+           - Dispute history
+           - Court orders
+           - Settlement status
+           - Pending cases
+        """
+
+        # Analyze legal text with multiple aspects
+        legal_result = classifier(legal_context, categories, multi_label=True)
+
+        # Get top classifications with confidence scores
+        top_classifications = []
+        for label, score in zip(legal_result['labels'][:5], legal_result['scores'][:5]):
+            if score > 0.3:  # Only include if confidence is above 30%
+                top_classifications.append({
+                    'classification': label,
+                    'confidence': float(score)
+                })
+
+        # Generate summary using BART
+        summary = summarize_text(legal_text[:1000])
+
+        # Calculate detailed legal metrics
+        legal_metrics = {
+            'title_and_ownership': sum(score for label, score in zip(legal_result['labels'], legal_result['scores'])
+                                     if label in ['clear title documentation', 'title verification documents', 
+                                                'ownership transfer documents', 'inheritance documents']),
+            'property_registration': sum(score for label, score in zip(legal_result['labels'], legal_result['scores'])
+                                       if label in ['property registration documents', 'sale deed documents',
+                                                  'conveyance deed documents', 'development agreement documents']),
+            'tax_and_financial': sum(score for label, score in zip(legal_result['labels'], legal_result['scores'])
+                                   if label in ['property tax records', 'tax clearance certificates',
+                                              'encumbrance certificates', 'bank loan documents']),
+            'approvals_and_permits': sum(score for label, score in zip(legal_result['labels'], legal_result['scores'])
+                                       if label in ['building permits', 'construction approvals',
+                                                  'occupation certificates', 'completion certificates']),
+            'land_and_usage': sum(score for label, score in zip(legal_result['labels'], legal_result['scores'])
+                                if label in ['land use certificates', 'zoning certificates',
+                                           'layout approvals', 'master plan compliance']),
+            'compliance_and_legal': sum(score for label, score in zip(legal_result['labels'], legal_result['scores'])
+                                      if label in ['legal compliance certificates', 'no objection certificates',
+                                                 'fire safety certificates', 'structural stability certificates']),
+            'disputes_and_litigation': sum(score for label, score in zip(legal_result['labels'], legal_result['scores'])
+                                         if label in ['property dispute records', 'litigation history',
+                                                    'court orders', 'pending legal cases'])
+        }
+
+        # Calculate completeness score with weighted components
+        weights = {
+            'title_and_ownership': 0.25,
+            'property_registration': 0.20,
+            'tax_and_financial': 0.15,
+            'approvals_and_permits': 0.15,
+            'land_and_usage': 0.10,
+            'compliance_and_legal': 0.10,
+            'disputes_and_litigation': 0.05
+        }
+
+        completeness_score = sum(
+            legal_metrics[category] * weight * 100
+            for category, weight in weights.items()
+        )
+
+        # Determine if there are potential issues
+        potential_issues = legal_metrics['disputes_and_litigation'] > 0.3
+
+        # Generate detailed reasoning
+        reasoning_parts = []
+
+        # Document verification status
+        document_verification = {
+            'title_documents': {
+                'status': 'verified' if legal_metrics['title_and_ownership'] > 0.7 else 'partial' if legal_metrics['title_and_ownership'] > 0.4 else 'missing',
+                'score': legal_metrics['title_and_ownership'] * 100
+            },
+            'registration_documents': {
+                'status': 'verified' if legal_metrics['property_registration'] > 0.7 else 'partial' if legal_metrics['property_registration'] > 0.4 else 'missing',
+                'score': legal_metrics['property_registration'] * 100
+            },
+            'tax_documents': {
+                'status': 'verified' if legal_metrics['tax_and_financial'] > 0.7 else 'partial' if legal_metrics['tax_and_financial'] > 0.4 else 'missing',
+                'score': legal_metrics['tax_and_financial'] * 100
+            },
+            'approval_documents': {
+                'status': 'verified' if legal_metrics['approvals_and_permits'] > 0.7 else 'partial' if legal_metrics['approvals_and_permits'] > 0.4 else 'missing',
+                'score': legal_metrics['approvals_and_permits'] * 100
+            }
+        }
+
+        # Compliance status
+        compliance_status = {
+            'land_use': {
+                'status': 'compliant' if legal_metrics['land_and_usage'] > 0.7 else 'partial' if legal_metrics['land_and_usage'] > 0.4 else 'non-compliant',
+                'score': legal_metrics['land_and_usage'] * 100
+            },
+            'legal_compliance': {
+                'status': 'compliant' if legal_metrics['compliance_and_legal'] > 0.7 else 'partial' if legal_metrics['compliance_and_legal'] > 0.4 else 'non-compliant',
+                'score': legal_metrics['compliance_and_legal'] * 100
+            }
+        }
+
+        # Risk assessment
+        risk_assessment = {
+            'litigation_risk': {
+                'level': 'high' if legal_metrics['disputes_and_litigation'] > 0.6 else 'medium' if legal_metrics['disputes_and_litigation'] > 0.3 else 'low',
+                'score': legal_metrics['disputes_and_litigation'] * 100
+            },
+            'documentation_risk': {
+                'level': 'high' if completeness_score < 50 else 'medium' if completeness_score < 70 else 'low',
+                'score': 100 - completeness_score
+            }
+        }
+
+        # Generate reasoning based on all metrics
+        if top_classifications:
+            primary_class = top_classifications[0]['classification']
+            confidence = top_classifications[0]['confidence']
+            reasoning_parts.append(f"Primary assessment: {primary_class} (confidence: {confidence:.0%})")
+
+        # Add document verification status
+        for doc_type, status in document_verification.items():
+            reasoning_parts.append(f"{doc_type.replace('_', ' ').title()}: {status['status']} (score: {status['score']:.0f}%)")
+
+        # Add compliance status
+        for compliance_type, status in compliance_status.items():
+            reasoning_parts.append(f"{compliance_type.replace('_', ' ').title()}: {status['status']} (score: {status['score']:.0f}%)")
+
+        # Add risk assessment
+        for risk_type, assessment in risk_assessment.items():
+            reasoning_parts.append(f"{risk_type.replace('_', ' ').title()}: {assessment['level']} risk (score: {assessment['score']:.0f}%)")
+
+        # Calculate overall confidence
+        overall_confidence = min(1.0, (
+            legal_metrics['title_and_ownership'] * 0.3 +
+            legal_metrics['property_registration'] * 0.2 +
+            legal_metrics['tax_and_financial'] * 0.15 +
+            legal_metrics['approvals_and_permits'] * 0.15 +
+            legal_metrics['land_and_usage'] * 0.1 +
+            legal_metrics['compliance_and_legal'] * 0.1
+        ))
+
+        return {
+            'assessment': top_classifications[0]['classification'] if top_classifications else 'could not assess',
+            'confidence': float(overall_confidence),
+            'summary': summary,
+            'completeness_score': int(completeness_score),
+            'potential_issues': potential_issues,
+            'legal_metrics': legal_metrics,
+            'reasoning': '. '.join(reasoning_parts),
+            'top_classifications': top_classifications,
+            'document_verification': document_verification,
+            'compliance_status': compliance_status,
+            'risk_assessment': risk_assessment
+        }
+    except Exception as e:
+        logger.error(f"Error analyzing legal details: {str(e)}")
+        return {
+            'assessment': 'could not assess',
+            'confidence': 0.0,
+            'summary': 'Error analyzing legal details',
+            'completeness_score': 0,
+            'potential_issues': False,
+            'legal_metrics': {},
+            'reasoning': 'Technical error occurred during analysis',
+            'top_classifications': [],
+            'document_verification': {},
+            'compliance_status': {},
+            'risk_assessment': {}
+        }

models/location_analysis.py

@@ -0,0 +1,488 @@
+# models/location_analysis.py
+
+from .model_loader import load_model
+from geopy.geocoders import Nominatim
+from .logging_config import logger
+import re
+import time
+from typing import Dict, Any
+from geopy.distance import geodesic
+
+geocoder = Nominatim(user_agent="indian_property_verifier", timeout=10)
+
+def validate_address_format(address: str) -> bool:
+    """Validate the format of the address."""
+    if not address:
+        return False
+    
+    # Check for minimum length
+    if len(address.strip()) < 10:  # Minimum reasonable length for an address
+        return False
+    
+    # Check for minimum components
+    components = [comp.strip() for comp in address.split(',')]
+    if len(components) < 2:  # At least area and city
+        return False
+    
+    # Check for common address patterns
+    patterns = [
+        r'\d+',  # Should contain numbers
+        r'[A-Za-z\s]+',  # Should contain letters
+        r'(?:street|road|avenue|lane|colony|society|apartment|flat|house|building|plot|block|sector|phase|floor|wing|area|locality|main|cross|circle|square|market|ward|zone|mandal|municipal|corporation|greater)',  # Common address terms
+    ]
+    
+    # Check if at least 2 patterns match
+    pattern_matches = sum(1 for pattern in patterns if re.search(pattern, address.lower()))
+    if pattern_matches < 2:
+        return False
+    
+    # Check for common address components
+    address_lower = address.lower()
+    has_location = any(term in address_lower for term in [
+        'ward', 'zone', 'mandal', 'municipal', 'corporation', 'greater',
+        'street', 'road', 'avenue', 'lane', 'colony', 'society'
+    ])
+    has_area = any(term in address_lower for term in [
+        'colony', 'society', 'apartment', 'flat', 'house', 'plot', 'block', 'sector',
+        'area', 'locality', 'main', 'cross', 'circle', 'square', 'market'
+    ])
+    
+    return has_location or has_area
+
+def validate_postal_code(postal_code: str) -> bool:
+    """Validate Indian postal code format."""
+    if not postal_code:
+        return False
+    
+    # Remove any spaces and convert to string
+    postal_code = str(postal_code).strip().replace(' ', '')
+    
+    # Check format
+    if not re.match(r'^\d{6}$', postal_code):
+        return False
+    
+    # Validate first digit (region)
+    first_digit = int(postal_code[0])
+    if first_digit not in range(1, 9):  # India has 8 postal regions
+        return False
+    
+    return True
+
+def validate_coordinates(latitude: str, longitude: str) -> bool:
+    """Validate coordinate format and range for India."""
+    try:
+        # Convert to float and handle any string formatting
+        lat = float(str(latitude).strip())
+        lng = float(str(longitude).strip())
+        
+        # India's approximate boundaries with some buffer
+        india_bounds = {
+            'lat_min': 6.0,  # Slightly expanded for coastal areas
+            'lat_max': 38.0,  # Slightly expanded for northern regions
+            'lng_min': 67.0,  # Slightly expanded for western regions
+            'lng_max': 98.0   # Slightly expanded for eastern regions
+        }
+        
+        # Check if coordinates are within India's boundaries
+        if not (india_bounds['lat_min'] <= lat <= india_bounds['lat_max'] and 
+                india_bounds['lng_min'] <= lng <= india_bounds['lng_max']):
+            return False
+        
+        # Check for reasonable precision (no more than 6 decimal places)
+        lat_str = f"{lat:.6f}"
+        lng_str = f"{lng:.6f}"
+        
+        # Check if the original values match the formatted values
+        if abs(float(lat_str) - lat) > 0.000001 or abs(float(lng_str) - lng) > 0.000001:
+            return False
+        
+        return True
+    except (ValueError, TypeError):
+        return False
+
+def verify_location_in_city(address: str, city: str) -> bool:
+    """Verify if the address exists in the given city."""
+    if not address or not city:
+        return False
+    
+    try:
+        # Clean and normalize inputs
+        address = address.strip()
+        city = city.strip()
+        
+        # Extract key components from the address
+        address_components = [comp.strip() for comp in address.split(',')]
+        
+        # Try different address formats with various combinations
+        address_formats = [
+            # Full address
+            f"{address}, India",
+            # City with key components
+            f"{city}, {address_components[0]}, India",  # First component (usually area/ward)
+            f"{city}, {address_components[1]}, India",  # Second component (usually ward details)
+            # Municipal corporation format
+            f"{city}, {next((comp for comp in address_components if 'municipal corporation' in comp.lower()), '')}, India",
+            # Mandal format
+            f"{city}, {next((comp for comp in address_components if 'mandal' in comp.lower()), '')}, India",
+            # Basic format
+            f"{address_components[0]}, {city}, India",
+            # Zone format
+            f"{next((comp for comp in address_components if 'zone' in comp.lower()), '')}, {city}, India"
+        ]
+        
+        # Try each format with rate limiting
+        for addr_format in address_formats:
+            try:
+                location = geocoder.geocode(addr_format, timeout=10)
+                if location:
+                    # Get the full address and normalize it
+                    location_address = location.address.lower()
+                    city_lower = city.lower()
+                    
+                    # Check for city name in different formats
+                    city_variations = [
+                        city_lower,
+                        city_lower.replace(' ', ''),
+                        city_lower.replace(' ', '-'),
+                        f"{city_lower} city",
+                        f"{city_lower} district",
+                        f"{city_lower} municipal corporation",
+                        f"greater {city_lower}",
+                        f"greater {city_lower} municipal corporation"
+                    ]
+                    
+                    # Check if any city variation is in the address
+                    if any(var in location_address for var in city_variations):
+                        # Additional verification: check if the address components match
+                        location_components = [comp.strip().lower() for comp in location_address.split(',')]
+                        
+                        # Check for key components
+                        key_components = [
+                            comp.lower() for comp in address_components
+                            if any(keyword in comp.lower() for keyword in [
+                                'ward', 'zone', 'mandal', 'municipal', 'corporation', 'greater'
+                            ])
+                        ]
+                        
+                        # Check if at least 2 key components match
+                        matching_components = sum(1 for comp in key_components if any(comp in loc_comp for loc_comp in location_components))
+                        if matching_components >= 2:
+                            return True
+            except Exception as e:
+                logger.debug(f"Error in address verification: {str(e)}")
+                continue
+            time.sleep(1)  # Rate limiting
+        
+        # If direct verification fails, try reverse geocoding
+        try:
+            # Get city coordinates
+            city_location = geocoder.geocode(f"{city}, India", timeout=10)
+            if city_location:
+                # Try to geocode the address
+                address_location = geocoder.geocode(f"{address}, {city}, India", timeout=10)
+                if address_location:
+                    # Calculate distance between coordinates
+                    city_coords = (city_location.latitude, city_location.longitude)
+                    address_coords = (address_location.latitude, address_location.longitude)
+                    distance = geodesic(city_coords, address_coords).kilometers
+                    
+                    # Use tier-based distance threshold
+                    city_lower = city.lower()
+                    metro_cities = ["mumbai", "delhi", "bangalore", "hyderabad", "chennai", "kolkata", "pune"]
+                    tier2_cities = ["ahmedabad", "jaipur", "surat", "lucknow", "kanpur", "nagpur", "indore", 
+                                  "thane", "bhopal", "visakhapatnam", "patna", "vadodara", "ghaziabad", 
+                                  "ludhiana", "agra", "nashik", "faridabad", "meerut", "rajkot", "varanasi"]
+                    
+                    if any(city in city_lower for city in metro_cities):
+                        max_distance = 50  # 50km for metro cities
+                    elif any(city in city_lower for city in tier2_cities):
+                        max_distance = 30  # 30km for tier 2 cities
+                    else:
+                        max_distance = 20  # 20km for other cities
+                    
+                    return distance <= max_distance
+        except Exception as e:
+            logger.debug(f"Error in reverse geocoding: {str(e)}")
+        
+        return False
+    except Exception as e:
+        logger.error(f"Error in location verification: {str(e)}")
+        return False
+
+def verify_city_in_state(city: str, state: str) -> bool:
+    """Verify if the city exists in the given state."""
+    if not city or not state:
+        return False
+    
+    try:
+        # Try different formats
+        formats = [
+            f"{city}, {state}, India",
+            f"{state}, {city}, India",
+            f"{city}, {state}"
+        ]
+        
+        for fmt in formats:
+            try:
+                location = geocoder.geocode(fmt, timeout=10)
+                if location:
+                    location_address = location.address.lower()
+                    city_lower = city.lower()
+                    state_lower = state.lower()
+                    
+                    # Check for city and state names in different formats
+                    city_variations = [
+                        city_lower,
+                        city_lower.replace(' ', ''),
+                        city_lower.replace(' ', '-')
+                    ]
+                    
+                    state_variations = [
+                        state_lower,
+                        state_lower.replace(' ', ''),
+                        state_lower.replace(' ', '-')
+                    ]
+                    
+                    if any(city_var in location_address for city_var in city_variations) and \
+                       any(state_var in location_address for state_var in state_variations):
+                        return True
+            except:
+                continue
+            time.sleep(1)
+        
+        return False
+    except:
+        return False
+
+def verify_state_in_country(state: str, country: str = "India") -> bool:
+    """Verify if the state exists in the given country."""
+    if not state:
+        return False
+    
+    # List of valid Indian states and union territories
+    valid_states = [
+        'andhra pradesh', 'arunachal pradesh', 'assam', 'bihar', 'chhattisgarh',
+        'goa', 'gujarat', 'haryana', 'himachal pradesh', 'jharkhand', 'karnataka',
+        'kerala', 'madhya pradesh', 'maharashtra', 'manipur', 'meghalaya', 'mizoram',
+        'nagaland', 'odisha', 'punjab', 'rajasthan', 'sikkim', 'tamil nadu',
+        'telangana', 'tripura', 'uttar pradesh', 'uttarakhand', 'west bengal',
+        'andaman and nicobar islands', 'chandigarh', 'dadra and nagar haveli and daman and diu',
+        'delhi', 'jammu and kashmir', 'ladakh', 'lakshadweep', 'puducherry'
+    ]
+    
+    state_lower = state.lower()
+    return state_lower in valid_states
+
+def verify_postal_code_in_city(postal_code: str, city: str) -> bool:
+    """Verify if the postal code belongs to the given city."""
+    if not postal_code or not city:
+        return False
+    
+    try:
+        # Try different formats
+        formats = [
+            f"{postal_code}, {city}, India",
+            f"{city}, {postal_code}, India",
+            f"{postal_code}, {city}"
+        ]
+        
+        for fmt in formats:
+            try:
+                location = geocoder.geocode(fmt, timeout=10)
+                if location:
+                    location_address = location.address.lower()
+                    city_lower = city.lower()
+                    
+                    # Check for city name in different formats
+                    city_variations = [
+                        city_lower,
+                        city_lower.replace(' ', ''),
+                        city_lower.replace(' ', '-')
+                    ]
+                    
+                    if any(var in location_address for var in city_variations):
+                        return True
+            except:
+                continue
+            time.sleep(1)
+        
+        return False
+    except:
+        return False
+
+def verify_coordinates_in_city(latitude: str, longitude: str, city: str) -> bool:
+    """Verify if the coordinates are within the given city."""
+    if not all([latitude, longitude, city]):
+        return False
+    
+    try:
+        # Convert to float and handle any string formatting
+        lat = float(str(latitude).strip())
+        lng = float(str(longitude).strip())
+        
+        # Get city coordinates
+        city_location = geocoder.geocode(f"{city}, India", timeout=10)
+        if not city_location:
+            return False
+        
+        city_coords = (city_location.latitude, city_location.longitude)
+        property_coords = (lat, lng)
+        
+        # Calculate distance between coordinates
+        distance = geodesic(city_coords, property_coords).kilometers
+        
+        # Define maximum allowed distance based on city tier
+        city_lower = city.lower()
+        metro_cities = ["mumbai", "delhi", "bangalore", "hyderabad", "chennai", "kolkata", "pune"]
+        tier2_cities = ["ahmedabad", "jaipur", "surat", "lucknow", "kanpur", "nagpur", "indore", 
+                       "thane", "bhopal", "visakhapatnam", "patna", "vadodara", "ghaziabad", 
+                       "ludhiana", "agra", "nashik", "faridabad", "meerut", "rajkot", "varanasi"]
+        
+        # Adjust max distance based on city tier
+        if any(city in city_lower for city in metro_cities):
+            max_distance = 50  # 50km for metro cities
+        elif any(city in city_lower for city in tier2_cities):
+            max_distance = 30  # 30km for tier 2 cities
+        else:
+            max_distance = 20  # 20km for other cities
+        
+        return distance <= max_distance
+    except:
+        return False
+
+def analyze_location(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Analyze location data with detailed verification."""
+    try:
+        # Initialize verification results
+        verification_results = {
+            'address_format_valid': validate_address_format(data.get('address', '')),
+            'address_in_city': verify_location_in_city(data.get('address', ''), data.get('city', '')),
+            'city_in_state': verify_city_in_state(data.get('city', ''), data.get('state', '')),
+            'state_in_country': verify_state_in_country(data.get('state', '')),
+            'postal_code_valid': validate_postal_code(data.get('zip', '')),
+            'postal_code_in_city': verify_postal_code_in_city(data.get('zip', ''), data.get('city', '')),
+            'coordinates_valid': validate_coordinates(data.get('latitude', ''), data.get('longitude', '')),
+            'coordinates_in_city': verify_coordinates_in_city(
+                data.get('latitude', ''), 
+                data.get('longitude', ''), 
+                data.get('city', '')
+            )
+        }
+        
+        # Calculate weighted completeness score with adjusted weights
+        weights = {
+            'address_format_valid': 0.15,
+            'address_in_city': 0.20,  # Increased weight for address verification
+            'city_in_state': 0.10,
+            'state_in_country': 0.10,
+            'postal_code_valid': 0.10,
+            'postal_code_in_city': 0.10,
+            'coordinates_valid': 0.10,
+            'coordinates_in_city': 0.15
+        }
+        
+        completeness_score = sum(
+            weights[key] * 100 if result else 0 
+            for key, result in verification_results.items()
+        )
+        
+        # Determine location quality with more lenient criteria
+        critical_checks = ['address_format_valid', 'city_in_state', 'state_in_country', 'postal_code_valid']
+        secondary_checks = ['address_in_city', 'postal_code_in_city', 'coordinates_valid', 'coordinates_in_city']
+        
+        # Location is verified if all critical checks pass and at least 2 secondary checks pass
+        critical_passed = all(verification_results[check] for check in critical_checks)
+        secondary_passed = sum(1 for check in secondary_checks if verification_results[check])
+        location_quality = "verified" if critical_passed and secondary_passed >= 2 else "unverified"
+        
+        # Analyze landmarks
+        landmarks_analysis = {
+            'provided': bool(data.get('nearby_landmarks')),
+            'count': len(data.get('nearby_landmarks', '').split(',')) if data.get('nearby_landmarks') else 0,
+            'types': []
+        }
+        
+        if data.get('nearby_landmarks'):
+            landmark_types = {
+                'transport': ['station', 'metro', 'bus', 'railway', 'airport', 'terminal', 'depot', 'stand', 'stop'],
+                'education': ['school', 'college', 'university', 'institute', 'academy', 'campus', 'library'],
+                'healthcare': ['hospital', 'clinic', 'medical', 'health', 'diagnostic', 'pharmacy', 'dispensary'],
+                'shopping': ['mall', 'market', 'shop', 'store', 'bazaar', 'complex', 'plaza', 'retail', 'outlet'],
+                'entertainment': ['park', 'garden', 'theater', 'cinema', 'stadium', 'auditorium', 'playground'],
+                'business': ['office', 'business', 'corporate', 'commercial', 'industrial', 'tech park', 'hub']
+            }
+            
+            landmarks = [landmark.strip() for landmark in data['nearby_landmarks'].lower().split(',')]
+            for landmark in landmarks:
+                for type_name, keywords in landmark_types.items():
+                    if any(keyword in landmark for keyword in keywords):
+                        if type_name not in landmarks_analysis['types']:
+                            landmarks_analysis['types'].append(type_name)
+        
+        # Determine city tier
+        city_tier = "unknown"
+        if data.get('city'):
+            city_lower = data['city'].lower()
+            metro_cities = ["mumbai", "delhi", "bangalore", "hyderabad", "chennai", "kolkata", "pune"]
+            tier2_cities = ["ahmedabad", "jaipur", "surat", "lucknow", "kanpur", "nagpur", "indore", 
+                          "thane", "bhopal", "visakhapatnam", "patna", "vadodara", "ghaziabad", 
+                          "ludhiana", "agra", "nashik", "faridabad", "meerut", "rajkot", "varanasi"]
+            
+            if any(city in city_lower for city in metro_cities):
+                city_tier = "metro"
+            elif any(city in city_lower for city in tier2_cities):
+                city_tier = "tier2"
+            else:
+                city_tier = "tier3"
+        
+        return {
+            **verification_results,
+            'assessment': "complete" if completeness_score >= 80 else "partial" if completeness_score >= 50 else "minimal",
+            'completeness_score': completeness_score,
+            'location_quality': location_quality,
+            'city_tier': city_tier,
+            'landmarks_analysis': landmarks_analysis,
+            'verification_status': "verified" if location_quality == "verified" else "unverified",
+            'formatted_address': f"{data.get('address', '')}, {data.get('city', '')}, {data.get('state', '')}, India - {data.get('zip', '')}"
+        }
+        
+    except Exception as e:
+        logger.error(f"Error analyzing location: {str(e)}")
+        return {
+            'assessment': 'error',
+            'completeness_score': 0,
+            'location_quality': 'error',
+            'city_tier': 'unknown',
+            'landmarks_analysis': {'provided': False, 'count': 0, 'types': []},
+            'verification_status': 'error',
+            'formatted_address': '',
+            'address_format_valid': False,
+            'address_in_city': False,
+            'city_in_state': False,
+            'state_in_country': False,
+            'postal_code_valid': False,
+            'postal_code_in_city': False,
+            'coordinates_valid': False,
+            'coordinates_in_city': False
+        }
+
+def calculate_location_completeness(data):
+    # Define weights for different fields
+    weights = {
+        'address': 0.25,
+        'city': 0.20,
+        'state': 0.15,
+        'country': 0.05,
+        'zip': 0.10,
+        'latitude': 0.10,
+        'longitude': 0.10,
+        'nearby_landmarks': 0.05
+    }
+
+    # Calculate weighted score
+    score = 0
+    for field, weight in weights.items():
+        if data[field]:
+            score += weight
+
+    return int(score * 100)

models/logging_config.py

@@ -0,0 +1,35 @@
+# models/logging_config.py
+
+import os
+import logging
+
+def setup_logging():
+    log_dir = os.environ.get('LOG_DIR', '/app/logs')
+    try:
+        os.makedirs(log_dir, exist_ok=True)
+        log_file = os.path.join(log_dir, 'app.log')
+
+        # Ensure log file exists and is writable
+        if not os.path.exists(log_file):
+            open(log_file, 'a').close()
+        os.chmod(log_file, 0o666)
+
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(levelname)s - %(message)s',
+            handlers=[
+                logging.FileHandler(log_file),
+                logging.StreamHandler()
+            ]
+        )
+        return logging.getLogger(__name__)
+    except Exception as e:
+        # Fallback to console-only logging if file logging fails
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(levelname)s - %(message)s',
+            handlers=[logging.StreamHandler()]
+        )
+        return logging.getLogger(__name__)
+
+logger = setup_logging()

models/market_value.py

@@ -0,0 +1,227 @@
+# models/market_value.py
+
+from datetime import datetime
+from .logging_config import logger
+
+def analyze_market_value(data):
+    """
+    Analyzes the market value of a property based on its specifications and location
+    for the Indian real estate market.
+    """
+    specs_verification = {
+        'is_valid': True,
+        'bedrooms_reasonable': True,
+        'bathrooms_reasonable': True,
+        'total_rooms_reasonable': True,
+        'parking_reasonable': True,
+        'sq_ft_reasonable': True,
+        'market_value_reasonable': True,
+        'year_built_reasonable': True,  # Added missing field
+        'issues': []
+    }
+
+    try:
+        # Validate property type
+        valid_property_types = [
+            'Apartment', 'House', 'Villa', 'Independent House', 'Independent Villa',
+            'Studio', 'Commercial', 'Office', 'Shop', 'Warehouse', 'Industrial'
+        ]
+
+        if 'property_type' not in data or data['property_type'] not in valid_property_types:
+            specs_verification['is_valid'] = False
+            specs_verification['issues'].append(f"Invalid property type: {data.get('property_type', 'Not specified')}")
+
+        # Validate bedrooms
+        if 'bedrooms' in data:
+            try:
+                bedrooms = int(data['bedrooms'])
+                if data['property_type'] in ['Apartment', 'Studio']:
+                    if bedrooms > 5 or bedrooms < 0:
+                        specs_verification['bedrooms_reasonable'] = False
+                        specs_verification['issues'].append(f"Invalid number of bedrooms for {data['property_type']}: {bedrooms}. Should be between 0 and 5.")
+                elif data['property_type'] in ['House', 'Villa', 'Independent House', 'Independent Villa']:
+                    if bedrooms > 8 or bedrooms < 0:
+                        specs_verification['bedrooms_reasonable'] = False
+                        specs_verification['issues'].append(f"Invalid number of bedrooms for {data['property_type']}: {bedrooms}. Should be between 0 and 8.")
+                elif data['property_type'] in ['Commercial', 'Office', 'Shop', 'Warehouse', 'Industrial']:
+                    if bedrooms > 0:
+                        specs_verification['bedrooms_reasonable'] = False
+                        specs_verification['issues'].append(f"Commercial properties typically don't have bedrooms: {bedrooms}")
+            except ValueError:
+                specs_verification['bedrooms_reasonable'] = False
+                specs_verification['issues'].append("Invalid bedrooms data: must be a number")
+
+        # Validate bathrooms
+        if 'bathrooms' in data:
+            try:
+                bathrooms = float(data['bathrooms'])
+                if data['property_type'] in ['Apartment', 'Studio']:
+                    if bathrooms > 4 or bathrooms < 0:
+                        specs_verification['bathrooms_reasonable'] = False
+                        specs_verification['issues'].append(f"Invalid number of bathrooms for {data['property_type']}: {bathrooms}. Should be between 0 and 4.")
+                elif data['property_type'] in ['House', 'Villa', 'Independent House', 'Independent Villa']:
+                    if bathrooms > 6 or bathrooms < 0:
+                        specs_verification['bathrooms_reasonable'] = False
+                        specs_verification['issues'].append(f"Invalid number of bathrooms for {data['property_type']}: {bathrooms}. Should be between 0 and 6.")
+                elif data['property_type'] in ['Commercial', 'Office', 'Shop', 'Warehouse', 'Industrial']:
+                    if bathrooms > 0:
+                        specs_verification['bathrooms_reasonable'] = False
+                        specs_verification['issues'].append(f"Commercial properties typically don't have bathrooms: {bathrooms}")
+            except ValueError:
+                specs_verification['bathrooms_reasonable'] = False
+                specs_verification['issues'].append("Invalid bathrooms data: must be a number")
+
+        # Validate total rooms
+        if 'total_rooms' in data:
+            try:
+                total_rooms = int(data['total_rooms'])
+                if total_rooms < 0:
+                    specs_verification['total_rooms_reasonable'] = False
+                    specs_verification['issues'].append(f"Invalid total rooms: {total_rooms}. Cannot be negative.")
+                elif 'bedrooms' in data and 'bathrooms' in data:
+                    try:
+                        bedrooms = int(data['bedrooms'])
+                        bathrooms = int(float(data['bathrooms']))
+                        if total_rooms < (bedrooms + bathrooms):
+                            specs_verification['total_rooms_reasonable'] = False
+                            specs_verification['issues'].append(f"Total rooms ({total_rooms}) is less than bedrooms + bathrooms ({bedrooms + bathrooms})")
+                    except ValueError:
+                        pass
+            except ValueError:
+                specs_verification['total_rooms_reasonable'] = False
+                specs_verification['issues'].append("Invalid total rooms data: must be a number")
+
+        # Validate parking
+        if 'parking' in data:
+            try:
+                parking = int(data['parking'])
+                if data['property_type'] in ['Apartment', 'Studio']:
+                    if parking > 2 or parking < 0:
+                        specs_verification['parking_reasonable'] = False
+                        specs_verification['issues'].append(f"Invalid parking spaces for {data['property_type']}: {parking}. Should be between 0 and 2.")
+                elif data['property_type'] in ['House', 'Villa', 'Independent House', 'Independent Villa']:
+                    if parking > 4 or parking < 0:
+                        specs_verification['parking_reasonable'] = False
+                        specs_verification['issues'].append(f"Invalid parking spaces for {data['property_type']}: {parking}. Should be between 0 and 4.")
+                elif data['property_type'] in ['Commercial', 'Office', 'Shop', 'Warehouse', 'Industrial']:
+                    if parking < 0:
+                        specs_verification['parking_reasonable'] = False
+                        specs_verification['issues'].append(f"Invalid parking spaces: {parking}. Cannot be negative.")
+            except ValueError:
+                specs_verification['parking_reasonable'] = False
+                specs_verification['issues'].append("Invalid parking data: must be a number")
+
+        # Validate square footage
+        if 'sq_ft' in data:
+            try:
+                sq_ft = float(data['sq_ft'].replace(',', ''))
+                if sq_ft <= 0:
+                    specs_verification['sq_ft_reasonable'] = False
+                    specs_verification['issues'].append(f"Invalid square footage: {sq_ft}. Must be greater than 0.")
+                else:
+                    if data['property_type'] in ['Apartment', 'Studio']:
+                        if sq_ft > 5000:
+                            specs_verification['sq_ft_reasonable'] = False
+                            specs_verification['issues'].append(f"Square footage ({sq_ft}) seems unreasonably high for {data['property_type']}")
+                        elif sq_ft < 200:
+                            specs_verification['sq_ft_reasonable'] = False
+                            specs_verification['issues'].append(f"Square footage ({sq_ft}) seems unreasonably low for {data['property_type']}")
+                    elif data['property_type'] in ['House', 'Villa', 'Independent House', 'Independent Villa']:
+                        if sq_ft > 10000:
+                            specs_verification['sq_ft_reasonable'] = False
+                            specs_verification['issues'].append(f"Square footage ({sq_ft}) seems unreasonably high for {data['property_type']}")
+                        elif sq_ft < 500:
+                            specs_verification['sq_ft_reasonable'] = False
+                            specs_verification['issues'].append(f"Square footage ({sq_ft}) seems unreasonably low for {data['property_type']}")
+            except ValueError:
+                specs_verification['sq_ft_reasonable'] = False
+                specs_verification['issues'].append("Invalid square footage data: must be a number")
+
+        # Validate market value
+        if 'market_value' in data:
+            try:
+                market_value = float(data['market_value'].replace(',', '').replace('₹', '').strip())
+                if market_value <= 0:
+                    specs_verification['market_value_reasonable'] = False
+                    specs_verification['issues'].append(f"Invalid market value: {market_value}. Must be greater than 0.")
+                else:
+                    if data['property_type'] in ['Apartment', 'Studio']:
+                        if market_value > 500000000:  # 5 crore limit for apartments
+                            specs_verification['market_value_reasonable'] = False
+                            specs_verification['issues'].append(f"Market value (₹{market_value:,.2f}) seems unreasonably high for {data['property_type']}")
+                        elif market_value < 500000:  # 5 lakh minimum
+                            specs_verification['market_value_reasonable'] = False
+                            specs_verification['issues'].append(f"Market value (₹{market_value:,.2f}) seems unreasonably low for {data['property_type']}")
+                    elif data['property_type'] in ['House', 'Villa', 'Independent House', 'Independent Villa']:
+                        if market_value > 2000000000:  # 20 crore limit for houses
+                            specs_verification['market_value_reasonable'] = False
+                            specs_verification['issues'].append(f"Market value (₹{market_value:,.2f}) seems unreasonably high for {data['property_type']}")
+                        elif market_value < 1000000:  # 10 lakh minimum
+                            specs_verification['market_value_reasonable'] = False
+                            specs_verification['issues'].append(f"Market value (₹{market_value:,.2f}) seems unreasonably low for {data['property_type']}")
+                    elif data['property_type'] in ['Commercial', 'Office', 'Shop']:
+                        if market_value < 2000000:  # 20 lakh minimum
+                            specs_verification['market_value_reasonable'] = False
+                            specs_verification['issues'].append(f"Market value (₹{market_value:,.2f}) seems unreasonably low for {data['property_type']}")
+                    elif data['property_type'] in ['Warehouse', 'Industrial']:
+                        if market_value < 5000000:  # 50 lakh minimum
+                            specs_verification['market_value_reasonable'] = False
+                            specs_verification['issues'].append(f"Market value (₹{market_value:,.2f}) seems unreasonably low for {data['property_type']}")
+
+                    # Check price per square foot
+                    if 'sq_ft' in data and float(data['sq_ft'].replace(',', '')) > 0:
+                        try:
+                            sq_ft = float(data['sq_ft'].replace(',', ''))
+                            price_per_sqft = market_value / sq_ft
+
+                            if data['property_type'] in ['Apartment', 'Studio']:
+                                if price_per_sqft < 1000:  # Less than ₹1000 per sq ft
+                                    specs_verification['market_value_reasonable'] = False
+                                    specs_verification['issues'].append(f"Price per sq ft (₹{price_per_sqft:,.2f}) seems unreasonably low for {data['property_type']}")
+                                elif price_per_sqft > 50000:  # More than ₹50k per sq ft
+                                    specs_verification['market_value_reasonable'] = False
+                                    specs_verification['issues'].append(f"Price per sq ft (₹{price_per_sqft:,.2f}) seems unreasonably high for {data['property_type']}")
+                            elif data['property_type'] in ['House', 'Villa', 'Independent House', 'Independent Villa']:
+                                if price_per_sqft < 500:  # Less than ₹500 per sq ft
+                                    specs_verification['market_value_reasonable'] = False
+                                    specs_verification['issues'].append(f"Price per sq ft (₹{price_per_sqft:,.2f}) seems unreasonably low for {data['property_type']}")
+                                elif price_per_sqft > 100000:  # More than ₹1 lakh per sq ft
+                                    specs_verification['market_value_reasonable'] = False
+                                    specs_verification['issues'].append(f"Price per sq ft (₹{price_per_sqft:,.2f}) seems unreasonably high for {data['property_type']}")
+                        except ValueError:
+                            pass
+            except ValueError:
+                specs_verification['market_value_reasonable'] = False
+                specs_verification['issues'].append("Invalid market value data: must be a number")
+
+        # Calculate verification score
+        valid_checks = sum([
+            specs_verification['bedrooms_reasonable'],
+            specs_verification['bathrooms_reasonable'],
+            specs_verification['total_rooms_reasonable'],
+            specs_verification['year_built_reasonable'],
+            specs_verification['parking_reasonable'],
+            specs_verification['sq_ft_reasonable'],
+            specs_verification['market_value_reasonable']
+        ])
+
+        total_checks = 7
+        specs_verification['verification_score'] = (valid_checks / total_checks) * 100
+
+        # Overall validity
+        specs_verification['is_valid'] = all([
+            specs_verification['bedrooms_reasonable'],
+            specs_verification['bathrooms_reasonable'],
+            specs_verification['total_rooms_reasonable'],
+            specs_verification['year_built_reasonable'],
+            specs_verification['parking_reasonable'],
+            specs_verification['sq_ft_reasonable'],
+            specs_verification['market_value_reasonable']
+        ])
+
+    except Exception as e:
+        logger.error(f"Error in property specs verification: {str(e)}")
+        specs_verification['is_valid'] = False
+        specs_verification['issues'].append(f"Error in verification: {str(e)}")
+
+    return specs_verification

models/model_loader.py

@@ -0,0 +1,14 @@
+# models/model_loader.py
+
+from functools import lru_cache
+from transformers import pipeline
+from .logging_config import logger
+
+@lru_cache(maxsize=10)
+def load_model(task, model_name):
+    try:
+        logger.info(f"Loading model: {model_name} for task: {task}")
+        return pipeline(task, model=model_name, device=-1)
+    except Exception as e:
+        logger.error(f"Error loading model {model_name}: {str(e)}")
+        raise

models/pdf_analysis.py

@@ -0,0 +1,173 @@
+# models/pdf_analysis.py
+
+import fitz  # PyMuPDF
+import re
+from .model_loader import load_model
+from .logging_config import logger
+from sentence_transformers import SentenceTransformer, util
+from .property_relation import check_if_property_related
+from .utils import summarize_text
+
+# Initialize sentence transformer
+try:
+    sentence_model = SentenceTransformer('paraphrase-MiniLM-L6-v2')
+    logger.info("Sentence transformer loaded successfully in pdf_analysis.py")
+except Exception as e:
+    logger.error(f"Error loading sentence transformer in pdf_analysis.py: {str(e)}")
+    sentence_model = None
+
+def extract_pdf_text(pdf_file):
+    try:
+        pdf_document = fitz.Document(stream=pdf_file.read(), filetype="pdf")
+        text = ""
+        for page in pdf_document:
+            text += page.get_text()
+        pdf_document.close()
+        return text
+    except Exception as e:
+        logger.error(f"Error extracting PDF text: {str(e)}")
+        return ""
+
+def analyze_pdf_content(document_text, property_data):
+    try:
+        if not document_text:
+            return {
+                'document_type': {'classification': 'unknown', 'confidence': 0.0},
+                'authenticity': {'assessment': 'could not verify', 'confidence': 0.0},
+                'key_info': {},
+                'consistency_score': 0.0,
+                'is_property_related': False,
+                'summary': 'Empty document',
+                'has_signatures': False,
+                'has_dates': False,
+                'verification_score': 0.0
+            }
+
+        # Use a more sophisticated model for document classification
+        classifier = load_model("zero-shot-classification", "typeform/mobilebert-uncased-mnli")
+
+        # Enhanced document types with more specific categories
+        doc_types = [
+            "property deed", "sales agreement", "mortgage document",
+            "property tax record", "title document", "khata certificate",
+            "encumbrance certificate", "lease agreement", "rental agreement",
+            "property registration document", "building permit", "other document"
+        ]
+
+        # Analyze document type with context
+        doc_context = f"{document_text[:1000]} property_type:{property_data.get('property_type', '')} location:{property_data.get('city', '')}"
+        doc_result = classifier(doc_context, doc_types)
+        doc_type = doc_result['labels'][0]
+        doc_confidence = doc_result['scores'][0]
+
+        # Enhanced authenticity check with multiple aspects
+        authenticity_aspects = [
+            "authentic legal document",
+            "questionable document",
+            "forged document",
+            "template document",
+            "official document"
+        ]
+        authenticity_result = classifier(document_text[:1000], authenticity_aspects)
+        authenticity = "likely authentic" if authenticity_result['labels'][0] == "authentic legal document" else "questionable"
+        authenticity_confidence = authenticity_result['scores'][0]
+
+        # Extract key information using NLP
+        key_info = extract_document_key_info(document_text)
+
+        # Enhanced consistency check
+        consistency_score = check_document_consistency(document_text, property_data)
+
+        # Property relation check with context
+        property_context = f"{document_text[:1000]} property:{property_data.get('property_name', '')} type:{property_data.get('property_type', '')}"
+        is_property_related = check_if_property_related(property_context)['is_related']
+
+        # Generate summary using BART
+        summary = summarize_text(document_text[:2000])
+
+        # Enhanced signature and date detection
+        has_signatures = bool(re.search(r'(?:sign|signature|signed|witness|notary|authorized).{0,50}(?:by|of|for)', document_text.lower()))
+        has_dates = bool(re.search(r'\d{1,2}[/-]\d{1,2}[/-]\d{2,4}|\d{4}[/-]\d{1,2}[/-]\d{1,2}', document_text))
+
+        # Calculate verification score with weighted components
+        verification_weights = {
+            'doc_type': 0.3,
+            'authenticity': 0.3,
+            'consistency': 0.2,
+            'property_relation': 0.1,
+            'signatures_dates': 0.1
+        }
+
+        verification_score = (
+            doc_confidence * verification_weights['doc_type'] +
+            authenticity_confidence * verification_weights['authenticity'] +
+            consistency_score * verification_weights['consistency'] +
+            float(is_property_related) * verification_weights['property_relation'] +
+            float(has_signatures and has_dates) * verification_weights['signatures_dates']
+        )
+
+        return {
+            'document_type': {'classification': doc_type, 'confidence': float(doc_confidence)},
+            'authenticity': {'assessment': authenticity, 'confidence': float(authenticity_confidence)},
+            'key_info': key_info,
+            'consistency_score': float(consistency_score),
+            'is_property_related': is_property_related,
+            'summary': summary,
+            'has_signatures': has_signatures,
+            'has_dates': has_dates,
+            'verification_score': float(verification_score)
+        }
+    except Exception as e:
+        logger.error(f"Error analyzing PDF content: {str(e)}")
+        return {
+            'document_type': {'classification': 'unknown', 'confidence': 0.0},
+            'authenticity': {'assessment': 'could not verify', 'confidence': 0.0},
+            'key_info': {},
+            'consistency_score': 0.0,
+            'is_property_related': False,
+            'summary': 'Could not analyze document',
+            'has_signatures': False,
+            'has_dates': False,
+            'verification_score': 0.0,
+            'error': str(e)
+        }
+
+def check_document_consistency(document_text, property_data):
+    try:
+        if not sentence_model:
+            logger.warning("Sentence model unavailable")
+            return 0.5
+        property_text = ' '.join([
+            property_data.get(key, '') for key in [
+                'property_name', 'property_type', 'address', 'city',
+                'state', 'market_value', 'sq_ft', 'bedrooms'
+            ]
+        ])
+        property_embedding = sentence_model.encode(property_text)
+        document_embedding = sentence_model.encode(document_text[:1000])
+        similarity = util.cos_sim(property_embedding, document_embedding)[0][0].item()
+        return max(0.0, min(1.0, float(similarity)))
+    except Exception as e:
+        logger.error(f"Error checking document consistency: {str(e)}")
+        return 0.0
+
+def extract_document_key_info(text):
+    try:
+        info = {}
+        patterns = {
+            'property_address': r'(?:property|premises|located at)[:\s]+([^\n.]+)',
+            'price': r'(?:price|value|amount)[:\s]+(?:Rs\.?|₹)?[\s]*([0-9,.]+)',
+            'date': r'(?:date|dated|executed on)[:\s]+([^\n.]+\d{4})',
+            'seller': r'(?:seller|grantor|owner)[:\s]+([^\n.]+)',
+            'buyer': r'(?:buyer|grantee|purchaser)[:\s]+([^\n.]+)',
+            'size': r'(?:area|size|extent)[:\s]+([0-9,.]+)[\s]*(?:sq\.?[\s]*(?:ft|feet))',
+            'registration_number': r'(?:registration|reg\.?|document)[\s]*(?:no\.?|number|#)[:\s]*([A-Za-z0-9\-/]+)'
+        }
+        for key, pattern in patterns.items():
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                info[key] = match.group(1).strip()
+        return info
+    except Exception as e:
+        logger.error(f"Error extracting document key info: {str(e)}")
+        return {}

models/price_analysis.py

@@ -0,0 +1,254 @@
+# models/price_analysis.py
+
+import re
+from .model_loader import load_model
+from .logging_config import logger
+
+def analyze_price(data):
+    try:
+        # Safely convert price to float
+        price_str = str(data.get('market_value', '0')).replace('$', '').replace(',', '').strip()
+        price = float(price_str) if price_str else 0
+        
+        # Safely convert sq_ft to float
+        sq_ft_str = str(data.get('sq_ft', '0')).replace(',', '').strip()
+        sq_ft = float(re.sub(r'[^\d.]', '', sq_ft_str)) if sq_ft_str else 0
+        
+        price_per_sqft = price / sq_ft if sq_ft else 0
+
+        if not price:
+            return {
+                'assessment': 'no price',
+                'confidence': 0.0,
+                'price': 0,
+                'formatted_price': '₹0',
+                'price_per_sqft': 0,
+                'formatted_price_per_sqft': '₹0',
+                'price_range': 'unknown',
+                'location_price_assessment': 'cannot assess',
+                'has_price': False,
+                'market_trends': {},
+                'price_factors': {},
+                'risk_indicators': []
+            }
+
+        # Use a more sophisticated model for price analysis
+        classifier = load_model("zero-shot-classification", "typeform/mobilebert-uncased-mnli")
+
+        # Create a detailed context for price analysis
+        price_context = f"""
+        Property Type: {data.get('property_type', '')}
+        Location: {data.get('city', '')}, {data.get('state', '')}
+        Size: {sq_ft} sq.ft.
+        Price: ₹{price:,.2f}
+        Price per sq.ft.: ₹{price_per_sqft:,.2f}
+        Property Status: {data.get('status', '')}
+        Year Built: {data.get('year_built', '')}
+        Bedrooms: {data.get('bedrooms', '')}
+        Bathrooms: {data.get('bathrooms', '')}
+        Amenities: {data.get('amenities', '')}
+        """
+
+        # Enhanced price categories with more specific indicators
+        price_categories = [
+            "reasonable market price",
+            "suspiciously low price",
+            "suspiciously high price",
+            "average market price",
+            "luxury property price",
+            "budget property price",
+            "premium property price",
+            "mid-range property price",
+            "overpriced for location",
+            "underpriced for location",
+            "price matches amenities",
+            "price matches property age",
+            "price matches location value",
+            "price matches property condition",
+            "price matches market trends"
+        ]
+
+        # Analyze price with multiple aspects
+        price_result = classifier(price_context, price_categories, multi_label=True)
+
+        # Get top classifications with enhanced confidence calculation
+        top_classifications = []
+        for label, score in zip(price_result['labels'][:5], price_result['scores'][:5]):
+            if score > 0.25:  # Lower threshold for better sensitivity
+                top_classifications.append({
+                    'classification': label,
+                    'confidence': float(score)
+                })
+
+        # Determine price range based on AI classification and market data
+        price_range = 'unknown'
+        if top_classifications:
+            primary_class = top_classifications[0]['classification']
+            if 'luxury' in primary_class:
+                price_range = 'luxury'
+            elif 'premium' in primary_class:
+                price_range = 'premium'
+            elif 'mid-range' in primary_class:
+                price_range = 'mid_range'
+            elif 'budget' in primary_class:
+                price_range = 'budget'
+
+        # Enhanced location-specific price assessment
+        location_assessment = "unknown"
+        market_trends = {}
+        if data.get('city') and price_per_sqft:
+            city_lower = data['city'].lower()
+            metro_cities = ["mumbai", "delhi", "bangalore", "hyderabad", "chennai", "kolkata", "pune"]
+
+            # Define price ranges for different city tiers
+            if any(city in city_lower for city in metro_cities):
+                market_trends = {
+                    'city_tier': 'metro',
+                    'avg_price_range': {
+                        'min': 5000,
+                        'max': 30000,
+                        'trend': 'stable'
+                    },
+                    'price_per_sqft': {
+                        'current': price_per_sqft,
+                        'market_avg': 15000,
+                        'deviation': abs(price_per_sqft - 15000) / 15000 * 100
+                    }
+                }
+                location_assessment = (
+                    "reasonable" if 5000 <= price_per_sqft <= 30000 else
+                    "suspiciously low" if price_per_sqft < 5000 else
+                    "suspiciously high"
+                )
+            else:
+                market_trends = {
+                    'city_tier': 'non-metro',
+                    'avg_price_range': {
+                        'min': 1500,
+                        'max': 15000,
+                        'trend': 'stable'
+                    },
+                    'price_per_sqft': {
+                        'current': price_per_sqft,
+                        'market_avg': 7500,
+                        'deviation': abs(price_per_sqft - 7500) / 7500 * 100
+                    }
+                }
+                location_assessment = (
+                    "reasonable" if 1500 <= price_per_sqft <= 15000 else
+                    "suspiciously low" if price_per_sqft < 1500 else
+                    "suspiciously high"
+                )
+
+        # Enhanced price analysis factors
+        price_factors = {}
+        risk_indicators = []
+
+        # Property age factor
+        try:
+            year_built = int(data.get('year_built', 0))
+            current_year = datetime.now().year
+            property_age = current_year - year_built
+
+            if property_age > 0:
+                depreciation_factor = max(0.5, 1 - (property_age * 0.01))  # 1% depreciation per year, min 50%
+                price_factors['age_factor'] = {
+                    'property_age': property_age,
+                    'depreciation_factor': depreciation_factor,
+                    'impact': 'high' if property_age > 30 else 'medium' if property_age > 15 else 'low'
+                }
+        except:
+            price_factors['age_factor'] = {'error': 'Invalid year built'}
+
+        # Size factor
+        if sq_ft > 0:
+            size_factor = {
+                'size': sq_ft,
+                'price_per_sqft': price_per_sqft,
+                'efficiency': 'high' if 800 <= sq_ft <= 2000 else 'medium' if 500 <= sq_ft <= 3000 else 'low'
+            }
+            price_factors['size_factor'] = size_factor
+
+            # Add risk indicators based on size
+            if sq_ft < 300:
+                risk_indicators.append('Unusually small property size')
+            elif sq_ft > 10000:
+                risk_indicators.append('Unusually large property size')
+
+        # Amenities factor
+        if data.get('amenities'):
+            amenities_list = [a.strip() for a in data['amenities'].split(',')]
+            amenities_score = min(1.0, len(amenities_list) * 0.1)  # 10% per amenity, max 100%
+            price_factors['amenities_factor'] = {
+                'count': len(amenities_list),
+                'score': amenities_score,
+                'impact': 'high' if amenities_score > 0.7 else 'medium' if amenities_score > 0.4 else 'low'
+            }
+
+        # Calculate overall confidence with weighted factors
+        confidence_weights = {
+            'primary_classification': 0.3,
+            'location_assessment': 0.25,
+            'age_factor': 0.2,
+            'size_factor': 0.15,
+            'amenities_factor': 0.1
+        }
+        confidence_scores = []
+
+        # Primary classification confidence
+        if top_classifications:
+            confidence_scores.append(price_result['scores'][0] * confidence_weights['primary_classification'])
+
+        # Location assessment confidence
+        location_confidence = 0.8 if location_assessment == "reasonable" else 0.4
+        confidence_scores.append(location_confidence * confidence_weights['location_assessment'])
+
+        # Age factor confidence
+        if 'age_factor' in price_factors and 'depreciation_factor' in price_factors['age_factor']:
+            age_confidence = price_factors['age_factor']['depreciation_factor']
+            confidence_scores.append(age_confidence * confidence_weights['age_factor'])
+
+        # Size factor confidence
+        if 'size_factor' in price_factors:
+            size_confidence = 0.8 if price_factors['size_factor']['efficiency'] == 'high' else 0.6
+            confidence_scores.append(size_confidence * confidence_weights['size_factor'])
+
+        # Amenities factor confidence
+        if 'amenities_factor' in price_factors:
+            amenities_confidence = price_factors['amenities_factor']['score']
+            confidence_scores.append(amenities_confidence * confidence_weights['amenities_factor'])
+
+        overall_confidence = sum(confidence_scores) / sum(confidence_weights.values())
+
+        return {
+            'assessment': top_classifications[0]['classification'] if top_classifications else 'could not classify',
+            'confidence': float(overall_confidence),
+            'price': price,
+            'formatted_price': f"₹{price:,.0f}",
+            'price_per_sqft': price_per_sqft,
+            'formatted_price_per_sqft': f"₹{price_per_sqft:,.2f}",
+            'price_range': price_range,
+            'location_price_assessment': location_assessment,
+            'has_price': True,
+            'market_trends': market_trends,
+            'price_factors': price_factors,
+            'risk_indicators': risk_indicators,
+            'top_classifications': top_classifications
+        }
+    except Exception as e:
+        logger.error(f"Error analyzing price: {str(e)}")
+        return {
+            'assessment': 'error',
+            'confidence': 0.0,
+            'price': 0,
+            'formatted_price': '₹0',
+            'price_per_sqft': 0,
+            'formatted_price_per_sqft': '₹0',
+            'price_range': 'unknown',
+            'location_price_assessment': 'error',
+            'has_price': False,
+            'market_trends': {},
+            'price_factors': {},
+            'risk_indicators': [],
+            'top_classifications': []
+        }

models/property_relation.py

@@ -0,0 +1,20 @@
+# models/property_relation.py
+
+from .model_loader import load_model
+from .logging_config import logger
+
+def check_if_property_related(text):
+    try:
+        classifier = load_model("zero-shot-classification", "typeform/mobilebert-uncased-mnli")
+        result = classifier(text[:1000], ["property-related", "non-property-related"])
+        is_related = result['labels'][0] == "property-related"
+        return {
+            'is_related': is_related,
+            'confidence': float(result['scores'][0])
+        }
+    except Exception as e:
+        logger.error(f"Error checking property relation: {str(e)}")
+        return {
+            'is_related': False,
+            'confidence': 0.0
+        }

models/property_specs.py

@@ -0,0 +1,241 @@
+# models/property_specs.py
+
+from datetime import datetime
+from .logging_config import logger
+
+def verify_property_specs(data):
+    """
+    Verify property specifications for reasonableness and consistency.
+    This function checks if the provided property details are within reasonable ranges
+    for the Indian real estate market.
+    """
+    specs_verification = {
+        'is_valid': True,
+        'bedrooms_reasonable': True,
+        'bathrooms_reasonable': True,
+        'total_rooms_reasonable': True,
+        'year_built_reasonable': True,
+        'parking_reasonable': True,
+        'sq_ft_reasonable': True,
+        'market_value_reasonable': True,
+        'issues': []
+    }
+
+    try:
+        # Helper function to safely convert values
+        def safe_float_convert(value, default=0.0):
+            try:
+                if isinstance(value, (int, float)):
+                    return float(value)
+                if isinstance(value, str):
+                    return float(value.replace(',', '').replace('₹', '').strip())
+                return default
+            except (ValueError, TypeError):
+                return default
+
+        def safe_int_convert(value, default=0):
+            try:
+                if isinstance(value, (int, float)):
+                    return int(value)
+                if isinstance(value, str):
+                    return int(float(value.replace(',', '').strip()))
+                return default
+            except (ValueError, TypeError):
+                return default
+
+        # Validate property type
+        valid_property_types = [
+            'Apartment', 'House', 'Villa', 'Independent House', 'Independent Villa',
+            'Studio', 'Commercial', 'Office', 'Shop', 'Warehouse', 'Industrial'
+        ]
+
+        if 'property_type' not in data or data['property_type'] not in valid_property_types:
+            specs_verification['is_valid'] = False
+            specs_verification['issues'].append(f"Invalid property type: {data.get('property_type', 'Not specified')}")
+
+        # Validate bedrooms
+        if 'bedrooms' in data:
+            bedrooms = safe_int_convert(data['bedrooms'])
+            if data['property_type'] in ['Apartment', 'Studio']:
+                if bedrooms > 5 or bedrooms < 0:
+                    specs_verification['bedrooms_reasonable'] = False
+                    specs_verification['issues'].append(f"Invalid number of bedrooms for {data['property_type']}: {bedrooms}. Should be between 0 and 5.")
+            elif data['property_type'] in ['House', 'Villa', 'Independent House', 'Independent Villa']:
+                if bedrooms > 8 or bedrooms < 0:
+                    specs_verification['bedrooms_reasonable'] = False
+                    specs_verification['issues'].append(f"Invalid number of bedrooms for {data['property_type']}: {bedrooms}. Should be between 0 and 8.")
+            elif data['property_type'] in ['Commercial', 'Office', 'Shop', 'Warehouse', 'Industrial']:
+                if bedrooms > 0:
+                    specs_verification['bedrooms_reasonable'] = False
+                    specs_verification['issues'].append(f"Commercial properties typically don't have bedrooms: {bedrooms}")
+
+        # Validate bathrooms
+        if 'bathrooms' in data:
+            bathrooms = safe_float_convert(data['bathrooms'])
+            if data['property_type'] in ['Apartment', 'Studio']:
+                if bathrooms > 4 or bathrooms < 0:
+                    specs_verification['bathrooms_reasonable'] = False
+                    specs_verification['issues'].append(f"Invalid number of bathrooms for {data['property_type']}: {bathrooms}. Should be between 0 and 4.")
+            elif data['property_type'] in ['House', 'Villa', 'Independent House', 'Independent Villa']:
+                if bathrooms > 6 or bathrooms < 0:
+                    specs_verification['bathrooms_reasonable'] = False
+                    specs_verification['issues'].append(f"Invalid number of bathrooms for {data['property_type']}: {bathrooms}. Should be between 0 and 6.")
+            elif data['property_type'] in ['Commercial', 'Office', 'Shop', 'Warehouse', 'Industrial']:
+                if bathrooms > 0:
+                    specs_verification['bathrooms_reasonable'] = False
+                    specs_verification['issues'].append(f"Commercial properties typically don't have bathrooms: {bathrooms}")
+
+        # Validate total rooms
+        if 'total_rooms' in data:
+            try:
+                total_rooms = int(data['total_rooms'])
+                if total_rooms < 0:
+                    specs_verification['total_rooms_reasonable'] = False
+                    specs_verification['issues'].append(f"Invalid total rooms: {total_rooms}. Cannot be negative.")
+                elif 'bedrooms' in data and 'bathrooms' in data:
+                    try:
+                        bedrooms = int(data['bedrooms'])
+                        bathrooms = int(float(data['bathrooms']))
+                        if total_rooms < (bedrooms + bathrooms):
+                            specs_verification['total_rooms_reasonable'] = False
+                            specs_verification['issues'].append(f"Total rooms ({total_rooms}) is less than bedrooms + bathrooms ({bedrooms + bathrooms})")
+                    except ValueError:
+                        pass
+            except ValueError:
+                specs_verification['total_rooms_reasonable'] = False
+                specs_verification['issues'].append("Invalid total rooms data: must be a number")
+
+        # Validate parking
+        if 'parking' in data:
+            try:
+                parking = int(data['parking'])
+                if data['property_type'] in ['Apartment', 'Studio']:
+                    if parking > 2 or parking < 0:
+                        specs_verification['parking_reasonable'] = False
+                        specs_verification['issues'].append(f"Invalid parking spaces for {data['property_type']}: {parking}. Should be between 0 and 2.")
+                elif data['property_type'] in ['House', 'Villa', 'Independent House', 'Independent Villa']:
+                    if parking > 4 or parking < 0:
+                        specs_verification['parking_reasonable'] = False
+                        specs_verification['issues'].append(f"Invalid parking spaces for {data['property_type']}: {parking}. Should be between 0 and 4.")
+                elif data['property_type'] in ['Commercial', 'Office', 'Shop', 'Warehouse', 'Industrial']:
+                    if parking < 0:
+                        specs_verification['parking_reasonable'] = False
+                        specs_verification['issues'].append(f"Invalid parking spaces: {parking}. Cannot be negative.")
+            except ValueError:
+                specs_verification['parking_reasonable'] = False
+                specs_verification['issues'].append("Invalid parking data: must be a number")
+
+        # Validate square footage
+        if 'sq_ft' in data:
+            try:
+                sq_ft = float(data['sq_ft'].replace(',', ''))
+                if sq_ft <= 0:
+                    specs_verification['sq_ft_reasonable'] = False
+                    specs_verification['issues'].append(f"Invalid square footage: {sq_ft}. Must be greater than 0.")
+                else:
+                    if data['property_type'] in ['Apartment', 'Studio']:
+                        if sq_ft > 5000:
+                            specs_verification['sq_ft_reasonable'] = False
+                            specs_verification['issues'].append(f"Square footage ({sq_ft}) seems unreasonably high for {data['property_type']}")
+                        elif sq_ft < 200:
+                            specs_verification['sq_ft_reasonable'] = False
+                            specs_verification['issues'].append(f"Square footage ({sq_ft}) seems unreasonably low for {data['property_type']}")
+                    elif data['property_type'] in ['House', 'Villa', 'Independent House', 'Independent Villa']:
+                        if sq_ft > 10000:
+                            specs_verification['sq_ft_reasonable'] = False
+                            specs_verification['issues'].append(f"Square footage ({sq_ft}) seems unreasonably high for {data['property_type']}")
+                        elif sq_ft < 500:
+                            specs_verification['sq_ft_reasonable'] = False
+                            specs_verification['issues'].append(f"Square footage ({sq_ft}) seems unreasonably low for {data['property_type']}")
+            except ValueError:
+                specs_verification['sq_ft_reasonable'] = False
+                specs_verification['issues'].append("Invalid square footage data: must be a number")
+
+        # Validate market value
+        if 'market_value' in data:
+            try:
+                market_value = float(data['market_value'].replace(',', '').replace('₹', '').strip())
+                if market_value <= 0:
+                    specs_verification['market_value_reasonable'] = False
+                    specs_verification['issues'].append(f"Invalid market value: {market_value}. Must be greater than 0.")
+                else:
+                    if data['property_type'] in ['Apartment', 'Studio']:
+                        if market_value > 500000000:  # 5 crore limit for apartments
+                            specs_verification['market_value_reasonable'] = False
+                            specs_verification['issues'].append(f"Market value (₹{market_value:,.2f}) seems unreasonably high for {data['property_type']}")
+                        elif market_value < 500000:  # 5 lakh minimum
+                            specs_verification['market_value_reasonable'] = False
+                            specs_verification['issues'].append(f"Market value (₹{market_value:,.2f}) seems unreasonably low for {data['property_type']}")
+                    elif data['property_type'] in ['House', 'Villa', 'Independent House', 'Independent Villa']:
+                        if market_value > 2000000000:  # 20 crore limit for houses
+                            specs_verification['market_value_reasonable'] = False
+                            specs_verification['issues'].append(f"Market value (₹{market_value:,.2f}) seems unreasonably high for {data['property_type']}")
+                        elif market_value < 1000000:  # 10 lakh minimum
+                            specs_verification['market_value_reasonable'] = False
+                            specs_verification['issues'].append(f"Market value (₹{market_value:,.2f}) seems unreasonably low for {data['property_type']}")
+                    elif data['property_type'] in ['Commercial', 'Office', 'Shop']:
+                        if market_value < 2000000:  # 20 lakh minimum
+                            specs_verification['market_value_reasonable'] = False
+                            specs_verification['issues'].append(f"Market value (₹{market_value:,.2f}) seems unreasonably low for {data['property_type']}")
+                    elif data['property_type'] in ['Warehouse', 'Industrial']:
+                        if market_value < 5000000:  # 50 lakh minimum
+                            specs_verification['market_value_reasonable'] = False
+                            specs_verification['issues'].append(f"Market value (₹{market_value:,.2f}) seems unreasonably low for {data['property_type']}")
+
+                    # Check price per square foot
+                    if 'sq_ft' in data and float(data['sq_ft'].replace(',', '')) > 0:
+                        try:
+                            sq_ft = float(data['sq_ft'].replace(',', ''))
+                            price_per_sqft = market_value / sq_ft
+
+                            if data['property_type'] in ['Apartment', 'Studio']:
+                                if price_per_sqft < 1000:  # Less than ₹1000 per sq ft
+                                    specs_verification['market_value_reasonable'] = False
+                                    specs_verification['issues'].append(f"Price per sq ft (₹{price_per_sqft:,.2f}) seems unreasonably low for {data['property_type']}")
+                                elif price_per_sqft > 50000:  # More than ₹50k per sq ft
+                                    specs_verification['market_value_reasonable'] = False
+                                    specs_verification['issues'].append(f"Price per sq ft (₹{price_per_sqft:,.2f}) seems unreasonably high for {data['property_type']}")
+                            elif data['property_type'] in ['House', 'Villa', 'Independent House', 'Independent Villa']:
+                                if price_per_sqft < 500:  # Less than ₹500 per sq ft
+                                    specs_verification['market_value_reasonable'] = False
+                                    specs_verification['issues'].append(f"Price per sq ft (₹{price_per_sqft:,.2f}) seems unreasonably low for {data['property_type']}")
+                                elif price_per_sqft > 100000:  # More than ₹1 lakh per sq ft
+                                    specs_verification['market_value_reasonable'] = False
+                                    specs_verification['issues'].append(f"Price per sq ft (₹{price_per_sqft:,.2f}) seems unreasonably high for {data['property_type']}")
+                        except ValueError:
+                            pass
+            except ValueError:
+                specs_verification['market_value_reasonable'] = False
+                specs_verification['issues'].append("Invalid market value data: must be a number")
+
+        # Calculate verification score
+        valid_checks = sum([
+            specs_verification['bedrooms_reasonable'],
+            specs_verification['bathrooms_reasonable'],
+            specs_verification['total_rooms_reasonable'],
+            specs_verification['year_built_reasonable'],
+            specs_verification['parking_reasonable'],
+            specs_verification['sq_ft_reasonable'],
+            specs_verification['market_value_reasonable']
+        ])
+
+        total_checks = 7
+        specs_verification['verification_score'] = (valid_checks / total_checks) * 100
+
+        # Overall validity
+        specs_verification['is_valid'] = all([
+            specs_verification['bedrooms_reasonable'],
+            specs_verification['bathrooms_reasonable'],
+            specs_verification['total_rooms_reasonable'],
+            specs_verification['year_built_reasonable'],
+            specs_verification['parking_reasonable'],
+            specs_verification['sq_ft_reasonable'],
+            specs_verification['market_value_reasonable']
+        ])
+
+    except Exception as e:
+        logger.error(f"Error in property specs verification: {str(e)}")
+        specs_verification['is_valid'] = False
+        specs_verification['issues'].append(f"Error in verification: {str(e)}")
+
+    return specs_verification

models/property_summary.py

@@ -0,0 +1,192 @@
+# models/property_summary.py
+
+from .model_loader import load_model
+from .logging_config import logger
+from .utils import summarize_text
+
+def validate_and_format_data(data):
+    """Validate and format property data"""
+    # Format square feet
+    try:
+        sq_ft = float(data.get('sq_ft', 0))
+        if sq_ft < 100:  # If square feet seems too small, it might be in wrong unit
+            sq_ft *= 100  # Convert to square feet if it was in square meters
+        data['sq_ft'] = int(sq_ft)
+    except:
+        data['sq_ft'] = 0
+
+    # Format market value
+    try:
+        market_value = float(data.get('market_value', 0))
+        if market_value > 1000000000:  # If value seems too high
+            market_value = market_value / 100  # Adjust if there's a decimal point issue
+        data['market_value'] = int(market_value)
+    except:
+        data['market_value'] = 0
+
+    # Format amenities
+    if data.get('amenities'):
+        if isinstance(data['amenities'], str):
+            amenities = [a.strip() for a in data['amenities'].split(',') if a.strip()]
+            data['amenities'] = amenities
+        elif isinstance(data['amenities'], list):
+            data['amenities'] = [a.strip() for a in data['amenities'] if a.strip()]
+    else:
+        data['amenities'] = []
+
+    return data
+
+def format_price(price):
+    """Format price in Indian currency format"""
+    try:
+        price = float(price)
+        if price >= 10000000:  # 1 Crore
+            return f"₹{price/10000000:.2f} Cr"
+        elif price >= 100000:  # 1 Lakh
+            return f"₹{price/100000:.2f} L"
+        else:
+            return f"₹{price:,.2f}"
+    except:
+        return f"₹{price}"
+
+def generate_static_summary(data):
+    """Generate a conversational property summary"""
+    # Validate and format data
+    data = validate_and_format_data(data)
+    price = format_price(data.get('market_value', '0'))
+    
+    # Get property type with proper formatting
+    property_type = data.get('property_type', 'property').strip()
+    if property_type.lower() == 'apartment':
+        property_type = '2 BHK Apartment'  # Add BHK information if available
+    
+    summary = f"""
+    Namaste! Let me tell you about this wonderful {property_type} that's {data.get('status', 'available').lower()}.
+
+    This beautiful property is located in {data.get('city', 'the city')}, {data.get('state', '')}. It's a spacious {property_type} spanning {data.get('sq_ft', '0')} square feet, perfect for your family.
+
+    Key Highlights:
+    • Price: {price}
+    • Bedrooms: {data.get('bedrooms', '0')} spacious bedrooms
+    • Bathrooms: {data.get('bathrooms', '0')} modern bathrooms
+    • Year Built: {data.get('year_built', 'N/A')}
+    • Parking: {data.get('parking_spaces', '0')} covered parking spaces
+    """
+
+    # Add property description if available
+    if data.get('property_description'):
+        summary += f"\n\nProperty Description:\n{data.get('property_description')}"
+
+    # Add possession date if available
+    if data.get('possession_date'):
+        summary += f"\n• Ready for possession from: {data.get('possession_date')}"
+
+    # Add amenities if available
+    if data.get('amenities'):
+        amenities = data['amenities']
+        if len(amenities) > 0:
+            summary += "\n\nNearby Amenities:\n• " + "\n• ".join(amenities)
+
+    # Add nearby landmarks if available
+    if data.get('nearby_landmarks'):
+        landmarks = data['nearby_landmarks']
+        if isinstance(landmarks, str):
+            landmarks = [l.strip() for l in landmarks.split(',') if l.strip()]
+        if len(landmarks) > 0:
+            summary += "\n\nNearby Landmarks:\n• " + "\n• ".join(landmarks)
+
+    # Add a friendly closing
+    summary += "\n\nThis property offers excellent value for money and is located in a prime area. Would you like to know more details about this property?"
+
+    return summary.strip()
+
+def generate_property_summary(data):
+    try:
+        # Validate and format data first
+        data = validate_and_format_data(data)
+
+        # Create a detailed context for summary generation
+        property_context = f"""
+        Property Details:
+        Name: {data.get('property_name', '')}
+        Type: {data.get('property_type', '')}
+        Status: {data.get('status', '')}
+        Location: {data.get('address', '')}, {data.get('city', '')}, {data.get('state', '')}, {data.get('country', '')}
+        Size: {data.get('sq_ft', '')} sq. ft.
+        Price: {format_price(data.get('market_value', '0'))}
+        Bedrooms: {data.get('bedrooms', '')}
+        Bathrooms: {data.get('bathrooms', '')}
+        Year Built: {data.get('year_built', '')}
+        Parking: {data.get('parking_spaces', '')} spaces
+        Description: {data.get('property_description', '')}
+        Possession Date: {data.get('possession_date', '')}
+        Amenities: {', '.join(data.get('amenities', []))}
+        Nearby Landmarks: {data.get('nearby_landmarks', '')}
+        """
+
+        # Try to use BART for summary generation
+        try:
+            summarizer = load_model("summarization", "sshleifer/distilbart-cnn-6-6")
+            summary_result = summarizer(property_context, max_length=500, min_length=100, do_sample=False)
+            initial_summary = summary_result[0]['summary_text']
+        except Exception as model_error:
+            logger.warning(f"Model generation failed, using static summary: {str(model_error)}")
+            initial_summary = generate_static_summary(data)
+
+        # Enhance summary with key features
+        key_features = []
+
+        # Add property type and status
+        if data.get('property_type') and data.get('status'):
+            key_features.append(f"This {data['property_type']} is {data['status'].lower()}")
+
+        # Add location if available
+        location_parts = []
+        if data.get('city'):
+            location_parts.append(data['city'])
+        if data.get('state'):
+            location_parts.append(data['state'])
+        if location_parts:
+            key_features.append(f"Located in {', '.join(location_parts)}")
+
+        # Add size and price if available
+        if data.get('sq_ft'):
+            key_features.append(f"Spans {data['sq_ft']} sq. ft.")
+        if data.get('market_value'):
+            key_features.append(f"Priced at {format_price(data['market_value'])}")
+
+        # Add rooms information
+        rooms_info = []
+        if data.get('bedrooms'):
+            rooms_info.append(f"{data['bedrooms']} bedroom{'s' if data['bedrooms'] != '1' else ''}")
+        if data.get('bathrooms'):
+            rooms_info.append(f"{data['bathrooms']} bathroom{'s' if data['bathrooms'] != '1' else ''}")
+        if rooms_info:
+            key_features.append(f"Features {' and '.join(rooms_info)}")
+
+        # Add parking information
+        if data.get('parking_spaces'):
+            key_features.append(f"Includes {data['parking_spaces']} covered parking space{'s' if data['parking_spaces'] != '1' else ''}")
+
+        # Add possession date if available
+        if data.get('possession_date'):
+            key_features.append(f"Ready for possession from {data['possession_date']}")
+
+        # Add amenities if available
+        if data.get('amenities'):
+            amenities = data['amenities']
+            if len(amenities) > 0:
+                key_features.append(f"Amenities: {', '.join(amenities)}")
+
+        # Combine initial summary with key features
+        enhanced_summary = initial_summary
+        if key_features:
+            enhanced_summary += "\n\nKey Features:\n• " + "\n• ".join(key_features)
+
+        # Clean up the summary
+        enhanced_summary = enhanced_summary.replace("  ", " ").strip()
+
+        return enhanced_summary
+    except Exception as e:
+        logger.error(f"Error generating property summary: {str(e)}")
+        return generate_static_summary(data)

models/suggestions.py

@@ -0,0 +1,150 @@
+# models/suggestions.py
+
+from .model_loader import load_model
+from .logging_config import logger
+
+def generate_suggestions(text, data=None):
+    try:
+        # Ensure text is string
+        text = str(text) if text is not None else ""
+        
+        # Safely convert data values
+        if data:
+            processed_data = {}
+            for key, value in data.items():
+                if isinstance(value, (int, float)):
+                    processed_data[key] = str(value)
+                else:
+                    processed_data[key] = str(value) if value is not None else ""
+            data = processed_data
+
+        # Initialize suggestions
+        suggestions = {
+            'improvements': [],
+            'warnings': [],
+            'recommendations': [],
+            'confidence': 0.0
+        }
+
+        # Load model for analysis
+        classifier = load_model("zero-shot-classification", "typeform/mobilebert-uncased-mnli")
+
+        # Define suggestion categories
+        categories = [
+            "property description improvement",
+            "price adjustment needed",
+            "documentation required",
+            "verification needed",
+            "legal compliance issue",
+            "location verification needed",
+            "property specification update",
+            "image quality improvement",
+            "market value adjustment",
+            "contact information update"
+        ]
+
+        # Analyze text with context
+        context = f"{text} property_data:{str(data) if data else ''}"
+        result = classifier(context, categories, multi_label=True)
+
+        # Process results
+        for label, score in zip(result['labels'], result['scores']):
+            if score > 0.3:  # Only include high confidence suggestions
+                suggestion = {
+                    'type': label,
+                    'confidence': float(score),
+                    'details': generate_suggestion_details(label, text, data)
+                }
+                
+                if 'improvement' in label or 'update' in label:
+                    suggestions['improvements'].append(suggestion)
+                elif 'warning' in label or 'issue' in label:
+                    suggestions['warnings'].append(suggestion)
+                else:
+                    suggestions['recommendations'].append(suggestion)
+
+        # Calculate overall confidence
+        if result['scores']:
+            suggestions['confidence'] = float(max(result['scores']))
+
+        return suggestions
+
+    except Exception as e:
+        logger.error(f"Error generating suggestions: {str(e)}")
+        return {
+            'improvements': [],
+            'warnings': [],
+            'recommendations': [],
+            'confidence': 0.0,
+            'error': str(e)
+        }
+
+def generate_suggestion_details(suggestion_type, text, data):
+    """Generate detailed suggestions based on the type."""
+    try:
+        details = {
+            'property description improvement': {
+                'title': 'Improve Property Description',
+                'message': 'Add more detailed information about the property features and amenities.',
+                'priority': 'medium'
+            },
+            'price adjustment needed': {
+                'title': 'Review Property Price',
+                'message': 'Consider adjusting the price based on market conditions and property specifications.',
+                'priority': 'high'
+            },
+            'documentation required': {
+                'title': 'Additional Documentation Needed',
+                'message': 'Please provide more property-related documents for verification.',
+                'priority': 'high'
+            },
+            'verification needed': {
+                'title': 'Property Verification Required',
+                'message': 'Additional verification steps are needed for property authenticity.',
+                'priority': 'high'
+            },
+            'legal compliance issue': {
+                'title': 'Legal Compliance Check',
+                'message': 'Review property legal documentation and compliance status.',
+                'priority': 'high'
+            },
+            'location verification needed': {
+                'title': 'Location Verification',
+                'message': 'Verify property location details and coordinates.',
+                'priority': 'medium'
+            },
+            'property specification update': {
+                'title': 'Update Property Specifications',
+                'message': 'Review and update property specifications for accuracy.',
+                'priority': 'medium'
+            },
+            'image quality improvement': {
+                'title': 'Improve Image Quality',
+                'message': 'Add more high-quality images of the property.',
+                'priority': 'low'
+            },
+            'market value adjustment': {
+                'title': 'Market Value Review',
+                'message': 'Review and adjust market value based on current market conditions.',
+                'priority': 'high'
+            },
+            'contact information update': {
+                'title': 'Update Contact Information',
+                'message': 'Ensure contact information is complete and up-to-date.',
+                'priority': 'low'
+            }
+        }
+        
+        return details.get(suggestion_type, {
+            'title': 'General Suggestion',
+            'message': 'Review property listing for improvements.',
+            'priority': 'medium'
+        })
+        
+    except Exception as e:
+        logger.error(f"Error generating suggestion details: {str(e)}")
+        return {
+            'title': 'Error',
+            'message': 'Could not generate detailed suggestion.',
+            'priority': 'low'
+        }

models/text_quality.py

@@ -0,0 +1,120 @@
+# models/text_quality.py
+
+from .model_loader import load_model
+from .logging_config import logger
+
+def assess_text_quality(text):
+    try:
+        if not text or len(text.strip()) < 20:
+            return {
+                'assessment': 'insufficient',
+                'score': 0,
+                'reasoning': 'Text too short.',
+                'is_ai_generated': False,
+                'quality_metrics': {}
+            }
+
+        classifier = load_model("zero-shot-classification", "typeform/mobilebert-uncased-mnli")
+
+        # Enhanced quality categories with more specific indicators
+        quality_categories = [
+            "detailed and informative",
+            "adequately detailed",
+            "basic information",
+            "vague description",
+            "misleading content",
+            "professional listing",
+            "amateur listing",
+            "spam-like content",
+            "template-based content",
+            "authentic description"
+        ]
+
+        # Analyze text with multiple aspects
+        quality_result = classifier(text[:1000], quality_categories, multi_label=True)
+
+        # Get top classifications with confidence scores
+        top_classifications = []
+        for label, score in zip(quality_result['labels'][:3], quality_result['scores'][:3]):
+            if score > 0.3:  # Only include if confidence is above 30%
+                top_classifications.append({
+                    'classification': label,
+                    'confidence': float(score)
+                })
+
+        # AI generation detection with multiple models
+        ai_check = classifier(text[:1000], ["human-written", "AI-generated", "template-based", "authentic"])
+        is_ai_generated = (
+            (ai_check['labels'][0] == "AI-generated" and ai_check['scores'][0] > 0.6) or
+            (ai_check['labels'][0] == "template-based" and ai_check['scores'][0] > 0.7)
+        )
+
+        # Calculate quality metrics
+        quality_metrics = {
+            'detail_level': sum(score for label, score in zip(quality_result['labels'], quality_result['scores'])
+                              if label in ['detailed and informative', 'adequately detailed']),
+            'professionalism': sum(score for label, score in zip(quality_result['labels'], quality_result['scores'])
+                                 if label in ['professional listing', 'authentic description']),
+            'clarity': sum(score for label, score in zip(quality_result['labels'], quality_result['scores'])
+                         if label not in ['vague description', 'misleading content', 'spam-like content']),
+            'authenticity': 1.0 - sum(score for label, score in zip(quality_result['labels'], quality_result['scores'])
+                                    if label in ['template-based content', 'spam-like content'])
+        }
+
+        # Calculate overall score with weighted metrics
+        weights = {
+            'detail_level': 0.3,
+            'professionalism': 0.25,
+            'clarity': 0.25,
+            'authenticity': 0.2
+        }
+
+        score = sum(metric * weights[metric_name] for metric_name, metric in quality_metrics.items())
+        score = score * 100  # Convert to percentage
+
+        # Adjust score for AI-generated content
+        if is_ai_generated:
+            score = score * 0.7  # Reduce score by 30% for AI-generated content
+
+        # Generate detailed reasoning
+        reasoning_parts = []
+        if top_classifications:
+            primary_class = top_classifications[0]['classification']
+            reasoning_parts.append(f"Primary assessment: {primary_class}")
+
+        if quality_metrics['detail_level'] > 0.7:
+            reasoning_parts.append("Contains comprehensive details")
+        elif quality_metrics['detail_level'] > 0.4:
+            reasoning_parts.append("Contains adequate details")
+        else:
+            reasoning_parts.append("Lacks important details")
+
+        if quality_metrics['professionalism'] > 0.7:
+            reasoning_parts.append("Professional listing style")
+        elif quality_metrics['professionalism'] < 0.4:
+            reasoning_parts.append("Amateur listing style")
+
+        if quality_metrics['clarity'] < 0.5:
+            reasoning_parts.append("Content clarity issues detected")
+
+        if is_ai_generated:
+            reasoning_parts.append("Content appears to be AI-generated")
+
+        return {
+            'assessment': top_classifications[0]['classification'] if top_classifications else 'could not assess',
+            'score': int(score),
+            'reasoning': '. '.join(reasoning_parts),
+            'is_ai_generated': is_ai_generated,
+            'quality_metrics': quality_metrics,
+            'top_classifications': top_classifications
+        }
+    except Exception as e:
+        logger.error(f"Error assessing text quality: {str(e)}")
+        return {
+            'assessment': 'could not assess',
+            'score': 50,
+            'reasoning': 'Technical error.',
+            'is_ai_generated': False,
+            'quality_metrics': {},
+            'top_classifications': []
+        }

models/trust_score.py

@@ -0,0 +1,120 @@
+# models/trust_score.py
+
+from .model_loader import load_model
+from .logging_config import logger
+
+def generate_trust_score(text, image_analysis, pdf_analysis):
+    try:
+        classifier = load_model("zero-shot-classification", "typeform/mobilebert-uncased-mnli")
+        aspects = [
+            "complete information provided",
+            "verified location",
+            "consistent data",
+            "authentic documents",
+            "authentic images",
+            "reasonable pricing",
+            "verified ownership",
+            "proper documentation"
+        ]
+        result = classifier(text[:1000], aspects, multi_label=True)
+
+        # Much stricter weights with higher emphasis on critical aspects
+        weights = {
+            "complete information provided": 0.25,
+            "verified location": 0.20,
+            "consistent data": 0.15,
+            "authentic documents": 0.15,
+            "authentic images": 0.10,
+            "reasonable pricing": 0.05,
+            "verified ownership": 0.05,
+            "proper documentation": 0.05
+        }
+
+        score = 0
+        reasoning_parts = []
+
+        # Much stricter scoring for each aspect
+        for label, confidence in zip(result['labels'], result['scores']):
+            adjusted_confidence = confidence
+
+            # Stricter document verification
+            if label == "authentic documents":
+                if not pdf_analysis or len(pdf_analysis) == 0:
+                    adjusted_confidence = 0.0
+                else:
+                    doc_scores = [p.get('verification_score', 0) for p in pdf_analysis]
+                    adjusted_confidence = sum(doc_scores) / max(1, len(doc_scores))
+                    # Heavily penalize if any document has low verification score
+                    if any(score < 0.7 for score in doc_scores):
+                        adjusted_confidence *= 0.4
+                    # Additional penalty for missing documents
+                    if len(doc_scores) < 2:
+                        adjusted_confidence *= 0.5
+
+            # Stricter image verification
+            elif label == "authentic images":
+                if not image_analysis or len(image_analysis) == 0:
+                    adjusted_confidence = 0.0
+                else:
+                    img_scores = [i.get('authenticity_score', 0) for i in image_analysis]
+                    adjusted_confidence = sum(img_scores) / max(1, len(img_scores))
+                    # Heavily penalize if any image has low authenticity score
+                    if any(score < 0.8 for score in img_scores):
+                        adjusted_confidence *= 0.4
+                    # Additional penalty for AI-generated images
+                    if any(i.get('is_ai_generated', False) for i in image_analysis):
+                        adjusted_confidence *= 0.5
+                    # Additional penalty for non-property related images
+                    if any(not i.get('is_property_related', False) for i in image_analysis):
+                        adjusted_confidence *= 0.6
+
+            # Stricter consistency check
+            elif label == "consistent data":
+                # Check for inconsistencies in the data
+                if "inconsistent" in text.lower() or "suspicious" in text.lower():
+                    adjusted_confidence *= 0.3
+                # Check for impossible values
+                if "impossible" in text.lower() or "invalid" in text.lower():
+                    adjusted_confidence *= 0.2
+                # Check for missing critical information
+                if "missing" in text.lower() or "not provided" in text.lower():
+                    adjusted_confidence *= 0.4
+
+            # Stricter completeness check
+            elif label == "complete information provided":
+                # Check for missing critical information
+                if len(text) < 300 or "not provided" in text.lower() or "missing" in text.lower():
+                    adjusted_confidence *= 0.4
+                # Check for vague or generic descriptions
+                if "generic" in text.lower() or "vague" in text.lower():
+                    adjusted_confidence *= 0.5
+                # Check for suspiciously short descriptions
+                if len(text) < 150:
+                    adjusted_confidence *= 0.3
+
+            score += adjusted_confidence * weights.get(label, 0.1)
+            reasoning_parts.append(f"{label} ({adjusted_confidence:.0%})")
+
+        # Apply additional penalties for suspicious patterns
+        if "suspicious" in text.lower() or "fraudulent" in text.lower():
+            score *= 0.5
+
+        # Apply penalties for suspiciously low values
+        if "suspiciously low" in text.lower() or "unusually small" in text.lower():
+            score *= 0.6
+
+        # Apply penalties for inconsistencies
+        if "inconsistent" in text.lower() or "mismatch" in text.lower():
+            score *= 0.6
+
+        # Apply penalties for missing critical information
+        if "missing critical" in text.lower() or "incomplete" in text.lower():
+            score *= 0.7
+
+        # Ensure score is between 0 and 100
+        score = min(100, max(0, int(score * 100)))
+        reasoning = f"Based on: {', '.join(reasoning_parts)}"
+        return score, reasoning
+    except Exception as e:
+        logger.error(f"Error generating trust score: {str(e)}")
+        return 20, "Could not assess trust."

models/utils.py

@@ -0,0 +1,16 @@
+from .model_loader import load_model
+from .logging_config import logger
+
+def summarize_text(text):
+    try:
+        if not text or len(text.strip()) < 10:
+            return "No text to summarize."
+        summarizer = load_model("summarization", "sshleifer/distilbart-cnn-6-6") # Use the smaller model here too
+        input_length = len(text.split())
+        max_length = max(50, min(150, input_length // 2))
+        min_length = max(20, input_length // 4)
+        summary = summarizer(text[:2000], max_length=max_length, min_length=min_length, do_sample=False)
+        return summary[0]['summary_text']
+    except Exception as e:
+        logger.error(f"Error summarizing text: {str(e)}")
+        return text[:200] + "..." if len(text) > 200 else text 

requirements.txt

@@ -0,0 +1,24 @@
+flask==2.3.3
+flask-cors==4.0.0
+gunicorn==21.2.0
+geopy==2.4.1
+Pillow==10.0.0
+numpy==1.24.3
+transformers==4.35.0
+torch==2.1.0
+spacy==3.7.2
+python-dotenv==1.0.0
+requests==2.31.0
+python-magic==0.4.27
+pdf2image==1.16.3
+pytesseract==0.3.10
+scikit-learn==1.3.2
+pandas==2.1.1
+nltk==3.8.1
+beautifulsoup4==4.12.2
+lxml==4.9.3
+python-dateutil==2.8.2
+tqdm==4.66.1
+joblib==1.3.2
+huggingface-hub==0.19.4
+sentence-transformers==2.2.2 

templates/index.html.bak

@@ -0,0 +1,1916 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI Property Verifier</title>
+    <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        :root {
+            --primary: #4361ee;
+            --secondary: #3f37c9;
+            --success: #4cc9f0;
+            --danger: #f72585;
+            --warning: #f8961e;
+            --info: #4895ef;
+            --light: #f8f9fa;
+            --dark: #212529;
+            --gray: #6c757d;
+            --border-radius: 12px;
+            --box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+        }
+        
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Poppins', sans-serif;
+            background-color: #f5f7fa;
+            color: #333;
+            line-height: 1.6;
+            padding: 20px;
+        }
+        
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        
+        header {
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        
+        h1 {
+            font-size: 2.5rem;
+            color: var(--primary);
+            margin-bottom: 10px;
+        }
+        
+        .subtitle {
+            font-size: 1.1rem;
+            color: var(--gray);
+        }
+        
+        .card {
+            background: white;
+            border-radius: var(--border-radius);
+            box-shadow: var(--box-shadow);
+            padding: 25px;
+            margin-bottom: 25px;
+        }
+        
+        .card-header {
+            border-bottom: 1px solid #eee;
+            padding-bottom: 15px;
+            margin-bottom: 20px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        
+        .card-title {
+            font-size: 1.5rem;
+            color: var(--dark);
+            font-weight: 600;
+        }
+        
+        .form-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+            gap: 20px;
+        }
+        
+        .form-group {
+            margin-bottom: 20px;
+        }
+        
+        .form-label {
+            display: block;
+            margin-bottom: 8px;
+            font-weight: 500;
+            color: var(--dark);
+        }
+        
+        .form-control {
+            width: 100%;
+            padding: 12px 15px;
+            border: 1px solid #ddd;
+            border-radius: var(--border-radius);
+            font-size: 1rem;
+            transition: border-color 0.3s;
+        }
+        
+        .form-control:focus {
+            border-color: var(--primary);
+            outline: none;
+            box-shadow: 0 0 0 3px rgba(67, 97, 238, 0.1);
+        }
+        
+        textarea.form-control {
+            min-height: 100px;
+            resize: vertical;
+        }
+        
+        .btn {
+            display: inline-block;
+            padding: 12px 24px;
+            background-color: var(--primary);
+            color: white;
+            border: none;
+            border-radius: var(--border-radius);
+            font-size: 1rem;
+            font-weight: 500;
+            cursor: pointer;
+            transition: all 0.3s;
+        }
+        
+        .btn:hover {
+            background-color: var(--secondary);
+            transform: translateY(-2px);
+        }
+        
+        .btn-block {
+            display: block;
+            width: 100%;
+        }
+        
+        .section-title {
+            font-size: 1.2rem;
+            color: var(--primary);
+            margin-bottom: 15px;
+            font-weight: 600;
+        }
+        
+        .results-container {
+            display: none;
+            margin-top: 30px;
+        }
+        
+        .results-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(450px, 1fr));
+    gap: 25px;
+}
+
+        
+        .result-card {
+            background: white;
+            border-radius: var(--border-radius);
+            box-shadow: var(--box-shadow);
+            padding: 20px;
+            height: 100%;
+        }
+        
+        .result-header {
+            display: flex;
+            align-items: center;
+            margin-bottom: 15px;
+        }
+        
+        .result-icon {
+            width: 40px;
+            height: 40px;
+            background-color: var(--light);
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            margin-right: 15px;
+        }
+        
+        .result-title {
+            font-size: 1.2rem;
+            font-weight: 600;
+            color: var(--dark);
+        }
+        
+        .trust-score {
+            text-align: center;
+            padding: 20px;
+        }
+        
+        .score-value {
+            font-size: 3rem;
+            font-weight: 700;
+            color: var(--primary);
+        }
+        
+        .score-label {
+            font-size: 1rem;
+            color: var(--gray);
+        }
+        
+        .progress-container {
+            margin: 15px 0;
+        }
+        
+        .progress-bar {
+            height: 10px;
+            background-color: #eee;
+            border-radius: 5px;
+            overflow: hidden;
+        }
+        
+        .progress-fill {
+            height: 100%;
+            background-color: var(--primary);
+            border-radius: 5px;
+            transition: width 0.5s ease-in-out;
+        }
+        
+        .alert {
+            padding: 15px;
+            border-radius: var(--border-radius);
+            margin-bottom: 20px;
+            font-weight: 500;
+        }
+        
+        .alert-danger {
+            background-color: rgba(247, 37, 133, 0.1);
+            color: var(--danger);
+            border-left: 4px solid var(--danger);
+        }
+        
+        .alert-warning {
+            background-color: rgba(248, 150, 30, 0.1);
+            color: var(--warning);
+            border-left: 4px solid var(--warning);
+        }
+        
+        .alert-success {
+            background-color: rgba(76, 201, 240, 0.1);
+            color: var(--success);
+            border-left: 4px solid var(--success);
+        }
+        
+        .suggestion-list {
+            list-style-type: none;
+            padding: 0;
+        }
+        
+        .suggestion-item {
+            padding: 10px 15px;
+            background-color: rgba(67, 97, 238, 0.05);
+            border-radius: var(--border-radius);
+            margin-bottom: 10px;
+            border-left: 3px solid var(--primary);
+        }
+        
+        .image-preview {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+            margin-top: 10px;
+        }
+        
+        .preview-item {
+            width: 100px;
+            height: 100px;
+            border-radius: 8px;
+            overflow: hidden;
+            position: relative;
+        }
+        
+        .preview-item img {
+            width: 100%;
+            height: 100%;
+            object-fit: cover;
+        }
+        
+        .preview-remove {
+            position: absolute;
+            top: 5px;
+            right: 5px;
+            background: rgba(0, 0, 0, 0.5);
+            color: white;
+            border: none;
+            border-radius: 50%;
+            width: 20px;
+            height: 20px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            cursor: pointer;
+        }
+        
+        .loading {
+            display: none;
+            text-align: center;
+            padding: 30px;
+        }
+        
+        .spinner {
+            width: 50px;
+            height: 50px;
+            border: 5px solid rgba(67, 97, 238, 0.1);
+            border-radius: 50%;
+            border-top-color: var(--primary);
+            animation: spin 1s ease-in-out infinite;
+            margin: 0 auto 20px;
+        }
+        
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+        
+        .chart-container {
+            position: relative;
+            height: 200px;
+            margin-bottom: 20px;
+        }
+        
+        .pdf-preview {
+            background-color: #f8f9fa;
+            padding: 15px;
+            border-radius: var(--border-radius);
+            margin-top: 10px;
+            max-height: 200px;
+            overflow-y: auto;
+        }
+        
+        .pdf-filename {
+            font-weight: 500;
+            margin-bottom: 5px;
+        }
+        
+        .image-gallery {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
+            gap: 15px;
+            margin-top: 20px;
+        }
+        
+        .gallery-item {
+            border-radius: var(--border-radius);
+            overflow: hidden;
+            box-shadow: var(--box-shadow);
+            aspect-ratio: 1;
+        }
+        
+        .gallery-item img {
+            width: 100%;
+            height: 100%;
+            object-fit: cover;
+        }
+        
+        .badge {
+            display: inline-block;
+            padding: 5px 10px;
+            border-radius: 20px;
+            font-size: 0.8rem;
+            font-weight: 500;
+            margin-right: 5px;
+            margin-bottom: 5px;
+        }
+        
+        .badge-primary { background-color: rgba(67, 97, 238, 0.1); color: var(--primary); }
+        .badge-success { background-color: rgba(76, 201, 240, 0.1); color: var(--success); }
+        .badge-warning { background-color: rgba(248, 150, 30, 0.1); color: var(--warning); }
+        .badge-danger { background-color: rgba(247, 37, 133, 0.1); color: var(--danger); }
+        
+        .explanation-box {
+            background-color: #f8f9fa;
+            border-radius: var(--border-radius);
+            padding: 15px;
+            margin-top: 15px;
+            border-left: 4px solid var(--info);
+        }
+        
+        .explanation-title {
+            font-weight: 600;
+            color: var(--info);
+            margin-bottom: 10px;
+        }
+        
+        @media (max-width: 768px) {
+            .form-grid, .results-grid {
+                grid-template-columns: 1fr;
+            }
+            
+            .card {
+                padding: 15px;
+            }
+        }
+        
+        .property-summary {
+            padding: 15px;
+        }
+        
+        .property-details p {
+            margin-bottom: 8px;
+        }
+        
+        .final-verdict {
+            padding: 15px;
+        }
+        
+        .verdict-box {
+            display: flex;
+            align-items: center;
+            padding: 15px;
+            border-radius: var(--border-radius);
+            margin-bottom: 15px;
+            background-color: #f8f9fa;
+        }
+        
+        .verdict-icon {
+            font-size: 2rem;
+            margin-right: 15px;
+        }
+        
+        .verdict-text {
+            font-size: 1.2rem;
+            font-weight: 600;
+        }
+        
+        .verdict-legitimate {
+            background-color: rgba(76, 201, 240, 0.1);
+            border-left: 4px solid var(--success);
+        }
+        
+        .verdict-suspicious {
+            background-color: rgba(248, 150, 30, 0.1);
+            border-left: 4px solid var(--warning);
+        }
+        
+        .verdict-fraudulent {
+            background-color: rgba(247, 37, 133, 0.1);
+            border-left: 4px solid var(--danger);
+        }
+        
+        .verification-scores {
+            padding: 15px;
+        }
+        
+        .score-item {
+            margin-bottom: 15px;
+        }
+        
+        .score-label {
+            font-weight: 500;
+            margin-bottom: 5px;
+        }
+        
+        .score-bar-container {
+            display: flex;
+            align-items: center;
+        }
+        
+        .score-bar {
+            height: 10px;
+            background-color: #e9ecef;
+            border-radius: 5px;
+            flex-grow: 1;
+            margin-right: 10px;
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .score-bar::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            height: 100%;
+            background-color: var(--primary);
+            border-radius: 5px;
+            width: 0%;
+            transition: width 0.5s ease;
+        }
+        
+        .score-value {
+            font-weight: 600;
+            min-width: 40px;
+            text-align: right;
+        }
+        
+        .red-flags {
+            padding: 15px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>AI Property Verifier & Fraud Detection</h1>
+            <p class="subtitle">Powered by advanced AI models to verify property listings and detect potential fraud</p>
+        </header>
+        
+        <div class="card">
+            <div class="card-header">
+                <h2 class="card-title">Property Details</h2>
+            </div>
+            
+                <form id="propertyForm">
+                <div class="section-title">Basic Information</div>
+                    <div class="form-grid">
+                        <div class="form-group">
+                        <label class="form-label" for="propertyName">Property Name</label>
+                        <input type="text" class="form-control" id="propertyName" name="property_name" required>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="propertyType">Property Type</label>
+                        <select class="form-control" id="propertyType" name="property_type" required>
+                            <option value="">Select Type</option>
+                                <option value="Apartment">Apartment</option>
+                                <option value="House">House</option>
+                                <option value="Condo">Condo</option>
+                                <option value="Townhouse">Townhouse</option>
+                            <option value="Villa">Villa</option>
+                                <option value="Land">Land</option>
+                                <option value="Commercial">Commercial</option>
+                                <option value="Other">Other</option>
+                            </select>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="status">Status</label>
+                        <select class="form-control" id="status" name="status" required>
+                            <option value="">Select Status</option>
+                                <option value="For Sale">For Sale</option>
+                                <option value="For Rent">For Rent</option>
+                                <option value="Sold">Sold</option>
+                            <option value="Under Contract">Under Contract</option>
+                                <option value="Pending">Pending</option>
+                            </select>
+                        </div>
+                        </div>
+                        
+                <div class="form-group">
+                    <label class="form-label" for="description">Property Description</label>
+                    <textarea class="form-control" id="description" name="description" rows="4" required></textarea>
+                    </div>
+                    
+                <div class="section-title">Location Details</div>
+                    <div class="form-grid">
+                        <div class="form-group">
+                        <label class="form-label" for="address">Address</label>
+                        <input type="text" class="form-control" id="address" name="address" required>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="city">City</label>
+                        <input type="text" class="form-control" id="city" name="city" required>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="state">State/Province</label>
+                        <input type="text" class="form-control" id="state" name="state" required>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="country">Country</label>
+                        <input type="text" class="form-control" id="country" name="country" required>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="zip">Zip/Postal Code</label>
+                        <input type="text" class="form-control" id="zip" name="zip" required>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="latitude">Latitude</label>
+                        <input type="text" class="form-control" id="latitude" name="latitude" placeholder="e.g. 40.7128">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="longitude">Longitude</label>
+                        <input type="text" class="form-control" id="longitude" name="longitude" placeholder="e.g. -74.0060">
+                        </div>
+                    </div>
+                    
+                <div class="section-title">Property Specifications</div>
+                    <div class="form-grid">
+                        <div class="form-group">
+                        <label class="form-label" for="bedrooms">Bedrooms</label>
+                        <input type="number" class="form-control" id="bedrooms" name="bedrooms" min="0">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="bathrooms">Bathrooms</label>
+                        <input type="number" class="form-control" id="bathrooms" name="bathrooms" min="0" step="0.5">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="totalRooms">Total Rooms</label>
+                        <input type="number" class="form-control" id="totalRooms" name="total_rooms" min="0">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="yearBuilt">Year Built</label>
+                        <input type="number" class="form-control" id="yearBuilt" name="year_built" min="1800" max="2100">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="parking">Parking Spaces</label>
+                        <input type="number" class="form-control" id="parking" name="parking" min="0">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="sqFt">Square Feet</label>
+                        <input type="text" class="form-control" id="sqFt" name="sq_ft" min="0">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="marketValue">Market Value</label>
+                        <input type="text" class="form-control" id="marketValue" name="market_value" min="0">
+                    </div>
+                        </div>
+                        
+                        <div class="form-group">
+                    <label class="form-label" for="amenities">Amenities (comma separated)</label>
+                    <input type="text" class="form-control" id="amenities" name="amenities" placeholder="e.g. Pool, Gym, Garden, Garage">
+                        </div>
+                        
+                        <div class="form-group">
+                    <label class="form-label" for="nearbyLandmarks">Nearby Landmarks</label>
+                    <input type="text" class="form-control" id="nearbyLandmarks" name="nearby_landmarks" placeholder="e.g. School, Hospital, Park, Shopping Mall">
+                        </div>
+                        
+                        <div class="form-group">
+                    <label class="form-label" for="legalDetails">Legal & Infrastructure Details</label>
+                    <textarea class="form-control" id="legalDetails" name="legal_details" rows="3" placeholder="Include zoning, permits, utilities, etc."></textarea>
+                        </div>
+                
+                <div class="section-title">Documents & Images</div>
+                <div class="form-group">
+                    <label class="form-label" for="images">Upload Images (JPG/PNG)</label>
+                    <input type="file" class="form-control" id="images" name="images" accept="image/jpeg, image/png" multiple>
+                    <div class="image-preview" id="imagePreview"></div>
+                    </div>
+                    
+                        <div class="form-group">
+                    <label class="form-label" for="documents">Upload Documents (PDF)</label>
+                    <input type="file" class="form-control" id="documents" name="documents" accept="application/pdf" multiple>
+                    <div id="pdfPreview"></div>
+                            </div>
+                        
+                        <div class="form-group">
+                    <button type="submit" class="btn btn-block" id="submitBtn">Verify Property with AI</button>
+                </div>
+            </form>
+                        </div>
+                        
+        <div class="loading" id="loadingIndicator">
+            <div class="spinner"></div>
+            <p>AI models are analyzing your property data...</p>
+            <p class="subtitle">This may take a moment as we're processing multiple AI models</p>
+                            </div>
+        
+        <div class="results-container" id="resultsContainer">
+            <div class="card">
+                <div class="card-header">
+                    <h2 class="card-title">AI Verification Results</h2>
+                        </div>
+                        
+                <div class="results-grid">
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🏠</div>
+                            <div class="result-title">Property Summary</div>
+                        </div>
+                        <div class="property-summary">
+                            <h3 id="propertyTitle">Property Details</h3>
+                            <div class="property-details">
+                                <p><strong>Name:</strong> <span id="summaryName"></span></p>
+                                <p><strong>Type:</strong> <span id="summaryType"></span></p>
+                                <p><strong>Status:</strong> <span id="summaryStatus"></span></p>
+                                <p><strong>Location:</strong> <span id="summaryLocation"></span></p>
+                                <p><strong>Price:</strong> <span id="summaryPrice"></span></p>
+                                <p><strong>Size:</strong> <span id="summarySize"></span></p>
+                                <p><strong>Bedrooms/Bathrooms:</strong> <span id="summaryRooms"></span></p>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">⚠️</div>
+                            <div class="result-title">Final Verdict</div>
+                        </div>
+                        <div class="final-verdict" id="finalVerdict">
+                            <div class="verdict-box" id="verdictBox">
+                                <div class="verdict-icon" id="verdictIcon">⏳</div>
+                                <div class="verdict-text" id="verdictText">Analysis in progress...</div>
+                            </div>
+                            <div class="verdict-reasons">
+                                <h4>Key Findings:</h4>
+                                <ul id="verdictReasons" class="suggestion-list">
+                                    <!-- Will be populated by JavaScript -->
+                                </ul>
+                            </div>
+                        </div>
+            </div>
+            
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🔍</div>
+                            <div class="result-title">Detailed Verification</div>
+                        </div>
+                        <div class="verification-scores">
+                            <div class="score-item">
+                                <div class="score-label">Trust Score</div>
+                                <div class="score-bar-container">
+                                    <div class="score-bar" id="trustBar"></div>
+                                    <div class="score-value" id="trustValue">--</div>
+                                </div>
+                            </div>
+                            <div class="score-item">
+                                <div class="score-label">Image Authenticity</div>
+                                <div class="score-bar-container">
+                                    <div class="score-bar" id="imageBar"></div>
+                                    <div class="score-value" id="imageValue">--</div>
+                                </div>
+                            </div>
+                            <div class="score-item">
+                                <div class="score-label">Document Verification</div>
+                                <div class="score-bar-container">
+                                    <div class="score-bar" id="documentBar"></div>
+                                    <div class="score-value" id="documentValue">--</div>
+                                </div>
+                            </div>
+                            <div class="score-item">
+                                <div class="score-label">Content Quality</div>
+                                <div class="score-bar-container">
+                                    <div class="score-bar" id="contentBar"></div>
+                                    <div class="score-value" id="contentValue">--</div>
+                                </div>
+                            </div>
+                            <div class="score-item">
+                                <div class="score-label">Location Accuracy</div>
+                                <div class="score-bar-container">
+                                    <div class="score-bar" id="locationBar"></div>
+                                    <div class="score-value" id="locationValue">--</div>
+                                </div>
+                            </div>
+                        </div>
+                </div>
+                
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🚩</div>
+                            <div class="result-title">Red Flags</div>
+                        </div>
+                        <div class="red-flags">
+                            <ul id="redFlagsList" class="suggestion-list">
+                                <!-- Will be populated by JavaScript -->
+                            </ul>
+                    </div>
+                </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">📊</div>
+                            <div class="result-title">Trust Score</div>
+                        </div>
+                        <div class="trust-score">
+                            <div class="score-value" id="trustScoreValue">--</div>
+                            <div class="score-label">Trust Score</div>
+                            <div class="progress-container">
+                                <div class="progress-bar">
+                                    <div class="progress-fill" id="trustScoreBar" style="width: 0%"></div>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="chart-container">
+                            <canvas id="trustScoreChart"></canvas>
+                        </div>
+                        <div class="explanation-box">
+                            <div class="explanation-title">AI Reasoning</div>
+                            <div id="trustReasoning"></div>
+                        </div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🔍</div>
+                            <div class="result-title">Fraud Analysis</div>
+                            </div>
+                        <div id="fraudAlertContainer"></div>
+                        <div class="chart-container">
+                            <canvas id="fraudAnalysisChart"></canvas>
+                        </div>
+                        <div class="explanation-box">
+                            <div class="explanation-title">AI Reasoning</div>
+                            <div id="fraudReasoning"></div>
+                        </div>
+            </div>
+            
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">📝</div>
+                            <div class="result-title">AI Summary</div>
+                        </div>
+                        <div id="aiSummary"></div>
+                </div>
+                
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">💡</div>
+                            <div class="result-title">Improvement Suggestions</div>
+                        </div>
+                        <ul class="suggestion-list" id="suggestionsList"></ul>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🏠</div>
+                            <div class="result-title">Property Quality Assessment</div>
+                </div>
+                        <div id="qualityAssessment"></div>
+                        <div class="chart-container">
+                            <canvas id="qualityChart"></canvas>
+                        </div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">📍</div>
+                            <div class="result-title">Location Analysis</div>
+                        </div>
+                        <div id="locationAnalysis"></div>
+                        <div class="chart-container">
+                            <canvas id="locationChart"></canvas>
+                        </div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">💰</div>
+                            <div class="result-title">Price Analysis</div>
+                        </div>
+                        <div id="priceAnalysis"></div>
+                        <div class="chart-container">
+                            <canvas id="priceChart"></canvas>
+                        </div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">⚖️</div>
+                            <div class="result-title">Legal Analysis</div>
+                        </div>
+                        <div id="legalAnalysis"></div>
+                        <div class="chart-container">
+                            <canvas id="legalChart"></canvas>
+                        </div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🔄</div>
+                            <div class="result-title">Cross-Validation Checks</div>
+                        </div>
+                        <div id="crossValidation"></div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">📄</div>
+                            <div class="result-title">Document Analysis</div>
+                        </div>
+                        <div id="documentAnalysis"></div>
+                        <div class="chart-container">
+                            <canvas id="documentChart"></canvas>
+                        </div>
+                    </div>
+                
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🖼️</div>
+                            <div class="result-title">Image Analysis</div>
+                        </div>
+                        <div id="imageAnalysis"></div>
+                        <div class="image-gallery" id="imageGallery"></div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <script>
+        // Global variables to store form data
+        let uploadedImages = [];
+        let uploadedPDFs = [];
+        
+        // Initialize charts
+        let trustScoreChart;
+        let fraudAnalysisChart;
+        let qualityChart;
+        let locationChart;
+        let priceChart;
+        let legalChart;
+        let documentChart;
+        
+        document.addEventListener('DOMContentLoaded', function() {
+            // Request location access when page loads
+            requestLocationAccess();
+            
+            const propertyForm = document.getElementById('propertyForm');
+            const loadingIndicator = document.getElementById('loadingIndicator');
+            const resultsContainer = document.getElementById('resultsContainer');
+            const imageInput = document.getElementById('images');
+            const imagePreview = document.getElementById('imagePreview');
+            const pdfInput = document.getElementById('documents');
+            const pdfPreview = document.getElementById('pdfPreview');
+            
+            // Handle image uploads
+            imageInput.addEventListener('change', function(e) {
+                handleImageUpload(e.target.files);
+            });
+            
+            // Handle PDF uploads
+            pdfInput.addEventListener('change', function(e) {
+                handlePDFUpload(e.target.files);
+            });
+            
+            // Form submission
+            propertyForm.addEventListener('submit', function(e) {
+                e.preventDefault();
+                submitForm();
+            });
+            
+            // Initialize charts
+            initCharts();
+        });
+        
+        function requestLocationAccess() {
+            if (navigator.geolocation) {
+                navigator.geolocation.getCurrentPosition(
+                    function(position) {
+                        const latitude = position.coords.latitude;
+                        const longitude = position.coords.longitude;
+                        
+                        // Update form fields with coordinates
+                        document.getElementById('latitude').value = latitude;
+                        document.getElementById('longitude').value = longitude;
+                        
+                        // Send to backend to get address details
+                        fetch('/get-location', {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                            },
+                            body: JSON.stringify({
+                                latitude: latitude,
+                                longitude: longitude
+                            }),
+                        })
+                        .then(response => response.json())
+                        .then(data => {
+                            if (data.status === 'success') {
+                                // Fill form fields with location data
+                                document.getElementById('address').value = data.address || '';
+                                document.getElementById('city').value = data.city || '';
+                                document.getElementById('state').value = data.state || '';
+                                document.getElementById('country').value = data.country || '';
+                                document.getElementById('zip').value = data.postal_code || '';
+                                
+                                console.log('Location data loaded successfully');
+                            } else {
+                                console.error('Error getting location details:', data.message);
+                            }
+                        })
+                        .catch(error => {
+                            console.error('Error getting location details:', error);
+                        });
+                    },
+                    function(error) {
+                        console.error('Error getting location:', error.message);
+                        // Show a message to the user about location access
+                        const locationMessage = document.createElement('div');
+                        locationMessage.className = 'alert alert-warning';
+                        locationMessage.innerHTML = 'Location access denied or unavailable. Please enter your location manually.';
+                        document.querySelector('.container').prepend(locationMessage);
+                        
+                        // Auto-remove the message after 5 seconds
+                        setTimeout(() => {
+                            locationMessage.remove();
+                        }, 5000);
+                    },
+                    {
+                        enableHighAccuracy: true,
+                        timeout: 5000,
+                        maximumAge: 0
+                    }
+                );
+            } else {
+                console.error('Geolocation is not supported by this browser');
+            }
+        }
+        
+        function handleImageUpload(files) {
+            const imagePreview = document.getElementById('imagePreview');
+            
+            for (let i = 0; i < files.length; i++) {
+                const file = files[i];
+                if (!file.type.match('image.*')) continue;
+                
+                const reader = new FileReader();
+                reader.onload = function(e) {
+                    const imageData = e.target.result;
+                    uploadedImages.push({
+                        name: file.name,
+                        data: imageData,
+                        file: file
+                    });
+                    
+                    // Create preview
+                    const previewItem = document.createElement('div');
+                    previewItem.className = 'preview-item';
+                    previewItem.innerHTML = `
+                        <img src="${imageData}" alt="${file.name}">
+                        <button type="button" class="preview-remove" data-index="${uploadedImages.length - 1}">×</button>
+                    `;
+                    imagePreview.appendChild(previewItem);
+                    
+                    // Add remove functionality
+                    previewItem.querySelector('.preview-remove').addEventListener('click', function() {
+                        const index = parseInt(this.getAttribute('data-index'));
+                        uploadedImages.splice(index, 1);
+                        imagePreview.removeChild(previewItem);
+                        updateImagePreviews();
+                    });
+                };
+                reader.readAsDataURL(file);
+            }
+        }
+        
+        function updateImagePreviews() {
+            const imagePreview = document.getElementById('imagePreview');
+            imagePreview.innerHTML = '';
+            
+            uploadedImages.forEach((image, index) => {
+                const previewItem = document.createElement('div');
+                previewItem.className = 'preview-item';
+                previewItem.innerHTML = `
+                    <img src="${image.data}" alt="${image.name}">
+                    <button type="button" class="preview-remove" data-index="${index}">×</button>
+                `;
+                imagePreview.appendChild(previewItem);
+                
+                previewItem.querySelector('.preview-remove').addEventListener('click', function() {
+                    uploadedImages.splice(index, 1);
+                    updateImagePreviews();
+                });
+            });
+        }
+        
+        function handlePDFUpload(files) {
+            const pdfPreview = document.getElementById('pdfPreview');
+            
+            for (let i = 0; i < files.length; i++) {
+                const file = files[i];
+                if (file.type !== 'application/pdf') continue;
+                
+                uploadedPDFs.push({
+                    name: file.name,
+                    file: file
+                });
+                
+                // Create preview
+                const previewItem = document.createElement('div');
+                previewItem.className = 'pdf-preview';
+                previewItem.innerHTML = `
+                    <div class="pdf-filename">${file.name}</div>
+                    <button type="button" class="btn" data-index="${uploadedPDFs.length - 1}">Remove</button>
+                `;
+                pdfPreview.appendChild(previewItem);
+                
+                // Add remove functionality
+                previewItem.querySelector('.btn').addEventListener('click', function() {
+                    const index = parseInt(this.getAttribute('data-index'));
+                    uploadedPDFs.splice(index, 1);
+                    pdfPreview.removeChild(previewItem);
+                    updatePDFPreviews();
+                });
+            }
+        }
+        
+        function updatePDFPreviews() {
+            const pdfPreview = document.getElementById('pdfPreview');
+            pdfPreview.innerHTML = '';
+            
+            uploadedPDFs.forEach((pdf, index) => {
+                const previewItem = document.createElement('div');
+                previewItem.className = 'pdf-preview';
+                previewItem.innerHTML = `
+                    <div class="pdf-filename">${pdf.name}</div>
+                    <button type="button" class="btn" data-index="${index}">Remove</button>
+                `;
+                pdfPreview.appendChild(previewItem);
+                
+                previewItem.querySelector('.btn').addEventListener('click', function() {
+                    uploadedPDFs.splice(index, 1);
+                    updatePDFPreviews();
+                });
+            });
+        }
+        
+        function initCharts() {
+            try {
+                // Store all charts in an array for easier management
+                window.charts = [];
+                
+                // Trust Score Chart initialization
+                const trustCtx = document.getElementById('trustScoreChart').getContext('2d');
+                trustScoreChart = new Chart(trustCtx, {
+                type: 'doughnut',
+                data: {
+                    datasets: [{
+                        data: [0, 100],
+                        backgroundColor: [
+                            '#4361ee',
+                            '#f1f1f1'
+                        ],
+                        borderWidth: 0
+                    }]
+                },
+                options: {
+                    cutout: '70%',
+                    circumference: 180,
+                    rotation: -90,
+                    plugins: {
+                        legend: {
+                            display: false
+                        },
+                        tooltip: {
+                            enabled: false
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+                charts.push(trustScoreChart);
+            
+            // Fraud Analysis Chart (Bar)
+            const fraudAnalysisCtx = document.getElementById('fraudAnalysisChart').getContext('2d');
+            fraudAnalysisChart = new Chart(fraudAnalysisCtx, {
+                type: 'bar',
+                data: {
+                    labels: ['Legitimate', 'Suspicious', 'Fraudulent'],
+                    datasets: [{
+                        label: 'Fraud Indicators',
+                        data: [0, 0, 0],
+                        backgroundColor: [
+                            '#4cc9f0',
+                            '#f8961e',
+                            '#f72585'
+                        ],
+                        borderWidth: 0
+                    }]
+                },
+                options: {
+                    indexAxis: 'y',
+                    plugins: {
+                        legend: {
+                            display: false
+                        }
+                    },
+                    scales: {
+                        x: {
+                            beginAtZero: true,
+                            max: 100
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+            
+            // Quality Assessment Chart
+            const qualityCtx = document.getElementById('qualityChart').getContext('2d');
+            qualityChart = new Chart(qualityCtx, {
+                type: 'radar',
+                data: {
+                    labels: ['Completeness', 'Accuracy', 'Clarity', 'Authenticity', 'Detail'],
+                    datasets: [{
+                        label: 'Quality Score',
+                        data: [0, 0, 0, 0, 0],
+                        backgroundColor: 'rgba(67, 97, 238, 0.2)',
+                        borderColor: '#4361ee',
+                        borderWidth: 2,
+                        pointBackgroundColor: '#4361ee'
+                    }]
+                },
+                options: {
+                    scales: {
+                        r: {
+                            beginAtZero: true,
+                            max: 100
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+            
+            // Location Analysis Chart
+            const locationCtx = document.getElementById('locationChart').getContext('2d');
+            locationChart = new Chart(locationCtx, {
+                type: 'pie',
+                data: {
+                    labels: ['Complete', 'Partial', 'Missing'],
+                    datasets: [{
+                        data: [0, 0, 0],
+                        backgroundColor: [
+                            '#4cc9f0',
+                            '#f8961e',
+                            '#f72585'
+                        ],
+                        borderWidth: 0
+                    }]
+                },
+                options: {
+                    plugins: {
+                        legend: {
+                            position: 'bottom'
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+            
+            // Price Analysis Chart
+            const priceCtx = document.getElementById('priceChart').getContext('2d');
+            priceChart = new Chart(priceCtx, {
+                type: 'bar',
+                data: {
+                    labels: ['Market Value', 'Price per Sq.Ft.'],
+                    datasets: [{
+                        label: 'Price Analysis',
+                        data: [0, 0],
+                        backgroundColor: [
+                            '#4361ee',
+                            '#4895ef'
+                        ],
+                        borderWidth: 0
+                    }]
+                },
+                options: {
+                    scales: {
+                        y: {
+                            beginAtZero: true
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+            
+            // Legal Analysis Chart
+            const legalCtx = document.getElementById('legalChart').getContext('2d');
+            legalChart = new Chart(legalCtx, {
+                type: 'doughnut',
+                data: {
+                    labels: ['Complete', 'Partial', 'Missing'],
+                    datasets: [{
+                        data: [0, 0, 0],
+                        backgroundColor: [
+                            '#4cc9f0',
+                            '#f8961e',
+                            '#f72585'
+                        ],
+                        borderWidth: 0
+                    }]
+                },
+                options: {
+                    plugins: {
+                        legend: {
+                            position: 'bottom'
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+            
+            // Document Analysis Chart
+            const documentCtx = document.getElementById('documentChart').getContext('2d');
+            documentChart = new Chart(documentCtx, {
+                type: 'polarArea',
+                data: {
+                    labels: ['Authentic', 'Suspicious', 'Incomplete'],
+                    datasets: [{
+                        data: [0, 0, 0],
+                        backgroundColor: [
+                            '#4cc9f0',
+                            '#f8961e',
+                            '#f72585'
+                        ],
+                        borderWidth: 0
+                    }]
+                },
+                options: {
+                    plugins: {
+                        legend: {
+                            position: 'bottom'
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+                
+                // Add window resize handler for chart responsiveness
+                window.addEventListener('resize', debounce(() => {
+                    charts.forEach(chart => {
+                        if (chart && typeof chart.resize === 'function') {
+                            chart.resize();
+                        }
+                    });
+                }, 250));
+                
+            } catch (error) {
+                console.error('Error initializing charts:', error);
+                document.getElementById('chartErrors').innerHTML = 
+                    '<div class="alert alert-danger">Error initializing charts. Please refresh the page.</div>';
+            }
+        }
+        
+        // Utility function for debouncing
+        function debounce(func, wait) {
+            let timeout;
+            return function executedFunction(...args) {
+                const later = () => {
+                    clearTimeout(timeout);
+                    func(...args);
+                };
+                clearTimeout(timeout);
+                timeout = setTimeout(later, wait);
+            };
+        }
+        
+        // Data validation function
+        function validateAnalysisData(data) {
+            return {
+                trustScore: {
+                    score: data.trust_score?.score ?? 0,
+                    reasoning: data.trust_score?.reasoning ?? 'No reasoning provided'
+                },
+                fraudClassification: {
+                    alertLevel: data.fraud_classification?.alert_level ?? 'low',
+                    classification: data.fraud_classification?.classification ?? 'Unknown',
+                    confidence: data.fraud_classification?.confidence ?? 0,
+                    indicators: data.fraud_classification?.fraud_indicators ?? [],
+                    scores: data.fraud_classification?.indicator_scores ?? []
+                },
+                qualityAssessment: {
+                    assessment: data.quality_assessment?.assessment ?? 'Unknown',
+                    score: data.quality_assessment?.score ?? 0,
+                    isAiGenerated: data.quality_assessment?.is_ai_generated ?? false,
+                    reasoning: data.quality_assessment?.reasoning ?? 'No reasoning provided'
+                },
+                // ... other validations
+            };
+        }
+        
+        // Safe chart update function
+        function updateChart(chart, newData, options = {}) {
+            try {
+                if (chart && typeof chart.update === 'function') {
+                    chart.data = newData;
+                    chart.update(options);
+                    return true;
+                }
+                return false;
+            } catch (error) {
+                console.error('Error updating chart:', error);
+                return false;
+            }
+        }
+        
+        function submitForm() {
+            // Show loading indicator
+            document.getElementById('loadingIndicator').style.display = 'block';
+            document.getElementById('resultsContainer').style.display = 'none';
+            
+            // Create form data
+            const formData = new FormData(document.getElementById('propertyForm'));
+            
+            // Add images
+            uploadedImages.forEach((image, index) => {
+                formData.append('images', image.file);
+            });
+            
+            // Add PDFs
+            uploadedPDFs.forEach((pdf, index) => {
+                formData.append('documents', pdf.file);
+            });
+            
+            // Send to backend
+            fetch('/verify', {
+                    method: 'POST',
+                    body: formData
+                })
+            .then(response => {
+                if (!response.ok) {
+                    throw new Error('Network response was not ok');
+                }
+                return response.json();
+            })
+                .then(data => {
+                // Hide loading indicator
+                document.getElementById('loadingIndicator').style.display = 'none';
+                
+                // Display results
+                displayResults(data);
+                
+                // Show results container
+                document.getElementById('resultsContainer').style.display = 'block';
+                
+                // Scroll to results
+                document.getElementById('resultsContainer').scrollIntoView({ behavior: 'smooth' });
+                })
+                .catch(error => {
+                console.error('Error:', error);
+                document.getElementById('loadingIndicator').style.display = 'none';
+                alert('An error occurred while processing your request. Please try again.');
+            });
+        }
+        function displayResults(data) {
+            console.log("Received data:", JSON.stringify(data));
+
+            // Validate and sanitize data
+            const validatedData = validateAnalysisData(data);
+            
+            try {
+                // Display Trust Score with validated data
+                const trustScore = validatedData.trustScore.score;
+                document.getElementById('trustScoreValue').textContent = trustScore;
+                document.getElementById('trustScoreBar').style.width = `${trustScore}%`;
+                document.getElementById('trustReasoning').textContent = validatedData.trustScore.reasoning;
+                
+                // Update Trust Score Chart safely
+                updateChart(trustScoreChart, {
+                    datasets: [{
+                        data: [trustScore, 100 - trustScore]
+                    }]
+                });
+                
+                // Display Fraud Analysis
+                const fraudLevel = validatedData.fraudClassification.alertLevel;
+                const fraudContainer = document.getElementById('fraudAlertContainer');
+                fraudContainer.innerHTML = '';
+
+                const alertClass = fraudLevel === 'high' ? 'alert-danger' :
+                                  fraudLevel === 'medium' ? 'alert-warning' : 'alert-success';
+
+                const alertDiv = document.createElement('div');
+                alertDiv.className = `alert ${alertClass}`;
+                alertDiv.textContent = `Classification: ${validatedData.fraudClassification.classification} (Confidence: ${Math.round(validatedData.fraudClassification.confidence * 100)}%)`;
+                fraudContainer.appendChild(alertDiv);
+
+                // Update Fraud Analysis Chart
+                const fraudIndicators = validatedData.fraudClassification.indicators || [];
+                const fraudScores = validatedData.fraudClassification.scores || [];
+                const formattedScores = fraudScores.map(score => score * 100);
+
+                updateChart(fraudAnalysisChart, {
+                    labels: fraudIndicators,
+                    datasets: [{
+                        data: formattedScores
+                    }]
+                });
+
+                document.getElementById('fraudReasoning').textContent = `This property was classified as ${validatedData.fraudClassification.classification} based on AI analysis of the listing details.`;
+
+                // Display AI Summary
+                document.getElementById('aiSummary').textContent = data.summary || "No summary available";
+
+                // Display Improvement Suggestions
+                const suggestionsList = document.getElementById('suggestionsList');
+                suggestionsList.innerHTML = '';
+
+                if (data.suggestions && Array.isArray(data.suggestions) && data.suggestions.length > 0) {
+                    data.suggestions.forEach(suggestion => {
+                        if (suggestion && suggestion.trim()) {
+                            const li = document.createElement('li');
+                            li.className = 'suggestion-item';
+                            li.textContent = suggestion;
+                            suggestionsList.appendChild(li);
+                        }
+                    });
+                } else {
+                    const li = document.createElement('li');
+                    li.className = 'suggestion-item';
+                    li.textContent = "No suggestions available";
+                    suggestionsList.appendChild(li);
+                }
+
+                // Display Quality Assessment
+                const qualityDiv = document.getElementById('qualityAssessment');
+                if (validatedData.qualityAssessment) {
+                    qualityDiv.innerHTML = `
+                        <p><strong>Assessment:</strong> ${validatedData.qualityAssessment.assessment}</p>
+                        <p><strong>Quality Score:</strong> ${validatedData.qualityAssessment.score}%</p>
+                        <p><strong>AI Generated:</strong> ${validatedData.qualityAssessment.isAiGenerated ? 'Likely' : 'Unlikely'}</p>
+                        <p><strong>Reasoning:</strong> ${validatedData.qualityAssessment.reasoning}</p>
+                    `;
+
+                    // Update Quality Chart
+                    updateChart(qualityChart, {
+                        datasets: [{
+                            data: [
+                                validatedData.qualityAssessment.score,
+                                validatedData.qualityAssessment.isAiGenerated ? 30 : 80,
+                                validatedData.qualityAssessment.score > 50 ? 70 : 40,
+                                validatedData.qualityAssessment.isAiGenerated ? 40 : 75,
+                                validatedData.qualityAssessment.score > 60 ? 80 : 50
+                            ]
+                        }]
+                    });
+                } else {
+                    qualityDiv.innerHTML = '<p>No quality assessment available</p>';
+                }
+
+                // Display Location Analysis
+                const locationDiv = document.getElementById('locationAnalysis');
+                if (data.location_analysis) {
+                    locationDiv.innerHTML = `
+                        <p><strong>Assessment:</strong> ${data.location_analysis.assessment || "Unknown"}</p>
+                        <p><strong>Completeness:</strong> ${data.location_analysis.completeness_score || 0}%</p>
+                        <p><strong>Coordinates:</strong> ${data.location_analysis.coordinates_check || "Unknown"}</p>
+                        <p><strong>Landmarks:</strong> ${data.location_analysis.landmarks_provided ? 'Provided' : 'Not provided'}</p>
+                    `;
+
+                    // Update Location Chart
+                    updateChart(locationChart, {
+                        datasets: [{
+                            data: [
+                                data.location_analysis.completeness_score || 0,
+                                100 - (data.location_analysis.completeness_score || 0),
+                                data.location_analysis.coordinates_check === 'coordinates_missing' ? 30 : 0
+                            ]
+                        }]
+                    });
+                } else {
+                    locationDiv.innerHTML = '<p>No location analysis available</p>';
+                }
+
+                // Display Price Analysis
+                const priceDiv = document.getElementById('priceAnalysis');
+                if (data.price_analysis && data.price_analysis.has_price) {
+                    priceDiv.innerHTML = `
+                        <p><strong>Assessment:</strong> ${data.price_analysis.assessment || "Unknown"}</p>
+                        <p><strong>Price:</strong> ₹${(data.price_analysis.price || 0).toLocaleString()}</p>
+                        ${data.price_analysis.has_sqft ? `<p><strong>Price per Sq.Ft.:</strong> ₹${(data.price_analysis.price_per_sqft || 0).toLocaleString(undefined, {maximumFractionDigits: 2})}</p>` : ''}
+                        <p><strong>Confidence:</strong> ${Math.round((data.price_analysis.confidence || 0) * 100)}%</p>
+                    `;
+
+                    // Update Price Chart
+                    updateChart(priceChart, {
+                        labels: ['Market Value (thousands)', 'Price per Sq.Ft.'],
+                        datasets: [{
+                            data: [
+                                (data.price_analysis.price || 0) / 1000, // Scale down for better visualization
+                                data.price_analysis.price_per_sqft || 0
+                            ]
+                        }]
+                    });
+                } else {
+                    priceDiv.innerHTML = `<p>No price information provided for analysis.</p>`;
+                }
+
+                // Display Legal Analysis
+                const legalDiv = document.getElementById('legalAnalysis');
+                if (data.legal_analysis) {
+                    legalDiv.innerHTML = `
+                        <p><strong>Assessment:</strong> ${data.legal_analysis.assessment || "Unknown"}</p>
+                        <p><strong>Completeness:</strong> ${data.legal_analysis.completeness_score || 0}%</p>
+                        <p><strong>Summary:</strong> ${data.legal_analysis.summary || "No summary available"}</p>
+                        ${data.legal_analysis.terms_found && data.legal_analysis.terms_found.length > 0 ? `<p><strong>Legal Terms Found:</strong> ${data.legal_analysis.terms_found.join(', ')}</p>` : ''}
+                        ${data.legal_analysis.potential_issues ? '<p class="alert alert-warning">Potential legal issues detected</p>' : ''}
+                    `;
+
+                    // Update Legal Chart
+                    updateChart(legalChart, {
+                        datasets: [{
+                            data: [
+                                data.legal_analysis.completeness_score || 0,
+                                100 - (data.legal_analysis.completeness_score || 0),
+                                data.legal_analysis.potential_issues ? 30 : 0
+                            ]
+                        }]
+                    });
+                } else {
+                    legalDiv.innerHTML = '<p>No legal analysis available</p>';
+                }
+
+                // Display Cross-Validation Checks
+                const crossValidationDiv = document.getElementById('crossValidation');
+                crossValidationDiv.innerHTML = '<ul class="suggestion-list">';
+
+                try {
+                    // Safely check if cross_validation exists and is an array
+                    if (data && data.cross_validation && Array.isArray(data.cross_validation)) {
+                        // Only proceed if the array has items
+                        if (data.cross_validation.length > 0) {
+                            data.cross_validation.forEach(check => {
+                                if (check && typeof check === 'object') {
+                                    const status = check.status || 'unknown';
+                                    const checkName = check.check || 'Check';
+                                    const message = check.message || 'No details available';
+
+                                    // Determine status class
+                                    let statusClass = 'badge-warning'; // Default
+                                    if (['consistent', 'valid', 'reasonable', 'match', 'likely_valid'].includes(status)) {
+                                        statusClass = 'badge-success';
+                                    } else if (['suspicious', 'inconsistent', 'invalid', 'no_match'].includes(status)) {
+                                        statusClass = 'badge-danger';
+                                    }
+
+                                    crossValidationDiv.innerHTML += `
+                                        <li class="suggestion-item">
+                                            <span class="badge ${statusClass}">${status}</span>
+                                            <strong>${checkName}:</strong> ${message}
+                                        </li>
+                                    `;
+                                }
+                            });
+                        } else {
+                            crossValidationDiv.innerHTML += '<li class="suggestion-item">No cross-validation checks performed</li>';
+                        }
+                    } else {
+                        crossValidationDiv.innerHTML += '<li class="suggestion-item">No cross-validation data available</li>';
+                    }
+                } catch (error) {
+                    console.error("Error displaying cross-validation:", error);
+                    crossValidationDiv.innerHTML += '<li class="suggestion-item">Error displaying cross-validation results</li>';
+                }
+
+                crossValidationDiv.innerHTML += '</ul>';
+
+                // Display Document Analysis
+                const documentDiv = document.getElementById('documentAnalysis');
+                documentDiv.innerHTML = '';
+
+                if (data.document_analysis && data.document_analysis.pdf_count > 0) {
+                    documentDiv.innerHTML = `<p><strong>Documents Analyzed:</strong> ${data.document_analysis.pdf_count}</p>`;
+
+                    data.document_analysis.pdf_analysis.forEach((pdf, index) => {
+                        documentDiv.innerHTML += `
+                            <div class="pdf-preview">
+                                <p><strong>Document ${index + 1}</strong></p>
+                                <p><strong>Type:</strong> ${pdf.document_type.classification} (${Math.round(pdf.document_type.confidence * 100)}% confidence)</p>
+                                <p><strong>Authenticity:</strong> ${pdf.authenticity.assessment} (${Math.round(pdf.authenticity.confidence * 100)}% confidence)</p>
+                                <p><strong>Summary:</strong> ${pdf.summary}</p>
+                                <p><strong>Contains Signatures:</strong> ${pdf.contains_signatures ? 'Yes' : 'No'}</p>
+                                <p><strong>Contains Dates:</strong> ${pdf.contains_dates ? 'Yes' : 'No'}</p>
+                            </div>
+                        `;
+                    });
+
+                    // Update Document Chart
+                    let authenticCount = 0;
+                    let suspiciousCount = 0;
+                    let incompleteCount = 0;
+
+                    data.document_analysis.pdf_analysis.forEach(pdf => {
+                        if (pdf.authenticity.assessment.includes('authentic')) {
+                            authenticCount++;
+                        } else if (pdf.authenticity.assessment.includes('fraudulent')) {
+                            suspiciousCount++;
+                        } else {
+                            incompleteCount++;
+                        }
+                    });
+
+                    updateChart(documentChart, {
+                        datasets: [{
+                            data: [
+                                authenticCount,
+                                suspiciousCount,
+                                incompleteCount
+                            ]
+                        }]
+                    });
+                } else {
+                    documentDiv.innerHTML = '<p>No documents were uploaded for analysis.</p>';
+                }
+
+                // Display Image Analysis
+                const imageAnalysisDiv = document.getElementById('imageAnalysis');
+                const imageGallery = document.getElementById('imageGallery');
+
+                imageAnalysisDiv.innerHTML = '';
+                imageGallery.innerHTML = '';
+
+                if (data.image_analysis && data.images && data.images.length > 0) {
+                    imageAnalysisDiv.innerHTML = `<p><strong>Images Analyzed:</strong> ${data.image_analysis.image_count}</p>`;
+
+                    let propertyRelatedCount = 0;
+                    data.image_analysis.image_analysis.forEach(img => {
+                        if (img && img.is_property_related) {
+                            propertyRelatedCount++;
+                        }
+                    });
+
+                    imageAnalysisDiv.innerHTML += `<p><strong>Property-Related Images:</strong> ${propertyRelatedCount} of ${data.image_analysis.image_count}</p>`;
+
+                    // Display images in gallery
+                    data.images.forEach((imgData, index) => {
+                        const imgAnalysis = data.image_analysis.image_analysis[index];
+                        const galleryItem = document.createElement('div');
+                        galleryItem.className = 'gallery-item';
+
+                        galleryItem.innerHTML = `
+                            <img src="data:image/jpeg;base64,${imgData}" alt="Property Image ${index + 1}">
+                            <div class="badge ${imgAnalysis && imgAnalysis.is_property_related ? 'badge-success' : 'badge-warning'}"
+                                 style="position: absolute; top: 5px; right: 5px;">
+                                ${imgAnalysis && imgAnalysis.is_property_related ? 'Property' : 'Not Property'}
+                            </div>
+                        `;
+
+                        imageGallery.appendChild(galleryItem);
+                    });
+                } else {
+                    imageAnalysisDiv.innerHTML = '<p>No images were uploaded for analysis.</p>';
+                }
+
+                // Update Property Summary
+                document.getElementById('summaryName').textContent = document.getElementById('propertyName').value || 'Not provided';
+                document.getElementById('summaryType').textContent = document.getElementById('propertyType').value || 'Not provided';
+                document.getElementById('summaryStatus').textContent = document.getElementById('status').value || 'Not provided';
+                document.getElementById('summaryLocation').textContent =
+                    `${document.getElementById('address').value || ''}, ${document.getElementById('city').value || ''}, ${document.getElementById('state').value || ''}, India`;
+                document.getElementById('summaryPrice').textContent = document.getElementById('marketValue').value ? `₹${document.getElementById('marketValue').value}` : 'Not provided';
+                document.getElementById('summarySize').textContent = document.getElementById('sqFt').value ? `${document.getElementById('sqFt').value} sq. ft.` : 'Not provided';
+                document.getElementById('summaryRooms').textContent =
+                    `${document.getElementById('bedrooms').value || '0'} BHK`;  // BHK is common in Indian real estate
+
+                // Update Final Verdict
+                const verdictBox = document.getElementById('verdictBox');
+                const verdictIcon = document.getElementById('verdictIcon');
+                const verdictText = document.getElementById('verdictText');
+
+                if (fraudLevel === 'high' || trustScore < 40) {
+                    verdictBox.className = 'verdict-box verdict-fraudulent';
+                    verdictIcon.textContent = '❌';
+                    verdictText.textContent = 'HIGH RISK - LIKELY FRAUDULENT';
+                } else if (fraudLevel === 'medium' || trustScore < 70) {
+                    verdictBox.className = 'verdict-box verdict-suspicious';
+                    verdictIcon.textContent = '⚠️';
+                    verdictText.textContent = 'CAUTION - SUSPICIOUS ELEMENTS';
+                } else {
+                    verdictBox.className = 'verdict-box verdict-legitimate';
+                    verdictIcon.textContent = '✅';
+                    verdictText.textContent = 'VERIFIED REAL ESTATE LISTING';
+                }
+
+                // Update Verdict Reasons
+                const verdictReasons = document.getElementById('verdictReasons');
+                verdictReasons.innerHTML = '';
+
+                // Add key findings based on analysis
+                const findings = [];
+
+                if (validatedData.qualityAssessment && validatedData.qualityAssessment.isAiGenerated) {
+                    findings.push('Description appears to be AI-generated');
+                }
+
+                if (data.cross_validation) {
+                    data.cross_validation.forEach(check => {
+                        if (check.status === 'inconsistent' || check.status === 'invalid' ||
+                            check.status === 'suspicious' || check.status === 'no_match') {
+                            findings.push(check.message);
+                        }
+                    });
+                }
+
+                if (data.price_analysis && data.price_analysis.assessment === 'suspicious pricing') {
+                    findings.push('Price appears suspicious for this type of property');
+                }
+
+                if (data.legal_analysis && data.legal_analysis.potential_issues) {
+                    findings.push('Potential legal issues detected');
+                }
+
+                // Add at least one positive finding if the verdict is good
+                if (findings.length === 0 && trustScore > 70) {
+                    findings.push('Property details appear consistent and legitimate');
+                    findings.push('No suspicious elements detected in the listing');
+                }
+
+                // If we still have no findings, add a generic one
+                if (findings.length === 0) {
+                    findings.push('Analysis inconclusive - insufficient information provided');
+                }
+
+                findings.forEach(finding => {
+                    const li = document.createElement('li');
+                    li.className = 'suggestion-item';
+                    li.textContent = finding;
+                    verdictReasons.appendChild(li);
+                });
+
+                // Update Verification Scores
+                updateScoreBar('trustBar', 'trustValue', trustScore);
+
+                // Image authenticity score
+                let imageScore = 0;
+                if (data.image_analysis && data.image_analysis.image_analysis) {
+                    const propertyImages = data.image_analysis.image_analysis.filter(img => img && img.is_property_related);
+                    imageScore = data.image_analysis.image_count > 0 ?
+                        Math.round((propertyImages.length / data.image_analysis.image_count) * 100) : 0;
+                }
+                updateScoreBar('imageBar', 'imageValue', imageScore);
+
+                // Document verification score
+                let docScore = 0;
+                if (data.document_analysis && data.document_analysis.pdf_analysis) {
+                    const authenticDocs = data.document_analysis.pdf_analysis.filter(
+                        pdf => pdf.authenticity && pdf.authenticity.assessment.includes('authentic')
+                    );
+                    docScore = data.document_analysis.pdf_count > 0 ?
+                        Math.round((authenticDocs.length / data.document_analysis.pdf_count) * 100) : 0;
+                }
+                updateScoreBar('documentBar', 'documentValue', docScore);
+
+                // Content quality score
+                const contentScore = validatedData.qualityAssessment ? validatedData.qualityAssessment.score : 0;
+                updateScoreBar('contentBar', 'contentValue', contentScore);
+
+                // Location accuracy score
+                const locationScore = data.location_analysis ? data.location_analysis.completeness_score || 0 : 0;
+                updateScoreBar('locationBar', 'locationValue', locationScore);
+
+                // Update Red Flags
+                const redFlagsList = document.getElementById('redFlagsList');
+                redFlagsList.innerHTML = '';
+
+                const redFlags = [];
+
+                // Check for inconsistencies and issues
+                if (data.cross_validation) {
+                    data.cross_validation.forEach(check => {
+                        if (check.status === 'inconsistent' || check.status === 'invalid' ||
+                            check.status === 'suspicious' || check.status === 'no_match') {
+                            redFlags.push(`${check.check}: ${check.message}`);
+                        }
+                    });
+                }
+
+                if (validatedData.qualityAssessment && validatedData.qualityAssessment.isAiGenerated) {
+                    redFlags.push('Description appears to be AI-generated, which may indicate a fake listing');
+                }
+
+                if (data.price_analysis &&
+                    (data.price_analysis.assessment === 'suspicious pricing' ||
+                     data.price_analysis.assessment === 'overpriced' ||
+                     data.price_analysis.assessment === 'underpriced')) {
+                    redFlags.push(`Price is ${data.price_analysis.assessment} for this type of property`);
+                }
+
+                if (data.legal_analysis && data.legal_analysis.potential_issues) {
+                    redFlags.push('Potential legal issues detected in the property documentation');
+                }
+
+                if (data.image_analysis && data.image_analysis.image_count > 0) {
+                    const propertyImages = data.image_analysis.image_analysis.filter(img => img && img.is_property_related);
+                    if (propertyImages.length === 0) {
+                        redFlags.push('None of the uploaded images appear to be related to real estate');
+                    }
+                }
+
+                // If no red flags, add a positive message
+                if (redFlags.length === 0) {
+                    redFlags.push('No significant red flags detected in this listing');
+                }
+
+                redFlags.forEach(flag => {
+                    const li = document.createElement('li');
+                    li.className = 'suggestion-item';
+                    li.textContent = flag;
+                    redFlagsList.appendChild(li);
+                });
+                
+            } catch (error) {
+                console.error('Error displaying results:', error);
+                document.getElementById('resultsContainer').innerHTML = 
+                    '<div class="alert alert-danger">Error displaying results. Please try again.</div>';
+            }
+        }
+        
+        function updateScoreBar(barId, valueId, score) {
+            const bar = document.getElementById(barId);
+            const value = document.getElementById(valueId);
+            
+            if (bar && value) {
+                bar.style.setProperty('--score-width', `${score}%`);
+                bar.style.background = `linear-gradient(to right, 
+                    ${getScoreColor(score)} ${score}%, 
+                    #e9ecef ${score}%)`;
+                value.textContent = `${score}%`;
+            }
+        }
+        
+        function getScoreColor(score) {
+            if (score >= 70) return 'var(--success)';
+            if (score >= 40) return 'var(--warning)';
+            return 'var(--danger)';
+        }
+    </script>
+</body>
+</html>

templates/index.html.new

@@ -0,0 +1,1160 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI Property Verifier</title>
+    <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        :root {
+            --primary: #4361ee;
+            --secondary: #3f37c9;
+            --success: #4cc9f0;
+            --danger: #f72585;
+            --warning: #f8961e;
+            --info: #4895ef;
+            --light: #f8f9fa;
+            --dark: #212529;
+            --gray: #6c757d;
+            --border-radius: 12px;
+            --box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+        }
+        
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Poppins', sans-serif;
+            background-color: #f5f7fa;
+            color: #333;
+            line-height: 1.6;
+            padding: 20px;
+        }
+        
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        
+        header {
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        
+        h1 {
+            font-size: 2.5rem;
+            color: var(--primary);
+            margin-bottom: 10px;
+        }
+        
+        .subtitle {
+            font-size: 1.1rem;
+            color: var(--gray);
+        }
+        
+        .card {
+            background: white;
+            border-radius: var(--border-radius);
+            box-shadow: var(--box-shadow);
+            padding: 25px;
+            margin-bottom: 25px;
+        }
+        
+        .card-header {
+            border-bottom: 1px solid #eee;
+            padding-bottom: 15px;
+            margin-bottom: 20px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        
+        .card-title {
+            font-size: 1.5rem;
+            color: var(--dark);
+            font-weight: 600;
+        }
+        
+        .form-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+            gap: 20px;
+        }
+        
+        .form-group {
+            margin-bottom: 20px;
+        }
+        
+        .form-label {
+            display: block;
+            margin-bottom: 8px;
+            font-weight: 500;
+            color: var(--dark);
+        }
+        
+        .form-control {
+            width: 100%;
+            padding: 12px 15px;
+            border: 1px solid #ddd;
+            border-radius: var(--border-radius);
+            font-size: 1rem;
+            transition: border-color 0.3s;
+        }
+        
+        .form-control:focus {
+            border-color: var(--primary);
+            outline: none;
+            box-shadow: 0 0 0 3px rgba(67, 97, 238, 0.1);
+        }
+        
+        textarea.form-control {
+            min-height: 100px;
+            resize: vertical;
+        }
+        
+        .btn {
+            display: inline-block;
+            padding: 12px 24px;
+            background-color: var(--primary);
+            color: white;
+            border: none;
+            border-radius: var(--border-radius);
+            font-size: 1rem;
+            font-weight: 500;
+            cursor: pointer;
+            transition: all 0.3s;
+        }
+        
+        .btn:hover {
+            background-color: var(--secondary);
+            transform: translateY(-2px);
+        }
+        
+        .btn-block {
+            display: block;
+            width: 100%;
+        }
+        
+        .section-title {
+            font-size: 1.2rem;
+            color: var(--primary);
+            margin-bottom: 15px;
+            font-weight: 600;
+        }
+        
+        .results-container {
+            display: none;
+            margin-top: 30px;
+        }
+        
+        .results-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(450px, 1fr));
+            gap: 25px;
+        }
+        
+        .result-card {
+            background: white;
+            border-radius: var(--border-radius);
+            box-shadow: var(--box-shadow);
+            padding: 20px;
+            height: 100%;
+        }
+        
+        .result-header {
+            display: flex;
+            align-items: center;
+            margin-bottom: 15px;
+        }
+        
+        .result-icon {
+            width: 40px;
+            height: 40px;
+            background-color: var(--light);
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            margin-right: 15px;
+        }
+        
+        .result-title {
+            font-size: 1.2rem;
+            font-weight: 600;
+            color: var(--dark);
+        }
+        
+        .trust-score {
+            text-align: center;
+            padding: 20px;
+        }
+        
+        .score-value {
+            font-size: 3rem;
+            font-weight: 700;
+            color: var(--primary);
+        }
+        
+        .score-label {
+            font-size: 1rem;
+            color: var(--gray);
+        }
+        
+        .progress-container {
+            margin: 15px 0;
+        }
+        
+        .progress-bar {
+            height: 10px;
+            background-color: #eee;
+            border-radius: 5px;
+            overflow: hidden;
+        }
+        
+        .progress-fill {
+            height: 100%;
+            background-color: var(--primary);
+            border-radius: 5px;
+            transition: width 0.5s ease-in-out;
+        }
+        
+        .alert {
+            padding: 15px;
+            border-radius: var(--border-radius);
+            margin-bottom: 20px;
+            font-weight: 500;
+        }
+        
+        .alert-danger {
+            background-color: rgba(247, 37, 133, 0.1);
+            color: var(--danger);
+            border-left: 4px solid var(--danger);
+        }
+        
+        .alert-warning {
+            background-color: rgba(248, 150, 30, 0.1);
+            color: var(--warning);
+            border-left: 4px solid var(--warning);
+        }
+        
+        .alert-success {
+            background-color: rgba(76, 201, 240, 0.1);
+            color: var(--success);
+            border-left: 4px solid var(--success);
+        }
+        
+        .suggestion-list {
+            list-style-type: none;
+            padding: 0;
+        }
+        
+        .suggestion-item {
+            padding: 10px 15px;
+            background-color: rgba(67, 97, 238, 0.05);
+            border-radius: var(--border-radius);
+            margin-bottom: 10px;
+            border-left: 3px solid var(--primary);
+        }
+        
+        .image-preview {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+            margin-top: 10px;
+        }
+        
+        .preview-item {
+            width: 100px;
+            height: 100px;
+            border-radius: 8px;
+            overflow: hidden;
+            position: relative;
+        }
+        
+        .preview-item img {
+            width: 100%;
+            height: 100%;
+            object-fit: cover;
+        }
+        
+        .preview-remove {
+            position: absolute;
+            top: 5px;
+            right: 5px;
+            background: rgba(0, 0, 0, 0.5);
+            color: white;
+            border: none;
+            border-radius: 50%;
+            width: 20px;
+            height: 20px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            cursor: pointer;
+        }
+        
+        .loading {
+            display: none;
+            text-align: center;
+            padding: 30px;
+        }
+        
+        .spinner {
+            width: 50px;
+            height: 50px;
+            border: 5px solid rgba(67, 97, 238, 0.1);
+            border-radius: 50%;
+            border-top-color: var(--primary);
+            animation: spin 1s ease-in-out infinite;
+            margin: 0 auto 20px;
+        }
+        
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+        
+        .chart-container {
+            position: relative;
+            height: 200px;
+            margin-bottom: 20px;
+        }
+        
+        .pdf-preview {
+            background-color: #f8f9fa;
+            padding: 15px;
+            border-radius: var(--border-radius);
+            margin-top: 10px;
+            max-height: 200px;
+            overflow-y: auto;
+        }
+        
+        .pdf-filename {
+            font-weight: 500;
+            margin-bottom: 5px;
+        }
+        
+        .image-gallery {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
+            gap: 15px;
+            margin-top: 20px;
+        }
+        
+        .gallery-item {
+            border-radius: var(--border-radius);
+            overflow: hidden;
+            box-shadow: var(--box-shadow);
+            aspect-ratio: 1;
+        }
+        
+        .gallery-item img {
+            width: 100%;
+            height: 100%;
+            object-fit: cover;
+        }
+        
+        .badge {
+            display: inline-block;
+            padding: 5px 10px;
+            border-radius: 20px;
+            font-size: 0.8rem;
+            font-weight: 500;
+            margin-right: 5px;
+            margin-bottom: 5px;
+        }
+        
+        .badge-primary { background-color: rgba(67, 97, 238, 0.1); color: var(--primary); }
+        .badge-success { background-color: rgba(76, 201, 240, 0.1); color: var(--success); }
+        .badge-warning { background-color: rgba(248, 150, 30, 0.1); color: var(--warning); }
+        .badge-danger { background-color: rgba(247, 37, 133, 0.1); color: var(--danger); }
+        
+        .explanation-box {
+            background-color: #f8f9fa;
+            border-radius: var(--border-radius);
+            padding: 15px;
+            margin-top: 15px;
+            border-left: 4px solid var(--info);
+        }
+        
+        .explanation-title {
+            font-weight: 600;
+            color: var(--info);
+            margin-bottom: 10px;
+        }
+        
+        .property-summary {
+            padding: 15px;
+        }
+        
+        .property-details p {
+            margin-bottom: 8px;
+        }
+        
+        .final-verdict {
+            padding: 15px;
+        }
+        
+        .verdict-box {
+            display: flex;
+            align-items: center;
+            padding: 15px;
+            border-radius: var(--border-radius);
+            margin-bottom: 15px;
+            background-color: #f8f9fa;
+        }
+        
+        .verdict-icon {
+            font-size: 2rem;
+            margin-right: 15px;
+        }
+        
+        .verdict-text {
+            font-size: 1.2rem;
+            font-weight: 600;
+        }
+        
+        .verdict-legitimate {
+            background-color: rgba(76, 201, 240, 0.1);
+            border-left: 4px solid var(--success);
+        }
+        
+        .verdict-suspicious {
+            background-color: rgba(248, 150, 30, 0.1);
+            border-left: 4px solid var(--warning);
+        }
+        
+        .verdict-fraudulent {
+            background-color: rgba(247, 37, 133, 0.1);
+            border-left: 4px solid var(--danger);
+        }
+        
+        .verification-scores {
+            padding: 15px;
+        }
+        
+        .score-item {
+            margin-bottom: 15px;
+        }
+        
+        .score-label {
+            font-weight: 500;
+            margin-bottom: 5px;
+        }
+        
+        .score-bar-container {
+            display: flex;
+            align-items: center;
+        }
+        
+        .score-bar {
+            height: 10px;
+            background-color: #e9ecef;
+            border-radius: 5px;
+            flex-grow: 1;
+            margin-right: 10px;
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .score-bar::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            height: 100%;
+            background-color: var(--primary);
+            border-radius: 5px;
+            width: 0%;
+            transition: width 0.5s ease;
+        }
+        
+        .score-value {
+            font-weight: 600;
+            min-width: 40px;
+            text-align: right;
+        }
+        
+        .red-flags {
+            padding: 15px;
+        }
+        
+        @media (max-width: 768px) {
+            .form-grid, .results-grid {
+                grid-template-columns: 1fr;
+            }
+            
+            .card {
+                padding: 15px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>AI Property Verifier & Fraud Detection</h1>
+            <p class="subtitle">Powered by advanced AI models to verify property listings and detect potential fraud</p>
+        </header>
+        
+        <div class="card">
+            <div class="card-header">
+                <h2 class="card-title">Property Details</h2>
+            </div>
+            <form id="propertyForm">
+                <div class="section-title">Basic Information</div>
+                <div class="form-grid">
+                    <div class="form-group">
+                        <label class="form-label" for="propertyName">Property Name</label>
+                        <input type="text" class="form-control" id="propertyName" name="property_name" required>
+                    </div>
+                    
+                    <div class="form-group">
+                        <label class="form-label" for="propertyType">Property Type</label>
+                        <select class="form-control" id="propertyType" name="property_type" required>
+                            <option value="">Select Type</option>
+                            <option value="Apartment">Apartment</option>
+                            <option value="House">House</option>
+                            <option value="Condo">Condo</option>
+                            <option value="Townhouse">Townhouse</option>
+                            <option value="Villa">Villa</option>
+                            <option value="Land">Land</option>
+                            <option value="Commercial">Commercial</option>
+                            <option value="Other">Other</option>
+                        </select>
+                    </div>
+                    
+                    <div class="form-group">
+                        <label class="form-label" for="status">Status</label>
+                        <select class="form-control" id="status" name="status" required>
+                            <option value="">Select Status</option>
+                            <option value="For Sale">For Sale</option>
+                            <option value="For Rent">For Rent</option>
+                            <option value="Sold">Sold</option>
+                            <option value="Under Contract">Under Contract</option>
+                            <option value="Pending">Pending</option>
+                        </select>
+                    </div>
+                </div>
+                
+                <div class="form-group">
+                    <label class="form-label" for="description">Property Description</label>
+                    <textarea class="form-control" id="description" name="description" rows="4" required></textarea>
+                </div>
+                
+                <div class="section-title">Location Details</div>
+                <div class="form-grid">
+                    <div class="form-group">
+                        <label class="form-label" for="address">Address</label>
+                        <input type="text" class="form-control" id="address" name="address" required>
+                    </div>
+                    
+                    <div class="form-group">
+                        <label class="form-label" for="city">City</label>
+                        <input type="text" class="form-control" id="city" name="city" required>
+                    </div>
+                    
+                    <div class="form-group">
+                        <label class="form-label" for="state">State/Province</label>
+                        <input type="text" class="form-control" id="state" name="state" required>
+                    </div>
+                    
+                    <div class="form-group">
+                        <label class="form-label" for="country">Country</label>
+                        <input type="text" class="form-control" id="country" name="country" required>
+                    </div>
+                    
+                    <div class="form-group">
+                        <label class="form-label" for="zip">Zip/Postal Code</label>
+                        <input type="text" class="form-control" id="zip" name="zip" required>
+                    </div>
+                    
+                    <div class="form-group">
+                        <label class="form-label" for="latitude">Latitude</label>
+                        <input type="text" class="form-control" id="latitude" name="latitude" placeholder="e.g. 40.7128">
+                    </div>
+                    
+                    <div class="form-group">
+                        <label class="form-label" for="longitude">Longitude</label>
+                        <input type="text" class="form-control" id="longitude" name="longitude" placeholder="e.g. -74.0060">
+                    </div>
+                </div>
+                
+                <div class="section-title">Property Specifications</div>
+                <div class="form-grid">
+                    <div class="form-group">
+                        <label class="form-label" for="bedrooms">Bedrooms</label>
+                        <input type="number" class="form-control" id="bedrooms" name="bedrooms" min="0">
+                    </div>
+                    
+                    <div class="form-group">
+                        <label class="form-label" for="bathrooms">Bathrooms</label>
+                        <input type="number" class="form-control" id="bathrooms" name="bathrooms" min="0" step="0.5">
+                    </div>
+                    
+                    <div class="form-group">
+                        <label class="form-label" for="squareFeet">Square Feet</label>
+                        <input type="number" class="form-control" id="squareFeet" name="square_feet" min="0">
+                    </div>
+                    
+                    <div class="form-group">
+                        <label class="form-label" for="yearBuilt">Year Built</label>
+                        <input type="number" class="form-control" id="yearBuilt" name="year_built" min="1800" max="2024">
+                    </div>
+                    
+                    <div class="form-group">
+                        <label class="form-label" for="price">Price</label>
+                        <input type="number" class="form-control" id="price" name="price" min="0" required>
+                    </div>
+                </div>
+                
+                <div class="section-title">Documents & Images</div>
+                <div class="form-group">
+                    <label class="form-label">Property Images</label>
+                    <input type="file" class="form-control" id="images" name="images" multiple accept="image/*">
+                    <div class="image-preview" id="imagePreview"></div>
+                </div>
+                
+                <div class="form-group">
+                    <label class="form-label">Property Documents (PDF)</label>
+                    <input type="file" class="form-control" id="documents" name="documents" multiple accept=".pdf">
+                    <div class="pdf-preview" id="pdfPreview"></div>
+                </div>
+                
+                <button type="submit" class="btn btn-block">Verify Property</button>
+            </form>
+        </div>
+        
+        <div class="loading" id="loading">
+            <div class="spinner"></div>
+            <p>Analyzing property details...</p>
+        </div>
+        
+        <div class="results-container" id="results">
+            <div class="results-grid">
+                <div class="result-card">
+                    <div class="result-header">
+                        <div class="result-icon">📊</div>
+                        <h3 class="result-title">Trust Score</h3>
+                    </div>
+                    <div class="trust-score">
+                        <div class="score-value" id="trustScore">0</div>
+                        <div class="score-label">Overall Trust Score</div>
+                        <div class="progress-container">
+                            <div class="progress-bar">
+                                <div class="progress-fill" id="trustScoreBar"></div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="result-card">
+                    <div class="result-header">
+                        <div class="result-icon">🔍</div>
+                        <h3 class="result-title">Fraud Analysis</h3>
+                    </div>
+                    <div class="chart-container">
+                        <canvas id="fraudChart"></canvas>
+                    </div>
+                    <div id="fraudDetails"></div>
+                </div>
+                
+                <div class="result-card">
+                    <div class="result-header">
+                        <div class="result-icon">📝</div>
+                        <h3 class="result-title">Quality Assessment</h3>
+                    </div>
+                    <div class="chart-container">
+                        <canvas id="qualityChart"></canvas>
+                    </div>
+                    <div id="qualityDetails"></div>
+                </div>
+                
+                <div class="result-card">
+                    <div class="result-header">
+                        <div class="result-icon">📍</div>
+                        <h3 class="result-title">Location Analysis</h3>
+                    </div>
+                    <div id="locationDetails"></div>
+                </div>
+                
+                <div class="result-card">
+                    <div class="result-header">
+                        <div class="result-icon">💰</div>
+                        <h3 class="result-title">Price Analysis</h3>
+                    </div>
+                    <div id="priceDetails"></div>
+                </div>
+                
+                <div class="result-card">
+                    <div class="result-header">
+                        <div class="result-icon">⚖️</div>
+                        <h3 class="result-title">Legal Analysis</h3>
+                    </div>
+                    <div class="chart-container">
+                        <canvas id="legalChart"></canvas>
+                    </div>
+                    <div id="legalDetails"></div>
+                </div>
+            </div>
+            
+            <div class="card">
+                <div class="card-header">
+                    <h2 class="card-title">Final Verdict</h2>
+                </div>
+                <div class="final-verdict">
+                    <div class="verdict-box" id="verdictBox">
+                        <div class="verdict-icon">✅</div>
+                        <div class="verdict-text" id="verdictText">Analyzing...</div>
+                    </div>
+                    <div id="verdictDetails"></div>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <script>
+        // Global variables
+        let uploadedImages = [];
+        let uploadedPDFs = [];
+        let fraudChart = null;
+        let qualityChart = null;
+        let legalChart = null;
+        
+        // Initialize charts
+        function initializeCharts() {
+            // Fraud Analysis Chart
+            const fraudCtx = document.getElementById('fraudChart').getContext('2d');
+            fraudChart = new Chart(fraudCtx, {
+                type: 'doughnut',
+                data: {
+                    labels: ['Low Risk', 'Medium Risk', 'High Risk'],
+                    datasets: [{
+                        data: [0, 0, 0],
+                        backgroundColor: [
+                            'rgba(76, 201, 240, 0.8)',
+                            'rgba(248, 150, 30, 0.8)',
+                            'rgba(247, 37, 133, 0.8)'
+                        ]
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    maintainAspectRatio: false
+                }
+            });
+            
+            // Quality Assessment Chart
+            const qualityCtx = document.getElementById('qualityChart').getContext('2d');
+            qualityChart = new Chart(qualityCtx, {
+                type: 'bar',
+                data: {
+                    labels: ['Completeness', 'Accuracy', 'Consistency'],
+                    datasets: [{
+                        label: 'Score',
+                        data: [0, 0, 0],
+                        backgroundColor: 'rgba(67, 97, 238, 0.8)'
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    scales: {
+                        y: {
+                            beginAtZero: true,
+                            max: 100
+                        }
+                    }
+                }
+            });
+            
+            // Legal Analysis Chart
+            const legalCtx = document.getElementById('legalChart').getContext('2d');
+            legalChart = new Chart(legalCtx, {
+                type: 'radar',
+                data: {
+                    labels: ['Documentation', 'Compliance', 'Risk Level'],
+                    datasets: [{
+                        label: 'Score',
+                        data: [0, 0, 0],
+                        backgroundColor: 'rgba(67, 97, 238, 0.2)',
+                        borderColor: 'rgba(67, 97, 238, 1)',
+                        pointBackgroundColor: 'rgba(67, 97, 238, 1)'
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    scales: {
+                        r: {
+                            beginAtZero: true,
+                            max: 100
+                        }
+                    }
+                }
+            });
+        }
+        
+        // Handle form submission
+        document.getElementById('propertyForm').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            
+            // Show loading indicator
+            document.getElementById('loading').style.display = 'block';
+            document.getElementById('results').style.display = 'none';
+            
+            try {
+                const formData = new FormData(e.target);
+                
+                // Append uploaded images
+                uploadedImages.forEach((file, index) => {
+                    formData.append(`image_${index}`, file);
+                });
+                
+                // Append uploaded PDFs
+                uploadedPDFs.forEach((file, index) => {
+                    formData.append(`document_${index}`, file);
+                });
+                
+                // Send request to backend
+                const response = await fetch('/verify', {
+                    method: 'POST',
+                    body: formData
+                });
+                
+                if (!response.ok) {
+                    throw new Error('Verification failed');
+                }
+                
+                const data = await response.json();
+                displayResults(data);
+                
+            } catch (error) {
+                console.error('Error:', error);
+                alert('An error occurred during verification. Please try again.');
+            } finally {
+                document.getElementById('loading').style.display = 'none';
+            }
+        });
+        
+        // Handle file uploads
+        document.getElementById('images').addEventListener('change', (e) => {
+            const files = Array.from(e.target.files);
+            uploadedImages = files;
+            displayImagePreviews(files);
+        });
+        
+        document.getElementById('documents').addEventListener('change', (e) => {
+            const files = Array.from(e.target.files);
+            uploadedPDFs = files;
+            displayPDFPreviews(files);
+        });
+        
+        // Display image previews
+        function displayImagePreviews(files) {
+            const preview = document.getElementById('imagePreview');
+            preview.innerHTML = '';
+            
+            files.forEach((file, index) => {
+                const reader = new FileReader();
+                reader.onload = (e) => {
+                    const div = document.createElement('div');
+                    div.className = 'preview-item';
+                    div.innerHTML = `
+                        <img src="${e.target.result}" alt="Preview">
+                        <button class="preview-remove" onclick="removeImage(${index})">&times;</button>
+                    `;
+                    preview.appendChild(div);
+                };
+                reader.readAsDataURL(file);
+            });
+        }
+        
+        // Display PDF previews
+        function displayPDFPreviews(files) {
+            const preview = document.getElementById('pdfPreview');
+            preview.innerHTML = '';
+            
+            files.forEach((file, index) => {
+                const div = document.createElement('div');
+                div.className = 'pdf-filename';
+                div.innerHTML = `
+                    ${file.name}
+                    <button class="preview-remove" onclick="removePDF(${index})">&times;</button>
+                `;
+                preview.appendChild(div);
+            });
+        }
+        
+        // Remove image
+        function removeImage(index) {
+            uploadedImages.splice(index, 1);
+            displayImagePreviews(uploadedImages);
+        }
+        
+        // Remove PDF
+        function removePDF(index) {
+            uploadedPDFs.splice(index, 1);
+            displayPDFPreviews(uploadedPDFs);
+        }
+        
+        // Display results
+        function displayResults(data) {
+            // Show results container
+            document.getElementById('results').style.display = 'block';
+            
+            // Update trust score
+            const trustScore = data.trust_score || 0;
+            document.getElementById('trustScore').textContent = trustScore;
+            document.getElementById('trustScoreBar').style.width = `${trustScore}%`;
+            
+            // Update fraud analysis
+            if (data.fraud_analysis) {
+                updateFraudAnalysis(data.fraud_analysis);
+            }
+            
+            // Update quality assessment
+            if (data.quality_assessment) {
+                updateQualityAssessment(data.quality_assessment);
+            }
+            
+            // Update location analysis
+            if (data.location_analysis) {
+                updateLocationAnalysis(data.location_analysis);
+            }
+            
+            // Update price analysis
+            if (data.price_analysis) {
+                updatePriceAnalysis(data.price_analysis);
+            }
+            
+            // Update legal analysis
+            if (data.legal_analysis) {
+                updateLegalAnalysis(data.legal_analysis);
+            }
+            
+            // Update final verdict
+            updateFinalVerdict(data);
+        }
+        
+        // Update fraud analysis
+        function updateFraudAnalysis(analysis) {
+            // Update chart
+            fraudChart.data.datasets[0].data = [
+                analysis.low_risk || 0,
+                analysis.medium_risk || 0,
+                analysis.high_risk || 0
+            ];
+            fraudChart.update();
+            
+            // Update details
+            const details = document.getElementById('fraudDetails');
+            details.innerHTML = `
+                <div class="alert ${getAlertClass(analysis.alert_level)}">
+                    ${analysis.summary || 'No fraud indicators detected.'}
+                </div>
+                ${analysis.indicators ? `
+                    <div class="red-flags">
+                        <h4>Risk Indicators:</h4>
+                        <ul>
+                            ${analysis.indicators.map(indicator => `
+                                <li>${indicator}</li>
+                            `).join('')}
+                        </ul>
+                    </div>
+                ` : ''}
+            `;
+        }
+        
+        // Update quality assessment
+        function updateQualityAssessment(assessment) {
+            // Update chart
+            qualityChart.data.datasets[0].data = [
+                assessment.completeness || 0,
+                assessment.accuracy || 0,
+                assessment.consistency || 0
+            ];
+            qualityChart.update();
+            
+            // Update details
+            const details = document.getElementById('qualityDetails');
+            details.innerHTML = `
+                <div class="explanation-box">
+                    <div class="explanation-title">Quality Assessment</div>
+                    <p>${assessment.summary || 'No quality issues detected.'}</p>
+                </div>
+                ${assessment.suggestions ? `
+                    <div class="suggestion-list">
+                        ${assessment.suggestions.map(suggestion => `
+                            <div class="suggestion-item">${suggestion}</div>
+                        `).join('')}
+                    </div>
+                ` : ''}
+            `;
+        }
+        
+        // Update location analysis
+        function updateLocationAnalysis(analysis) {
+            const details = document.getElementById('locationDetails');
+            details.innerHTML = `
+                <div class="explanation-box">
+                    <div class="explanation-title">Location Analysis</div>
+                    <p>${analysis.summary || 'Location verified.'}</p>
+                </div>
+                ${analysis.verification ? `
+                    <div class="verification-scores">
+                        ${Object.entries(analysis.verification).map(([key, value]) => `
+                            <div class="score-item">
+                                <div class="score-label">${formatLabel(key)}</div>
+                                <div class="score-bar-container">
+                                    <div class="score-bar" style="--score: ${value}%"></div>
+                                    <div class="score-value">${value}%</div>
+                                </div>
+                            </div>
+                        `).join('')}
+                    </div>
+                ` : ''}
+            `;
+        }
+        
+        // Update price analysis
+        function updatePriceAnalysis(analysis) {
+            const details = document.getElementById('priceDetails');
+            details.innerHTML = `
+                <div class="explanation-box">
+                    <div class="explanation-title">Price Analysis</div>
+                    <p>${analysis.summary || 'Price analysis completed.'}</p>
+                </div>
+                ${analysis.market_trends ? `
+                    <div class="property-summary">
+                        <h4>Market Trends</h4>
+                        <p>${analysis.market_trends}</p>
+                    </div>
+                ` : ''}
+                ${analysis.price_factors ? `
+                    <div class="property-summary">
+                        <h4>Price Factors</h4>
+                        <ul>
+                            ${analysis.price_factors.map(factor => `
+                                <li>${factor}</li>
+                            `).join('')}
+                        </ul>
+                    </div>
+                ` : ''}
+                ${analysis.risk_indicators ? `
+                    <div class="red-flags">
+                        <h4>Risk Indicators</h4>
+                        <ul>
+                            ${analysis.risk_indicators.map(indicator => `
+                                <li>${indicator}</li>
+                            `).join('')}
+                        </ul>
+                    </div>
+                ` : ''}
+            `;
+        }
+        
+        // Update legal analysis
+        function updateLegalAnalysis(analysis) {
+            // Update chart
+            legalChart.data.datasets[0].data = [
+                analysis.documentation_score || 0,
+                analysis.compliance_score || 0,
+                analysis.risk_score || 0
+            ];
+            legalChart.update();
+            
+            // Update details
+            const details = document.getElementById('legalDetails');
+            details.innerHTML = `
+                <div class="explanation-box">
+                    <div class="explanation-title">Legal Analysis</div>
+                    <p>${analysis.summary || 'Legal analysis completed.'}</p>
+                </div>
+                ${analysis.issues ? `
+                    <div class="red-flags">
+                        <h4>Legal Issues</h4>
+                        <ul>
+                            ${analysis.issues.map(issue => `
+                                <li>${issue}</li>
+                            `).join('')}
+                        </ul>
+                    </div>
+                ` : ''}
+                ${analysis.recommendations ? `
+                    <div class="suggestion-list">
+                        ${analysis.recommendations.map(recommendation => `
+                            <div class="suggestion-item">${recommendation}</div>
+                        `).join('')}
+                    </div>
+                ` : ''}
+            `;
+        }
+        
+        // Update final verdict
+        function updateFinalVerdict(data) {
+            const verdictBox = document.getElementById('verdictBox');
+            const verdictText = document.getElementById('verdictText');
+            const verdictDetails = document.getElementById('verdictDetails');
+            
+            // Determine verdict class and icon
+            let verdictClass = 'verdict-legitimate';
+            let verdictIcon = '✅';
+            
+            if (data.trust_score < 60) {
+                verdictClass = 'verdict-fraudulent';
+                verdictIcon = '❌';
+            } else if (data.trust_score < 80) {
+                verdictClass = 'verdict-suspicious';
+                verdictIcon = '⚠️';
+            }
+            
+            // Update verdict box
+            verdictBox.className = `verdict-box ${verdictClass}`;
+            verdictBox.querySelector('.verdict-icon').textContent = verdictIcon;
+            verdictText.textContent = data.verdict || 'Analysis complete';
+            
+            // Update verdict details
+            verdictDetails.innerHTML = `
+                <div class="verification-scores">
+                    ${Object.entries(data.scores || {}).map(([key, value]) => `
+                        <div class="score-item">
+                            <div class="score-label">${formatLabel(key)}</div>
+                            <div class="score-bar-container">
+                                <div class="score-bar" style="--score: ${value}%"></div>
+                                <div class="score-value">${value}%</div>
+                            </div>
+                        </div>
+                    `).join('')}
+                </div>
+            `;
+        }
+        
+        // Helper functions
+        function getAlertClass(level) {
+            switch (level?.toLowerCase()) {
+                case 'high':
+                    return 'alert-danger';
+                case 'medium':
+                    return 'alert-warning';
+                case 'low':
+                    return 'alert-success';
+                default:
+                    return 'alert-success';
+            }
+        }
+        
+        function formatLabel(key) {
+            return key.split('_')
+                .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+                .join(' ');
+        }
+        
+        // Initialize charts when the page loads
+        document.addEventListener('DOMContentLoaded', initializeCharts);
+    </script>
+</body>
+</html> 

templates/newindex.html

@@ -0,0 +1,1916 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI Property Verifier</title>
+    <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        :root {
+            --primary: #4361ee;
+            --secondary: #3f37c9;
+            --success: #4cc9f0;
+            --danger: #f72585;
+            --warning: #f8961e;
+            --info: #4895ef;
+            --light: #f8f9fa;
+            --dark: #212529;
+            --gray: #6c757d;
+            --border-radius: 12px;
+            --box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+        }
+        
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Poppins', sans-serif;
+            background-color: #f5f7fa;
+            color: #333;
+            line-height: 1.6;
+            padding: 20px;
+        }
+        
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        
+        header {
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        
+        h1 {
+            font-size: 2.5rem;
+            color: var(--primary);
+            margin-bottom: 10px;
+        }
+        
+        .subtitle {
+            font-size: 1.1rem;
+            color: var(--gray);
+        }
+        
+        .card {
+            background: white;
+            border-radius: var(--border-radius);
+            box-shadow: var(--box-shadow);
+            padding: 25px;
+            margin-bottom: 25px;
+        }
+        
+        .card-header {
+            border-bottom: 1px solid #eee;
+            padding-bottom: 15px;
+            margin-bottom: 20px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        
+        .card-title {
+            font-size: 1.5rem;
+            color: var(--dark);
+            font-weight: 600;
+        }
+        
+        .form-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+            gap: 20px;
+        }
+        
+        .form-group {
+            margin-bottom: 20px;
+        }
+        
+        .form-label {
+            display: block;
+            margin-bottom: 8px;
+            font-weight: 500;
+            color: var(--dark);
+        }
+        
+        .form-control {
+            width: 100%;
+            padding: 12px 15px;
+            border: 1px solid #ddd;
+            border-radius: var(--border-radius);
+            font-size: 1rem;
+            transition: border-color 0.3s;
+        }
+        
+        .form-control:focus {
+            border-color: var(--primary);
+            outline: none;
+            box-shadow: 0 0 0 3px rgba(67, 97, 238, 0.1);
+        }
+        
+        textarea.form-control {
+            min-height: 100px;
+            resize: vertical;
+        }
+        
+        .btn {
+            display: inline-block;
+            padding: 12px 24px;
+            background-color: var(--primary);
+            color: white;
+            border: none;
+            border-radius: var(--border-radius);
+            font-size: 1rem;
+            font-weight: 500;
+            cursor: pointer;
+            transition: all 0.3s;
+        }
+        
+        .btn:hover {
+            background-color: var(--secondary);
+            transform: translateY(-2px);
+        }
+        
+        .btn-block {
+            display: block;
+            width: 100%;
+        }
+        
+        .section-title {
+            font-size: 1.2rem;
+            color: var(--primary);
+            margin-bottom: 15px;
+            font-weight: 600;
+        }
+        
+        .results-container {
+            display: none;
+            margin-top: 30px;
+        }
+        
+        .results-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(450px, 1fr));
+    gap: 25px;
+}
+
+        
+        .result-card {
+            background: white;
+            border-radius: var(--border-radius);
+            box-shadow: var(--box-shadow);
+            padding: 20px;
+            height: 100%;
+        }
+        
+        .result-header {
+            display: flex;
+            align-items: center;
+            margin-bottom: 15px;
+        }
+        
+        .result-icon {
+            width: 40px;
+            height: 40px;
+            background-color: var(--light);
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            margin-right: 15px;
+        }
+        
+        .result-title {
+            font-size: 1.2rem;
+            font-weight: 600;
+            color: var(--dark);
+        }
+        
+        .trust-score {
+            text-align: center;
+            padding: 20px;
+        }
+        
+        .score-value {
+            font-size: 3rem;
+            font-weight: 700;
+            color: var(--primary);
+        }
+        
+        .score-label {
+            font-size: 1rem;
+            color: var(--gray);
+        }
+        
+        .progress-container {
+            margin: 15px 0;
+        }
+        
+        .progress-bar {
+            height: 10px;
+            background-color: #eee;
+            border-radius: 5px;
+            overflow: hidden;
+        }
+        
+        .progress-fill {
+            height: 100%;
+            background-color: var(--primary);
+            border-radius: 5px;
+            transition: width 0.5s ease-in-out;
+        }
+        
+        .alert {
+            padding: 15px;
+            border-radius: var(--border-radius);
+            margin-bottom: 20px;
+            font-weight: 500;
+        }
+        
+        .alert-danger {
+            background-color: rgba(247, 37, 133, 0.1);
+            color: var(--danger);
+            border-left: 4px solid var(--danger);
+        }
+        
+        .alert-warning {
+            background-color: rgba(248, 150, 30, 0.1);
+            color: var(--warning);
+            border-left: 4px solid var(--warning);
+        }
+        
+        .alert-success {
+            background-color: rgba(76, 201, 240, 0.1);
+            color: var(--success);
+            border-left: 4px solid var(--success);
+        }
+        
+        .suggestion-list {
+            list-style-type: none;
+            padding: 0;
+        }
+        
+        .suggestion-item {
+            padding: 10px 15px;
+            background-color: rgba(67, 97, 238, 0.05);
+            border-radius: var(--border-radius);
+            margin-bottom: 10px;
+            border-left: 3px solid var(--primary);
+        }
+        
+        .image-preview {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+            margin-top: 10px;
+        }
+        
+        .preview-item {
+            width: 100px;
+            height: 100px;
+            border-radius: 8px;
+            overflow: hidden;
+            position: relative;
+        }
+        
+        .preview-item img {
+            width: 100%;
+            height: 100%;
+            object-fit: cover;
+        }
+        
+        .preview-remove {
+            position: absolute;
+            top: 5px;
+            right: 5px;
+            background: rgba(0, 0, 0, 0.5);
+            color: white;
+            border: none;
+            border-radius: 50%;
+            width: 20px;
+            height: 20px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            cursor: pointer;
+        }
+        
+        .loading {
+            display: none;
+            text-align: center;
+            padding: 30px;
+        }
+        
+        .spinner {
+            width: 50px;
+            height: 50px;
+            border: 5px solid rgba(67, 97, 238, 0.1);
+            border-radius: 50%;
+            border-top-color: var(--primary);
+            animation: spin 1s ease-in-out infinite;
+            margin: 0 auto 20px;
+        }
+        
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+        
+        .chart-container {
+            position: relative;
+            height: 200px;
+            margin-bottom: 20px;
+        }
+        
+        .pdf-preview {
+            background-color: #f8f9fa;
+            padding: 15px;
+            border-radius: var(--border-radius);
+            margin-top: 10px;
+            max-height: 200px;
+            overflow-y: auto;
+        }
+        
+        .pdf-filename {
+            font-weight: 500;
+            margin-bottom: 5px;
+        }
+        
+        .image-gallery {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
+            gap: 15px;
+            margin-top: 20px;
+        }
+        
+        .gallery-item {
+            border-radius: var(--border-radius);
+            overflow: hidden;
+            box-shadow: var(--box-shadow);
+            aspect-ratio: 1;
+        }
+        
+        .gallery-item img {
+            width: 100%;
+            height: 100%;
+            object-fit: cover;
+        }
+        
+        .badge {
+            display: inline-block;
+            padding: 5px 10px;
+            border-radius: 20px;
+            font-size: 0.8rem;
+            font-weight: 500;
+            margin-right: 5px;
+            margin-bottom: 5px;
+        }
+        
+        .badge-primary { background-color: rgba(67, 97, 238, 0.1); color: var(--primary); }
+        .badge-success { background-color: rgba(76, 201, 240, 0.1); color: var(--success); }
+        .badge-warning { background-color: rgba(248, 150, 30, 0.1); color: var(--warning); }
+        .badge-danger { background-color: rgba(247, 37, 133, 0.1); color: var(--danger); }
+        
+        .explanation-box {
+            background-color: #f8f9fa;
+            border-radius: var(--border-radius);
+            padding: 15px;
+            margin-top: 15px;
+            border-left: 4px solid var(--info);
+        }
+        
+        .explanation-title {
+            font-weight: 600;
+            color: var(--info);
+            margin-bottom: 10px;
+        }
+        
+        @media (max-width: 768px) {
+            .form-grid, .results-grid {
+                grid-template-columns: 1fr;
+            }
+            
+            .card {
+                padding: 15px;
+            }
+        }
+        
+        .property-summary {
+            padding: 15px;
+        }
+        
+        .property-details p {
+            margin-bottom: 8px;
+        }
+        
+        .final-verdict {
+            padding: 15px;
+        }
+        
+        .verdict-box {
+            display: flex;
+            align-items: center;
+            padding: 15px;
+            border-radius: var(--border-radius);
+            margin-bottom: 15px;
+            background-color: #f8f9fa;
+        }
+        
+        .verdict-icon {
+            font-size: 2rem;
+            margin-right: 15px;
+        }
+        
+        .verdict-text {
+            font-size: 1.2rem;
+            font-weight: 600;
+        }
+        
+        .verdict-legitimate {
+            background-color: rgba(76, 201, 240, 0.1);
+            border-left: 4px solid var(--success);
+        }
+        
+        .verdict-suspicious {
+            background-color: rgba(248, 150, 30, 0.1);
+            border-left: 4px solid var(--warning);
+        }
+        
+        .verdict-fraudulent {
+            background-color: rgba(247, 37, 133, 0.1);
+            border-left: 4px solid var(--danger);
+        }
+        
+        .verification-scores {
+            padding: 15px;
+        }
+        
+        .score-item {
+            margin-bottom: 15px;
+        }
+        
+        .score-label {
+            font-weight: 500;
+            margin-bottom: 5px;
+        }
+        
+        .score-bar-container {
+            display: flex;
+            align-items: center;
+        }
+        
+        .score-bar {
+            height: 10px;
+            background-color: #e9ecef;
+            border-radius: 5px;
+            flex-grow: 1;
+            margin-right: 10px;
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .score-bar::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            height: 100%;
+            background-color: var(--primary);
+            border-radius: 5px;
+            width: 0%;
+            transition: width 0.5s ease;
+        }
+        
+        .score-value {
+            font-weight: 600;
+            min-width: 40px;
+            text-align: right;
+        }
+        
+        .red-flags {
+            padding: 15px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>AI Property Verifier & Fraud Detection</h1>
+            <p class="subtitle">Powered by advanced AI models to verify property listings and detect potential fraud</p>
+        </header>
+        
+        <div class="card">
+            <div class="card-header">
+                <h2 class="card-title">Property Details</h2>
+            </div>
+            
+                <form id="propertyForm">
+                <div class="section-title">Basic Information</div>
+                    <div class="form-grid">
+                        <div class="form-group">
+                        <label class="form-label" for="propertyName">Property Name</label>
+                        <input type="text" class="form-control" id="propertyName" name="property_name" required>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="propertyType">Property Type</label>
+                        <select class="form-control" id="propertyType" name="property_type" required>
+                            <option value="">Select Type</option>
+                                <option value="Apartment">Apartment</option>
+                                <option value="House">House</option>
+                                <option value="Condo">Condo</option>
+                                <option value="Townhouse">Townhouse</option>
+                            <option value="Villa">Villa</option>
+                                <option value="Land">Land</option>
+                                <option value="Commercial">Commercial</option>
+                                <option value="Other">Other</option>
+                            </select>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="status">Status</label>
+                        <select class="form-control" id="status" name="status" required>
+                            <option value="">Select Status</option>
+                                <option value="For Sale">For Sale</option>
+                                <option value="For Rent">For Rent</option>
+                                <option value="Sold">Sold</option>
+                            <option value="Under Contract">Under Contract</option>
+                                <option value="Pending">Pending</option>
+                            </select>
+                        </div>
+                        </div>
+                        
+                <div class="form-group">
+                    <label class="form-label" for="description">Property Description</label>
+                    <textarea class="form-control" id="description" name="description" rows="4" required></textarea>
+                    </div>
+                    
+                <div class="section-title">Location Details</div>
+                    <div class="form-grid">
+                        <div class="form-group">
+                        <label class="form-label" for="address">Address</label>
+                        <input type="text" class="form-control" id="address" name="address" required>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="city">City</label>
+                        <input type="text" class="form-control" id="city" name="city" required>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="state">State/Province</label>
+                        <input type="text" class="form-control" id="state" name="state" required>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="country">Country</label>
+                        <input type="text" class="form-control" id="country" name="country" required>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="zip">Zip/Postal Code</label>
+                        <input type="text" class="form-control" id="zip" name="zip" required>
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="latitude">Latitude</label>
+                        <input type="text" class="form-control" id="latitude" name="latitude" placeholder="e.g. 40.7128">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="longitude">Longitude</label>
+                        <input type="text" class="form-control" id="longitude" name="longitude" placeholder="e.g. -74.0060">
+                        </div>
+                    </div>
+                    
+                <div class="section-title">Property Specifications</div>
+                    <div class="form-grid">
+                        <div class="form-group">
+                        <label class="form-label" for="bedrooms">Bedrooms</label>
+                        <input type="number" class="form-control" id="bedrooms" name="bedrooms" min="0">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="bathrooms">Bathrooms</label>
+                        <input type="number" class="form-control" id="bathrooms" name="bathrooms" min="0" step="0.5">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="totalRooms">Total Rooms</label>
+                        <input type="number" class="form-control" id="totalRooms" name="total_rooms" min="0">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="yearBuilt">Year Built</label>
+                        <input type="number" class="form-control" id="yearBuilt" name="year_built" min="1800" max="2100">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="parking">Parking Spaces</label>
+                        <input type="number" class="form-control" id="parking" name="parking" min="0">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="sqFt">Square Feet</label>
+                        <input type="text" class="form-control" id="sqFt" name="sq_ft" min="0">
+                        </div>
+                        
+                        <div class="form-group">
+                        <label class="form-label" for="marketValue">Market Value</label>
+                        <input type="text" class="form-control" id="marketValue" name="market_value" min="0">
+                    </div>
+                        </div>
+                        
+                        <div class="form-group">
+                    <label class="form-label" for="amenities">Amenities (comma separated)</label>
+                    <input type="text" class="form-control" id="amenities" name="amenities" placeholder="e.g. Pool, Gym, Garden, Garage">
+                        </div>
+                        
+                        <div class="form-group">
+                    <label class="form-label" for="nearbyLandmarks">Nearby Landmarks</label>
+                    <input type="text" class="form-control" id="nearbyLandmarks" name="nearby_landmarks" placeholder="e.g. School, Hospital, Park, Shopping Mall">
+                        </div>
+                        
+                        <div class="form-group">
+                    <label class="form-label" for="legalDetails">Legal & Infrastructure Details</label>
+                    <textarea class="form-control" id="legalDetails" name="legal_details" rows="3" placeholder="Include zoning, permits, utilities, etc."></textarea>
+                        </div>
+                
+                <div class="section-title">Documents & Images</div>
+                <div class="form-group">
+                    <label class="form-label" for="images">Upload Images (JPG/PNG)</label>
+                    <input type="file" class="form-control" id="images" name="images" accept="image/jpeg, image/png" multiple>
+                    <div class="image-preview" id="imagePreview"></div>
+                    </div>
+                    
+                        <div class="form-group">
+                    <label class="form-label" for="documents">Upload Documents (PDF)</label>
+                    <input type="file" class="form-control" id="documents" name="documents" accept="application/pdf" multiple>
+                    <div id="pdfPreview"></div>
+                            </div>
+                        
+                        <div class="form-group">
+                    <button type="submit" class="btn btn-block" id="submitBtn">Verify Property with AI</button>
+                </div>
+            </form>
+                        </div>
+                        
+        <div class="loading" id="loadingIndicator">
+            <div class="spinner"></div>
+            <p>AI models are analyzing your property data...</p>
+            <p class="subtitle">This may take a moment as we're processing multiple AI models</p>
+                            </div>
+        
+        <div class="results-container" id="resultsContainer">
+            <div class="card">
+                <div class="card-header">
+                    <h2 class="card-title">AI Verification Results</h2>
+                        </div>
+                        
+                <div class="results-grid">
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🏠</div>
+                            <div class="result-title">Property Summary</div>
+                        </div>
+                        <div class="property-summary">
+                            <h3 id="propertyTitle">Property Details</h3>
+                            <div class="property-details">
+                                <p><strong>Name:</strong> <span id="summaryName"></span></p>
+                                <p><strong>Type:</strong> <span id="summaryType"></span></p>
+                                <p><strong>Status:</strong> <span id="summaryStatus"></span></p>
+                                <p><strong>Location:</strong> <span id="summaryLocation"></span></p>
+                                <p><strong>Price:</strong> <span id="summaryPrice"></span></p>
+                                <p><strong>Size:</strong> <span id="summarySize"></span></p>
+                                <p><strong>Bedrooms/Bathrooms:</strong> <span id="summaryRooms"></span></p>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">⚠️</div>
+                            <div class="result-title">Final Verdict</div>
+                        </div>
+                        <div class="final-verdict" id="finalVerdict">
+                            <div class="verdict-box" id="verdictBox">
+                                <div class="verdict-icon" id="verdictIcon">⏳</div>
+                                <div class="verdict-text" id="verdictText">Analysis in progress...</div>
+                            </div>
+                            <div class="verdict-reasons">
+                                <h4>Key Findings:</h4>
+                                <ul id="verdictReasons" class="suggestion-list">
+                                    <!-- Will be populated by JavaScript -->
+                                </ul>
+                            </div>
+                        </div>
+            </div>
+            
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🔍</div>
+                            <div class="result-title">Detailed Verification</div>
+                        </div>
+                        <div class="verification-scores">
+                            <div class="score-item">
+                                <div class="score-label">Trust Score</div>
+                                <div class="score-bar-container">
+                                    <div class="score-bar" id="trustBar"></div>
+                                    <div class="score-value" id="trustValue">--</div>
+                                </div>
+                            </div>
+                            <div class="score-item">
+                                <div class="score-label">Image Authenticity</div>
+                                <div class="score-bar-container">
+                                    <div class="score-bar" id="imageBar"></div>
+                                    <div class="score-value" id="imageValue">--</div>
+                                </div>
+                            </div>
+                            <div class="score-item">
+                                <div class="score-label">Document Verification</div>
+                                <div class="score-bar-container">
+                                    <div class="score-bar" id="documentBar"></div>
+                                    <div class="score-value" id="documentValue">--</div>
+                                </div>
+                            </div>
+                            <div class="score-item">
+                                <div class="score-label">Content Quality</div>
+                                <div class="score-bar-container">
+                                    <div class="score-bar" id="contentBar"></div>
+                                    <div class="score-value" id="contentValue">--</div>
+                                </div>
+                            </div>
+                            <div class="score-item">
+                                <div class="score-label">Location Accuracy</div>
+                                <div class="score-bar-container">
+                                    <div class="score-bar" id="locationBar"></div>
+                                    <div class="score-value" id="locationValue">--</div>
+                                </div>
+                            </div>
+                        </div>
+                </div>
+                
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🚩</div>
+                            <div class="result-title">Red Flags</div>
+                        </div>
+                        <div class="red-flags">
+                            <ul id="redFlagsList" class="suggestion-list">
+                                <!-- Will be populated by JavaScript -->
+                            </ul>
+                    </div>
+                </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">📊</div>
+                            <div class="result-title">Trust Score</div>
+                        </div>
+                        <div class="trust-score">
+                            <div class="score-value" id="trustScoreValue">--</div>
+                            <div class="score-label">Trust Score</div>
+                            <div class="progress-container">
+                                <div class="progress-bar">
+                                    <div class="progress-fill" id="trustScoreBar" style="width: 0%"></div>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="chart-container">
+                            <canvas id="trustScoreChart"></canvas>
+                        </div>
+                        <div class="explanation-box">
+                            <div class="explanation-title">AI Reasoning</div>
+                            <div id="trustReasoning"></div>
+                        </div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🔍</div>
+                            <div class="result-title">Fraud Analysis</div>
+                            </div>
+                        <div id="fraudAlertContainer"></div>
+                        <div class="chart-container">
+                            <canvas id="fraudAnalysisChart"></canvas>
+                        </div>
+                        <div class="explanation-box">
+                            <div class="explanation-title">AI Reasoning</div>
+                            <div id="fraudReasoning"></div>
+                        </div>
+            </div>
+            
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">📝</div>
+                            <div class="result-title">AI Summary</div>
+                        </div>
+                        <div id="aiSummary"></div>
+                </div>
+                
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">💡</div>
+                            <div class="result-title">Improvement Suggestions</div>
+                        </div>
+                        <ul class="suggestion-list" id="suggestionsList"></ul>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🏠</div>
+                            <div class="result-title">Property Quality Assessment</div>
+                </div>
+                        <div id="qualityAssessment"></div>
+                        <div class="chart-container">
+                            <canvas id="qualityChart"></canvas>
+                        </div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">📍</div>
+                            <div class="result-title">Location Analysis</div>
+                        </div>
+                        <div id="locationAnalysis"></div>
+                        <div class="chart-container">
+                            <canvas id="locationChart"></canvas>
+                        </div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">💰</div>
+                            <div class="result-title">Price Analysis</div>
+                        </div>
+                        <div id="priceAnalysis"></div>
+                        <div class="chart-container">
+                            <canvas id="priceChart"></canvas>
+                        </div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">⚖️</div>
+                            <div class="result-title">Legal Analysis</div>
+                        </div>
+                        <div id="legalAnalysis"></div>
+                        <div class="chart-container">
+                            <canvas id="legalChart"></canvas>
+                        </div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🔄</div>
+                            <div class="result-title">Cross-Validation Checks</div>
+                        </div>
+                        <div id="crossValidation"></div>
+                    </div>
+                    
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">📄</div>
+                            <div class="result-title">Document Analysis</div>
+                        </div>
+                        <div id="documentAnalysis"></div>
+                        <div class="chart-container">
+                            <canvas id="documentChart"></canvas>
+                        </div>
+                    </div>
+                
+                    <div class="result-card">
+                        <div class="result-header">
+                            <div class="result-icon">🖼️</div>
+                            <div class="result-title">Image Analysis</div>
+                        </div>
+                        <div id="imageAnalysis"></div>
+                        <div class="image-gallery" id="imageGallery"></div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <script>
+        // Global variables to store form data
+        let uploadedImages = [];
+        let uploadedPDFs = [];
+        
+        // Initialize charts
+        let trustScoreChart;
+        let fraudAnalysisChart;
+        let qualityChart;
+        let locationChart;
+        let priceChart;
+        let legalChart;
+        let documentChart;
+        
+        document.addEventListener('DOMContentLoaded', function() {
+            // Request location access when page loads
+            requestLocationAccess();
+            
+            const propertyForm = document.getElementById('propertyForm');
+            const loadingIndicator = document.getElementById('loadingIndicator');
+            const resultsContainer = document.getElementById('resultsContainer');
+            const imageInput = document.getElementById('images');
+            const imagePreview = document.getElementById('imagePreview');
+            const pdfInput = document.getElementById('documents');
+            const pdfPreview = document.getElementById('pdfPreview');
+            
+            // Handle image uploads
+            imageInput.addEventListener('change', function(e) {
+                handleImageUpload(e.target.files);
+            });
+            
+            // Handle PDF uploads
+            pdfInput.addEventListener('change', function(e) {
+                handlePDFUpload(e.target.files);
+            });
+            
+            // Form submission
+            propertyForm.addEventListener('submit', function(e) {
+                e.preventDefault();
+                submitForm();
+            });
+            
+            // Initialize charts
+            initCharts();
+        });
+        
+        function requestLocationAccess() {
+            if (navigator.geolocation) {
+                navigator.geolocation.getCurrentPosition(
+                    function(position) {
+                        const latitude = position.coords.latitude;
+                        const longitude = position.coords.longitude;
+                        
+                        // Update form fields with coordinates
+                        document.getElementById('latitude').value = latitude;
+                        document.getElementById('longitude').value = longitude;
+                        
+                        // Send to backend to get address details
+                        fetch('/get-location', {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                            },
+                            body: JSON.stringify({
+                                latitude: latitude,
+                                longitude: longitude
+                            }),
+                        })
+                        .then(response => response.json())
+                        .then(data => {
+                            if (data.status === 'success') {
+                                // Fill form fields with location data
+                                document.getElementById('address').value = data.address || '';
+                                document.getElementById('city').value = data.city || '';
+                                document.getElementById('state').value = data.state || '';
+                                document.getElementById('country').value = data.country || '';
+                                document.getElementById('zip').value = data.postal_code || '';
+                                
+                                console.log('Location data loaded successfully');
+                            } else {
+                                console.error('Error getting location details:', data.message);
+                            }
+                        })
+                        .catch(error => {
+                            console.error('Error getting location details:', error);
+                        });
+                    },
+                    function(error) {
+                        console.error('Error getting location:', error.message);
+                        // Show a message to the user about location access
+                        const locationMessage = document.createElement('div');
+                        locationMessage.className = 'alert alert-warning';
+                        locationMessage.innerHTML = 'Location access denied or unavailable. Please enter your location manually.';
+                        document.querySelector('.container').prepend(locationMessage);
+                        
+                        // Auto-remove the message after 5 seconds
+                        setTimeout(() => {
+                            locationMessage.remove();
+                        }, 5000);
+                    },
+                    {
+                        enableHighAccuracy: true,
+                        timeout: 5000,
+                        maximumAge: 0
+                    }
+                );
+            } else {
+                console.error('Geolocation is not supported by this browser');
+            }
+        }
+        
+        function handleImageUpload(files) {
+            const imagePreview = document.getElementById('imagePreview');
+            
+            for (let i = 0; i < files.length; i++) {
+                const file = files[i];
+                if (!file.type.match('image.*')) continue;
+                
+                const reader = new FileReader();
+                reader.onload = function(e) {
+                    const imageData = e.target.result;
+                    uploadedImages.push({
+                        name: file.name,
+                        data: imageData,
+                        file: file
+                    });
+                    
+                    // Create preview
+                    const previewItem = document.createElement('div');
+                    previewItem.className = 'preview-item';
+                    previewItem.innerHTML = `
+                        <img src="${imageData}" alt="${file.name}">
+                        <button type="button" class="preview-remove" data-index="${uploadedImages.length - 1}">×</button>
+                    `;
+                    imagePreview.appendChild(previewItem);
+                    
+                    // Add remove functionality
+                    previewItem.querySelector('.preview-remove').addEventListener('click', function() {
+                        const index = parseInt(this.getAttribute('data-index'));
+                        uploadedImages.splice(index, 1);
+                        imagePreview.removeChild(previewItem);
+                        updateImagePreviews();
+                    });
+                };
+                reader.readAsDataURL(file);
+            }
+        }
+        
+        function updateImagePreviews() {
+            const imagePreview = document.getElementById('imagePreview');
+            imagePreview.innerHTML = '';
+            
+            uploadedImages.forEach((image, index) => {
+                const previewItem = document.createElement('div');
+                previewItem.className = 'preview-item';
+                previewItem.innerHTML = `
+                    <img src="${image.data}" alt="${image.name}">
+                    <button type="button" class="preview-remove" data-index="${index}">×</button>
+                `;
+                imagePreview.appendChild(previewItem);
+                
+                previewItem.querySelector('.preview-remove').addEventListener('click', function() {
+                    uploadedImages.splice(index, 1);
+                    updateImagePreviews();
+                });
+            });
+        }
+        
+        function handlePDFUpload(files) {
+            const pdfPreview = document.getElementById('pdfPreview');
+            
+            for (let i = 0; i < files.length; i++) {
+                const file = files[i];
+                if (file.type !== 'application/pdf') continue;
+                
+                uploadedPDFs.push({
+                    name: file.name,
+                    file: file
+                });
+                
+                // Create preview
+                const previewItem = document.createElement('div');
+                previewItem.className = 'pdf-preview';
+                previewItem.innerHTML = `
+                    <div class="pdf-filename">${file.name}</div>
+                    <button type="button" class="btn" data-index="${uploadedPDFs.length - 1}">Remove</button>
+                `;
+                pdfPreview.appendChild(previewItem);
+                
+                // Add remove functionality
+                previewItem.querySelector('.btn').addEventListener('click', function() {
+                    const index = parseInt(this.getAttribute('data-index'));
+                    uploadedPDFs.splice(index, 1);
+                    pdfPreview.removeChild(previewItem);
+                    updatePDFPreviews();
+                });
+            }
+        }
+        
+        function updatePDFPreviews() {
+            const pdfPreview = document.getElementById('pdfPreview');
+            pdfPreview.innerHTML = '';
+            
+            uploadedPDFs.forEach((pdf, index) => {
+                const previewItem = document.createElement('div');
+                previewItem.className = 'pdf-preview';
+                previewItem.innerHTML = `
+                    <div class="pdf-filename">${pdf.name}</div>
+                    <button type="button" class="btn" data-index="${index}">Remove</button>
+                `;
+                pdfPreview.appendChild(previewItem);
+                
+                previewItem.querySelector('.btn').addEventListener('click', function() {
+                    uploadedPDFs.splice(index, 1);
+                    updatePDFPreviews();
+                });
+            });
+        }
+        
+        function initCharts() {
+            try {
+                // Store all charts in an array for easier management
+                window.charts = [];
+                
+                // Trust Score Chart initialization
+                const trustCtx = document.getElementById('trustScoreChart').getContext('2d');
+                trustScoreChart = new Chart(trustCtx, {
+                type: 'doughnut',
+                data: {
+                    datasets: [{
+                        data: [0, 100],
+                        backgroundColor: [
+                            '#4361ee',
+                            '#f1f1f1'
+                        ],
+                        borderWidth: 0
+                    }]
+                },
+                options: {
+                    cutout: '70%',
+                    circumference: 180,
+                    rotation: -90,
+                    plugins: {
+                        legend: {
+                            display: false
+                        },
+                        tooltip: {
+                            enabled: false
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+                charts.push(trustScoreChart);
+            
+            // Fraud Analysis Chart (Bar)
+            const fraudAnalysisCtx = document.getElementById('fraudAnalysisChart').getContext('2d');
+            fraudAnalysisChart = new Chart(fraudAnalysisCtx, {
+                type: 'bar',
+                data: {
+                    labels: ['Legitimate', 'Suspicious', 'Fraudulent'],
+                    datasets: [{
+                        label: 'Fraud Indicators',
+                        data: [0, 0, 0],
+                        backgroundColor: [
+                            '#4cc9f0',
+                            '#f8961e',
+                            '#f72585'
+                        ],
+                        borderWidth: 0
+                    }]
+                },
+                options: {
+                    indexAxis: 'y',
+                    plugins: {
+                        legend: {
+                            display: false
+                        }
+                    },
+                    scales: {
+                        x: {
+                            beginAtZero: true,
+                            max: 100
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+            
+            // Quality Assessment Chart
+            const qualityCtx = document.getElementById('qualityChart').getContext('2d');
+            qualityChart = new Chart(qualityCtx, {
+                type: 'radar',
+                data: {
+                    labels: ['Completeness', 'Accuracy', 'Clarity', 'Authenticity', 'Detail'],
+                    datasets: [{
+                        label: 'Quality Score',
+                        data: [0, 0, 0, 0, 0],
+                        backgroundColor: 'rgba(67, 97, 238, 0.2)',
+                        borderColor: '#4361ee',
+                        borderWidth: 2,
+                        pointBackgroundColor: '#4361ee'
+                    }]
+                },
+                options: {
+                    scales: {
+                        r: {
+                            beginAtZero: true,
+                            max: 100
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+            
+            // Location Analysis Chart
+            const locationCtx = document.getElementById('locationChart').getContext('2d');
+            locationChart = new Chart(locationCtx, {
+                type: 'pie',
+                data: {
+                    labels: ['Complete', 'Partial', 'Missing'],
+                    datasets: [{
+                        data: [0, 0, 0],
+                        backgroundColor: [
+                            '#4cc9f0',
+                            '#f8961e',
+                            '#f72585'
+                        ],
+                        borderWidth: 0
+                    }]
+                },
+                options: {
+                    plugins: {
+                        legend: {
+                            position: 'bottom'
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+            
+            // Price Analysis Chart
+            const priceCtx = document.getElementById('priceChart').getContext('2d');
+            priceChart = new Chart(priceCtx, {
+                type: 'bar',
+                data: {
+                    labels: ['Market Value', 'Price per Sq.Ft.'],
+                    datasets: [{
+                        label: 'Price Analysis',
+                        data: [0, 0],
+                        backgroundColor: [
+                            '#4361ee',
+                            '#4895ef'
+                        ],
+                        borderWidth: 0
+                    }]
+                },
+                options: {
+                    scales: {
+                        y: {
+                            beginAtZero: true
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+            
+            // Legal Analysis Chart
+            const legalCtx = document.getElementById('legalChart').getContext('2d');
+            legalChart = new Chart(legalCtx, {
+                type: 'doughnut',
+                data: {
+                    labels: ['Complete', 'Partial', 'Missing'],
+                    datasets: [{
+                        data: [0, 0, 0],
+                        backgroundColor: [
+                            '#4cc9f0',
+                            '#f8961e',
+                            '#f72585'
+                        ],
+                        borderWidth: 0
+                    }]
+                },
+                options: {
+                    plugins: {
+                        legend: {
+                            position: 'bottom'
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+            
+            // Document Analysis Chart
+            const documentCtx = document.getElementById('documentChart').getContext('2d');
+            documentChart = new Chart(documentCtx, {
+                type: 'polarArea',
+                data: {
+                    labels: ['Authentic', 'Suspicious', 'Incomplete'],
+                    datasets: [{
+                        data: [0, 0, 0],
+                        backgroundColor: [
+                            '#4cc9f0',
+                            '#f8961e',
+                            '#f72585'
+                        ],
+                        borderWidth: 0
+                    }]
+                },
+                options: {
+                    plugins: {
+                        legend: {
+                            position: 'bottom'
+                        }
+                    },
+                    maintainAspectRatio: false
+                }
+            });
+                
+                // Add window resize handler for chart responsiveness
+                window.addEventListener('resize', debounce(() => {
+                    charts.forEach(chart => {
+                        if (chart && typeof chart.resize === 'function') {
+                            chart.resize();
+                        }
+                    });
+                }, 250));
+                
+            } catch (error) {
+                console.error('Error initializing charts:', error);
+                document.getElementById('chartErrors').innerHTML = 
+                    '<div class="alert alert-danger">Error initializing charts. Please refresh the page.</div>';
+            }
+        }
+        
+        // Utility function for debouncing
+        function debounce(func, wait) {
+            let timeout;
+            return function executedFunction(...args) {
+                const later = () => {
+                    clearTimeout(timeout);
+                    func(...args);
+                };
+                clearTimeout(timeout);
+                timeout = setTimeout(later, wait);
+            };
+        }
+        
+        // Data validation function
+        function validateAnalysisData(data) {
+            return {
+                trustScore: {
+                    score: data.trust_score?.score ?? 0,
+                    reasoning: data.trust_score?.reasoning ?? 'No reasoning provided'
+                },
+                fraudClassification: {
+                    alertLevel: data.fraud_classification?.alert_level ?? 'low',
+                    classification: data.fraud_classification?.classification ?? 'Unknown',
+                    confidence: data.fraud_classification?.confidence ?? 0,
+                    indicators: data.fraud_classification?.fraud_indicators ?? [],
+                    scores: data.fraud_classification?.indicator_scores ?? []
+                },
+                qualityAssessment: {
+                    assessment: data.quality_assessment?.assessment ?? 'Unknown',
+                    score: data.quality_assessment?.score ?? 0,
+                    isAiGenerated: data.quality_assessment?.is_ai_generated ?? false,
+                    reasoning: data.quality_assessment?.reasoning ?? 'No reasoning provided'
+                },
+                // ... other validations
+            };
+        }
+        
+        // Safe chart update function
+        function updateChart(chart, newData, options = {}) {
+            try {
+                if (chart && typeof chart.update === 'function') {
+                    chart.data = newData;
+                    chart.update(options);
+                    return true;
+                }
+                return false;
+            } catch (error) {
+                console.error('Error updating chart:', error);
+                return false;
+            }
+        }
+        
+        function submitForm() {
+            // Show loading indicator
+            document.getElementById('loadingIndicator').style.display = 'block';
+            document.getElementById('resultsContainer').style.display = 'none';
+            
+            // Create form data
+            const formData = new FormData(document.getElementById('propertyForm'));
+            
+            // Add images
+            uploadedImages.forEach((image, index) => {
+                formData.append('images', image.file);
+            });
+            
+            // Add PDFs
+            uploadedPDFs.forEach((pdf, index) => {
+                formData.append('documents', pdf.file);
+            });
+            
+            // Send to backend
+            fetch('/verify', {
+                    method: 'POST',
+                    body: formData
+                })
+            .then(response => {
+                if (!response.ok) {
+                    throw new Error('Network response was not ok');
+                }
+                return response.json();
+            })
+                .then(data => {
+                // Hide loading indicator
+                document.getElementById('loadingIndicator').style.display = 'none';
+                
+                // Display results
+                displayResults(data);
+                
+                // Show results container
+                document.getElementById('resultsContainer').style.display = 'block';
+                
+                // Scroll to results
+                document.getElementById('resultsContainer').scrollIntoView({ behavior: 'smooth' });
+                })
+                .catch(error => {
+                console.error('Error:', error);
+                document.getElementById('loadingIndicator').style.display = 'none';
+                alert('An error occurred while processing your request. Please try again.');
+            });
+        }
+        function displayResults(data) {
+            console.log("Received data:", JSON.stringify(data));
+
+            // Validate and sanitize data
+            const validatedData = validateAnalysisData(data);
+            
+            try {
+                // Display Trust Score with validated data
+                const trustScore = validatedData.trustScore.score;
+                document.getElementById('trustScoreValue').textContent = trustScore;
+                document.getElementById('trustScoreBar').style.width = `${trustScore}%`;
+                document.getElementById('trustReasoning').textContent = validatedData.trustScore.reasoning;
+                
+                // Update Trust Score Chart safely
+                updateChart(trustScoreChart, {
+                    datasets: [{
+                        data: [trustScore, 100 - trustScore]
+                    }]
+                });
+                
+                // Display Fraud Analysis
+                const fraudLevel = validatedData.fraudClassification.alertLevel;
+                const fraudContainer = document.getElementById('fraudAlertContainer');
+                fraudContainer.innerHTML = '';
+
+                const alertClass = fraudLevel === 'high' ? 'alert-danger' :
+                                  fraudLevel === 'medium' ? 'alert-warning' : 'alert-success';
+
+                const alertDiv = document.createElement('div');
+                alertDiv.className = `alert ${alertClass}`;
+                alertDiv.textContent = `Classification: ${validatedData.fraudClassification.classification} (Confidence: ${Math.round(validatedData.fraudClassification.confidence * 100)}%)`;
+                fraudContainer.appendChild(alertDiv);
+
+                // Update Fraud Analysis Chart
+                const fraudIndicators = validatedData.fraudClassification.indicators || [];
+                const fraudScores = validatedData.fraudClassification.scores || [];
+                const formattedScores = fraudScores.map(score => score * 100);
+
+                updateChart(fraudAnalysisChart, {
+                    labels: fraudIndicators,
+                    datasets: [{
+                        data: formattedScores
+                    }]
+                });
+
+                document.getElementById('fraudReasoning').textContent = `This property was classified as ${validatedData.fraudClassification.classification} based on AI analysis of the listing details.`;
+
+                // Display AI Summary
+                document.getElementById('aiSummary').textContent = data.summary || "No summary available";
+
+                // Display Improvement Suggestions
+                const suggestionsList = document.getElementById('suggestionsList');
+                suggestionsList.innerHTML = '';
+
+                if (data.suggestions && Array.isArray(data.suggestions) && data.suggestions.length > 0) {
+                    data.suggestions.forEach(suggestion => {
+                        if (suggestion && suggestion.trim()) {
+                            const li = document.createElement('li');
+                            li.className = 'suggestion-item';
+                            li.textContent = suggestion;
+                            suggestionsList.appendChild(li);
+                        }
+                    });
+                } else {
+                    const li = document.createElement('li');
+                    li.className = 'suggestion-item';
+                    li.textContent = "No suggestions available";
+                    suggestionsList.appendChild(li);
+                }
+
+                // Display Quality Assessment
+                const qualityDiv = document.getElementById('qualityAssessment');
+                if (validatedData.qualityAssessment) {
+                    qualityDiv.innerHTML = `
+                        <p><strong>Assessment:</strong> ${validatedData.qualityAssessment.assessment}</p>
+                        <p><strong>Quality Score:</strong> ${validatedData.qualityAssessment.score}%</p>
+                        <p><strong>AI Generated:</strong> ${validatedData.qualityAssessment.isAiGenerated ? 'Likely' : 'Unlikely'}</p>
+                        <p><strong>Reasoning:</strong> ${validatedData.qualityAssessment.reasoning}</p>
+                    `;
+
+                    // Update Quality Chart
+                    updateChart(qualityChart, {
+                        datasets: [{
+                            data: [
+                                validatedData.qualityAssessment.score,
+                                validatedData.qualityAssessment.isAiGenerated ? 30 : 80,
+                                validatedData.qualityAssessment.score > 50 ? 70 : 40,
+                                validatedData.qualityAssessment.isAiGenerated ? 40 : 75,
+                                validatedData.qualityAssessment.score > 60 ? 80 : 50
+                            ]
+                        }]
+                    });
+                } else {
+                    qualityDiv.innerHTML = '<p>No quality assessment available</p>';
+                }
+
+                // Display Location Analysis
+                const locationDiv = document.getElementById('locationAnalysis');
+                if (data.location_analysis) {
+                    locationDiv.innerHTML = `
+                        <p><strong>Assessment:</strong> ${data.location_analysis.assessment || "Unknown"}</p>
+                        <p><strong>Completeness:</strong> ${data.location_analysis.completeness_score || 0}%</p>
+                        <p><strong>Coordinates:</strong> ${data.location_analysis.coordinates_check || "Unknown"}</p>
+                        <p><strong>Landmarks:</strong> ${data.location_analysis.landmarks_provided ? 'Provided' : 'Not provided'}</p>
+                    `;
+
+                    // Update Location Chart
+                    updateChart(locationChart, {
+                        datasets: [{
+                            data: [
+                                data.location_analysis.completeness_score || 0,
+                                100 - (data.location_analysis.completeness_score || 0),
+                                data.location_analysis.coordinates_check === 'coordinates_missing' ? 30 : 0
+                            ]
+                        }]
+                    });
+                } else {
+                    locationDiv.innerHTML = '<p>No location analysis available</p>';
+                }
+
+                // Display Price Analysis
+                const priceDiv = document.getElementById('priceAnalysis');
+                if (data.price_analysis && data.price_analysis.has_price) {
+                    priceDiv.innerHTML = `
+                        <p><strong>Assessment:</strong> ${data.price_analysis.assessment || "Unknown"}</p>
+                        <p><strong>Price:</strong> ₹${(data.price_analysis.price || 0).toLocaleString()}</p>
+                        ${data.price_analysis.has_sqft ? `<p><strong>Price per Sq.Ft.:</strong> ₹${(data.price_analysis.price_per_sqft || 0).toLocaleString(undefined, {maximumFractionDigits: 2})}</p>` : ''}
+                        <p><strong>Confidence:</strong> ${Math.round((data.price_analysis.confidence || 0) * 100)}%</p>
+                    `;
+
+                    // Update Price Chart
+                    updateChart(priceChart, {
+                        labels: ['Market Value (thousands)', 'Price per Sq.Ft.'],
+                        datasets: [{
+                            data: [
+                                (data.price_analysis.price || 0) / 1000, // Scale down for better visualization
+                                data.price_analysis.price_per_sqft || 0
+                            ]
+                        }]
+                    });
+                } else {
+                    priceDiv.innerHTML = `<p>No price information provided for analysis.</p>`;
+                }
+
+                // Display Legal Analysis
+                const legalDiv = document.getElementById('legalAnalysis');
+                if (data.legal_analysis) {
+                    legalDiv.innerHTML = `
+                        <p><strong>Assessment:</strong> ${data.legal_analysis.assessment || "Unknown"}</p>
+                        <p><strong>Completeness:</strong> ${data.legal_analysis.completeness_score || 0}%</p>
+                        <p><strong>Summary:</strong> ${data.legal_analysis.summary || "No summary available"}</p>
+                        ${data.legal_analysis.terms_found && data.legal_analysis.terms_found.length > 0 ? `<p><strong>Legal Terms Found:</strong> ${data.legal_analysis.terms_found.join(', ')}</p>` : ''}
+                        ${data.legal_analysis.potential_issues ? '<p class="alert alert-warning">Potential legal issues detected</p>' : ''}
+                    `;
+
+                    // Update Legal Chart
+                    updateChart(legalChart, {
+                        datasets: [{
+                            data: [
+                                data.legal_analysis.completeness_score || 0,
+                                100 - (data.legal_analysis.completeness_score || 0),
+                                data.legal_analysis.potential_issues ? 30 : 0
+                            ]
+                        }]
+                    });
+                } else {
+                    legalDiv.innerHTML = '<p>No legal analysis available</p>';
+                }
+
+                // Display Cross-Validation Checks
+                const crossValidationDiv = document.getElementById('crossValidation');
+                crossValidationDiv.innerHTML = '<ul class="suggestion-list">';
+
+                try {
+                    // Safely check if cross_validation exists and is an array
+                    if (data && data.cross_validation && Array.isArray(data.cross_validation)) {
+                        // Only proceed if the array has items
+                        if (data.cross_validation.length > 0) {
+                            data.cross_validation.forEach(check => {
+                                if (check && typeof check === 'object') {
+                                    const status = check.status || 'unknown';
+                                    const checkName = check.check || 'Check';
+                                    const message = check.message || 'No details available';
+
+                                    // Determine status class
+                                    let statusClass = 'badge-warning'; // Default
+                                    if (['consistent', 'valid', 'reasonable', 'match', 'likely_valid'].includes(status)) {
+                                        statusClass = 'badge-success';
+                                    } else if (['suspicious', 'inconsistent', 'invalid', 'no_match'].includes(status)) {
+                                        statusClass = 'badge-danger';
+                                    }
+
+                                    crossValidationDiv.innerHTML += `
+                                        <li class="suggestion-item">
+                                            <span class="badge ${statusClass}">${status}</span>
+                                            <strong>${checkName}:</strong> ${message}
+                                        </li>
+                                    `;
+                                }
+                            });
+                        } else {
+                            crossValidationDiv.innerHTML += '<li class="suggestion-item">No cross-validation checks performed</li>';
+                        }
+                    } else {
+                        crossValidationDiv.innerHTML += '<li class="suggestion-item">No cross-validation data available</li>';
+                    }
+                } catch (error) {
+                    console.error("Error displaying cross-validation:", error);
+                    crossValidationDiv.innerHTML += '<li class="suggestion-item">Error displaying cross-validation results</li>';
+                }
+
+                crossValidationDiv.innerHTML += '</ul>';
+
+                // Display Document Analysis
+                const documentDiv = document.getElementById('documentAnalysis');
+                documentDiv.innerHTML = '';
+
+                if (data.document_analysis && data.document_analysis.pdf_count > 0) {
+                    documentDiv.innerHTML = `<p><strong>Documents Analyzed:</strong> ${data.document_analysis.pdf_count}</p>`;
+
+                    data.document_analysis.pdf_analysis.forEach((pdf, index) => {
+                        documentDiv.innerHTML += `
+                            <div class="pdf-preview">
+                                <p><strong>Document ${index + 1}</strong></p>
+                                <p><strong>Type:</strong> ${pdf.document_type.classification} (${Math.round(pdf.document_type.confidence * 100)}% confidence)</p>
+                                <p><strong>Authenticity:</strong> ${pdf.authenticity.assessment} (${Math.round(pdf.authenticity.confidence * 100)}% confidence)</p>
+                                <p><strong>Summary:</strong> ${pdf.summary}</p>
+                                <p><strong>Contains Signatures:</strong> ${pdf.contains_signatures ? 'Yes' : 'No'}</p>
+                                <p><strong>Contains Dates:</strong> ${pdf.contains_dates ? 'Yes' : 'No'}</p>
+                            </div>
+                        `;
+                    });
+
+                    // Update Document Chart
+                    let authenticCount = 0;
+                    let suspiciousCount = 0;
+                    let incompleteCount = 0;
+
+                    data.document_analysis.pdf_analysis.forEach(pdf => {
+                        if (pdf.authenticity.assessment.includes('authentic')) {
+                            authenticCount++;
+                        } else if (pdf.authenticity.assessment.includes('fraudulent')) {
+                            suspiciousCount++;
+                        } else {
+                            incompleteCount++;
+                        }
+                    });
+
+                    updateChart(documentChart, {
+                        datasets: [{
+                            data: [
+                                authenticCount,
+                                suspiciousCount,
+                                incompleteCount
+                            ]
+                        }]
+                    });
+                } else {
+                    documentDiv.innerHTML = '<p>No documents were uploaded for analysis.</p>';
+                }
+
+                // Display Image Analysis
+                const imageAnalysisDiv = document.getElementById('imageAnalysis');
+                const imageGallery = document.getElementById('imageGallery');
+
+                imageAnalysisDiv.innerHTML = '';
+                imageGallery.innerHTML = '';
+
+                if (data.image_analysis && data.images && data.images.length > 0) {
+                    imageAnalysisDiv.innerHTML = `<p><strong>Images Analyzed:</strong> ${data.image_analysis.image_count}</p>`;
+
+                    let propertyRelatedCount = 0;
+                    data.image_analysis.image_analysis.forEach(img => {
+                        if (img && img.is_property_related) {
+                            propertyRelatedCount++;
+                        }
+                    });
+
+                    imageAnalysisDiv.innerHTML += `<p><strong>Property-Related Images:</strong> ${propertyRelatedCount} of ${data.image_analysis.image_count}</p>`;
+
+                    // Display images in gallery
+                    data.images.forEach((imgData, index) => {
+                        const imgAnalysis = data.image_analysis.image_analysis[index];
+                        const galleryItem = document.createElement('div');
+                        galleryItem.className = 'gallery-item';
+
+                        galleryItem.innerHTML = `
+                            <img src="data:image/jpeg;base64,${imgData}" alt="Property Image ${index + 1}">
+                            <div class="badge ${imgAnalysis && imgAnalysis.is_property_related ? 'badge-success' : 'badge-warning'}"
+                                 style="position: absolute; top: 5px; right: 5px;">
+                                ${imgAnalysis && imgAnalysis.is_property_related ? 'Property' : 'Not Property'}
+                            </div>
+                        `;
+
+                        imageGallery.appendChild(galleryItem);
+                    });
+                } else {
+                    imageAnalysisDiv.innerHTML = '<p>No images were uploaded for analysis.</p>';
+                }
+
+                // Update Property Summary
+                document.getElementById('summaryName').textContent = document.getElementById('propertyName').value || 'Not provided';
+                document.getElementById('summaryType').textContent = document.getElementById('propertyType').value || 'Not provided';
+                document.getElementById('summaryStatus').textContent = document.getElementById('status').value || 'Not provided';
+                document.getElementById('summaryLocation').textContent =
+                    `${document.getElementById('address').value || ''}, ${document.getElementById('city').value || ''}, ${document.getElementById('state').value || ''}, India`;
+                document.getElementById('summaryPrice').textContent = document.getElementById('marketValue').value ? `₹${document.getElementById('marketValue').value}` : 'Not provided';
+                document.getElementById('summarySize').textContent = document.getElementById('sqFt').value ? `${document.getElementById('sqFt').value} sq. ft.` : 'Not provided';
+                document.getElementById('summaryRooms').textContent =
+                    `${document.getElementById('bedrooms').value || '0'} BHK`;  // BHK is common in Indian real estate
+
+                // Update Final Verdict
+                const verdictBox = document.getElementById('verdictBox');
+                const verdictIcon = document.getElementById('verdictIcon');
+                const verdictText = document.getElementById('verdictText');
+
+                if (fraudLevel === 'high' || trustScore < 40) {
+                    verdictBox.className = 'verdict-box verdict-fraudulent';
+                    verdictIcon.textContent = '❌';
+                    verdictText.textContent = 'HIGH RISK - LIKELY FRAUDULENT';
+                } else if (fraudLevel === 'medium' || trustScore < 70) {
+                    verdictBox.className = 'verdict-box verdict-suspicious';
+                    verdictIcon.textContent = '⚠️';
+                    verdictText.textContent = 'CAUTION - SUSPICIOUS ELEMENTS';
+                } else {
+                    verdictBox.className = 'verdict-box verdict-legitimate';
+                    verdictIcon.textContent = '✅';
+                    verdictText.textContent = 'VERIFIED REAL ESTATE LISTING';
+                }
+
+                // Update Verdict Reasons
+                const verdictReasons = document.getElementById('verdictReasons');
+                verdictReasons.innerHTML = '';
+
+                // Add key findings based on analysis
+                const findings = [];
+
+                if (validatedData.qualityAssessment && validatedData.qualityAssessment.isAiGenerated) {
+                    findings.push('Description appears to be AI-generated');
+                }
+
+                if (data.cross_validation) {
+                    data.cross_validation.forEach(check => {
+                        if (check.status === 'inconsistent' || check.status === 'invalid' ||
+                            check.status === 'suspicious' || check.status === 'no_match') {
+                            findings.push(check.message);
+                        }
+                    });
+                }
+
+                if (data.price_analysis && data.price_analysis.assessment === 'suspicious pricing') {
+                    findings.push('Price appears suspicious for this type of property');
+                }
+
+                if (data.legal_analysis && data.legal_analysis.potential_issues) {
+                    findings.push('Potential legal issues detected');
+                }
+
+                // Add at least one positive finding if the verdict is good
+                if (findings.length === 0 && trustScore > 70) {
+                    findings.push('Property details appear consistent and legitimate');
+                    findings.push('No suspicious elements detected in the listing');
+                }
+
+                // If we still have no findings, add a generic one
+                if (findings.length === 0) {
+                    findings.push('Analysis inconclusive - insufficient information provided');
+                }
+
+                findings.forEach(finding => {
+                    const li = document.createElement('li');
+                    li.className = 'suggestion-item';
+                    li.textContent = finding;
+                    verdictReasons.appendChild(li);
+                });
+
+                // Update Verification Scores
+                updateScoreBar('trustBar', 'trustValue', trustScore);
+
+                // Image authenticity score
+                let imageScore = 0;
+                if (data.image_analysis && data.image_analysis.image_analysis) {
+                    const propertyImages = data.image_analysis.image_analysis.filter(img => img && img.is_property_related);
+                    imageScore = data.image_analysis.image_count > 0 ?
+                        Math.round((propertyImages.length / data.image_analysis.image_count) * 100) : 0;
+                }
+                updateScoreBar('imageBar', 'imageValue', imageScore);
+
+                // Document verification score
+                let docScore = 0;
+                if (data.document_analysis && data.document_analysis.pdf_analysis) {
+                    const authenticDocs = data.document_analysis.pdf_analysis.filter(
+                        pdf => pdf.authenticity && pdf.authenticity.assessment.includes('authentic')
+                    );
+                    docScore = data.document_analysis.pdf_count > 0 ?
+                        Math.round((authenticDocs.length / data.document_analysis.pdf_count) * 100) : 0;
+                }
+                updateScoreBar('documentBar', 'documentValue', docScore);
+
+                // Content quality score
+                const contentScore = validatedData.qualityAssessment ? validatedData.qualityAssessment.score : 0;
+                updateScoreBar('contentBar', 'contentValue', contentScore);
+
+                // Location accuracy score
+                const locationScore = data.location_analysis ? data.location_analysis.completeness_score || 0 : 0;
+                updateScoreBar('locationBar', 'locationValue', locationScore);
+
+                // Update Red Flags
+                const redFlagsList = document.getElementById('redFlagsList');
+                redFlagsList.innerHTML = '';
+
+                const redFlags = [];
+
+                // Check for inconsistencies and issues
+                if (data.cross_validation) {
+                    data.cross_validation.forEach(check => {
+                        if (check.status === 'inconsistent' || check.status === 'invalid' ||
+                            check.status === 'suspicious' || check.status === 'no_match') {
+                            redFlags.push(`${check.check}: ${check.message}`);
+                        }
+                    });
+                }
+
+                if (validatedData.qualityAssessment && validatedData.qualityAssessment.isAiGenerated) {
+                    redFlags.push('Description appears to be AI-generated, which may indicate a fake listing');
+                }
+
+                if (data.price_analysis &&
+                    (data.price_analysis.assessment === 'suspicious pricing' ||
+                     data.price_analysis.assessment === 'overpriced' ||
+                     data.price_analysis.assessment === 'underpriced')) {
+                    redFlags.push(`Price is ${data.price_analysis.assessment} for this type of property`);
+                }
+
+                if (data.legal_analysis && data.legal_analysis.potential_issues) {
+                    redFlags.push('Potential legal issues detected in the property documentation');
+                }
+
+                if (data.image_analysis && data.image_analysis.image_count > 0) {
+                    const propertyImages = data.image_analysis.image_analysis.filter(img => img && img.is_property_related);
+                    if (propertyImages.length === 0) {
+                        redFlags.push('None of the uploaded images appear to be related to real estate');
+                    }
+                }
+
+                // If no red flags, add a positive message
+                if (redFlags.length === 0) {
+                    redFlags.push('No significant red flags detected in this listing');
+                }
+
+                redFlags.forEach(flag => {
+                    const li = document.createElement('li');
+                    li.className = 'suggestion-item';
+                    li.textContent = flag;
+                    redFlagsList.appendChild(li);
+                });
+                
+            } catch (error) {
+                console.error('Error displaying results:', error);
+                document.getElementById('resultsContainer').innerHTML = 
+                    '<div class="alert alert-danger">Error displaying results. Please try again.</div>';
+            }
+        }
+        
+        function updateScoreBar(barId, valueId, score) {
+            const bar = document.getElementById(barId);
+            const value = document.getElementById(valueId);
+            
+            if (bar && value) {
+                bar.style.setProperty('--score-width', `${score}%`);
+                bar.style.background = `linear-gradient(to right, 
+                    ${getScoreColor(score)} ${score}%, 
+                    #e9ecef ${score}%)`;
+                value.textContent = `${score}%`;
+            }
+        }
+        
+        function getScoreColor(score) {
+            if (score >= 70) return 'var(--success)';
+            if (score >= 40) return 'var(--warning)';
+            return 'var(--danger)';
+        }
+    </script>
+</body>
+</html>