AI Opportunities for Checkatrade considering PERN Stack

-- User preferences and behavior tracking
CREATE TABLE user_preferences (
    user_id UUID PRIMARY KEY,
    preferences JSONB,
    behavior_vector VECTOR(128), -- Using pgvector extension
    last_updated TIMESTAMP DEFAULT NOW()
);

-- Matching scores table for optimization
CREATE TABLE matching_scores (
    user_id UUID,
    provider_id UUID,
    score DECIMAL(5,4),
    factors JSONB,
    created_at TIMESTAMP DEFAULT NOW(),
    PRIMARY KEY (user_id, provider_id)
);

-- Create indexes for vector similarity search
CREATE INDEX ON user_preferences USING ivfflat (behavior_vector vector_cosine_ops);

// AI matching service
class AIMatchingService {
  async calculateMatches(userId) {
    const userVector = await this.getUserVector(userId);
    const providers = await this.getActiveProviders();
    
    const matches = await Promise.all(
      providers.map(async (provider) => {
        const similarity = await this.calculateSimilarity(userVector, provider.vector);
        const contextualScore = await this.getContextualFactors(userId, provider.id);
        
        return {
          providerId: provider.id,
          score: similarity * contextualScore,
          factors: this.getExplainabilityFactors(userId, provider.id)
        };
      })
    );
    
    return matches.sort((a, b) => b.score - a.score).slice(0, 10);
  }
  
  async updateUserVector(userId, interaction) {
    // Update user behavior vector based on interactions
    const currentVector = await this.getUserVector(userId);
    const updatedVector = this.weightedUpdate(currentVector, interaction);
    
    await db.query(
      'UPDATE user_preferences SET behavior_vector = $1 WHERE user_id = $2',
      [updatedVector, userId]
    );
  }
}

// Smart matching interface
const SmartMatchingComponent = () => {
  const [matches, setMatches] = useState([]);
  const [loading, setLoading] = useState(false);
  const { user } = useAuth();
  
  const fetchMatches = async () => {
    setLoading(true);
    try {
      const response = await fetch(`/api/matches/${user.id}`);
      const data = await response.json();
      setMatches(data.matches);
    } catch (error) {
      console.error('Failed to fetch matches:', error);
    } finally {
      setLoading(false);
    }
  };
  
  const handleInteraction = async (providerId, interaction) => {
    // Track user interaction for ML learning
    await fetch('/api/interactions', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        userId: user.id,
        providerId,
        interaction,
        timestamp: new Date().toISOString()
      })
    });
    
    // Refresh matches
    fetchMatches();
  };
  
  return (
    <div className="smart-matching">
      <h2>Recommended for You</h2>
      {loading ? (
        <MatchingSkeleton />
      ) : (
        matches.map(match => (
          <MatchCard 
            key={match.providerId}
            match={match}
            onInteraction={handleInteraction}
          />
        ))
      )}
    </div>
  );
};

-- Price history and market data
CREATE TABLE price_history (
    id SERIAL PRIMARY KEY,
    service_id UUID,
    price DECIMAL(10,2),
    demand_score DECIMAL(5,4),
    competition_factor DECIMAL(5,4),
    market_conditions JSONB,
    timestamp TIMESTAMP DEFAULT NOW()
);

-- Real-time demand tracking
CREATE TABLE demand_signals (
    service_id UUID,
    region VARCHAR(50),
    search_count INTEGER,
    booking_rate DECIMAL(5,4),
    time_slot TIMESTAMP,
    PRIMARY KEY (service_id, region, time_slot)
);

// Dynamic pricing engine
class DynamicPricingEngine {
  async calculatePrice(serviceId, region, timeSlot) {
    const demandData = await this.getDemandSignals(serviceId, region, timeSlot);
    const competitionData = await this.getCompetitionAnalysis(serviceId, region);
    const historicalData = await this.getHistoricalPricing(serviceId);
    
    // AI model for price prediction
    const features = this.extractFeatures({
      demandData,
      competitionData,
      historicalData,
      timeSlot,
      region
    });
    
    const predictedPrice = await this.mlModel.predict(features);
    const adjustedPrice = this.applyBusinessRules(predictedPrice, serviceId);
    
    // Log pricing decision for learning
    await this.logPricingDecision({
      serviceId,
      region,
      timeSlot,
      predictedPrice,
      adjustedPrice,
      features
    });
    
    return adjustedPrice;
  }
  
  async updatePricingModel() {
    // Retrain model based on actual booking outcomes
    const trainingData = await this.getTrainingData();
    await this.mlModel.retrain(trainingData);
  }
}

// Dynamic pricing dashboard
const PricingDashboard = () => {
  const [pricingData, setPricingData] = useState(null);
  const [priceOptimization, setPriceOptimization] = useState(null);
  
  const fetchPricingInsights = async (serviceId) => {
    const response = await fetch(`/api/pricing/insights/${serviceId}`);
    const data = await response.json();
    setPricingData(data);
  };
  
  const optimizePrice = async (serviceId, targetMetric) => {
    const response = await fetch('/api/pricing/optimize', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ serviceId, targetMetric })
    });
    const optimization = await response.json();
    setPriceOptimization(optimization);
  };
  
  return (
    <div className="pricing-dashboard">
      <PriceChart data={pricingData?.historical} />
      <DemandHeatmap data={pricingData?.demand} />
      <OptimizationSuggestions 
        suggestions={priceOptimization?.suggestions}
        onApply={optimizePrice}
      />
    </div>
  );
};

-- Market data aggregation
CREATE TABLE market_metrics (
    id SERIAL PRIMARY KEY,
    metric_type VARCHAR(50),
    region VARCHAR(100),
    value DECIMAL(15,4),
    metadata JSONB,
    source VARCHAR(100),
    collected_at TIMESTAMP DEFAULT NOW()
);

-- Trend analysis results
CREATE TABLE trend_analysis (
    id SERIAL PRIMARY KEY,
    category VARCHAR(100),
    trend_direction VARCHAR(20), -- increasing, decreasing, stable
    confidence_score DECIMAL(5,4),
    key_factors JSONB,
    forecast_data JSONB,
    analysis_date TIMESTAMP DEFAULT NOW()
);

// Market analysis service
class MarketAnalysisService {
  async generateMarketReport(region, timeframe) {
    const rawData = await this.collectMarketData(region, timeframe);
    const processedData = await this.preprocessData(rawData);
    
    // AI-powered trend analysis
    const trends = await this.analyzeTrends(processedData);
    const forecasts = await this.generateForecasts(processedData);
    const insights = await this.extractInsights(trends, forecasts);
    
    const report = {
      region,
      timeframe,
      marketSize: this.calculateMarketSize(processedData),
      growthRate: this.calculateGrowthRate(processedData),
      trends,
      forecasts,
      actionableInsights: insights,
      competitiveAnalysis: await this.analyzeCompetition(region)
    };
    
    await this.saveReport(report);
    return report;
  }
  
  async detectMarketAnomalies() {
    const recentData = await this.getRecentMarketData();
    const anomalies = await this.anomalyDetectionModel.predict(recentData);
    
    if (anomalies.length > 0) {
      await this.triggerAnomalyAlerts(anomalies);
    }
    
    return anomalies;
  }
}

// Market analysis dashboard
const MarketAnalysisDashboard = () => {
  const [marketData, setMarketData] = useState(null);
  const [selectedRegion, setSelectedRegion] = useState('all');
  const [timeframe, setTimeframe] = useState('30d');
  
  const generateReport = async () => {
    setLoading(true);
    try {
      const response = await fetch('/api/market-analysis/report', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ region: selectedRegion, timeframe })
      });
      const report = await response.json();
      setMarketData(report);
    } catch (error) {
      console.error('Failed to generate report:', error);
    } finally {
      setLoading(false);
    }
  };
  
  return (
    <div className="market-dashboard">
      <ReportFilters 
        region={selectedRegion}
        timeframe={timeframe}
        onRegionChange={setSelectedRegion}
        onTimeframeChange={setTimeframe}
        onGenerate={generateReport}
      />
      
      {marketData && (
        <>
          <MarketOverview data={marketData.overview} />
          <TrendVisualization trends={marketData.trends} />
          <ForecastChart forecasts={marketData.forecasts} />
          <InsightsPanel insights={marketData.actionableInsights} />
        </>
      )}
    </div>
  );
};

-- Fraud detection features
CREATE TABLE fraud_signals (
    id SERIAL PRIMARY KEY,
    user_id UUID,
    session_id VARCHAR(100),
    signal_type VARCHAR(50),
    risk_score DECIMAL(5,4),
    signal_data JSONB,
    detected_at TIMESTAMP DEFAULT NOW()
);

-- Fraud cases for model training
CREATE TABLE fraud_cases (
    case_id UUID PRIMARY KEY,
    user_id UUID,
    transaction_id UUID,
    is_fraud BOOLEAN,
    investigation_notes TEXT,
    resolved_at TIMESTAMP
);

// Fraud detection engine
class FraudDetectionEngine {
  async analyzeTransaction(transaction) {
    const features = await this.extractFeatures(transaction);
    const riskScores = await Promise.all([
      this.deviceFingerprintAnalysis(transaction),
      this.behaviorAnalysis(transaction.userId),
      this.networkAnalysis(transaction),
      this.amountAnalysis(transaction)
    ]);
    
    const aggregateRisk = this.calculateAggregateRisk(riskScores);
    
    if (aggregateRisk > this.config.highRiskThreshold) {
      await this.triggerSecurityAction(transaction, 'BLOCK');
      return { action: 'BLOCK', risk: aggregateRisk, reasons: this.getReasons(riskScores) };
    } else if (aggregateRisk > this.config.mediumRiskThreshold) {
      await this.triggerSecurityAction(transaction, 'REVIEW');
      return { action: 'REVIEW', risk: aggregateRisk, reasons: this.getReasons(riskScores) };
    }
    
    return { action: 'ALLOW', risk: aggregateRisk };
  }
  
  async updateFraudModel() {
    const labeledData = await this.getLabeledFraudData();
    await this.fraudModel.retrain(labeledData);
    
    // Update detection thresholds based on performance metrics
    const performance = await this.evaluateModelPerformance();
    this.optimizeThresholds(performance);
  }
}

// Fraud monitoring dashboard
const FraudMonitoringDashboard = () => {
  const [fraudAlerts, setFraudAlerts] = useState([]);
  const [riskMetrics, setRiskMetrics] = useState(null);
  
  const fetchFraudData = async () => {
    const [alerts, metrics] = await Promise.all([
      fetch('/api/fraud/alerts').then(r => r.json()),
      fetch('/api/fraud/metrics').then(r => r.json())
    ]);
    
    setFraudAlerts(alerts);
    setRiskMetrics(metrics);
  };
  
  const investigateCase = async (caseId) => {
    const response = await fetch(`/api/fraud/investigate/${caseId}`, {
      method: 'POST'
    });
    const investigation = await response.json();
    
    // Update case status and refresh data
    await fetchFraudData();
    return investigation;
  };
  
  return (
    <div className="fraud-dashboard">
      <RiskMetrics metrics={riskMetrics} />
      <FraudAlertsList 
        alerts={fraudAlerts}
        onInvestigate={investigateCase}
      />
      <ModelPerformanceChart />
    </div>
  );
};

-- Conversation context storage
CREATE TABLE conversation_contexts (
    session_id UUID PRIMARY KEY,
    user_id UUID,
    context_data JSONB,
    intent_history JSONB,
    task_queue JSONB,
    updated_at TIMESTAMP DEFAULT NOW()
);

-- Task execution tracking
CREATE TABLE mcp_tasks (
    task_id UUID PRIMARY KEY,
    session_id UUID,
    task_type VARCHAR(100),
    parameters JSONB,
    status VARCHAR(50),
    result JSONB,
    created_at TIMESTAMP DEFAULT NOW()
);

// Proposed MCP Implementation for Checkatrade
class CheckatradeMCPService {
  async processCustomerInquiry(sessionId, message, customerHistory) {
    const context = await this.buildCustomerContext(sessionId, customerHistory);
    const jobIntent = await this.analyzeJobRequirements(message, context);
    
    // Update persistent context with new information
    const updatedContext = await this.updateCustomerContext(context, message, jobIntent);
    
    // Execute Checkatrade-specific workflows
    const actionResults = await this.executeTradeWorkflows(jobIntent, updatedContext);
    
    // Generate contextual response with Checkatrade insights
    const response = await this.generateTradeResponse(jobIntent, actionResults, updatedContext);
    
    return {
      message: response,
      recommendations: actionResults,
      customerContext: updatedContext,
      nextSteps: await this.generateNextSteps(updatedContext)
    };
  }
  
  async executeTradeWorkflows(intent, context) {
    const workflows = [];
    
    switch (intent.type) {
      case 'COMPLEX_JOB_SCOPING':
        workflows.push(await this.scopeComplexJob(intent.requirements, context));
        break;
        
      case 'MULTI_TRADE_PROJECT':
        const projectPlan = await this.planMultiTradeProject(intent.requirements, context);
        workflows.push({ type: 'PROJECT_PLANNED', data: projectPlan });
        break;
        
      case 'BUDGET_OPTIMIZATION':
        const alternatives = await this.suggestBudgetAlternatives(intent.budget, context);
        workflows.push({ type: 'ALTERNATIVES_GENERATED', data: alternatives });
        break;
        
      case 'REPEAT_CUSTOMER_SERVICE':
        const tailored = await this.customizeForRepeatCustomer(intent.requirements, context);
        workflows.push({ type: 'TAILORED_SERVICE', data: tailored });
        break;
        
      case 'QUALITY_FOLLOW_UP':
        const followUp = await this.generateQualityFollowUp(context.previousJobs);
        workflows.push({ type: 'FOLLOW_UP_SCHEDULED', data: followUp });
        break;
    }
    
    return workflows;
  }
  
  async scopeComplexJob(requirements, context) {
    // Intelligent job scoping using customer context and trade knowledge
    const propertyContext = context.propertyDetails;
    const jobComplexity = await this.assessJobComplexity(requirements, propertyContext);
    
    const scope = {
      primaryTrade: await this.identifyPrimaryTrade(requirements),
      additionalTrades: await this.identifySecondaryTrades(requirements, propertyContext),
      phaseBreakdown: await this.createPhaseBreakdown(requirements, jobComplexity),
      riskFactors: await this.identifyRiskFactors(requirements, propertyContext),
      estimatedDuration: await this.estimateProjectDuration(requirements, jobComplexity),
      materialConsiderations: await this.analyzeSpecialRequirements(requirements, propertyContext)
    };
    
    return scope;
  }
  
  async planMultiTradeProject(requirements, context) {
    // Coordinate multiple tradespeople for complex renovations
    const trades = await this.identifyRequiredTrades(requirements);
    const sequencing = await this.optimizeTradeSequencing(trades, requirements);
    const availability = await this.checkMultiTradeAvailability(trades, sequencing);
    
    return {
      tradeSequence: sequencing,
      timelineOptimized: availability.optimizedSchedule,
      coordinationPoints: await this.identifyCoordinationNeeds(trades),
      qualityCheckpoints: await this.defineQualityGates(sequencing),
      customerCommunicationPlan: await this.createCommunicationSchedule(sequencing)
    };
  }
  
  async buildCustomerContext(sessionId, customerHistory) {
    // Build comprehensive customer context for Checkatrade
    const context = {
      propertyDetails: await this.getPropertyInformation(customerHistory),
      serviceHistory: await this.getCheckatradeHistory(customerHistory.customerId),
      preferences: await this.extractCustomerPreferences(customerHistory),
      budgetPatterns: await this.analyzeBudgetHistory(customerHistory),
      communicationStyle: await this.determinePreferredCommunication(customerHistory),
      qualityStandards: await this.inferQualityExpectations(customerHistory),
      urgencyPatterns: await this.analyzeUrgencyBehavior(customerHistory),
      seasonalNeeds: await this.identifySeasonalPatterns(customerHistory)
    };
    
    return context;
  }
  
  async generateQualityFollowUp(previousJobs) {
    // Proactive quality assurance for Checkatrade customers
    const followUpPlan = [];
    
    for (const job of previousJobs) {
      const timeElapsed = Date.now() - new Date(job.completionDate);
      const followUpNeeds = await this.assessFollowUpNeeds(job, timeElapsed);
      
      if (followUpNeeds.warrantsContact) {
        followUpPlan.push({
          jobId: job.id,
          followUpType: followUpNeeds.type,
          suggestedActions: followUpNeeds.actions,
          tradespersonInvolved: job.tradespersonId,
          scheduledDate: followUpNeeds.optimalContactDate
        });
      }
    }
    
    return followUpPlan;
  }
}

// MCP Voice Commerce Interface
const MCPVoiceCommerceInterface = () => {
  const [conversation, setConversation] = useState([]);
  const [isListening, setIsListening] = useState(false);
  const [isProcessing, setIsProcessing] = useState(false);
  const [voiceEnabled, setVoiceEnabled] = useState(true);
  const [currentQuote, setCurrentQuote] = useState(null);
  const [sessionContext, setSessionContext] = useState(null);
  
  const mediaRecorderRef = useRef(null);
  const audioChunksRef = useRef([]);
  
  const startVoiceRecording = async () => {
    try {
      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
      mediaRecorderRef.current = new MediaRecorder(stream);
      audioChunksRef.current = [];
      
      mediaRecorderRef.current.ondataavailable = (event) => {
        audioChunksRef.current.push(event.data);
      };
      
      mediaRecorderRef.current.onstop = async () => {
        const audioBlob = new Blob(audioChunksRef.current, { type: 'audio/wav' });
        await processVoiceMessage(audioBlob);
      };
      
      mediaRecorderRef.current.start();
      setIsListening(true);
    } catch (error) {
      console.error('Voice recording failed:', error);
    }
  };
  
  const stopVoiceRecording = () => {
    if (mediaRecorderRef.current && isListening) {
      mediaRecorderRef.current.stop();
      setIsListening(false);
    }
  };
  
  const processVoiceMessage = async (audioBlob) => {
    setIsProcessing(true);
    
    try {
      const formData = new FormData();
      formData.append('audio', audioBlob);
      formData.append('sessionId', sessionContext?.sessionId || uuidv4());
      formData.append('customerContext', JSON.stringify(sessionContext?.customerProfile));
      
      const response = await fetch('/api/mcp/voice', {
        method: 'POST',
        body: formData
      });
      
      const data = await response.json();
      
      // Add user message to conversation
      const userMessage = {
        id: uuidv4(),
        type: 'user',
        content: data.transcript,
        timestamp: new Date(),
        isVoice: true
      };
      
      // Add AI response to conversation
      const aiMessage = {
        id: uuidv4(),
        type: 'assistant',
        content: data.textResponse,
        timestamp: new Date(),
        audioUrl: data.audioResponse ? URL.createObjectURL(data.audioResponse) : null,
        actions: data.actions
      };
      
      setConversation(prev => [...prev, userMessage, aiMessage]);
      setSessionContext(data.conversationState);
      
      // Play audio response if voice is enabled
      if (voiceEnabled && data.audioResponse) {
        const audio = new Audio(aiMessage.audioUrl);
        audio.play();
      }
      
      // Process commerce actions
      await executeCommerceActions(data.actions);
      
    } catch (error) {
      console.error('Voice processing failed:', error);
    } finally {
      setIsProcessing(false);
    }
  };
  
  const executeCommerceActions = async (actions) => {
    for (const action of actions) {
      switch (action.type) {
        case 'QUOTE_GENERATED':
          setCurrentQuote(action.data);
          // Show quote modal with pricing breakdown
          break;
          
        case 'BOOKING_CREATED':
          // Navigate to booking confirmation
          showBookingConfirmation(action.data);
          break;
          
        case 'PAYMENT_PROCESSED':
          // Show payment success
          showPaymentSuccess(action.data);
          break;
          
        case 'COMPARISON_GENERATED':
          // Display service comparison table
          showServiceComparison(action.data);
          break;
          
        case 'AVAILABILITY_CHECKED':
          // Update calendar view
          updateAvailabilityView(action.data);
          break;
      }
    }
  };
  
  const sendTextMessage = async (messageText) => {
    try {
      const response = await fetch('/api/mcp/text', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          sessionId: sessionContext?.sessionId || uuidv4(),
          message: messageText,
          customerContext: sessionContext?.customerProfile
        })
      });
      
      const data = await response.json();
      
      const userMessage = {
        id: uuidv4(),
        type: 'user',
        content: messageText,
        timestamp: new Date(),
        isVoice: false
      };
      
      const aiMessage = {
        id: uuidv4(),
        type: 'assistant',
        content: data.message,
        timestamp: new Date(),
        actions: data.actions
      };
      
      setConversation(prev => [...prev, userMessage, aiMessage]);
      setSessionContext(data.context);
      
      await executeCommerceActions(data.actions);
      
    } catch (error) {
      console.error('Text message failed:', error);
    }
  };
  
  return (
    <div className="mcp-voice-commerce">
      <div className="conversation-header">
        <h3>AI Shopping Assistant</h3>
        <VoiceToggle enabled={voiceEnabled} onChange={setVoiceEnabled} />
      </div>
      
      <ConversationHistory messages={conversation} />
      
      {currentQuote && (
        <QuoteDisplay 
          quote={currentQuote}
          onAccept={() => acceptQuote(currentQuote)}
          onModify={() => modifyQuote(currentQuote)}
        />
      )}
      
      <div className="input-section">
        <VoiceButton
          isListening={isListening}
          isProcessing={isProcessing}
          onStart={startVoiceRecording}
          onStop={stopVoiceRecording}
        />
        
        <TextInput 
          onSend={sendTextMessage}
          placeholder="Type your message or use voice..."
        />
      </div>
      
      <ConversationSuggestions 
        suggestions={sessionContext?.suggestions}
        onSelect={sendTextMessage}
      />
    </div>
  );
};

-- Knowledge base for support content
CREATE TABLE support_articles (
    id SERIAL PRIMARY KEY,
    title VARCHAR(255),
    content TEXT,
    category VARCHAR(100),
    tags TEXT[],
    embedding VECTOR(1536), -- OpenAI embedding dimension
    created_at TIMESTAMP DEFAULT NOW(),
    updated_at TIMESTAMP DEFAULT NOW()
);

-- Support conversation tracking
CREATE TABLE support_conversations (
    conversation_id UUID PRIMARY KEY,
    user_id UUID,
    channel VARCHAR(50), -- chat, email, phone
    status VARCHAR(50), -- active, resolved, escalated
    satisfaction_score INTEGER,
    resolution_time INTEGER, -- in minutes
    created_at TIMESTAMP DEFAULT NOW()
);

-- Create index for semantic search
CREATE INDEX ON support_articles USING ivfflat (embedding vector_cosine_ops);

// AI Customer Support Service
class AICustomerSupportService {
  async handleInquiry(conversationId, userMessage) {
    const conversation = await this.getConversation(conversationId);
    const context = await this.buildContext(conversation);
    
    // Classify inquiry intent
    const intent = await this.classifyIntent(userMessage, context);
    
    // Search knowledge base
    const relevantArticles = await this.searchKnowledgeBase(userMessage, intent);
    
    // Generate response using AI
    const response = await this.generateResponse({
      userMessage,
      intent,
      relevantArticles,
      context,
      conversationHistory: conversation.messages
    });
    
    // Determine if escalation is needed
    const shouldEscalate = await this.shouldEscalateToHuman(
      intent,
      response.confidence,
      conversation.escalationAttempts
    );
    
    await this.saveMessage(conversationId, {
      type: 'bot_response',
      content: response.message,
      confidence: response.confidence,
      sources: relevantArticles,
      escalated: shouldEscalate
    });
    
    return {
      message: response.message,
      shouldEscalate,
      suggestedActions: response.actions,
      confidence: response.confidence
    };
  }
  
  async searchKnowledgeBase(query, intent) {
    const queryEmbedding = await this.generateEmbedding(query);
    
    const results = await db.query(`
      SELECT id, title, content, category,
             1 - (embedding <=> $1) as similarity
      FROM support_articles
      WHERE 1 - (embedding <=> $1) > 0.8
      ORDER BY similarity DESC
      LIMIT 5
    `, [queryEmbedding]);
    
    return results.rows;
  }
}

// AI Support Chat Widget
const AISupportChat = () => {
  const [isOpen, setIsOpen] = useState(false);
  const [messages, setMessages] = useState([]);
  const [conversationId, setConversationId] = useState(null);
  const [isTyping, setIsTyping] = useState(false);
  
  const sendMessage = async (messageText) => {
    const userMessage = {
      id: Date.now(),
      type: 'user',
      content: messageText,
      timestamp: new Date()
    };
    
    setMessages(prev => [...prev, userMessage]);
    setIsTyping(true);
    
    try {
      const response = await fetch('/api/support/chat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          conversationId,
          message: messageText
        })
      });
      
      const data = await response.json();
      
      const botMessage = {
        id: Date.now() + 1,
        type: 'bot',
        content: data.message,
        confidence: data.confidence,
        sources: data.sources,
        timestamp: new Date()
      };
      
      setMessages(prev => [...prev, botMessage]);
      
      if (data.shouldEscalate) {
        setMessages(prev => [...prev, {
          id: Date.now() + 2,
          type: 'system',
          content: 'Connecting you with a human agent...',
          timestamp: new Date()
        }]);
      }
      
      if (!conversationId) {
        setConversationId(data.conversationId);
      }
    } catch (error) {
      console.error('Failed to send message:', error);
    } finally {
      setIsTyping(false);
    }
  };
  
  return (
    <div className={`support-chat ${isOpen ? 'open' : 'closed'}`}>
      <ChatHeader 
        onToggle={() => setIsOpen(!isOpen)}
        isOpen={isOpen}
      />
      {isOpen && (
        <div className="chat-container">
          <MessageList messages={messages} />
          {isTyping && <TypingIndicator />}
          <ChatInput onSend={sendMessage} />
        </div>
      )}
    </div>
  );
};

-- Inspection data storage
CREATE TABLE roof_inspections (
    inspection_id UUID PRIMARY KEY,
    property_id UUID,
    drone_operator_id UUID,
    inspection_date TIMESTAMP,
    weather_conditions JSONB,
    flight_path JSONB,
    status VARCHAR(50),
    created_at TIMESTAMP DEFAULT NOW()
);

-- AI analysis results
CREATE TABLE inspection_analysis (
    analysis_id UUID PRIMARY KEY,
    inspection_id UUID REFERENCES roof_inspections(inspection_id),
    image_url VARCHAR(500),
    damage_detected BOOLEAN,
    damage_types TEXT[],
    severity_score DECIMAL(3,2),
    confidence_score DECIMAL(3,2),
    coordinates JSONB, -- damage location coordinates
    recommendations TEXT,
    processed_at TIMESTAMP DEFAULT NOW()
);

// Drone Inspection AI Service (Based on Checkatrade Labs Implementation)
class DroneInspectionService {
  async processInspectionImages(inspectionId, imageUrls) {
    const results = [];
    
    for (const imageUrl of imageUrls) {
      const analysisResult = await this.analyzeRoofImage(imageUrl);
      
      await db.query(`
        INSERT INTO inspection_analysis 
        (analysis_id, inspection_id, image_url, damage_detected, 
         damage_types, severity_score, confidence_score, coordinates, recommendations)
        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
      `, [
        uuidv4(),
        inspectionId,
        imageUrl,
        analysisResult.damageDetected,
        analysisResult.damageTypes,
        analysisResult.severityScore,
        analysisResult.confidenceScore,
        JSON.stringify(analysisResult.coordinates),
        analysisResult.recommendations
      ]);
      
      results.push(analysisResult);
    }
    
    // Generate comprehensive report
    const report = await this.generateInspectionReport(inspectionId, results);
    return report;
  }
  
  async analyzeRoofImage(imageUrl) {
    // Computer vision model for roof damage detection
    const imageData = await this.downloadImage(imageUrl);
    const predictions = await this.roofAnalysisModel.predict(imageData);
    
    const damageTypes = [];
    const coordinates = [];
    let maxSeverity = 0;
    let avgConfidence = 0;
    
    predictions.forEach(prediction => {
      if (prediction.confidence > 0.7) {
        damageTypes.push(prediction.class);
        coordinates.push({
          type: prediction.class,
          bbox: prediction.bbox,
          confidence: prediction.confidence
        });
        maxSeverity = Math.max(maxSeverity, prediction.severity);
        avgConfidence += prediction.confidence;
      }
    });
    
    avgConfidence = avgConfidence / predictions.length;
    
    const recommendations = await this.generateRecommendations(damageTypes, maxSeverity);
    
    return {
      damageDetected: damageTypes.length > 0,
      damageTypes,
      severityScore: maxSeverity,
      confidenceScore: avgConfidence,
      coordinates,
      recommendations
    };
  }
}

// Drone Inspection Dashboard
const DroneInspectionDashboard = () => {
  const [inspections, setInspections] = useState([]);
  const [selectedInspection, setSelectedInspection] = useState(null);
  const [analysisResults, setAnalysisResults] = useState([]);
  
  const uploadInspectionImages = async (inspectionId, files) => {
    const formData = new FormData();
    files.forEach(file => formData.append('images', file));
    formData.append('inspectionId', inspectionId);
    
    try {
      const response = await fetch('/api/inspections/upload', {
        method: 'POST',
        body: formData
      });
      
      const result = await response.json();
      
      if (result.success) {
        // Start AI analysis
        await processInspection(inspectionId);
      }
    } catch (error) {
      console.error('Upload failed:', error);
    }
  };
  
  const processInspection = async (inspectionId) => {
    try {
      const response = await fetch(`/api/inspections/${inspectionId}/analyze`, {
        method: 'POST'
      });
      
      const analysis = await response.json();
      setAnalysisResults(analysis.results);
    } catch (error) {
      console.error('Analysis failed:', error);
    }
  };
  
  return (
    <div className="inspection-dashboard">
      <InspectionList 
        inspections={inspections}
        onSelect={setSelectedInspection}
      />
      
      {selectedInspection && (
        <InspectionDetails 
          inspection={selectedInspection}
          onUpload={uploadInspectionImages}
        />
      )}
      
      {analysisResults.length > 0 && (
        <AnalysisResults 
          results={analysisResults}
          inspectionId={selectedInspection?.id}
        />
      )}
    </div>
  );
};

-- Asset tracking for predictive maintenance
CREATE TABLE maintenance_assets (
    asset_id UUID PRIMARY KEY,
    property_id UUID,
    asset_type VARCHAR(100), -- hvac, plumbing, electrical, etc.
    installation_date DATE,
    last_service_date DATE,
    manufacturer VARCHAR(100),
    model VARCHAR(100),
    specifications JSONB,
    current_condition JSONB
);

-- Maintenance predictions
CREATE TABLE maintenance_predictions (
    prediction_id UUID PRIMARY KEY,
    asset_id UUID REFERENCES maintenance_assets(asset_id),
    predicted_failure_date DATE,
    confidence_score DECIMAL(3,2),
    risk_factors JSONB,
    recommended_actions TEXT[],
    estimated_cost DECIMAL(10,2),
    created_at TIMESTAMP DEFAULT NOW()
);

// Predictive Maintenance Service
class PredictiveMaintenanceService {
  async generateMaintenancePredictions(propertyId) {
    const assets = await this.getPropertyAssets(propertyId);
    const predictions = [];
    
    for (const asset of assets) {
      const historicalData = await this.getAssetHistory(asset.asset_id);
      const currentCondition = await this.assessCurrentCondition(asset);
      
      const prediction = await this.predictFailure({
        asset,
        historicalData,
        currentCondition,
        environmentalFactors: await this.getEnvironmentalData(propertyId)
      });
      
      if (prediction.riskScore > 0.3) {
        const savedPrediction = await this.savePrediction(asset.asset_id, prediction);
        predictions.push(savedPrediction);
        
        // Schedule proactive maintenance if risk is high
        if (prediction.riskScore > 0.7) {
          await this.schedulePreventiveMaintenance(asset.asset_id, prediction);
        }
      }
    }
    
    return predictions;
  }
  
  async predictFailure(data) {
    const features = this.extractMaintenanceFeatures(data);
    const prediction = await this.maintenanceModel.predict(features);
    
    return {
      predictedFailureDate: prediction.failureDate,
      riskScore: prediction.riskScore,
      confidenceScore: prediction.confidence,
      riskFactors: prediction.factors,
      recommendedActions: this.generateRecommendations(prediction),
      estimatedCost: this.estimateMaintenanceCost(data.asset, prediction)
    };
  }
  
  extractMaintenanceFeatures(data) {
    const { asset, historicalData, currentCondition, environmentalFactors } = data;
    
    return {
      assetAge: this.calculateAssetAge(asset.installation_date),
      usageIntensity: this.calculateUsageIntensity(historicalData),
      maintenanceHistory: this.analyzeMaintenancePattern(historicalData),
      environmentalStress: this.calculateEnvironmentalStress(environmentalFactors),
      currentConditionScore: this.scoreCondition(currentCondition),
      manufacturerReliability: this.getManufacturerScore(asset.manufacturer),
      seasonalFactors: this.getSeasonalAdjustments(new Date())
    };
  }
}