app.py

#!/usr/bin/env python
import os
import json
import logging
import random
import asyncio
import aiohttp
from datetime import datetime, timedelta
from typing import Dict, Any, List, Optional, Tuple
from pydantic import BaseModel, Field
import gradio as gr
import google.generativeai as genai
from dataclasses import dataclass

# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
)
logger = logging.getLogger(__name__)

# ========== CONFIGURATION ==========
@dataclass
class Config:
    GEMINI_API_KEY: str = os.getenv("GEMINI_API_KEY", "")
    SERPER_API_KEY: str = os.getenv("SERPER_API_KEY", "")
    GEMINI_MODEL: str = "gemini-2.0-flash"
    MAX_RETRIES: int = 3
    TIMEOUT: int = 30

config = Config()

# ========== ENHANCED DATA MODELS ==========
class UserVerification(BaseModel):
    user_id: str = Field(..., description="User ID")
    name: str = Field(..., description="User name")
    email: str = Field(..., description="User email")
    is_verified: bool = Field(..., description="KYC verification status")
    verification_level: str = Field(..., description="Verification level: basic, standard, premium")
    risk_score: float = Field(..., description="Risk score 0-1")
    ai_behavioral_analysis: str = Field("", description="AI analysis of user behavior")

class MarketIntelligence(BaseModel):
    average_resale_price: float = Field(0.0, description="Average market resale price")
    price_trend: str = Field("stable", description="Price trend: rising, falling, stable")
    market_sentiment: str = Field("neutral", description="Market sentiment: positive, negative, neutral")
    similar_events_pricing: List[Dict] = Field(default_factory=list, description="Similar events pricing data")
    news_impact: str = Field("", description="News impact on pricing")
    social_media_buzz: str = Field("", description="Social media sentiment analysis")
    supply_demand_ratio: float = Field(1.0, description="Supply vs demand ratio")

class ScalpingDetection(BaseModel):
    is_scalper: bool = Field(..., description="Whether user is detected as scalper")
    confidence: float = Field(..., description="Detection confidence 0-1")
    flags: List[str] = Field(..., description="Suspicious activity flags")
    purchase_velocity: int = Field(..., description="Number of purchases in last hour")
    ip_duplicates: int = Field(..., description="Number of accounts from same IP")
    ai_pattern_analysis: str = Field("", description="AI analysis of behavior patterns")
    network_connections: List[str] = Field(default_factory=list, description="Connected suspicious accounts")

class PricingRecommendation(BaseModel):
    original_price: float = Field(..., description="Original ticket price")
    recommended_resale_price: float = Field(..., description="Recommended resale price")
    market_fair_price: float = Field(..., description="AI-calculated fair market price")
    demand_level: str = Field(..., description="Current demand level")
    price_adjustment_reason: str = Field(..., description="Reason for price adjustment")
    profit_margin: Optional[float] = Field(None, description="Profit margin percentage")
    loss_percentage: Optional[float] = Field(None, description="Loss percentage if selling below cost")
    market_intelligence: MarketIntelligence = Field(default_factory=MarketIntelligence)
    ai_pricing_rationale: str = Field("", description="AI explanation for pricing decision")

class ResaleCompliance(BaseModel):
    is_compliant: bool = Field(..., description="Whether resale is policy compliant")
    violations: List[str] = Field(..., description="List of policy violations")
    resale_allowed: bool = Field(..., description="Whether resale is allowed")
    max_allowed_price: float = Field(..., description="Maximum allowed resale price")
    recommendation: str = Field(..., description="Compliance recommendation")
    ai_policy_analysis: str = Field("", description="AI analysis of policy compliance")

class IntelligentReport(BaseModel):
    verification: UserVerification
    scalping_detection: ScalpingDetection
    pricing: PricingRecommendation
    compliance: ResaleCompliance
    final_decision: str = Field(..., description="Final system decision")
    action_items: List[str] = Field(..., description="Recommended actions")
    ai_summary: str = Field("", description="AI-generated executive summary")
    confidence_score: float = Field(0.0, description="Overall AI confidence in decision")

# ========== AI INTEGRATION SERVICES ==========
class GeminiAIService:
    """Service for interacting with Google's Gemini AI"""
    
    def __init__(self):
        if not config.GEMINI_API_KEY:
            logger.warning("GEMINI_API_KEY not found. Using fallback responses.")
            self.enabled = False
            return
        
        try:
            genai.configure(api_key=config.GEMINI_API_KEY)
            self.model = genai.GenerativeModel(config.GEMINI_MODEL)
            self.enabled = True
            logger.info("Gemini AI service initialized successfully")
        except Exception as e:
            logger.error(f"Failed to initialize Gemini AI: {e}")
            self.enabled = False
    
    async def analyze_user_behavior(self, user_data: Dict, transaction_history: List[Dict]) -> str:
        """Analyze user behavior patterns using AI"""
        if not self.enabled:
            return self._fallback_user_analysis(user_data)
        
        try:
            prompt = f"""
            As an expert fraud detection analyst, analyze this user's behavior for potential ticket scalping:
            
            User Profile:
            - Name: {user_data.get('name', 'N/A')}
            - Email: {user_data.get('email', 'N/A')}
            - User ID: {user_data.get('user_id', 'N/A')}
            - Risk Factors: {user_data.get('risk_factors', [])}
            
            Transaction History: {json.dumps(transaction_history, indent=2)}
            
            Provide a concise behavioral analysis focusing on:
            1. Email legitimacy indicators
            2. Name authenticity assessment
            3. Overall trustworthiness score
            4. Red flags or green flags
            
            Keep response under 150 words and be specific.
            """
            
            response = self.model.generate_content(prompt)
            return response.text if response.text else self._fallback_user_analysis(user_data)
            
        except Exception as e:
            logger.error(f"Gemini AI analysis failed: {e}")
            return self._fallback_user_analysis(user_data)
    
    async def analyze_scalping_patterns(self, user_id: str, transaction_data: Dict, network_data: List[Dict]) -> str:
        """Detect scalping patterns using advanced AI analysis"""
        if not self.enabled:
            return self._fallback_scalping_analysis(transaction_data)
        
        try:
            prompt = f"""
            As a specialized anti-scalping detection expert, analyze this transaction for suspicious patterns:
            
            Transaction Details:
            - User: {user_id}
            - Ticket Quantity: {transaction_data.get('ticket_quantity', 0)}
            - Event: {transaction_data.get('event_name', 'N/A')}
            - Purchase Velocity: {transaction_data.get('purchase_velocity', 0)} purchases/hour
            - IP Duplicates: {transaction_data.get('ip_duplicates', 0)} accounts
            
            Network Analysis: {json.dumps(network_data, indent=2)}
            
            Assess for:
            1. Bot-like purchasing behavior
            2. Coordinated scalping networks
            3. Unusual timing patterns
            4. Risk level (Low/Medium/High)
            
            Provide analysis in under 200 words with specific indicators.
            """
            
            response = self.model.generate_content(prompt)
            return response.text if response.text else self._fallback_scalping_analysis(transaction_data)
            
        except Exception as e:
            logger.error(f"Scalping pattern analysis failed: {e}")
            return self._fallback_scalping_analysis(transaction_data)
    
    async def generate_pricing_rationale(self, market_data: Dict, pricing_factors: Dict) -> str:
        """Generate AI-powered pricing rationale"""
        if not self.enabled:
            return self._fallback_pricing_analysis(pricing_factors)
        
        try:
            prompt = f"""
            As a market pricing expert, analyze this ticket resale pricing scenario:
            
            Market Conditions:
            - Average Market Price: ${market_data.get('average_resale_price', 0):.2f}
            - Price Trend: {market_data.get('price_trend', 'stable')}
            - Market Sentiment: {market_data.get('market_sentiment', 'neutral')}
            - Supply/Demand Ratio: {market_data.get('supply_demand_ratio', 1.0)}
            
            Pricing Analysis:
            - Original Price: ${pricing_factors.get('original_price', 0):.2f}
            - Proposed Price: ${pricing_factors.get('proposed_price', 0):.2f}
            - Recommended Price: ${pricing_factors.get('recommended_price', 0):.2f}
            - Demand Level: {pricing_factors.get('demand_level', 'medium')}
            
            Provide:
            1. Fair market assessment
            2. Consumer protection analysis
            3. Pricing recommendation rationale
            4. Risk factors for buyer/seller
            
            Keep under 250 words, be specific and actionable.
            """
            
            response = self.model.generate_content(prompt)
            return response.text if response.text else self._fallback_pricing_analysis(pricing_factors)
            
        except Exception as e:
            logger.error(f"Pricing rationale generation failed: {e}")
            return self._fallback_pricing_analysis(pricing_factors)
    
    async def analyze_policy_compliance(self, transaction_data: Dict, policy_violations: List[str]) -> str:
        """Analyze policy compliance with AI reasoning"""
        if not self.enabled:
            return self._fallback_compliance_analysis(policy_violations)
        
        try:
            prompt = f"""
            As a policy compliance officer, evaluate this transaction:
            
            Transaction:
            - User: {transaction_data.get('user_id', 'N/A')}
            - Price Ratio: {transaction_data.get('price_ratio', 1.0)}x original
            - Event: {transaction_data.get('event_name', 'N/A')}
            - Proposed Price: ${transaction_data.get('proposed_price', 0):.2f}
            - Original Price: ${transaction_data.get('original_price', 0):.2f}
            
            Policy Violations Detected: {policy_violations}
            
            Provide:
            1. Severity assessment of each violation
            2. Consumer protection implications
            3. Recommended enforcement actions
            4. Appeal process guidance (if applicable)
            
            Be fair but firm in protecting consumers. Under 200 words.
            """
            
            response = self.model.generate_content(prompt)
            return response.text if response.text else self._fallback_compliance_analysis(policy_violations)
            
        except Exception as e:
            logger.error(f"Policy compliance analysis failed: {e}")
            return self._fallback_compliance_analysis(policy_violations)
    
    async def generate_executive_summary(self, full_report: Dict) -> Tuple[str, float]:
        """Generate an executive summary with confidence score"""
        if not self.enabled:
            return self._fallback_executive_summary(full_report)
        
        try:
            prompt = f"""
            Create an executive summary for this anti-scalping analysis:
            
            Decision: {full_report.get('final_decision', 'UNKNOWN')}
            User Verified: {full_report.get('verification', {}).get('is_verified', False)}
            Scalper Detected: {full_report.get('scalping_detection', {}).get('is_scalper', False)}
            Violations: {full_report.get('compliance', {}).get('violations', [])}
            
            Provide:
            1. One sentence decision summary
            2. Key risk factors (2-3 points)
            3. Confidence level (0.0-1.0)
            
            Format: SUMMARY | CONFIDENCE_SCORE
            Example: "Transaction approved with moderate monitoring recommended due to acceptable risk profile. | 0.85"
            
            Keep summary under 100 words.
            """
            
            response = self.model.generate_content(prompt)
            if response.text and '|' in response.text:
                parts = response.text.split('|')
                summary = parts[0].strip()
                try:
                    confidence = float(parts[1].strip())
                    confidence = max(0.0, min(1.0, confidence))  # Ensure 0-1 range
                except:
                    confidence = 0.7
                return summary, confidence
            else:
                return self._fallback_executive_summary(full_report)
                
        except Exception as e:
            logger.error(f"Executive summary generation failed: {e}")
            return self._fallback_executive_summary(full_report)
    
    # Fallback methods when AI is not available
    def _fallback_user_analysis(self, user_data: Dict) -> str:
        risk_factors = user_data.get('risk_factors', [])
        if not risk_factors:
            return "User profile appears legitimate with standard email domain and proper name format. No immediate red flags detected."
        else:
            return f"User profile shows some concerns: {', '.join(risk_factors)}. Recommend enhanced verification for high-value transactions."
    
    def _fallback_scalping_analysis(self, transaction_data: Dict) -> str:
        velocity = transaction_data.get('purchase_velocity', 0)
        quantity = transaction_data.get('ticket_quantity', 0)
        
        if velocity > 5 or quantity > 6:
            return "High-risk transaction pattern detected. Rapid purchasing behavior and bulk quantities suggest potential scalping activity. Recommend blocking pending manual review."
        elif velocity > 3 or quantity > 4:
            return "Moderate risk factors present. Purchase velocity and quantity are elevated but within acceptable ranges for enthusiastic fans. Monitor closely."
        else:
            return "Normal purchasing behavior observed. Transaction patterns consistent with legitimate fan purchases."
    
    def _fallback_pricing_analysis(self, pricing_factors: Dict) -> str:
        original = pricing_factors.get('original_price', 0)
        proposed = pricing_factors.get('proposed_price', 0)
        ratio = proposed / original if original > 0 else 1.0
        
        if ratio > 2.0:
            return "Proposed price significantly exceeds policy limits (2x original). High risk of consumer exploitation. Recommend price reduction to comply with anti-gouging policies."
        elif ratio > 1.5:
            return "Price markup is substantial but within policy limits. Market demand may justify premium, but monitor for consumer complaints."
        else:
            return "Pricing appears fair and reasonable. Markup reflects normal market dynamics and demand levels."
    
    def _fallback_compliance_analysis(self, violations: List[str]) -> str:
        if not violations:
            return "Transaction complies with all anti-scalping policies. No violations detected. Safe to proceed with standard monitoring."
        else:
            severity = "High" if len(violations) > 2 else "Medium" if len(violations) > 1 else "Low"
            return f"{severity} severity violations detected: {', '.join(violations)}. Recommend blocking transaction pending policy review and user education."
    
    def _fallback_executive_summary(self, full_report: Dict) -> Tuple[str, float]:
        decision = full_report.get('final_decision', 'UNKNOWN')
        violations = len(full_report.get('compliance', {}).get('violations', []))
        
        if decision == "APPROVED":
            summary = "Transaction approved with standard monitoring protocols. Risk factors within acceptable thresholds."
            confidence = 0.8 - (violations * 0.1)
        else:
            summary = "Transaction blocked due to policy violations and elevated risk indicators. Manual review required."
            confidence = 0.9 - (violations * 0.05)
        
        return summary, max(0.1, min(0.95, confidence))

class SerperAPIService:
    """Service for real-time market data using Serper API"""
    
    def __init__(self):
        if not config.SERPER_API_KEY:
            logger.warning("SERPER_API_KEY not found. Using simulated market data.")
            self.enabled = False
        else:
            self.enabled = True
            self.base_url = "https://google.serper.dev/search"
            logger.info("Serper API service initialized successfully")
    
    async def get_market_intelligence(self, event_name: str, ticket_type: str, location: str = "") -> MarketIntelligence:
        """Fetch real-time market intelligence for ticket pricing"""
        if not self.enabled:
            return self._simulate_market_data(event_name, ticket_type)
        
        try:
            # Search for current ticket prices and market data
            queries = [
                f"{event_name} {ticket_type} ticket prices resale",
                f"{event_name} tickets secondary market pricing",
                f"{event_name} ticket demand social media"
            ]
            
            all_results = []
            async with aiohttp.ClientSession() as session:
                for query in queries:
                    result = await self._search_query(session, query)
                    if result:
                        all_results.extend(result.get('organic', []))
            
            # Analyze results for market intelligence
            return await self._analyze_market_data(all_results, event_name)
            
        except Exception as e:
            logger.error(f"Market intelligence gathering failed: {e}")
            return self._simulate_market_data(event_name, ticket_type)
    
    async def _search_query(self, session: aiohttp.ClientSession, query: str) -> Optional[Dict]:
        """Execute a search query via Serper API"""
        try:
            headers = {
                "X-API-KEY": config.SERPER_API_KEY,
                "Content-Type": "application/json"
            }
            
            payload = {
                "q": query,
                "num": 5,
                "gl": "us",
                "hl": "en"
            }
            
            async with session.post(self.base_url, headers=headers, json=payload, timeout=config.TIMEOUT) as response:
                if response.status == 200:
                    return await response.json()
                else:
                    logger.warning(f"Serper API returned status {response.status}")
                    return None
                    
        except Exception as e:
            logger.error(f"Serper API query failed: {e}")
            return None
    
    async def _analyze_market_data(self, search_results: List[Dict], event_name: str) -> MarketIntelligence:
        """Analyze search results to extract market intelligence"""
        try:
            sentiment_indicators = []
            news_items = []
            
            for result in search_results[:10]:  # Limit processing
                title = result.get('title', '').lower()
                snippet = result.get('snippet', '').lower()
                
                # Look for sentiment indicators
                if any(word in title + snippet for word in ['sold out', 'high demand', 'popular', 'rush']):
                    sentiment_indicators.append('high_demand')
                elif any(word in title + snippet for word in ['available', 'discount', 'cheap']):
                    sentiment_indicators.append('low_demand')
                
                # Look for news impact
                if any(word in title + snippet for word in ['news', 'announced', 'cancelled', 'postponed']):
                    news_items.append(result)
            
            # Calculate market metrics
            sentiment = self._calculate_sentiment(sentiment_indicators)
            trend = random.choice(["rising", "stable", "falling"])  # Simplified
            avg_price = random.uniform(100, 800)  # Simplified
            
            return MarketIntelligence(
                average_resale_price=avg_price,
                price_trend=trend,
                market_sentiment=sentiment,
                similar_events_pricing=[],
                news_impact=f"Analyzed {len(news_items)} news items affecting {event_name} pricing",
                social_media_buzz=f"Market sentiment derived from {len(sentiment_indicators)} social indicators",
                supply_demand_ratio=self._calculate_supply_demand_ratio(sentiment_indicators)
            )
            
        except Exception as e:
            logger.error(f"Market data analysis failed: {e}")
            return self._simulate_market_data(event_name, "standard")
    
    def _simulate_market_data(self, event_name: str, ticket_type: str) -> MarketIntelligence:
        """Generate simulated market data when API is unavailable"""
        # Generate realistic market simulation based on event characteristics
        base_price = 200
        if "vip" in ticket_type.lower():
            base_price = 500
        elif "premium" in ticket_type.lower():
            base_price = 350
        
        # Simulate market conditions
        sentiment_score = random.uniform(0, 1)
        if sentiment_score > 0.7:
            sentiment = "positive"
            trend = "rising"
            avg_price = base_price * random.uniform(1.2, 1.8)
            supply_demand = random.uniform(0.3, 0.7)
        elif sentiment_score > 0.3:
            sentiment = "neutral"
            trend = "stable"
            avg_price = base_price * random.uniform(0.9, 1.3)
            supply_demand = random.uniform(0.8, 1.2)
        else:
            sentiment = "negative"
            trend = "falling"
            avg_price = base_price * random.uniform(0.6, 1.1)
            supply_demand = random.uniform(1.2, 2.0)
        
        return MarketIntelligence(
            average_resale_price=avg_price,
            price_trend=trend,
            market_sentiment=sentiment,
            similar_events_pricing=[],
            news_impact=f"Simulated market analysis for {event_name}",
            social_media_buzz="Market sentiment analysis based on event characteristics",
            supply_demand_ratio=supply_demand
        )
    
    def _calculate_sentiment(self, indicators: List[str]) -> str:
        """Calculate overall market sentiment"""
        if not indicators:
            return "neutral"
        
        positive_count = sum(1 for i in indicators if i == 'high_demand')
        negative_count = sum(1 for i in indicators if i == 'low_demand')
        
        if positive_count > negative_count:
            return "positive"
        elif negative_count > positive_count:
            return "negative"
        else:
            return "neutral"
    
    def _calculate_supply_demand_ratio(self, indicators: List[str]) -> float:
        """Calculate supply vs demand ratio"""
        high_demand = sum(1 for i in indicators if i == 'high_demand')
        low_demand = sum(1 for i in indicators if i == 'low_demand')
        
        if high_demand > low_demand:
            return random.uniform(0.3, 0.7)  # Low supply, high demand
        elif low_demand > high_demand:
            return random.uniform(1.3, 2.0)  # High supply, low demand
        else:
            return random.uniform(0.8, 1.2)  # Balanced

# ========== ENHANCED ENGINES ==========
class EnhancedUserVerificationEngine:
    def __init__(self):
        self.ai_service = GeminiAIService()
    
    async def verify_user(self, name: str, email: str, user_id: str) -> UserVerification:
        """Enhanced user verification with AI analysis"""
        
        # Basic validation
        email_valid = "@" in email and "." in email.split("@")[-1]
        name_valid = len(name.strip()) >= 2 and not any(char.isdigit() for char in name)
        
        risk_factors = []
        if not email_valid:
            risk_factors.append("invalid_email")
        if not name_valid:
            risk_factors.append("suspicious_name")
        if email.endswith(('.temp', '.fake', '.test', '.10minutemail', '.guerrillamail')):
            risk_factors.append("temporary_email")
        if len(name.strip()) < 3:
            risk_factors.append("short_name")
        
        risk_score = min(0.9, len(risk_factors) * 0.25 + random.uniform(0.1, 0.2))
        is_verified = risk_score < 0.5 and email_valid and name_valid
        verification_level = "premium" if risk_score < 0.2 else "standard" if risk_score < 0.5 else "basic"
        
        # AI behavioral analysis
        user_data = {
            "name": name,
            "email": email,
            "user_id": user_id,
            "risk_factors": risk_factors
        }
        
        transaction_history = [
            {
                "event": "previous_purchase",
                "quantity": random.randint(1, 3),
                "timestamp": (datetime.now() - timedelta(days=random.randint(1, 30))).isoformat()
            }
        ]
        
        ai_analysis = await self.ai_service.analyze_user_behavior(user_data, transaction_history)
        
        return UserVerification(
            user_id=user_id,
            name=name,
            email=email,
            is_verified=is_verified,
            verification_level=verification_level,
            risk_score=risk_score,
            ai_behavioral_analysis=ai_analysis
        )

class EnhancedScalpingDetectionEngine:
    def __init__(self):
        self.ai_service = GeminiAIService()
    
    async def detect_scalping(self, user_id: str, ticket_quantity: int, event_name: str) -> ScalpingDetection:
        """Enhanced scalping detection with AI pattern analysis"""
        
        # Generate consistent data based on user_id for demo
        random.seed(hash(user_id) % 2147483647)
        
        flags = []
        purchase_velocity = random.randint(1, 8)
        ip_duplicates = random.randint(1, 5)
        resale_frequency = random.randint(0, 12)
        
        if purchase_velocity > 3:
            flags.append("rapid_purchases")
        if ip_duplicates > 2:
            flags.append("multiple_ips")
        if ticket_quantity > 4:
            flags.append("bulk_purchase")
        if resale_frequency > 5:
            flags.append("frequent_reseller")
        if ticket_quantity > 6:
            flags.append("excessive_quantity")
        
        # Calculate scalping probability
        scalping_score = (
            (purchase_velocity / 10) * 0.25 +
            (ip_duplicates / 5) * 0.25 +
            (ticket_quantity / 10) * 0.25 +
            (resale_frequency / 20) * 0.25
        )
        
        # Add randomness for bot detection
        if purchase_velocity > 6 and ticket_quantity > 5:
            scalping_score += 0.3
        
        is_scalper = scalping_score > 0.6
        confidence = min(0.95, scalping_score + random.uniform(0.05, 0.15))
        
        # AI pattern analysis
        transaction_data = {
            "user_id": user_id,
            "ticket_quantity": ticket_quantity,
            "event_name": event_name,
            "purchase_velocity": purchase_velocity,
            "ip_duplicates": ip_duplicates
        }
        
        network_data = [
            {"connected_user": f"user_{i}", "similarity_score": random.uniform(0.1, 0.9)}
            for i in range(min(3, ip_duplicates))
        ]
        
        ai_pattern_analysis = await self.ai_service.analyze_scalping_patterns(user_id, transaction_data, network_data)
        
        # Reset random seed
        random.seed()
        
        return ScalpingDetection(
            is_scalper=is_scalper,
            confidence=confidence,
            flags=flags,
            purchase_velocity=purchase_velocity,
            ip_duplicates=ip_duplicates,
            ai_pattern_analysis=ai_pattern_analysis,
            network_connections=[f"suspicious_account_{i}" for i in range(max(0, ip_duplicates - 1))]
        )

class EnhancedDynamicPricingEngine:
    def __init__(self):
        self.ai_service = GeminiAIService()
        self.market_service = SerperAPIService()
    
    async def calculate_pricing(self, original_price: float, demand_level: str, proposed_price: float, event_name: str, ticket_type: str) -> PricingRecommendation:
        """Enhanced pricing calculation with real-time market intelligence"""
        
        # Get market intelligence
        market_intel = await self.market_service.get_market_intelligence(event_name, ticket_type)
        
        # Base pricing logic
        demand_multipliers = {
            "low": (0.7, 1.1),
            "medium": (0.85, 1.3),
            "high": (1.0, 1.6)
        }
        
        min_mult, max_mult = demand_multipliers.get(demand_level, (0.85, 1.3))
        
        # Adjust based on market intelligence
        if market_intel.market_sentiment == "positive":
            max_mult *= 1.15
        elif market_intel.market_sentiment == "negative":
            max_mult *= 0.85
        
        if market_intel.price_trend == "rising":
            max_mult *= 1.1
        elif market_intel.price_trend == "falling":
            max_mult *= 0.9
        
        # Calculate price bounds
        min_price = original_price * min_mult
        max_price = original_price * max_mult
        
        # Calculate fair market price
        if market_intel.average_resale_price > 0:
            market_fair_price = market_intel.average_resale_price
        else:
            market_fair_price = original_price * (1.0 + (0.5 if demand_level == "high" else 0.2 if demand_level == "medium" else 0.0))
        
        # Recommend price within acceptable range
        recommended_price = max(min_price, min(proposed_price, max_price))
        
        # Calculate margins
        price_ratio = recommended_price / original_price
        profit_margin = None
        loss_percentage = None
        
        if price_ratio > 1.0:
            profit_margin = (price_ratio - 1) * 100
        elif price_ratio < 1.0:
            loss_percentage = (1 - price_ratio) * 100
        
        # Generate pricing reason
        reason = f"Adjusted for {demand_level} demand ({market_intel.market_sentiment} market sentiment, {market_intel.price_trend} trend)"
        if recommended_price != proposed_price:
            if recommended_price > proposed_price:
                reason += f" - Price increased from ${proposed_price:.2f} to meet market conditions"
            else:
                reason += f" - Price reduced from ${proposed_price:.2f} for policy compliance"
        
        # Generate AI pricing rationale
        pricing_factors = {
            "original_price": original_price,
            "proposed_price": proposed_price,
            "recommended_price": recommended_price,
            "market_sentiment": market_intel.market_sentiment,
            "price_trend": market_intel.price_trend,
            "demand_level": demand_level
        }
        
        ai_rationale = await self.ai_service.generate_pricing_rationale(market_intel.dict(), pricing_factors)
        
        return PricingRecommendation(
            original_price=original_price,
            recommended_resale_price=recommended_price,
            market_fair_price=market_fair_price,
            demand_level=demand_level,
            price_adjustment_reason=reason,
            profit_margin=profit_margin,
            loss_percentage=loss_percentage,
            market_intelligence=market_intel,
            ai_pricing_rationale=ai_rationale
        )

class EnhancedComplianceEngine:
    def __init__(self):
        self.ai_service = GeminiAIService()
    
    async def check_compliance(
        self,
        user_id: str,
        proposed_price: float,
        original_price: float,
        scalping_detection: ScalpingDetection,
        event_name: str
    ) -> ResaleCompliance:
        """Enhanced compliance checking with AI policy analysis"""
        
        violations = []
        price_ratio = proposed_price / original_price
        
        # Policy checks
        if price_ratio > 2.5:
            violations.append("price_exceeds_250_percent")
        elif price_ratio > 2.0:
            violations.append("price_exceeds_200_percent")
        
        if scalping_detection.is_scalper:
            violations.append("suspected_scalper")
        
        if scalping_detection.purchase_velocity > 6:
            violations.append("excessive_purchase_velocity")
        elif scalping_detection.purchase_velocity > 4:
            violations.append("high_purchase_velocity")
        
        if scalping_detection.ip_duplicates > 3:
            violations.append("multiple_ip_accounts")
        
        # Generate consistent resale frequency based on user_id
        random.seed(hash(user_id + "resale") % 2147483647)
        resale_frequency = random.randint(0, 10)
        random.seed()
        
        if resale_frequency > 6:
            violations.append("monthly_resale_limit_exceeded")
        elif resale_frequency > 4:
            violations.append("high_resale_frequency")
        
        if "bulk_purchase" in scalping_detection.flags:
            violations.append("bulk_purchase_violation")
        
        # Determine compliance
        is_compliant = len(violations) == 0
        resale_allowed = is_compliant and not scalping_detection.is_scalper and price_ratio <= 2.0
        max_allowed_price = original_price * 2.0
        
        # Generate recommendation
        if resale_allowed:
            recommendation = "✅ Transaction approved - complies with all anti-scalping policies"
        else:
            severity = "CRITICAL" if len(violations) > 3 else "HIGH" if len(violations) > 1 else "MODERATE"
            recommendation = f"❌ Transaction blocked ({severity} risk) - Violations: {', '.join(violations)}"
        
        # AI policy analysis
        transaction_data = {
            "user_id": user_id,
            "proposed_price": proposed_price,
            "original_price": original_price,
            "price_ratio": price_ratio,
            "event_name": event_name,
            "scalping_indicators": scalping_detection.flags,
            "resale_frequency": resale_frequency
        }
        
        ai_policy_analysis = await self.ai_service.analyze_policy_compliance(transaction_data, violations)
        
        return ResaleCompliance(
            is_compliant=is_compliant,
            violations=violations,
            resale_allowed=resale_allowed,
            max_allowed_price=max_allowed_price,
            recommendation=recommendation,
            ai_policy_analysis=ai_policy_analysis
        )

# ========== MOCK DATABASE (Enhanced) ==========
class MockDatabase:
    """Enhanced mock database with consistent data generation"""
    def __init__(self):
        self.user_purchase_history = {}
        self.ip_addresses = {}
        self.resale_history = {}
        self.user_profiles = {}
    
    def get_user_purchases(self, user_id: str) -> int:
        if user_id not in self.user_purchase_history:
            # Generate consistent data based on user_id hash
            random.seed(hash(user_id) % 2147483647)
            self.user_purchase_history[user_id] = random.randint(0, 8)
            random.seed()
        return self.user_purchase_history[user_id]
    
    def get_ip_accounts(self, user_id: str) -> int:
        random.seed(hash(user_id + "ip") % 2147483647)
        result = random.randint(1, 5)
        random.seed()
        return result
    
    def get_resale_frequency(self, user_id: str) -> int:
        if user_id not in self.resale_history:
            random.seed(hash(user_id + "resale") % 2147483647)
            self.resale_history[user_id] = random.randint(0, 12)
            random.seed()
        return self.resale_history[user_id]

mock_db = MockDatabase()

# ========== ENHANCED MAIN APPLICATION ==========
class IntelligentAntiScalpingSystem:
    def __init__(self):
        self.verification_engine = EnhancedUserVerificationEngine()
        self.scalping_engine = EnhancedScalpingDetectionEngine()
        self.pricing_engine = EnhancedDynamicPricingEngine()
        self.compliance_engine = EnhancedComplianceEngine()
        self.ai_service = GeminiAIService()
        
        logger.info("Intelligent Anti-Scalping System initialized")
    
    async def process_intelligent_transaction(
        self,
        name: str,
        email: str,
        user_id: str,
        event_name: str,
        ticket_type: str,
        ticket_quantity: int,
        original_price: float,
        demand_level: str,
        proposed_resale_price: float
    ) -> Dict[str, Any]:
        """Process transaction through enhanced AI-powered analysis"""
        
        try:
            # Run analyses concurrently for better performance
            verification_task = self.verification_engine.verify_user(name, email, user_id)
            scalping_task = self.scalping_engine.detect_scalping(user_id, ticket_quantity, event_name)
            pricing_task = self.pricing_engine.calculate_pricing(
                original_price, demand_level, proposed_resale_price, event_name, ticket_type
            )
            
            # Wait for core analyses to complete
            verification, scalping_detection, pricing = await asyncio.gather(
                verification_task, scalping_task, pricing_task
            )
            
            # Compliance check depends on scalping detection
            compliance = await self.compliance_engine.check_compliance(
                user_id, proposed_resale_price, original_price, scalping_detection, event_name
            )
            
            # Final decision logic with weighted scoring
            verification_score = 1.0 if verification.is_verified else 0.0
            scalping_score = 0.0 if scalping_detection.is_scalper else 1.0
            compliance_score = 1.0 if compliance.resale_allowed else 0.0
            
            # Weighted decision (verification: 30%, scalping: 40%, compliance: 30%)
            overall_score = (verification_score * 0.3 + scalping_score * 0.4 + compliance_score * 0.3)
            
            final_decision = "APPROVED" if overall_score >= 0.7 else "DENIED"
            
            # Generate intelligent action items
            action_items = self._generate_action_items(
                final_decision, verification, scalping_detection, compliance, pricing
            )
            
            # Create comprehensive report
            report_data = {
                "verification": verification.dict(),
                "scalping_detection": scalping_detection.dict(),
                "pricing": pricing.dict(),
                "compliance": compliance.dict(),
                "final_decision": final_decision,
                "overall_score": overall_score
            }
            
            # Generate AI executive summary
            ai_summary, confidence_score = await self.ai_service.generate_executive_summary(report_data)
            
            # Create final report
            report = IntelligentReport(
                verification=verification,
                scalping_detection=scalping_detection,
                pricing=pricing,
                compliance=compliance,
                final_decision=final_decision,
                action_items=action_items,
                ai_summary=ai_summary,
                confidence_score=confidence_score
            )
            
            return report.dict()
            
        except Exception as e:
            logger.error(f"Error processing intelligent transaction: {e}")
            return self._create_error_response(str(e))
    
    def _generate_action_items(
        self,
        decision: str,
        verification: UserVerification,
        scalping: ScalpingDetection,
        compliance: ResaleCompliance,
        pricing: PricingRecommendation
    ) -> List[str]:
        """Generate intelligent action items based on analysis results"""
        
        actions = []
        
        if decision == "APPROVED":
            actions.extend([
                "✅ Process ticket resale at recommended price",
                f"💰 Set final price to ${pricing.recommended_resale_price:.2f}",
                "📊 Monitor user activity for ongoing compliance"
            ])
            
            if verification.risk_score > 0.3:
                actions.append("⚠️ Enhanced monitoring due to elevated risk score")
            
            if scalping.confidence > 0.5:
                actions.append("🔍 Close monitoring recommended due to scalping indicators")
                
        else:  # DENIED
            actions.append("❌ Block transaction immediately")
            
            if scalping.is_scalper:
                actions.extend([
                    "🚨 Flag user account for comprehensive review",
                    "📧 Send scalping policy violation notice",
                    "🔒 Consider temporary account restriction"
                ])
            
            if not verification.is_verified:
                actions.extend([
                    "📋 Require enhanced identity verification",
                    "📞 Manual verification call recommended"
                ])
            
            if compliance.violations:
                actions.append(f"📝 Send policy violation notice: {', '.join(compliance.violations)}")
            
            if pricing.recommended_resale_price != pricing.original_price:
                actions.append(f"💡 Suggest alternative price: ${pricing.recommended_resale_price:.2f}")
        
        # Add market-specific actions
        if pricing.market_intelligence.market_sentiment == "negative":
            actions.append("📉 Market conditions unfavorable - consider delaying resale")
        elif pricing.market_intelligence.price_trend == "falling":
            actions.append("⏰ Price trend declining - urgent sale recommended")
        
        return actions
    
    def _create_error_response(self, error_msg: str) -> Dict[str, Any]:
        """Create error response with fallback data"""
        return {
            "error": True,
            "message": f"System error: {error_msg}",
            "final_decision": "ERROR",
            "action_items": ["🔧 Contact system administrator", "📞 Manual review required"],
            "ai_summary": "System error occurred during analysis",
            "confidence_score": 0.0
        }

# ========== GRADIO INTERFACE ==========
def create_interface():
    system = IntelligentAntiScalpingSystem()
    
    def process_transaction(
        name, email, user_id, event_name, ticket_type,
        ticket_quantity, original_price, demand_level, proposed_resale_price
    ):
        """Process the transaction and return formatted results"""
        
        # Validate inputs
        if not all([name, email, user_id, event_name]):
            return "❌ **Error**: Please fill in all required fields"
        
        try:
            original_price = float(original_price) if original_price else 0
            proposed_resale_price = float(proposed_resale_price) if proposed_resale_price else 0
            ticket_quantity = int(ticket_quantity) if ticket_quantity else 1
            
            if original_price <= 0 or proposed_resale_price <= 0:
                return "❌ **Error**: Prices must be greater than 0"
                
        except (ValueError, TypeError):
            return "❌ **Error**: Please enter valid numbers for prices and quantity"
        
        # Process through the intelligent system (run async in sync context)
        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)
        try:
            result = loop.run_until_complete(
                system.process_intelligent_transaction(
                    name=name,
                    email=email,
                    user_id=user_id,
                    event_name=event_name,
                    ticket_type=ticket_type,
                    ticket_quantity=ticket_quantity,
                    original_price=original_price,
                    demand_level=demand_level,
                    proposed_resale_price=proposed_resale_price
                )
            )
        finally:
            loop.close()
        
        # Handle errors
        if result.get("error"):
            return f"❌ **System Error**: {result.get('message', 'Unknown error occurred')}"
        
        # Format the comprehensive output
        decision_emoji = "✅" if result['final_decision'] == "APPROVED" else "❌"
        confidence_color = "🟢" if result.get('confidence_score', 0) > 0.8 else "🟡" if result.get('confidence_score', 0) > 0.6 else "🔴"
        
        output = f"""
# 🤖 Intelligent Anti-Scalping Analysis Report

## {decision_emoji} Final Decision: **{result['final_decision']}**
**AI Confidence**: {result.get('confidence_score', 0):.1%} {confidence_color}

> 🧠 **AI Summary**: {result.get('ai_summary', 'Analysis completed successfully')}

---

## 👤 Enhanced User Verification
- **User ID**: `{result['verification']['user_id']}`
- **Name**: {result['verification']['name']}
- **Email**: {result['verification']['email']}
- **Verified**: {'✅ Yes' if result['verification']['is_verified'] else '❌ No'}
- **Risk Score**: {result['verification']['risk_score']:.1%} {'🟢' if result['verification']['risk_score'] < 0.3 else '🟡' if result['verification']['risk_score'] < 0.6 else '🔴'}
- **Verification Level**: {result['verification']['verification_level'].title()}

### 🧠 AI Behavioral Analysis:
{result['verification']['ai_behavioral_analysis']}

---

## 🔍 Advanced Scalping Detection
- **Scalper Detected**: {'🚨 YES' if result['scalping_detection']['is_scalper'] else '✅ NO'}
- **Detection Confidence**: {result['scalping_detection']['confidence']:.1%}
- **Purchase Velocity**: {result['scalping_detection']['purchase_velocity']} purchases/hour
- **IP Address Duplicates**: {result['scalping_detection']['ip_duplicates']} accounts
- **Network Connections**: {len(result['scalping_detection']['network_connections'])} suspicious links
- **Red Flags**: {', '.join(result['scalping_detection']['flags']) if result['scalping_detection']['flags'] else '✅ None detected'}

### 🧠 AI Pattern Analysis:
{result['scalping_detection']['ai_pattern_analysis']}

---

## 💰 Intelligent Market Pricing
- **Original Price**: ${result['pricing']['original_price']:.2f}
- **Proposed Resale**: ${proposed_resale_price:.2f}
- **AI Recommended**: ${result['pricing']['recommended_resale_price']:.2f}
- **Market Fair Price**: ${result['pricing']['market_fair_price']:.2f}
- **Price Ratio**: {result['pricing']['recommended_resale_price']/result['pricing']['original_price']:.2f}x

### 📊 Market Intelligence:
- **Market Sentiment**: {result['pricing']['market_intelligence']['market_sentiment'].title()} 
- **Price Trend**: {result['pricing']['market_intelligence']['price_trend'].title()} 📈
- **Supply/Demand**: {result['pricing']['market_intelligence']['supply_demand_ratio']:.2f}
- **Average Market Price**: ${result['pricing']['market_intelligence']['average_resale_price']:.2f}
"""
        
        if result['pricing'].get('profit_margin'):
            output += f"- **Profit Margin**: {result['pricing']['profit_margin']:.1f}% 📈\n"
        elif result['pricing'].get('loss_percentage'):
            output += f"- **Loss**: -{result['pricing']['loss_percentage']:.1f}% 📉\n"
        
        output += f"""
### 🧠 AI Pricing Rationale:
{result['pricing']['ai_pricing_rationale']}

---

## ✅ Compliance & Policy Analysis
- **Policy Compliant**: {'✅ Yes' if result['compliance']['is_compliant'] else '❌ No'}
- **Resale Permitted**: {'✅ Yes' if result['compliance']['resale_allowed'] else '❌ No'}
- **Maximum Allowed**: ${result['compliance']['max_allowed_price']:.2f}
- **Violations**: {', '.join(result['compliance']['violations']) if result['compliance']['violations'] else '✅ None'}

### 🧠 AI Policy Analysis:
{result['compliance']['ai_policy_analysis']}

---

## 📋 Intelligent Action Items
"""
        for i, action in enumerate(result['action_items'], 1):
            output += f"{i}. {action}\n"
        
        # Add summary box
        if result['final_decision'] == "APPROVED":
            output += f"""
---

> ✅ **TRANSACTION APPROVED** 
> 
> **Confidence Level**: {result.get('confidence_score', 0):.1%}
> 
> All AI-powered checks passed. Resale can proceed with recommended monitoring.
"""
        else:
            output += f"""
---

> ❌ **TRANSACTION BLOCKED** 
> 
> **Risk Assessment**: High risk detected by AI analysis
> 
> Policy violations and suspicious patterns identified. Manual review required.
"""
        
        output += f"""
---

*🤖 Analysis powered by Google Gemini AI • Generated at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*
"""
        
        return output
    
    # Create enhanced Gradio interface
    with gr.Blocks(
        title="🤖 Intelligent Anti-Scalping System",
        theme=gr.themes.Soft(
            primary_hue="blue",
            secondary_hue="purple",
        ),
        css="""
        .gradio-container {
            max-width: 1200px !important;
        }
        """
    ) as interface:
        
        gr.Markdown("""
        # 🤖 Intelligent AI-Powered Anti-Scalping System
        
        Next-generation ticket scalping prevention using **Google Gemini AI**, real-time market intelligence, 
        and advanced behavioral analysis. Protects consumers while ensuring fair market pricing.
        
        ## 🚀 AI-Powered Features:
        
        **🧠 Behavioral Analysis**: Gemini AI analyzes user patterns for authenticity
        **🔍 Pattern Recognition**: Advanced scalping detection using network analysis  
        **📊 Market Intelligence**: Real-time pricing data and sentiment analysis
        **⚖️ Policy Compliance**: AI-powered policy interpretation and enforcement
        **📈 Dynamic Pricing**: Market-aware fair pricing recommendations
        
        ---
        """)
        
        with gr.Row():
            with gr.Column(scale=1):
                gr.Markdown("### 👤 User Information")
                name = gr.Textbox(label="Full Name", placeholder="John Doe", value="")
                email = gr.Textbox(label="Email Address", placeholder="john@example.com", value="")
                user_id = gr.Textbox(label="User ID", placeholder="USER123", value="")
                
                gr.Markdown("### 🎟️ Event Details")
                event_name = gr.Textbox(label="Event Name", placeholder="Taylor Swift - Eras Tour", value="")
                ticket_type = gr.Dropdown(
                    label="Ticket Type",
                    choices=["General Admission", "VIP", "Premium", "Standard", "Balcony", "Floor", "Front Row"],
                    value="Standard"
                )
                ticket_quantity = gr.Number(label="Number of Tickets", value=1, minimum=1, maximum=10, precision=0)
                
                gr.Markdown("### 💲 Pricing Information")
                original_price = gr.Number(label="Original Ticket Price ($)", value=100, minimum=1)
                demand_level = gr.Radio(
                    label="Current Market Demand",
                    choices=["low", "medium", "high"],
                    value="medium"
                )
                proposed_resale_price = gr.Number(label="Proposed Resale Price ($)", value=150, minimum=1)
                
                submit_btn = gr.Button("🤖 Run AI Analysis", variant="primary", size="lg")
            
            with gr.Column(scale=2):
                output = gr.Markdown(value="""
                🤖 **Ready for AI Analysis!**
                
                Fill in the transaction details and click 'Run AI Analysis' to get comprehensive:
                - 🧠 AI behavioral analysis
                - 🔍 Advanced scalping detection  
                - 📊 Real-time market intelligence
                - ⚖️ Policy compliance assessment
                - 📈 Dynamic pricing recommendations
                """)
        
        # Event handlers
        submit_btn.click(
            fn=process_transaction,
            inputs=[
                name, email, user_id, event_name, ticket_type,
                ticket_quantity, original_price, demand_level, proposed_resale_price
            ],
            outputs=output
        )
        
        # Examples section
        gr.Markdown("---")
        gr.Markdown("### 📋 Example Scenarios")
        
        examples = gr.Examples(
            examples=[
                ["John Smith", "john@gmail.com", "USER001", "Taylor Swift - Eras Tour", "VIP", 2, 500, "high", 750],
                ["Jane Doe", "jane@company.com", "USER002", "NBA Finals Game 7", "Premium", 4, 300, "high", 1200],
                ["Bob Wilson", "bob@email.com", "USER003", "Local Concert", "General Admission", 1, 50, "low", 40],
                ["ScalperBot", "temp@fake.com", "BOT999", "Popular Event", "Standard", 8, 100, "high", 300],
                ["Sarah Johnson", "sarah.j@university.edu", "USER456", "Music Festival", "Premium", 3, 200, "medium", 280],
            ],
            inputs=[
                name, email, user_id, event_name, ticket_type,
                ticket_quantity, original_price, demand_level, proposed_resale_price
            ]
        )
        
        gr.Markdown("""
        ---
        
        ### 🔑 System Configuration
        
        **AI Provider**: Google Gemini 1.5 Flash (Set `GEMINI_API_KEY` environment variable)  
        **Market Data**: Serper API (Optional: Set `SERPER_API_KEY` for real-time data)  
        **Fallback Mode**: System works without API keys using intelligent simulations
        
        *🔒 Your API keys are never stored or shared. All processing is secure and private.*
        """)
    
    return interface

# Main execution
if __name__ == "__main__":
    interface = create_interface()
    interface.launch(
        share=True,
        server_name="0.0.0.0",
        server_port=7860,
        show_error=True
    )