Complete Data Analysis Service

import $, { ai, db, on, send } from 'sdk.do'

// Define the analysis service with complete configuration
const analysisService = await $.Service.create({
  id: 'analysis-service-v1',
  name: 'AI-Powered Data Analysis Service',
  description: 'Comprehensive data analysis service supporting sentiment analysis, market research, and financial analysis with quality guarantees',

  type: $.ServiceType.DataAnalysis,
  version: '1.0.0',

  // Service capabilities and features
  capabilities: ['sentiment-analysis', 'market-research', 'financial-analysis', 'multi-model-validation', 'visualization-generation'],

  // Provider configuration
  provider: {
    id: 'your-organization-id',
    name: 'Your Organization',
    contact: '[email protected]',
  },

  // Service status and availability
  status: $.ServiceStatus.Active,
  availability: {
    regions: ['us-east-1', 'us-west-2', 'eu-west-1', 'ap-southeast-1'],
    maintenanceWindows: [
      {
        day: 'Sunday',
        startTime: '02:00',
        endTime: '04:00',
        timezone: 'UTC',
      },
    ],
  },
})

console.log('Analysis service created:', analysisService.id)

// Configure dynamic pricing model
const pricingConfig = await $.Service.configurePricing(analysisService.id, {
  model: $.PricingModel.PerAnalysis,
  currency: 'USD',

  // Base pricing tiers by analysis type
  tiers: [
    {
      name: 'Sentiment Analysis',
      type: 'sentiment-analysis',
      basePrice: 25.0,

      // Volume-based adjustments
      volumePricing: [
        { minRecords: 1, maxRecords: 1000, pricePerRecord: 0.025 },
        { minRecords: 1001, maxRecords: 10000, pricePerRecord: 0.015 },
        { minRecords: 10001, maxRecords: 100000, pricePerRecord: 0.008 },
      ],

      // Complexity multipliers
      complexityMultipliers: {
        simple: 1.0, // Basic sentiment scoring
        standard: 1.5, // Sentiment + themes + emotions
        advanced: 2.5, // Full analysis + custom categories
      },

      // Turnaround time pricing
      turnaroundPricing: {
        standard: 1.0, // 24 hours
        priority: 1.5, // 6 hours
        urgent: 2.5, // 1 hour
      },
    },
    {
      name: 'Market Research',
      type: 'market-research',
      basePrice: 75.0,

      volumePricing: [
        { minRecords: 1, maxRecords: 500, pricePerRecord: 0.15 },
        { minRecords: 501, maxRecords: 5000, pricePerRecord: 0.1 },
        { minRecords: 5001, maxRecords: 50000, pricePerRecord: 0.05 },
      ],

      complexityMultipliers: {
        simple: 1.0, // Basic trend analysis
        standard: 1.8, // Trends + competitive analysis
        advanced: 3.0, // Full market intelligence report
      },

      turnaroundPricing: {
        standard: 1.0, // 48 hours
        priority: 1.8, // 12 hours
        urgent: 3.0, // 3 hours
      },
    },
    {
      name: 'Financial Analysis',
      type: 'financial-analysis',
      basePrice: 150.0,

      volumePricing: [
        { minRecords: 1, maxRecords: 100, pricePerRecord: 1.5 },
        { minRecords: 101, maxRecords: 1000, pricePerRecord: 1.0 },
        { minRecords: 1001, maxRecords: 10000, pricePerRecord: 0.5 },
      ],

      complexityMultipliers: {
        simple: 1.0, // Basic ratio analysis
        standard: 2.0, // Comprehensive financial health
        advanced: 3.5, // Predictive modeling + recommendations
      },

      turnaroundPricing: {
        standard: 1.0, // 48 hours
        priority: 2.0, // 12 hours
        urgent: 4.0, // 3 hours
      },
    },
  ],

  // Additional options and add-ons
  addOns: [
    {
      id: 'custom-visualization',
      name: 'Custom Visualization Package',
      description: 'Professional charts and interactive dashboards',
      price: 50.0,
    },
    {
      id: 'executive-summary',
      name: 'Executive Summary Report',
      description: 'Concise summary for leadership presentation',
      price: 35.0,
    },
    {
      id: 'data-export',
      name: 'Raw Data Export',
      description: 'Complete dataset with all analysis metadata',
      price: 20.0,
    },
  ],

  // Discounts and promotions
  discounts: [
    {
      type: 'volume',
      name: 'High Volume Discount',
      conditions: { minMonthlySpend: 1000 },
      discountPercentage: 10,
    },
    {
      type: 'subscription',
      name: 'Annual Commitment Discount',
      conditions: { commitmentMonths: 12 },
      discountPercentage: 20,
    },
  ],

  // Payment terms
  paymentTerms: {
    dueDate: 'immediate',
    methods: ['card', 'ach', 'wire'],
    refundPolicy: 'full-refund-if-sla-violated',
  },
})

console.log('Pricing configuration applied:', pricingConfig)

// Configure comprehensive SLA
const slaConfig = await $.Service.configureSLA(analysisService.id, {
  // Response time guarantees
  responseTime: {
    standard: {
      maxHours: 24,
      guarantee: '99%',
      penalty: 'full-refund',
    },
    priority: {
      maxHours: 6,
      guarantee: '99.5%',
      penalty: 'full-refund-plus-credit',
    },
    urgent: {
      maxHours: 1,
      guarantee: '99.9%',
      penalty: 'double-refund',
    },
  },

  // Accuracy guarantees
  accuracy: {
    sentimentAnalysis: {
      minConfidence: 0.85,
      validationMethod: 'multi-model-consensus',
      penalty: 'partial-refund',
    },
    marketResearch: {
      minConfidence: 0.8,
      validationMethod: 'data-triangulation',
      penalty: 'partial-refund',
    },
    financialAnalysis: {
      minConfidence: 0.9,
      validationMethod: 'statistical-verification',
      penalty: 'full-refund',
    },
  },

  // Availability guarantees
  availability: {
    uptime: '99.9%',
    maxDowntimePerMonth: 43.2, // minutes
    compensationPerHour: 10.0, // percentage of monthly bill
  },

  // Data quality standards
  dataQuality: {
    completeness: 0.95,
    consistency: 0.9,
    timeliness: 0.98,
  },

  // Support response times
  support: {
    critical: { maxMinutes: 15, availability: '24/7' },
    high: { maxHours: 2, availability: '24/7' },
    medium: { maxHours: 8, availability: 'business-hours' },
    low: { maxHours: 24, availability: 'business-hours' },
  },

  // Monitoring and reporting
  monitoring: {
    realTimeAlerts: true,
    weeklyReports: true,
    monthlyReviews: true,
    dashboardAccess: true,
  },
})

console.log('SLA configuration established:', slaConfig)

import $, { ai, db, on, send } from 'sdk.do'

// Type definitions for analysis requests
interface AnalysisRequest {
  id: string
  type: 'sentiment-analysis' | 'market-research' | 'financial-analysis'
  complexity: 'simple' | 'standard' | 'advanced'
  turnaround: 'standard' | 'priority' | 'urgent'
  data: DataSource
  options: AnalysisOptions
  customerId: string
}

interface DataSource {
  format: 'csv' | 'json' | 'api' | 'database'
  location: string
  credentials?: Record<string, string>
  schema?: Record<string, string>
}

interface AnalysisOptions {
  addOns: string[]
  customCategories?: string[]
  visualizationPreferences?: VisualizationPreferences
  deliveryFormat: 'pdf' | 'html' | 'json' | 'all'
}

// Data collection and preparation function
async function collectAndPrepareData(request: AnalysisRequest) {
  const startTime = Date.now()

  // Log the data collection start
  await $.Event.log({
    type: 'data-collection-started',
    requestId: request.id,
    dataSource: request.data.format,
    timestamp: new Date().toISOString(),
  })

  try {
    // Step 1: Collect raw data from source
    let rawData: any[]

    switch (request.data.format) {
      case 'csv':
        rawData = await collectFromCSV(request.data.location)
        break
      case 'json':
        rawData = await collectFromJSON(request.data.location)
        break
      case 'api':
        rawData = await collectFromAPI(request.data.location, request.data.credentials)
        break
      case 'database':
        rawData = await collectFromDatabase(request.data.location, request.data.credentials, request.data.schema)
        break
      default:
        throw new Error(`Unsupported data format: ${request.data.format}`)
    }

    // Step 2: Validate data quality
    const validationResults = await validateDataQuality(rawData, request.type)

    if (validationResults.completeness < 0.95) {
      throw new Error(`Data completeness ${validationResults.completeness} below threshold 0.95`)
    }

    // Step 3: Clean and normalize data
    const cleanedData = await cleanData(rawData, request.type)

    // Step 4: Enrich data with additional context if needed
    const enrichedData = await enrichData(cleanedData, request.type)

    // Step 5: Structure data for analysis
    const structuredData = await structureData(enrichedData, request.type)

    // Calculate statistics
    const stats = {
      totalRecords: structuredData.length,
      validRecords: structuredData.filter((r) => r.isValid).length,
      processingTimeMs: Date.now() - startTime,
      qualityScore: validationResults.overallQuality,
    }

    // Store prepared data
    await db.prepared_data.create({
      requestId: request.id,
      data: structuredData,
      stats,
      timestamp: new Date(),
    })

    // Log successful completion
    await $.Event.log({
      type: 'data-collection-completed',
      requestId: request.id,
      stats,
      timestamp: new Date().toISOString(),
    })

    return {
      success: true,
      data: structuredData,
      stats,
    }
  } catch (error) {
    // Log failure
    await $.Event.log({
      type: 'data-collection-failed',
      requestId: request.id,
      error: error.message,
      timestamp: new Date().toISOString(),
    })

    throw error
  }
}

// Helper function: Collect data from CSV
async function collectFromCSV(location: string) {
  const response = await fetch(location)
  const csvText = await response.text()

  // Parse CSV (simplified - use proper CSV parser in production)
  const lines = csvText.split('\n')
  const headers = lines[0].split(',')

  return lines.slice(1).map((line) => {
    const values = line.split(',')
    return headers.reduce(
      (obj, header, index) => {
        obj[header.trim()] = values[index]?.trim()
        return obj
      },
      {} as Record<string, string>
    )
  })
}

// Helper function: Validate data quality
async function validateDataQuality(data: any[], analysisType: string) {
  const requiredFields = getRequiredFields(analysisType)

  let completeRecords = 0
  let totalFields = 0
  let presentFields = 0

  data.forEach((record) => {
    const hasAllRequired = requiredFields.every((field) => record[field] !== undefined && record[field] !== null && record[field] !== '')

    if (hasAllRequired) completeRecords++

    totalFields += requiredFields.length
    presentFields += requiredFields.filter((field) => record[field] !== undefined && record[field] !== null && record[field] !== '').length
  })

  const completeness = data.length > 0 ? completeRecords / data.length : 0
  const fieldCoverage = totalFields > 0 ? presentFields / totalFields : 0

  return {
    completeness,
    fieldCoverage,
    totalRecords: data.length,
    completeRecords,
    overallQuality: (completeness + fieldCoverage) / 2,
  }
}

// Helper function: Get required fields by analysis type
function getRequiredFields(analysisType: string): string[] {
  switch (analysisType) {
    case 'sentiment-analysis':
      return ['text', 'timestamp']
    case 'market-research':
      return ['metric', 'value', 'date', 'source']
    case 'financial-analysis':
      return ['period', 'revenue', 'expenses', 'date']
    default:
      return ['id', 'data']
  }
}

// Helper function: Clean data
async function cleanData(data: any[], analysisType: string) {
  return data
    .map((record) => {
      // Remove duplicates, handle missing values, standardize formats
      const cleaned = { ...record }

      // Trim string fields
      Object.keys(cleaned).forEach((key) => {
        if (typeof cleaned[key] === 'string') {
          cleaned[key] = cleaned[key].trim()
        }
      })

      // Handle analysis-specific cleaning
      if (analysisType === 'sentiment-analysis' && cleaned.text) {
        // Remove special characters, normalize whitespace
        cleaned.text = cleaned.text.replace(/[^\w\s.,!?-]/g, '').replace(/\s+/g, ' ')
      }

      if (analysisType === 'financial-analysis') {
        // Convert numeric strings to numbers
        ;['revenue', 'expenses', 'profit', 'assets', 'liabilities'].forEach((field) => {
          if (cleaned[field] && typeof cleaned[field] === 'string') {
            cleaned[field] = parseFloat(cleaned[field].replace(/[^0-9.-]/g, ''))
          }
        })
      }

      return cleaned
    })
    .filter((record) => record !== null)
}

// Helper function: Enrich data
async function enrichData(data: any[], analysisType: string) {
  // Add contextual information, lookup reference data, calculate derived fields
  return Promise.all(
    data.map(async (record) => {
      const enriched = { ...record }

      if (analysisType === 'sentiment-analysis') {
        // Add metadata like language detection, word count
        enriched.language = 'en' // Would use actual language detection
        enriched.wordCount = enriched.text?.split(/\s+/).length || 0
      }

      if (analysisType === 'market-research') {
        // Add industry benchmarks, historical context
        enriched.industryAverage = await getIndustryAverage(enriched.metric)
      }

      if (analysisType === 'financial-analysis') {
        // Calculate financial ratios
        if (enriched.revenue && enriched.expenses) {
          enriched.profitMargin = (enriched.revenue - enriched.expenses) / enriched.revenue
        }
      }

      return enriched
    })
  )
}

// Helper function: Structure data
async function structureData(data: any[], analysisType: string) {
  return data.map((record, index) => ({
    id: record.id || `record-${index}`,
    originalData: record,
    isValid: true,
    processingMetadata: {
      structuredAt: new Date().toISOString(),
      analysisType,
    },
  }))
}

import $, { ai, db, on, send } from 'sdk.do'

// Sentiment analysis implementation
async function performSentimentAnalysis(data: PreparedData[], complexity: string) {
  const results = []

  for (const record of data) {
    // Analyze with GPT-5
    const gpt5Analysis = await ai.chat({
      model: 'gpt-5',
      messages: [
        {
          role: 'system',
          content: `You are a sentiment analysis expert. Analyze the following text and provide:
1. Overall sentiment (positive/negative/neutral)
2. Sentiment score (-1 to 1)
3. Confidence level (0 to 1)
${complexity === 'standard' || complexity === 'advanced' ? '4. Key themes and emotions identified' : ''}
${complexity === 'advanced' ? '5. Specific positive and negative aspects\n6. Actionable insights' : ''}

Return your analysis as JSON.`,
        },
        {
          role: 'user',
          content: record.originalData.text,
        },
      ],
      temperature: 0.3,
      response_format: { type: 'json_object' },
    })

    // Analyze with Claude Sonnet 4.5
    const claudeAnalysis = await ai.chat({
      model: 'claude-sonnet-4.5',
      messages: [
        {
          role: 'system',
          content: `You are a sentiment analysis expert. Analyze the following text and provide:
1. Overall sentiment (positive/negative/neutral)
2. Sentiment score (-1 to 1)
3. Confidence level (0 to 1)
${complexity === 'standard' || complexity === 'advanced' ? '4. Key themes and emotions identified' : ''}
${complexity === 'advanced' ? '5. Specific positive and negative aspects\n6. Actionable insights' : ''}

Return your analysis as JSON.`,
        },
        {
          role: 'user',
          content: record.originalData.text,
        },
      ],
      temperature: 0.3,
    })

    // Parse responses
    const gpt5Result = JSON.parse(gpt5Analysis.choices[0].message.content)
    const claudeResult = JSON.parse(claudeAnalysis.content[0].text)

    // Cross-validate and merge results
    const mergedResult = await crossValidateResults(gpt5Result, claudeResult)

    results.push({
      recordId: record.id,
      text: record.originalData.text,
      analysis: mergedResult,
      models: ['gpt-5', 'claude-sonnet-4.5'],
      timestamp: new Date().toISOString(),
    })
  }

  return results
}

// Market research analysis implementation
async function performMarketResearchAnalysis(data: PreparedData[], complexity: string) {
  // Aggregate market data
  const aggregatedData = aggregateMarketData(data)

  // Analyze with GPT-5
  const gpt5Analysis = await ai.chat({
    model: 'gpt-5',
    messages: [
      {
        role: 'system',
        content: `You are a market research analyst. Analyze the following market data and provide:
1. Key trends identified
2. Market opportunities
3. Competitive threats
${complexity === 'standard' || complexity === 'advanced' ? '4. Consumer behavior insights\n5. Market segment analysis' : ''}
${complexity === 'advanced' ? '6. Strategic recommendations\n7. Risk assessment\n8. Growth projections' : ''}

Return your analysis as JSON with detailed explanations.`,
      },
      {
        role: 'user',
        content: JSON.stringify(aggregatedData, null, 2),
      },
    ],
    temperature: 0.4,
    response_format: { type: 'json_object' },
  })

  // Analyze with Claude Sonnet 4.5
  const claudeAnalysis = await ai.chat({
    model: 'claude-sonnet-4.5',
    messages: [
      {
        role: 'system',
        content: `You are a market research analyst. Analyze the following market data and provide:
1. Key trends identified
2. Market opportunities
3. Competitive threats
${complexity === 'standard' || complexity === 'advanced' ? '4. Consumer behavior insights\n5. Market segment analysis' : ''}
${complexity === 'advanced' ? '6. Strategic recommendations\n7. Risk assessment\n8. Growth projections' : ''}

Return your analysis as JSON with detailed explanations.`,
      },
      {
        role: 'user',
        content: JSON.stringify(aggregatedData, null, 2),
      },
    ],
    temperature: 0.4,
  })

  // Parse and merge results
  const gpt5Result = JSON.parse(gpt5Analysis.choices[0].message.content)
  const claudeResult = JSON.parse(claudeAnalysis.content[0].text)

  const mergedResult = await crossValidateResults(gpt5Result, claudeResult)

  return {
    rawData: data,
    aggregatedData,
    analysis: mergedResult,
    models: ['gpt-5', 'claude-sonnet-4.5'],
    timestamp: new Date().toISOString(),
  }
}

// Financial analysis implementation
async function performFinancialAnalysis(data: PreparedData[], complexity: string) {
  // Calculate financial metrics
  const metrics = calculateFinancialMetrics(data)

  // Analyze with GPT-5
  const gpt5Analysis = await ai.chat({
    model: 'gpt-5',
    messages: [
      {
        role: 'system',
        content: `You are a financial analyst. Analyze the following financial data and provide:
1. Financial health assessment
2. Key performance indicators analysis
3. Trend analysis
${complexity === 'standard' || complexity === 'advanced' ? '4. Ratio analysis (liquidity, profitability, efficiency)\n5. Year-over-year comparisons' : ''}
${complexity === 'advanced' ? '6. Predictive modeling and forecasts\n7. Risk assessment\n8. Investment recommendations' : ''}

Return your analysis as JSON with detailed explanations and numbers.`,
      },
      {
        role: 'user',
        content: JSON.stringify(metrics, null, 2),
      },
    ],
    temperature: 0.2,
    response_format: { type: 'json_object' },
  })

  // Analyze with Claude Sonnet 4.5
  const claudeAnalysis = await ai.chat({
    model: 'claude-sonnet-4.5',
    messages: [
      {
        role: 'system',
        content: `You are a financial analyst. Analyze the following financial data and provide:
1. Financial health assessment
2. Key performance indicators analysis
3. Trend analysis
${complexity === 'standard' || complexity === 'advanced' ? '4. Ratio analysis (liquidity, profitability, efficiency)\n5. Year-over-year comparisons' : ''}
${complexity === 'advanced' ? '6. Predictive modeling and forecasts\n7. Risk assessment\n8. Investment recommendations' : ''}

Return your analysis as JSON with detailed explanations and numbers.`,
      },
      {
        role: 'user',
        content: JSON.stringify(metrics, null, 2),
      },
    ],
    temperature: 0.2,
  })

  // Parse and merge results
  const gpt5Result = JSON.parse(gpt5Analysis.choices[0].message.content)
  const claudeResult = JSON.parse(claudeAnalysis.content[0].text)

  const mergedResult = await crossValidateResults(gpt5Result, claudeResult)

  return {
    rawData: data,
    calculatedMetrics: metrics,
    analysis: mergedResult,
    models: ['gpt-5', 'claude-sonnet-4.5'],
    timestamp: new Date().toISOString(),
  }
}

// Cross-validation helper
async function crossValidateResults(result1: any, result2: any) {
  // Compare sentiment scores, confidence levels, identified themes
  const merged: any = {}

  // Merge sentiment/scores with averaging
  if (result1.sentiment_score !== undefined && result2.sentiment_score !== undefined) {
    merged.sentiment_score = (result1.sentiment_score + result2.sentiment_score) / 2
    merged.sentiment_agreement = Math.abs(result1.sentiment_score - result2.sentiment_score) < 0.2
  }

  // Merge confidence with conservative approach (use minimum)
  if (result1.confidence !== undefined && result2.confidence !== undefined) {
    merged.confidence = Math.min(result1.confidence, result2.confidence)
  }

  // Merge categorical assessments
  if (result1.sentiment !== undefined && result2.sentiment !== undefined) {
    merged.sentiment = result1.sentiment === result2.sentiment ? result1.sentiment : 'mixed'
    merged.models_agree = result1.sentiment === result2.sentiment
  }

  // Merge themes/insights by combining unique items
  if (result1.themes && result2.themes) {
    merged.themes = [...new Set([...result1.themes, ...result2.themes])]
  }

  // Include both model outputs for transparency
  merged.model_outputs = {
    gpt5: result1,
    claude: result2,
  }

  // Calculate overall validation score
  const agreementFactors = [merged.sentiment_agreement ? 1 : 0, merged.models_agree ? 1 : 0, merged.confidence > 0.7 ? 1 : 0]
  merged.validation_score = agreementFactors.reduce((a, b) => a + b, 0) / agreementFactors.length

  return merged
}

// Helper: Aggregate market data
function aggregateMarketData(data: PreparedData[]) {
  const byMetric: Record<string, any[]> = {}

  data.forEach((record) => {
    const metric = record.originalData.metric
    if (!byMetric[metric]) {
      byMetric[metric] = []
    }
    byMetric[metric].push(record.originalData)
  })

  return {
    metrics: Object.keys(byMetric),
    aggregations: Object.entries(byMetric).map(([metric, values]) => ({
      metric,
      count: values.length,
      average: values.reduce((sum, v) => sum + (parseFloat(v.value) || 0), 0) / values.length,
      min: Math.min(...values.map((v) => parseFloat(v.value) || 0)),
      max: Math.max(...values.map((v) => parseFloat(v.value) || 0)),
      trend: calculateTrend(values),
    })),
    timeRange: {
      start: Math.min(...data.map((d) => new Date(d.originalData.date).getTime())),
      end: Math.max(...data.map((d) => new Date(d.originalData.date).getTime())),
    },
  }
}

// Helper: Calculate financial metrics
function calculateFinancialMetrics(data: PreparedData[]) {
  const periods = data.map((d) => d.originalData)

  return {
    periods: periods.length,
    totalRevenue: periods.reduce((sum, p) => sum + (p.revenue || 0), 0),
    totalExpenses: periods.reduce((sum, p) => sum + (p.expenses || 0), 0),
    averageRevenue: periods.reduce((sum, p) => sum + (p.revenue || 0), 0) / periods.length,
    averageExpenses: periods.reduce((sum, p) => sum + (p.expenses || 0), 0) / periods.length,
    revenueGrowth: calculateGrowthRate(periods.map((p) => p.revenue)),
    expenseGrowth: calculateGrowthRate(periods.map((p) => p.expenses)),
    profitMargins: periods.map((p) => (p.revenue ? ((p.revenue - p.expenses) / p.revenue) * 100 : 0)),
  }
}

// Helper: Calculate trend
function calculateTrend(values: any[]) {
  if (values.length < 2) return 'insufficient-data'

  const sorted = values.sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())

  const first = parseFloat(sorted[0].value) || 0
  const last = parseFloat(sorted[sorted.length - 1].value) || 0

  const change = ((last - first) / first) * 100

  if (change > 10) return 'strongly-increasing'
  if (change > 2) return 'increasing'
  if (change > -2) return 'stable'
  if (change > -10) return 'decreasing'
  return 'strongly-decreasing'
}

// Helper: Calculate growth rate
function calculateGrowthRate(values: number[]) {
  if (values.length < 2) return 0

  const growthRates = []
  for (let i = 1; i < values.length; i++) {
    if (values[i - 1] !== 0) {
      growthRates.push(((values[i] - values[i - 1]) / values[i - 1]) * 100)
    }
  }

  return growthRates.length > 0 ? growthRates.reduce((sum, rate) => sum + rate, 0) / growthRates.length : 0
}

import $, { ai, db, on, send } from 'sdk.do'

// Extract insights from analysis results
async function extractInsights(analysisResults: any, analysisType: string, complexity: string) {
  const insights: any = {
    type: analysisType,
    complexity,
    extractedAt: new Date().toISOString(),
    keyFindings: [],
    recommendations: [],
    metrics: {},
  }

  if (analysisType === 'sentiment-analysis') {
    // Calculate aggregate sentiment metrics
    const sentiments = analysisResults.map((r: any) => r.analysis.sentiment_score)
    const avgSentiment = sentiments.reduce((a: number, b: number) => a + b, 0) / sentiments.length
    const positiveCount = sentiments.filter((s: number) => s > 0.2).length
    const negativeCount = sentiments.filter((s: number) => s < -0.2).length
    const neutralCount = sentiments.length - positiveCount - negativeCount

    insights.metrics = {
      averageSentiment: avgSentiment,
      totalResponses: sentiments.length,
      positivePercentage: (positiveCount / sentiments.length) * 100,
      negativePercentage: (negativeCount / sentiments.length) * 100,
      neutralPercentage: (neutralCount / sentiments.length) * 100,
    }

    insights.keyFindings.push({
      finding: `Overall sentiment is ${avgSentiment > 0.2 ? 'positive' : avgSentiment < -0.2 ? 'negative' : 'neutral'}`,
      impact: 'high',
      confidence: 0.9,
    })

    if (complexity === 'advanced') {
      // Extract themes
      const allThemes = analysisResults.flatMap((r: any) => r.analysis.themes || [])
      const themeCounts = countOccurrences(allThemes)
      insights.themes = Object.entries(themeCounts)
        .sort((a: any, b: any) => b[1] - a[1])
        .slice(0, 10)
        .map(([theme, count]) => ({ theme, frequency: count }))
    }
  }

  if (analysisType === 'market-research') {
    insights.metrics = analysisResults.analysis

    // Extract opportunities
    if (analysisResults.analysis.opportunities) {
      insights.keyFindings = analysisResults.analysis.opportunities.map((opp: any) => ({
        finding: opp.description,
        impact: opp.impact || 'medium',
        confidence: opp.confidence || 0.7,
      }))
    }
  }

  if (analysisType === 'financial-analysis') {
    insights.metrics = analysisResults.calculatedMetrics

    // Key financial findings
    const profitMargin = insights.metrics.profitMargins[insights.metrics.profitMargins.length - 1]
    const revenueGrowth = insights.metrics.revenueGrowth

    insights.keyFindings.push({
      finding: `Current profit margin: ${profitMargin.toFixed(2)}%`,
      impact: profitMargin > 20 ? 'positive' : profitMargin < 5 ? 'concerning' : 'moderate',
      confidence: 0.95,
    })

    insights.keyFindings.push({
      finding: `Revenue growth rate: ${revenueGrowth.toFixed(2)}%`,
      impact: revenueGrowth > 15 ? 'excellent' : revenueGrowth > 5 ? 'good' : 'needs-improvement',
      confidence: 0.92,
    })
  }

  // Generate recommendations using AI
  const recommendations = await generateRecommendations(insights, analysisType)
  insights.recommendations = recommendations

  return insights
}

// Generate visualizations for the report
async function generateVisualizations(insights: any, analysisType: string) {
  const visualizations = []

  if (analysisType === 'sentiment-analysis') {
    // Sentiment distribution pie chart
    visualizations.push({
      type: 'pie-chart',
      title: 'Sentiment Distribution',
      data: [
        { label: 'Positive', value: insights.metrics.positivePercentage, color: '#10b981' },
        { label: 'Neutral', value: insights.metrics.neutralPercentage, color: '#6b7280' },
        { label: 'Negative', value: insights.metrics.negativePercentage, color: '#ef4444' },
      ],
    })

    // Theme frequency bar chart
    if (insights.themes) {
      visualizations.push({
        type: 'bar-chart',
        title: 'Top Themes',
        data: insights.themes.map((t: any) => ({
          label: t.theme,
          value: t.frequency,
        })),
      })
    }
  }

  if (analysisType === 'market-research') {
    // Trend lines for key metrics
    visualizations.push({
      type: 'line-chart',
      title: 'Market Trends',
      data: insights.metrics.aggregations?.map((agg: any) => ({
        metric: agg.metric,
        trend: agg.trend,
        values: [agg.min, agg.average, agg.max],
      })),
    })
  }

  if (analysisType === 'financial-analysis') {
    // Revenue vs expenses over time
    visualizations.push({
      type: 'line-chart',
      title: 'Revenue vs Expenses',
      data: {
        labels: Array.from({ length: insights.metrics.periods }, (_, i) => `Period ${i + 1}`),
        datasets: [
          {
            label: 'Revenue',
            data: Array.from({ length: insights.metrics.periods }, () => insights.metrics.averageRevenue + (Math.random() - 0.5) * 10000),
          },
          {
            label: 'Expenses',
            data: Array.from({ length: insights.metrics.periods }, () => insights.metrics.averageExpenses + (Math.random() - 0.5) * 8000),
          },
        ],
      },
    })

    // Profit margin trend
    visualizations.push({
      type: 'bar-chart',
      title: 'Profit Margin by Period',
      data: insights.metrics.profitMargins.map((margin: number, i: number) => ({
        label: `Period ${i + 1}`,
        value: margin,
      })),
    })
  }

  return visualizations
}

// Generate final report with all components
async function generateReport(request: AnalysisRequest, analysisResults: any, insights: any) {
  const visualizations = await generateVisualizations(insights, request.type)

  // Create report structure
  const report = {
    id: `report-${request.id}`,
    type: request.type,
    complexity: request.complexity,
    generatedAt: new Date().toISOString(),

    executiveSummary: await generateExecutiveSummary(insights, request.type),

    sections: [
      {
        title: 'Overview',
        content: generateOverviewSection(request, analysisResults),
      },
      {
        title: 'Key Findings',
        content: insights.keyFindings.map((f: any) => `${f.finding} (Impact: ${f.impact}, Confidence: ${(f.confidence * 100).toFixed(0)}%)`).join('\n\n'),
      },
      {
        title: 'Detailed Analysis',
        content: generateDetailedAnalysis(analysisResults, insights, request.type),
      },
      {
        title: 'Recommendations',
        content: insights.recommendations
          .map((r: any, i: number) => `${i + 1}. ${r.recommendation}\n   Priority: ${r.priority}\n   Expected Impact: ${r.expectedImpact}`)
          .join('\n\n'),
      },
      {
        title: 'Methodology',
        content: generateMethodologySection(request),
      },
    ],

    visualizations,

    metadata: {
      dataPoints: analysisResults.length || analysisResults.rawData?.length || 0,
      modelsUsed: analysisResults[0]?.models || analysisResults.models || [],
      qualityScore: insights.metrics.averageConfidence || 0.85,
      processingTime: '45 minutes', // Would track actual time
    },
  }

  // Store report in database
  await db.analysis_reports.create({
    requestId: request.id,
    customerId: request.customerId,
    report,
    createdAt: new Date(),
  })

  // Generate formatted outputs based on delivery preferences
  const outputs = await formatReportOutputs(report, request.options.deliveryFormat)

  return {
    report,
    outputs,
  }
}

// Helper: Generate executive summary
async function generateExecutiveSummary(insights: any, analysisType: string) {
  const prompt = `Generate a concise executive summary (2-3 paragraphs) for this ${analysisType} report:

Key Findings:
${insights.keyFindings.map((f: any) => `- ${f.finding}`).join('\n')}

Recommendations:
${insights.recommendations.map((r: any) => `- ${r.recommendation}`).join('\n')}

The summary should be suitable for C-level executives.`

  const response = await ai.chat({
    model: 'gpt-5',
    messages: [
      { role: 'system', content: 'You are a business analyst writing executive summaries.' },
      { role: 'user', content: prompt },
    ],
    temperature: 0.5,
  })

  return response.choices[0].message.content
}

// Helper: Generate detailed analysis section
function generateDetailedAnalysis(analysisResults: any, insights: any, analysisType: string) {
  let content = ''

  if (analysisType === 'sentiment-analysis') {
    content = `
Sentiment Analysis Results:

Total Responses Analyzed: ${insights.metrics.totalResponses}
Average Sentiment Score: ${insights.metrics.averageSentiment.toFixed(3)} (scale: -1 to 1)

Distribution:
- Positive: ${insights.metrics.positivePercentage.toFixed(1)}%
- Neutral: ${insights.metrics.neutralPercentage.toFixed(1)}%
- Negative: ${insights.metrics.negativePercentage.toFixed(1)}%

The analysis reveals ${insights.metrics.averageSentiment > 0 ? 'generally positive' : insights.metrics.averageSentiment < 0 ? 'generally negative' : 'mixed'} sentiment across all responses.
    `.trim()
  }

  if (analysisType === 'market-research') {
    content = `
Market Research Analysis:

Key Metrics Analyzed: ${insights.metrics.aggregations?.length || 0}
Time Period: ${new Date(insights.metrics.timeRange?.start).toLocaleDateString()} to ${new Date(insights.metrics.timeRange?.end).toLocaleDateString()}

The market analysis indicates several important trends and opportunities that warrant strategic attention.
    `.trim()
  }

  if (analysisType === 'financial-analysis') {
    content = `
Financial Analysis Results:

Periods Analyzed: ${insights.metrics.periods}
Total Revenue: $${insights.metrics.totalRevenue.toLocaleString()}
Total Expenses: $${insights.metrics.totalExpenses.toLocaleString()}
Average Profit Margin: ${(insights.metrics.profitMargins.reduce((a: number, b: number) => a + b, 0) / insights.metrics.profitMargins.length).toFixed(2)}%
Revenue Growth Rate: ${insights.metrics.revenueGrowth.toFixed(2)}%

The financial health indicators suggest ${insights.metrics.revenueGrowth > 10 ? 'strong growth' : insights.metrics.revenueGrowth > 0 ? 'moderate growth' : 'declining performance'}.
    `.trim()
  }

  return content
}

// Helper: Format report outputs
async function formatReportOutputs(report: any, format: string) {
  const outputs: any = {}

  if (format === 'pdf' || format === 'all') {
    // Generate PDF (would use actual PDF generation library)
    outputs.pdf = {
      url: `https://storage.do/reports/${report.id}.pdf`,
      size: '2.4 MB',
      pages: 15,
    }
  }

  if (format === 'html' || format === 'all') {
    // Generate HTML version
    outputs.html = {
      url: `https://reports.do/${report.id}`,
      responsive: true,
    }
  }

  if (format === 'json' || format === 'all') {
    // JSON export
    outputs.json = report
  }

  return outputs
}

// Helper: Count occurrences
function countOccurrences(arr: string[]) {
  return arr.reduce(
    (acc, item) => {
      acc[item] = (acc[item] || 0) + 1
      return acc
    },
    {} as Record<string, number>
  )
}

// Helper: Generate recommendations
async function generateRecommendations(insights: any, analysisType: string) {
  const prompt = `Based on these analysis results, provide 3-5 actionable recommendations:

${JSON.stringify(insights.keyFindings, null, 2)}

Format as JSON array with: recommendation, priority, expectedImpact`

  const response = await ai.chat({
    model: 'gpt-5',
    messages: [
      { role: 'system', content: 'You are a business consultant providing strategic recommendations.' },
      { role: 'user', content: prompt },
    ],
    temperature: 0.6,
    response_format: { type: 'json_object' },
  })

  const result = JSON.parse(response.choices[0].message.content)
  return result.recommendations || []
}

// Helper: Generate methodology section
function generateMethodologySection(request: AnalysisRequest) {
  return `
This analysis was performed using the following methodology:

1. Data Collection: ${request.data.format} format data was collected and validated
2. Data Preparation: Cleaning, normalization, and enrichment processes applied
3. AI Analysis: Multi-model analysis using GPT-5 and Claude Sonnet 4.5 for cross-validation
4. Insight Extraction: Automated identification of key findings and patterns
5. Report Generation: Comprehensive report with visualizations and recommendations

Quality Assurance: All results were validated for accuracy and consistency across models.
  `.trim()
}

import $, { ai, db, on, send } from 'sdk.do'
import Stripe from 'stripe'

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)

// Main analysis service event handler
on.Analysis.requested, async (event) => {
  const request: AnalysisRequest = event.data
  const startTime = Date.now()

  try {
    // Stage 1: Validate and price the request
    await $.Event.emit($.Analysis.validating, { requestId: request.id })

    const pricing = await calculatePricing(request)
    const slaRequirements = await getSLARequirements(request.turnaround)

    await db.analysis_requests.create({
      id: request.id,
      customerId: request.customerId,
      type: request.type,
      status: 'pending-payment',
      pricing,
      slaRequirements,
      createdAt: new Date(),
    })

    // Stage 2: Process payment
    await $.Event.emit($.Analysis.processing_payment, { requestId: request.id })

    const paymentIntent = await stripe.paymentIntents.create({
      amount: Math.round(pricing.total * 100),
      currency: 'usd',
      customer: request.customerId,
      description: `Analysis Service: ${request.type}`,
      metadata: {
        requestId: request.id,
        analysisType: request.type,
        complexity: request.complexity,
      },
    })

    // Wait for payment confirmation (simplified - would use webhooks)
    await new Promise((resolve) => setTimeout(resolve, 2000))

    // Stage 3: Collect and prepare data
    await $.Event.emit($.Analysis.collecting_data, { requestId: request.id })

    const preparedData = await collectAndPrepareData(request)

    if (!preparedData.success) {
      throw new Error('Data preparation failed')
    }

    // Stage 4: Perform AI analysis
    await $.Event.emit($.Analysis.analyzing, { requestId: request.id })

    let analysisResults
    switch (request.type) {
      case 'sentiment-analysis':
        analysisResults = await performSentimentAnalysis(preparedData.data, request.complexity)
        break
      case 'market-research':
        analysisResults = await performMarketResearchAnalysis(preparedData.data, request.complexity)
        break
      case 'financial-analysis':
        analysisResults = await performFinancialAnalysis(preparedData.data, request.complexity)
        break
      default:
        throw new Error(`Unsupported analysis type: ${request.type}`)
    }

    // Stage 5: Extract insights
    await $.Event.emit($.Analysis.extracting_insights, { requestId: request.id })

    const insights = await extractInsights(analysisResults, request.type, request.complexity)

    // Stage 6: Generate report
    await $.Event.emit($.Analysis.generating_report, { requestId: request.id })

    const reportData = await generateReport(request, analysisResults, insights)

    // Stage 7: Quality validation
    await $.Event.emit($.Analysis.validating_quality, { requestId: request.id })

    const qualityCheck = await validateQuality(reportData.report, slaRequirements, request.type)

    if (!qualityCheck.passed) {
      throw new Error(`Quality validation failed: ${qualityCheck.issues.join(', ')}`)
    }

    // Stage 8: Check SLA compliance
    const processingTime = Date.now() - startTime
    const slaCompliant = processingTime <= slaRequirements.maxProcessingTime

    if (!slaCompliant) {
      await handleSLAViolation(request.id, paymentIntent.id, slaRequirements)
    }

    // Stage 9: Deliver results
    await $.Event.emit($.Analysis.delivering, { requestId: request.id })

    await deliverResults(request, reportData)

    // Stage 10: Complete and log
    await $.Event.emit($.Analysis.completed, {
      requestId: request.id,
      processingTime,
      qualityScore: qualityCheck.score,
      slaCompliant,
    })

    await db.analysis_requests.update(request.id, {
      status: 'completed',
      completedAt: new Date(),
      processingTime,
      qualityScore: qualityCheck.score,
      slaCompliant,
    })

    // Send completion notification to customer
    send.Email.to(request.customerId), {
      subject: 'Your Analysis Report is Ready',
      template: 'analysis-complete',
      data: {
        reportUrl: reportData.outputs.html?.url,
        analysisType: request.type,
        qualityScore: qualityCheck.score,
      },
    })
  } catch (error) {
    // Handle failure
    await $.Event.emit($.Analysis.failed, {
      requestId: request.id,
      error: error.message,
      timestamp: new Date().toISOString(),
    })

    await db.analysis_requests.update(request.id, {
      status: 'failed',
      error: error.message,
      failedAt: new Date(),
    })

    // Refund customer
    if (paymentIntent?.id) {
      await stripe.refunds.create({
        payment_intent: paymentIntent.id,
        reason: 'requested_by_customer',
      })
    }

    // Notify customer of failure
    send.Email.to(request.customerId), {
      subject: 'Analysis Request Failed',
      template: 'analysis-failed',
      data: {
        requestId: request.id,
        error: error.message,
        refundAmount: pricing?.total || 0,
      },
    })

    throw error
  }
})

// Helper: Calculate pricing
async function calculatePricing(request: AnalysisRequest) {
  const config = await $.Service.getPricing('analysis-service-v1')
  const tier = config.tiers.find((t: any) => t.type === request.type)

  if (!tier) {
    throw new Error(`No pricing tier found for ${request.type}`)
  }

  // Determine record count (would parse actual data)
  const recordCount = 1000 // Example

  // Find volume pricing
  const volumePrice = tier.volumePricing.find((vp: any) => recordCount >= vp.minRecords && recordCount <= vp.maxRecords)

  // Calculate base cost
  let cost = tier.basePrice + volumePrice.pricePerRecord * recordCount

  // Apply complexity multiplier
  cost *= tier.complexityMultipliers[request.complexity]

  // Apply turnaround multiplier
  cost *= tier.turnaroundPricing[request.turnaround]

  // Add-ons
  const addOnsCost = request.options.addOns.reduce((total, addOnId) => {
    const addOn = config.addOns.find((a: any) => a.id === addOnId)
    return total + (addOn?.price || 0)
  }, 0)

  return {
    base: tier.basePrice,
    volume: volumePrice.pricePerRecord * recordCount,
    complexityMultiplier: tier.complexityMultipliers[request.complexity],
    turnaroundMultiplier: tier.turnaroundPricing[request.turnaround],
    addOns: addOnsCost,
    subtotal: cost + addOnsCost,
    total: cost + addOnsCost,
  }
}

// Helper: Get SLA requirements
async function getSLARequirements(turnaround: string) {
  const sla = await $.Service.getSLA('analysis-service-v1')

  return {
    maxProcessingTime: sla.responseTime[turnaround].maxHours * 60 * 60 * 1000,
    guaranteePercentage: parseFloat(sla.responseTime[turnaround].guarantee),
    penalty: sla.responseTime[turnaround].penalty,
  }
}

// Helper: Validate quality
async function validateQuality(report: any, slaRequirements: any, analysisType: string) {
  const issues = []
  let score = 1.0

  // Check confidence levels
  const avgConfidence = report.metadata.qualityScore
  if (avgConfidence < 0.8) {
    issues.push('Confidence level below threshold')
    score -= 0.2
  }

  // Check completeness
  if (!report.executiveSummary || report.sections.length < 5) {
    issues.push('Report incomplete')
    score -= 0.3
  }

  // Check visualizations
  if (!report.visualizations || report.visualizations.length === 0) {
    issues.push('Missing visualizations')
    score -= 0.1
  }

  return {
    passed: issues.length === 0,
    score: Math.max(0, score),
    issues,
  }
}

// Helper: Handle SLA violation
async function handleSLAViolation(requestId: string, paymentIntentId: string, slaRequirements: any) {
  await $.Event.log({
    type: 'sla-violation',
    requestId,
    penalty: slaRequirements.penalty,
    timestamp: new Date().toISOString(),
  })

  // Apply penalty based on SLA configuration
  if (slaRequirements.penalty === 'full-refund') {
    await stripe.refunds.create({
      payment_intent: paymentIntentId,
      reason: 'requested_by_customer',
    })
  } else if (slaRequirements.penalty === 'partial-refund') {
    const paymentIntent = await stripe.paymentIntents.retrieve(paymentIntentId)
    await stripe.refunds.create({
      payment_intent: paymentIntentId,
      amount: Math.round(paymentIntent.amount * 0.5),
    })
  }
}

// Helper: Deliver results
async function deliverResults(request: AnalysisRequest, reportData: any) {
  // Upload files to storage
  const storageUrls = await uploadReportFiles(reportData.outputs)

  // Create delivery record
  await db.report_deliveries.create({
    requestId: request.id,
    customerId: request.customerId,
    urls: storageUrls,
    deliveredAt: new Date(),
  })

  // Send webhook notification if configured
  if (request.options.webhookUrl) {
    await fetch(request.options.webhookUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        requestId: request.id,
        status: 'completed',
        reportUrls: storageUrls,
      }),
    })
  }
}

// Helper: Upload report files
async function uploadReportFiles(outputs: any) {
  // Would use actual storage service (S3, R2, etc.)
  return {
    pdf: outputs.pdf?.url || null,
    html: outputs.html?.url || null,
    json: outputs.json ? 'https://storage.do/reports/data.json' : null,
  }
}

import { describe, it, expect, beforeEach } from 'vitest'
import { collectAndPrepareData, performSentimentAnalysis, extractInsights } from './analysis-service'

describe('Analysis Service Unit Tests', () => {
  describe('Data Collection', () => {
    it('should successfully collect and prepare CSV data', async () => {
      const mockRequest = {
        id: 'test-request-1',
        type: 'sentiment-analysis',
        complexity: 'simple',
        turnaround: 'standard',
        data: {
          format: 'csv',
          location: 'https://example.com/test-data.csv',
        },
        options: { addOns: [], deliveryFormat: 'json' },
        customerId: 'cust-123',
      }

      const result = await collectAndPrepareData(mockRequest)

      expect(result.success).toBe(true)
      expect(result.data).toBeDefined()
      expect(result.stats.totalRecords).toBeGreaterThan(0)
      expect(result.stats.qualityScore).toBeGreaterThan(0.9)
    })

    it('should handle invalid data format gracefully', async () => {
      const mockRequest = {
        id: 'test-request-2',
        type: 'sentiment-analysis',
        data: {
          format: 'invalid-format',
          location: 'https://example.com/data',
        },
      }

      await expect(collectAndPrepareData(mockRequest)).rejects.toThrow('Unsupported data format')
    })

    it('should validate data quality thresholds', async () => {
      const mockRequest = {
        id: 'test-request-3',
        type: 'sentiment-analysis',
        data: {
          format: 'json',
          location: 'https://example.com/incomplete-data.json',
        },
      }

      // Mock data with poor quality
      const result = await collectAndPrepareData(mockRequest)

      if (result.stats.qualityScore < 0.95) {
        expect(result.success).toBe(false)
      }
    })
  })

  describe('Sentiment Analysis', () => {
    it('should correctly identify positive sentiment', async () => {
      const mockData = [
        {
          id: 'record-1',
          originalData: {
            text: 'This product is absolutely amazing! Best purchase ever.',
          },
          isValid: true,
        },
      ]

      const results = await performSentimentAnalysis(mockData, 'simple')

      expect(results[0].analysis.sentiment_score).toBeGreaterThan(0.5)
      expect(results[0].analysis.sentiment).toBe('positive')
      expect(results[0].analysis.confidence).toBeGreaterThan(0.7)
    })

    it('should correctly identify negative sentiment', async () => {
      const mockData = [
        {
          id: 'record-2',
          originalData: {
            text: 'Terrible experience. Would not recommend to anyone.',
          },
          isValid: true,
        },
      ]

      const results = await performSentimentAnalysis(mockData, 'simple')

      expect(results[0].analysis.sentiment_score).toBeLessThan(-0.5)
      expect(results[0].analysis.sentiment).toBe('negative')
    })

    it('should extract themes in advanced mode', async () => {
      const mockData = [
        {
          id: 'record-3',
          originalData: {
            text: 'Great customer service but the product quality could be better.',
          },
          isValid: true,
        },
      ]

      const results = await performSentimentAnalysis(mockData, 'advanced')

      expect(results[0].analysis.themes).toBeDefined()
      expect(results[0].analysis.themes.length).toBeGreaterThan(0)
    })
  })

  describe('Insight Extraction', () => {
    it('should calculate aggregate sentiment metrics', async () => {
      const mockResults = [
        { analysis: { sentiment_score: 0.8 } },
        { analysis: { sentiment_score: 0.6 } },
        { analysis: { sentiment_score: -0.3 } },
        { analysis: { sentiment_score: 0.1 } },
      ]

      const insights = await extractInsights(mockResults, 'sentiment-analysis', 'simple')

      expect(insights.metrics.averageSentiment).toBeCloseTo(0.3, 1)
      expect(insights.metrics.totalResponses).toBe(4)
      expect(insights.keyFindings.length).toBeGreaterThan(0)
    })
  })
})

import { describe, it, expect, beforeAll, afterAll } from 'vitest'
import $, { on } from 'sdk.do'

describe('Analysis Service Integration Tests', () => {
  let testRequestId: string

  beforeAll(async () => {
    // Setup test environment
    await $.Service.init('analysis-service-v1')
  })

  afterAll(async () => {
    // Cleanup
    if (testRequestId) {
      await db.analysis_requests.delete(testRequestId)
    }
  })

  it('should complete full sentiment analysis workflow', async () => {
    // Create test request
    const request = {
      id: `test-${Date.now()}`,
      type: 'sentiment-analysis',
      complexity: 'standard',
      turnaround: 'standard',
      data: {
        format: 'json',
        location: 'https://storage.do/test-data/sentiment-test.json',
      },
      options: {
        addOns: ['custom-visualization'],
        deliveryFormat: 'all',
      },
      customerId: 'test-customer-1',
    }

    testRequestId = request.id

    // Track events
    const events: string[] = []

    const unsubscribeValidating = on.Analysis.validating, () => {
      events.push('validating')
    })

    const unsubscribeAnalyzing = on.Analysis.analyzing, () => {
      events.push('analyzing')
    })

    const unsubscribeCompleted = on.Analysis.completed, () => {
      events.push('completed')
    })

    // Trigger analysis
    await $.Event.emit($.Analysis.requested, request)

    // Wait for completion (with timeout)
    await new Promise((resolve, reject) => {
      const timeout = setTimeout(() => reject(new Error('Timeout')), 120000)

      const checkCompletion = setInterval(async () => {
        const status = await db.analysis_requests.findOne({ id: request.id })
        if (status?.status === 'completed') {
          clearInterval(checkCompletion)
          clearTimeout(timeout)
          resolve(status)
        }
      }, 1000)
    })

    // Verify workflow
    expect(events).toContain('validating')
    expect(events).toContain('analyzing')
    expect(events).toContain('completed')

    // Verify results
    const result = await db.analysis_requests.findOne({ id: request.id })
    expect(result.status).toBe('completed')
    expect(result.qualityScore).toBeGreaterThan(0.8)
    expect(result.slaCompliant).toBe(true)

    const report = await db.analysis_reports.findOne({ requestId: request.id })
    expect(report).toBeDefined()
    expect(report.report.sections.length).toBeGreaterThan(4)
    expect(report.report.visualizations.length).toBeGreaterThan(0)

    // Cleanup listeners
    unsubscribeValidating()
    unsubscribeAnalyzing()
    unsubscribeCompleted()
  }, 180000) // 3 minute timeout

  it('should handle SLA violations correctly', async () => {
    // Create request with urgent turnaround
    const request = {
      id: `test-urgent-${Date.now()}`,
      type: 'financial-analysis',
      complexity: 'advanced',
      turnaround: 'urgent', // 1 hour SLA
      data: {
        format: 'csv',
        location: 'https://storage.do/test-data/large-financial-data.csv',
      },
      options: {
        addOns: [],
        deliveryFormat: 'pdf',
      },
      customerId: 'test-customer-2',
    }

    // Mock slow processing (would simulate in test environment)
    await $.Event.emit($.Analysis.requested, request)

    // Check for SLA violation handling
    const slaEvent = await new Promise((resolve) => {
      on.Analysis.sla_violated, (event) => {
        resolve(event)
      })
    })

    expect(slaEvent).toBeDefined()

    // Verify refund was issued
    const result = await db.analysis_requests.findOne({ id: request.id })
    expect(result.refundIssued).toBe(true)
  })
})

import $, { ai, db } from 'sdk.do'

// Production deployment configuration
const productionConfig = {
  service: {
    id: 'analysis-service-v1',
    environment: 'production',
    region: 'us-east-1',

    // Scaling configuration
    scaling: {
      minInstances: 3,
      maxInstances: 20,
      targetUtilization: 0.7,
      scaleUpThreshold: 0.8,
      scaleDownThreshold: 0.4,
      cooldownPeriod: 300, // seconds
    },

    // Resource allocation
    resources: {
      memory: '2GB',
      cpu: '1.0',
      timeout: 900, // 15 minutes
    },

    // Queue configuration
    queue: {
      maxConcurrent: 10,
      maxRetries: 3,
      retryDelay: 60, // seconds
      deadLetterQueue: true,
    },

    // Database configuration
    database: {
      connectionPool: {
        min: 5,
        max: 20,
      },
      queryTimeout: 30000, // ms
    },

    // AI model configuration
    ai: {
      models: ['gpt-5', 'claude-sonnet-4.5'],
      fallbackModel: 'gpt-4o',
      timeout: 60000, // ms per call
      maxRetries: 2,
    },

    // Storage configuration
    storage: {
      provider: 'cloudflare-r2',
      bucket: 'analysis-reports-production',
      cdnEnabled: true,
      retentionDays: 90,
    },

    // Payment configuration
    payment: {
      provider: 'stripe',
      mode: 'live',
      webhookSecret: process.env.STRIPE_WEBHOOK_SECRET,
    },

    // Monitoring configuration
    monitoring: {
      enabled: true,
      metricsInterval: 60, // seconds
      alerting: {
        errorRate: { threshold: 0.05, window: 300 },
        responseTime: { threshold: 60000, window: 300 },
        queueDepth: { threshold: 50, window: 60 },
      },
    },

    // Security configuration
    security: {
      apiKeyRequired: true,
      rateLimiting: {
        enabled: true,
        requestsPerMinute: 60,
        burstSize: 100,
      },
      encryption: {
        atRest: true,
        inTransit: true,
      },
    },
  },
}

// Deploy to production
async function deployToProduction() {
  console.log('Deploying analysis service to production...')

  // Validate configuration
  const validation = await $.Service.validateConfig(productionConfig)
  if (!validation.valid) {
    throw new Error(`Invalid configuration: ${validation.errors.join(', ')}`)
  }

  // Deploy service
  const deployment = await $.Service.deploy('analysis-service-v1', productionConfig)

  console.log(`Deployed successfully: ${deployment.url}`)
  console.log(`Version: ${deployment.version}`)
  console.log(`Status: ${deployment.status}`)

  // Run health check
  const health = await $.Service.healthCheck('analysis-service-v1')
  if (health.status !== 'healthy') {
    throw new Error(`Health check failed: ${health.message}`)
  }

  // Enable traffic
  await $.Service.enableTraffic('analysis-service-v1', {
    percentage: 100,
    strategy: 'rolling',
  })

  console.log('Service is now receiving traffic')

  return deployment
}

// Environment variables configuration
const requiredEnvVars = [
  'STRIPE_SECRET_KEY',
  'STRIPE_WEBHOOK_SECRET',
  'OPENAI_API_KEY',
  'ANTHROPIC_API_KEY',
  'DATABASE_URL',
  'STORAGE_BUCKET',
  'STORAGE_ACCESS_KEY',
  'STORAGE_SECRET_KEY',
]

// Validate environment
function validateEnvironment() {
  const missing = requiredEnvVars.filter((key) => !process.env[key])

  if (missing.length > 0) {
    throw new Error(`Missing required environment variables: ${missing.join(', ')}`)
  }

  console.log('Environment validation passed')
}

// Main deployment script
async function main() {
  try {
    validateEnvironment()
    const deployment = await deployToProduction()
    console.log('Deployment completed successfully')
    process.exit(0)
  } catch (error) {
    console.error('Deployment failed:', error)
    process.exit(1)
  }
}

// Run if executed directly
if (require.main === module) {
  main()
}