app/ml/models/user_role_context_handler.py

#!/usr/bin/env python3
"""
user_role_context_handler.py - Handle different user roles and rental models
Supports: Airbnb (host/guest), African rentals (landlord/renter/tenant)
"""

import logging
from typing import Dict, Tuple, Optional
from enum import Enum
import re

logger = logging.getLogger(__name__)


class RentalModel(Enum):
    """Different rental models"""
    AIRBNB = "airbnb"           # Short-stay, host/guest model
    AFRICAN_RENTAL = "african"  # Long-term rent, landlord/tenant model
    ROOMMATE = "roommate"       # Room sharing in existing space
    MIXED = "mixed"             # Both types possible
    UNKNOWN = "unknown"


class UserRole:
    """Handle different user roles across rental models"""
    
    # Airbnb roles
    AIRBNB_HOST = "airbnb_host"
    AIRBNB_GUEST = "airbnb_guest"
    
    # African rental roles
    LANDLORD = "landlord"
    RENTER = "renter"
    TENANT = "tenant"  # Alias for renter
    
    # Roommate roles
    HOMEOWNER_SEEKING_ROOMMATE = "homeowner_seeking_roommate"  # Has space, looking for roommate
    ROOMMATE_SEEKER = "roommate_seeker"  # Looking for a room to share
    
    # Generic
    OWNER = "owner"
    BUYER = "buyer"
    SELLER = "seller"


class UserRoleDetector:
    """Intelligently detect user role from context"""
    
    def __init__(self):
        # Keywords for role detection
        self.host_keywords = {
            "airbnb": ["host", "hosting", "list my property", "list my place", "rent out", "share"],
            "african": ["landlord", "owner", "property owner", "im renting out", "im listing"]
        }
        
        self.guest_keywords = {
            "airbnb": ["guest", "book", "looking for place", "need accommodation", "airbnb"],
            "african": ["renter", "tenant", "looking to rent", "seeking", "want to rent", "im looking for"]
        }
        
        self.buyer_keywords = ["buy", "purchase", "for sale", "selling", "acquire"]
        self.seller_keywords = ["sell", "selling", "sale", "list for sale"]
        
        # Roommate keywords
        self.homeowner_seeking_roommate_keywords = [
            "looking for a roommate", "need a roommate", "seeking roommate", 
            "want to share my", "have a spare room", "room available",
            "looking to share", "share my apartment", "share my house",
            "my place is too big", "extra room", "can share"
        ]
        
        self.roommate_seeker_keywords = [
            "looking for a room", "seeking a room", "need a room",
            "looking for roommate", "want to share a place", "room for rent",
            "share accommodation", "shared apartment", "shared house",
            "need accommodation", "looking for a place to share"
        ]
        
        logger.info("🔍 User Role Detector initialized")
    
    def detect_rental_model(self, user_message: str, location: str = None) -> RentalModel:
        """Detect which rental model user is in"""
        
        msg_lower = user_message.lower().strip()
        
        # Keywords indicating Airbnb model
        airbnb_indicators = ["airbnb", "short stay", "nightly", "daily", "vacation rental", "host"]
        
        # Keywords indicating African rental model
        african_indicators = ["landlord", "tenant", "renter", "monthly rent", "long term", "furnished room"]
        
        # Keywords indicating roommate model
        roommate_indicators = ["roommate", "share my", "spare room", "share apartment", "shared house", "share a place"]
        
        # Check for explicit indicators
        for indicator in roommate_indicators:
            if indicator in msg_lower:
                logger.info(f"🏘️ Detected roommate model: '{indicator}'")
                return RentalModel.ROOMMATE
        
        for indicator in airbnb_indicators:
            if indicator in msg_lower:
                logger.info(f"🏨 Detected Airbnb model: '{indicator}'")
                return RentalModel.AIRBNB
        
        for indicator in african_indicators:
            if indicator in msg_lower:
                logger.info(f"🏢 Detected African rental model: '{indicator}'")
                return RentalModel.AFRICAN_RENTAL
        
        # Location-based inference (African locations more likely = African model)
        if location:
            african_countries = ["benin", "nigeria", "kenya", "ghana", "south africa", "uganda", "senegal"]
            if any(country in location.lower() for country in african_countries):
                logger.info(f"📍 African location detected: {location}")
                return RentalModel.AFRICAN_RENTAL
        
        # Default to mixed
        return RentalModel.MIXED
    
    def detect_user_role(self, user_message: str, rental_model: RentalModel = None) -> Tuple[str, float]:
        """
        Detect user role from message
        Returns: (role, confidence)
        """
        
        msg_lower = user_message.lower().strip()
        
        if rental_model is None:
            rental_model = self.detect_rental_model(user_message)
        
        # ==================== SELLER / LANDLORD ====================
        
        # Check for explicit landlord/owner language
        landlord_explicit = ["im a landlord", "im the landlord", "i own", "i own this", "as a landlord"]
        for phrase in landlord_explicit:
            if phrase in msg_lower:
                logger.info(f"✅ Explicit landlord detected: '{phrase}'")
                return UserRole.LANDLORD, 0.99
        
        # Check for listing/rental language
        if rental_model == RentalModel.AFRICAN_RENTAL:
            landlord_signals = [
                "im listing", "list my", "im renting out", "property for rent",
                "available for rent", "i have a", "i own a"
            ]
            for signal in landlord_signals:
                if signal in msg_lower:
                    logger.info(f"🏠 African landlord signal: '{signal}'")
                    return UserRole.LANDLORD, 0.90
        
        if rental_model == RentalModel.AIRBNB:
            host_signals = ["im hosting", "im a host", "list on airbnb", "airbnb host", "share my place"]
            for signal in host_signals:
                if signal in msg_lower:
                    logger.info(f"🏨 Airbnb host signal: '{signal}'")
                    return UserRole.AIRBNB_HOST, 0.90
        
        # ==================== BUYER / SELLER (SALE) ====================
        
        # Explicit sale language
        seller_signals = ["im selling", "for sale", "sell my", "selling property", "list for sale"]
        for signal in seller_signals:
            if signal in msg_lower:
                logger.info(f"💰 Seller detected: '{signal}'")
                return UserRole.SELLER, 0.95
        
        buyer_signals = ["want to buy", "looking to purchase", "im buying", "purchase property"]
        for signal in buyer_signals:
            if signal in msg_lower:
                logger.info(f"💳 Buyer detected: '{signal}'")
                return UserRole.BUYER, 0.95
        
        # ==================== RENTER / GUEST ====================
        
        # Check for explicit renter language
        renter_explicit = ["im a tenant", "im a renter", "im looking to rent", "looking for a place to rent"]
        for phrase in renter_explicit:
            if phrase in msg_lower:
                logger.info(f"✅ Explicit renter/tenant detected: '{phrase}'")
                
                if rental_model == RentalModel.AFRICAN_RENTAL:
                    return UserRole.TENANT, 0.99
                else:
                    return UserRole.AIRBNB_GUEST, 0.99
        
        # ==================== ROOMMATE ROLES ====================
        
        # Homeowner seeking roommate
        for keyword in self.homeowner_seeking_roommate_keywords:
            if keyword in msg_lower:
                logger.info(f"✅ Homeowner seeking roommate detected: '{keyword}'")
                return UserRole.HOMEOWNER_SEEKING_ROOMMATE, 0.90
        
        # Roommate seeker
        for keyword in self.roommate_seeker_keywords:
            if keyword in msg_lower:
                logger.info(f"✅ Roommate seeker detected: '{keyword}'")
                return UserRole.ROOMMATE_SEEKER, 0.90
        
        # Guest/renter signals
        if rental_model == RentalModel.AFRICAN_RENTAL:
            renter_signals = [
                "looking for a", "need a", "seeking", "want to rent",
                "im looking for", "show me", "what do you have", "available rooms"
            ]
            for signal in renter_signals:
                if signal in msg_lower:
                    logger.info(f"🔍 African renter signal: '{signal}'")
                    return UserRole.RENTER, 0.80
        
        if rental_model == RentalModel.AIRBNB:
            guest_signals = [
                "looking for accommodation", "need a place", "book",
                "where can i stay", "available places", "show me listings"
            ]
            for signal in guest_signals:
                if signal in msg_lower:
                    logger.info(f"🔍 Airbnb guest signal: '{signal}'")
                    return UserRole.AIRBNB_GUEST, 0.80
        
        logger.warning(f"⚠️ Could not determine user role from: {user_message}")
        return None, 0.0
    
    def validate_role_consistency(self, user_role: str, rental_model: RentalModel) -> bool:
        """Validate that role matches rental model"""
        
        valid_combinations = {
            RentalModel.AIRBNB: [UserRole.AIRBNB_HOST, UserRole.AIRBNB_GUEST],
            RentalModel.AFRICAN_RENTAL: [UserRole.LANDLORD, UserRole.RENTER, UserRole.TENANT],
            RentalModel.ROOMMATE: [UserRole.HOMEOWNER_SEEKING_ROOMMATE, UserRole.ROOMMATE_SEEKER],
            RentalModel.MIXED: [UserRole.LANDLORD, UserRole.RENTER, UserRole.TENANT, 
                               UserRole.AIRBNB_HOST, UserRole.AIRBNB_GUEST,
                               UserRole.HOMEOWNER_SEEKING_ROOMMATE, UserRole.ROOMMATE_SEEKER],
        }
        
        valid = valid_combinations.get(rental_model, [])
        
        if user_role in valid:
            logger.info(f"✅ Role {user_role} valid for {rental_model.value}")
            return True
        
        logger.warning(f"⚠️ Role {user_role} may not match {rental_model.value}")
        return False


class RoleBasedInferenceEngine:
    """Adapt inference based on user role and rental model"""
    
    def __init__(self):
        self.role_detector = UserRoleDetector()
        logger.info("🧠 Role-based Inference Engine initialized")
    
    def infer_listing_type(self, state: Dict, user_message: str, rental_model: RentalModel = None) -> Tuple[str, float]:
        """
        Infer listing type based on user role and rental model
        
        Returns: (listing_type, confidence)
        """
        
        # Detect rental model
        if rental_model is None:
            rental_model = self.role_detector.detect_rental_model(user_message, state.get("location"))
        
        # Detect user role
        user_role, role_confidence = self.role_detector.detect_user_role(user_message, rental_model)
        
        logger.info(f"🔍 Rental Model: {rental_model.value}")
        logger.info(f"👤 User Role: {user_role} (confidence: {role_confidence:.0%})")
        
        # Store in state for later use
        state["rental_model"] = rental_model.value
        state["user_role"] = user_role
        
        # ==================== AIRBNB MODEL ====================
        
        if rental_model == RentalModel.AIRBNB:
            
            # Host listing = short-stay
            if user_role == UserRole.AIRBNB_HOST:
                logger.info("📍 Host → short-stay listing")
                return "short-stay", 0.98
            
            # Guest searching = just needs to search
            if user_role == UserRole.AIRBNB_GUEST:
                logger.info("📍 Guest → searching for short-stay")
                return "short-stay", 0.95
        
        # ==================== AFRICAN RENTAL MODEL ====================
        
        elif rental_model == RentalModel.AFRICAN_RENTAL:
            
            # Landlord listing = rent listing
            if user_role in [UserRole.LANDLORD, UserRole.OWNER]:
                logger.info("📍 Landlord → rent listing")
                return "rent", 0.98
            
            # Renter/tenant searching = rent listing
            if user_role in [UserRole.RENTER, UserRole.TENANT]:
                logger.info("📍 Tenant/Renter → searching for rent")
                return "rent", 0.95
        
        # ==================== ROOMMATE MODEL ====================
        
        elif rental_model == RentalModel.ROOMMATE:
            
            # Homeowner seeking roommate = roommate listing
            if user_role == UserRole.HOMEOWNER_SEEKING_ROOMMATE:
                logger.info("📍 Homeowner → roommate listing")
                return "roommate", 0.98
            
            # Roommate seeker = searching roommate
            if user_role == UserRole.ROOMMATE_SEEKER:
                logger.info("📍 Roommate seeker → searching for roommate")
                return "roommate", 0.95
        
        # ==================== SALE MODEL (both) ====================
        
        if user_role == UserRole.SELLER:
            logger.info("📍 Seller → sale listing")
            return "sale", 0.98
        
        if user_role == UserRole.BUYER:
            logger.info("📍 Buyer → searching for sale")
            return "sale", 0.95
        
        # Fallback: check explicit listing_type
        explicit_type = state.get("listing_type")
        if explicit_type:
            logger.info(f"📍 Using explicit listing_type: {explicit_type}")
            return explicit_type, 0.85
        
        logger.warning("⚠️ Could not infer listing_type, defaulting to rent")
        return "rent", 0.5
    
    def adapt_field_extraction(self, state: Dict, user_message: str) -> Dict:
        """
        Adapt field extraction based on user role and rental model
        """
        
        rental_model = self.role_detector.detect_rental_model(user_message, state.get("location"))
        user_role, _ = self.role_detector.detect_user_role(user_message, rental_model)
        
        extraction_config = {
            "rental_model": rental_model.value,
            "user_role": user_role,
            "required_fields": [],
            "price_type_suggestions": [],
            "amenity_focus": [],
            "validation_rules": []
        }
        
        # ==================== AIRBNB HOST ====================
        if user_role == UserRole.AIRBNB_HOST:
            extraction_config["required_fields"] = [
                "location", "bedrooms", "bathrooms", "price", "amenities"
            ]
            extraction_config["price_type_suggestions"] = ["nightly", "daily", "weekly"]
            extraction_config["amenity_focus"] = ["wifi", "parking", "pool", "kitchen", "ac"]
            extraction_config["validation_rules"] = [
                "price must be per night (nightly/daily)",
                "bedrooms minimum 1",
                "bathrooms can be shared"
            ]
        
        # ==================== AIRBNB GUEST ====================
        elif user_role == UserRole.AIRBNB_GUEST:
            extraction_config["required_fields"] = ["location", "check_in", "check_out"]
            extraction_config["price_type_suggestions"] = ["nightly"]
            extraction_config["amenity_focus"] = ["wifi", "kitchen", "parking"]
            extraction_config["validation_rules"] = [
                "check dates for availability",
                "show prices in nightly rates"
            ]
        
        # ==================== LANDLORD (African) ====================
        elif user_role == UserRole.LANDLORD:
            extraction_config["required_fields"] = [
                "location", "bedrooms", "bathrooms", "price", "price_type", "furnished"
            ]
            extraction_config["price_type_suggestions"] = ["monthly", "yearly"]
            extraction_config["amenity_focus"] = [
                "furnished", "kitchen", "water", "electricity", "security"
            ]
            extraction_config["validation_rules"] = [
                "price must be monthly or yearly",
                "specify if furnished/unfurnished",
                "include utility info if available",
                "bedrooms and bathrooms required"
            ]
        
        # ==================== RENTER/TENANT (African) ====================
        elif user_role in [UserRole.RENTER, UserRole.TENANT]:
            extraction_config["required_fields"] = [
                "location", "budget", "bedrooms", "price_type"
            ]
            extraction_config["price_type_suggestions"] = ["monthly", "yearly"]
            extraction_config["amenity_focus"] = [
                "furnished", "security", "water", "electricity", "parking"
            ]
            extraction_config["validation_rules"] = [
                "show monthly/yearly prices",
                "filter by budget",
                "highlight furnished options",
                "show security features"
            ]
        
        # ==================== HOMEOWNER SEEKING ROOMMATE ====================
        elif user_role == UserRole.HOMEOWNER_SEEKING_ROOMMATE:
            extraction_config["required_fields"] = [
                "location", "bedrooms_available", "bathrooms_available", "price", "price_type"
            ]
            extraction_config["price_type_suggestions"] = ["monthly", "yearly"]
            extraction_config["amenity_focus"] = [
                "furnished", "utilities_included", "kitchen_access", "laundry",
                "internet", "parking", "living_room_access"
            ]
            extraction_config["validation_rules"] = [
                "price must be monthly or yearly",
                "specify which rooms are available",
                "describe house/apartment condition",
                "list utilities included",
                "mention house rules"
            ]
        
        # ==================== ROOMMATE SEEKER ====================
        elif user_role == UserRole.ROOMMATE_SEEKER:
            extraction_config["required_fields"] = [
                "location", "budget", "move_in_date"
            ]
            extraction_config["price_type_suggestions"] = ["monthly", "yearly"]
            extraction_config["amenity_focus"] = [
                "furnished", "utilities_included", "kitchen_access", "internet",
                "parking", "proximity_to_work"
            ]
            extraction_config["validation_rules"] = [
                "show monthly/yearly prices",
                "filter by budget",
                "check roommate compatibility",
                "show lease terms"
            ]
        
        # ==================== SELLER ====================
        elif user_role == UserRole.SELLER:
            extraction_config["required_fields"] = [
                "location", "bedrooms", "bathrooms", "price", "property_type"
            ]
            extraction_config["price_type_suggestions"] = ["fixed"]
            extraction_config["amenity_focus"] = ["land size", "property type", "condition"]
            extraction_config["validation_rules"] = [
                "price is total sale price",
                "property type required (apartment, house, etc)",
                "include land/property size if known"
            ]
        
        # ==================== BUYER ====================
        elif user_role == UserRole.BUYER:
            extraction_config["required_fields"] = [
                "location", "budget", "bedrooms", "property_type"
            ]
            extraction_config["price_type_suggestions"] = []
            extraction_config["amenity_focus"] = ["property type", "land size", "condition"]
            extraction_config["validation_rules"] = [
                "show total sale prices",
                "filter by budget range",
                "group by property type"
            ]
        
        logger.info(f"✅ Extraction config adapted for {user_role}")
        
        return extraction_config
    
    def get_role_context_prompt(self, user_role: str, rental_model: str) -> str:
        """Get AI prompt context based on role"""
        
        prompts = {
            UserRole.AIRBNB_HOST: """
You are helping an Airbnb host list their property.
- Focus on: short-stay rental features, nightly rates, guest amenities
- Price type: nightly/daily/weekly
- Emphasize: WiFi, kitchen, parking, cleanliness
""",
            
            UserRole.AIRBNB_GUEST: """
You are helping someone find an Airbnb accommodation.
- Focus on: guest experience, amenities, location convenience
- Price type: show nightly rates
- Emphasize: cleanliness, safety, host responsiveness
""",
            
            UserRole.LANDLORD: """
You are helping an African landlord/property owner list a rental.
- Focus on: long-term rental (monthly/yearly), tenant features, property durability
- Price type: monthly or yearly
- Emphasize: furnished/unfurnished, utilities, security, maintenance
- Include: lease terms, deposit requirements
""",
            
            UserRole.RENTER: """
You are helping a tenant/renter find an apartment or room.
- Focus on: long-term rental suitability, affordability, amenities for living
- Price type: monthly or yearly budget
- Emphasize: security, utilities included, furnished options, commute
- Ask about: move-in date, lease length, budget
""",
            
            UserRole.TENANT: """
You are helping a tenant/renter find an apartment or room.
- Focus on: long-term rental suitability, affordability, amenities for living
- Price type: monthly or yearly budget
- Emphasize: security, utilities included, furnished options, commute
- Ask about: move-in date, lease length, budget
""",
            
            UserRole.SELLER: """
You are helping someone sell a property.
- Focus on: property value, unique features, condition, potential
- Price type: total sale price
- Emphasize: location, size, renovations, investment potential
- Include: property history, legal documents status
""",
            
            UserRole.BUYER: """
You are helping someone find and purchase a property.
- Focus on: property value, investment potential, location
- Price type: show total purchase price
- Emphasize: property condition, neighborhood, future value
- Include: financing options, inspection recommendations
""",
            
            UserRole.HOMEOWNER_SEEKING_ROOMMATE: """
You are helping someone find a roommate to share their home with.
- Focus on: compatibility, house/apartment details, shared spaces
- Price type: monthly or yearly
- Emphasize: house rules, utilities included, available rooms, amenities
- Include: lease terms, deposit, move-in date, roommate preferences
- Ask about: their lifestyle, work schedule, cleanliness standards
""",
            
            UserRole.ROOMMATE_SEEKER: """
You are helping someone find a room to share with a roommate.
- Focus on: affordability, roommate compatibility, location, utilities
- Price type: monthly or yearly budget
- Emphasize: house rules, amenities, commute, lifestyle fit
- Include: move-in date, lease length, deposit requirements
- Ask about: budget, preferred location, work/study location, lifestyle
"""
        }
        
        return prompts.get(user_role, "")


# ==================== EXAMPLE USAGE ====================

if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    
    engine = RoleBasedInferenceEngine()
    
    # Test cases
    test_cases = [
        # Airbnb host
        ("I'm a host on Airbnb and want to list my apartment in Lagos", "Lagos"),
        
        # Airbnb guest
        ("I'm looking for accommodation on Airbnb in Accra next week", "Accra"),
        
        # African landlord
        ("I'm a landlord in Cotonou with a 2-bedroom apartment for monthly rent", "Cotonou"),
        
        # African tenant
        ("I'm looking to rent a furnished room in Nairobi, my budget is 30000 KES per month", "Nairobi"),
        
        # Homeowner seeking roommate
        ("My house in Lagos is too big for just me. I have 2 extra bedrooms and want to share", "Lagos"),
        
        # Roommate seeker
        ("I'm looking for a room to share in Accra, somewhere near my workplace", "Accra"),
        
        # Seller
        ("I want to sell my house in Lagos for 50 million NGN", "Lagos"),
        
        # Buyer
        ("I'm looking to buy a 3-bedroom apartment in Cape Town", "Cape Town"),
    ]
    
    print("\n" + "="*70)
    print("🧠 ROLE-BASED INFERENCE ENGINE TEST")
    print("="*70 + "\n")
    
    for message, location in test_cases:
        print(f"📝 Message: {message}")
        print(f"📍 Location: {location}\n")
        
        state = {"location": location}
        listing_type, confidence = engine.infer_listing_type(state, message)
        
        print(f"✅ Listing Type: {listing_type} (confidence: {confidence:.0%})")
        
        config = engine.adapt_field_extraction(state, message)
        print(f"📋 Required fields: {', '.join(config['required_fields'])}")
        print(f"💰 Price types: {', '.join(config['price_type_suggestions'])}")
        
        prompt = engine.get_role_context_prompt(config['user_role'], config['rental_model'])
        print(f"🎯 AI Context:\n{prompt}")
        
        print("-" * 70 + "\n")