Service Types

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

// Blog post generation service
const blogService = await $.Service.create({
  name: 'AI Blog Writer',
  type: $.ServiceType.ContentGeneration,
  subtype: 'blog-posts',

  pricing: {
    model: 'per-word',
    rate: 0.05,
    minimumCharge: 50.0,
  },
})

on($.ServiceRequest.created, async (request) => {
  if (request.serviceId !== blogService.id) return

  // Generate blog post
  const post = await ai.generate({
    model: 'gpt-5',
    type: 'blog-post',
    inputs: {
      topic: request.inputs.topic,
      keywords: request.inputs.keywords,
      tone: request.inputs.tone || 'professional',
      length: request.inputs.wordCount || 1500,
      audience: request.inputs.audience,
    },
    quality: {
      minReadability: 60,
      keywordDensity: { min: 0.01, max: 0.03 },
      uniqueness: 0.95,
    },
  })

  // Generate SEO metadata
  const seo = await ai.generate({
    model: 'gpt-5',
    type: 'seo-metadata',
    context: { post, keywords: request.inputs.keywords },
  })

  // Deliver results
  await send($.ServiceResult.deliver, {
    requestId: request.id,
    outputs: {
      content: post.content,
      title: post.title,
      excerpt: post.excerpt,
      seo: {
        metaDescription: seo.description,
        metaKeywords: seo.keywords,
        ogTitle: seo.ogTitle,
        ogDescription: seo.ogDescription,
      },
    },
  })

  // Bill for service
  const cost = Math.max(post.wordCount * blogService.pricing.rate, blogService.pricing.minimumCharge)

  await send($.Payment.charge, {
    customerId: request.customerId,
    amount: cost,
    description: `Blog Post: ${post.title}`,
  })
})

// Market research analysis service
const researchService = await $.Service.create({
  name: 'Market Research Analyzer',
  type: $.ServiceType.Analysis,
  subtype: 'market-research',

  pricing: {
    model: 'per-analysis',
    baseRate: 100.0,
    variables: {
      dataSize: { perGB: 10.0 },
      depth: { basic: 1.0, detailed: 1.5, comprehensive: 2.0 },
    },
  },
})

on($.ServiceRequest.created, async (request) => {
  if (request.serviceId !== researchService.id) return

  // Analyze market data
  const analysis = await ai.analyze({
    model: 'gpt-5',
    data: request.inputs.marketData,
    analyses: ['market-size-estimation', 'competitor-analysis', 'trend-identification', 'opportunity-assessment', 'risk-analysis', 'growth-projections'],
    depth: request.inputs.depth || 'detailed',
  })

  // Generate visualizations
  const visualizations = await ai.visualize({
    data: analysis,
    types: ['market-size-chart', 'competitor-matrix', 'trend-graph'],
  })

  // Create executive summary
  const summary = await ai.summarize({
    model: 'gpt-5',
    content: analysis,
    format: 'executive-summary',
    length: 'one-page',
  })

  // Deliver comprehensive report
  await send($.ServiceResult.deliver, {
    requestId: request.id,
    outputs: {
      analysis,
      visualizations,
      summary,
      recommendations: analysis.recommendations,
    },
    format: request.inputs.format || 'pdf',
  })
})

// Pricing optimization service
const pricingService = await $.Service.create({
  name: 'Dynamic Pricing Optimizer',
  type: $.ServiceType.DecisionSupport,
  subtype: 'pricing-optimization',

  pricing: {
    model: 'value-based',
    valueMultiplier: 0.1, // 10% of value created
  },
})

on($.ServiceRequest.created, async (request) => {
  if (request.serviceId !== pricingService.id) return

  // Analyze current pricing
  const currentPerformance = await ai.analyze({
    model: 'gpt-5',
    data: request.inputs.salesData,
    focus: ['revenue', 'conversion-rate', 'price-elasticity'],
  })

  // Optimize pricing
  const optimization = await ai.optimize({
    model: 'gpt-5',
    objective: 'maximize-revenue',
    constraints: {
      minMargin: request.inputs.minMargin || 0.3,
      competitorPricing: request.inputs.competitors,
      brandPositioning: request.inputs.positioning,
    },
    variables: {
      currentPricing: request.inputs.currentPrices,
      costStructure: request.inputs.costs,
      marketData: request.inputs.marketData,
    },
  })

  // Simulate outcomes
  const simulation = await ai.simulate({
    model: 'gpt-5',
    scenarios: optimization.recommendations,
    timeframe: '90-days',
    iterations: 1000,
  })

  // Deliver recommendations
  await send($.ServiceResult.deliver, {
    requestId: request.id,
    outputs: {
      currentAnalysis: currentPerformance,
      recommendations: optimization.recommendations,
      expectedImpact: simulation.summary,
      implementation: optimization.implementationPlan,
    },
  })

  // Value-based billing
  const expectedValue = simulation.summary.revenueIncrease
  const fee = expectedValue * pricingService.pricing.valueMultiplier

  await send($.Payment.charge, {
    customerId: request.customerId,
    amount: fee,
    description: 'Pricing Optimization (10% of projected value)',
  })
})

// Invoice processing automation
const invoiceService = await $.Service.create({
  name: 'Invoice Processor',
  type: $.ServiceType.Automation,
  subtype: 'invoice-processing',

  pricing: {
    model: 'per-invoice',
    rate: 2.0,
    volume: [
      { min: 0, max: 100, rate: 2.0 },
      { min: 101, max: 1000, rate: 1.5 },
      { min: 1001, max: Infinity, rate: 1.0 },
    ],
  },
})

on($.Invoice.received, async (invoice) => {
  // Extract data from invoice
  const data = await ai.extract({
    model: 'gpt-5',
    document: invoice.file,
    schema: {
      vendorName: 'string',
      invoiceNumber: 'string',
      invoiceDate: 'date',
      dueDate: 'date',
      lineItems: [
        {
          description: 'string',
          quantity: 'number',
          unitPrice: 'number',
          amount: 'number',
        },
      ],
      subtotal: 'number',
      tax: 'number',
      total: 'number',
    },
  })

  // Validate invoice
  const validation = await validateInvoice(data, invoice.purchaseOrder)

  if (!validation.valid) {
    await send($.Invoice.flagForReview, {
      invoiceId: invoice.id,
      issues: validation.issues,
    })
    return
  }

  // Match with purchase order
  const poMatch = await db.findOne($.PurchaseOrder, {
    number: data.poNumber,
  })

  // Create accounting entries
  await send($.AccountingEntry.create, {
    type: 'accounts-payable',
    vendor: data.vendorName,
    amount: data.total,
    dueDate: data.dueDate,
    invoice: invoice.id,
  })

  // Schedule payment
  await send($.Payment.schedule, {
    payee: data.vendorName,
    amount: data.total,
    date: data.dueDate,
    reference: data.invoiceNumber,
  })

  // Update inventory
  for (const item of data.lineItems) {
    await send($.Inventory.update, {
      sku: item.sku,
      quantity: { increment: item.quantity },
    })
  }

  // Mark invoice as processed
  await db.update(invoice, {
    status: 'processed',
    processedAt: new Date(),
    extractedData: data,
  })
})

// ETL pipeline service
const etlService = await $.Service.create({
  name: 'Data Pipeline Builder',
  type: $.ServiceType.DataPipeline,
  subtype: 'etl',

  pricing: {
    model: 'per-gb',
    rate: 1.0,
    minimumCharge: 10.0,
  },
})

on($.DataPipeline.execute, async (pipeline) => {
  // Extract from source
  const sourceData = await extractData(pipeline.source)

  // Transform data
  const transformed = await ai.transform({
    model: 'gpt-5',
    data: sourceData,
    operations: pipeline.transformations,
    schema: pipeline.targetSchema,
  })

  // Validate transformed data
  const validation = await ai.validate({
    data: transformed,
    schema: pipeline.targetSchema,
    rules: pipeline.validationRules,
  })

  if (!validation.valid) {
    await send($.DataPipeline.fail, {
      pipelineId: pipeline.id,
      errors: validation.errors,
    })
    return
  }

  // Load to destination
  await loadData(pipeline.destination, transformed)

  // Update pipeline metrics
  await db.update(pipeline, {
    lastRun: new Date(),
    recordsProcessed: transformed.length,
    status: 'success',
  })
})

// Contact enrichment service
const enrichmentService = await $.Service.create({
  name: 'Contact Enricher',
  type: $.ServiceType.DataEnrichment,
  subtype: 'contact-data',

  pricing: {
    model: 'per-contact',
    rate: 0.5,
    enrichmentLevels: {
      basic: 1.0, // Email verification only
      standard: 2.0, // + company info
      premium: 3.0, // + social profiles, job details
    },
  },
})

on($.ServiceRequest.created, async (request) => {
  if (request.serviceId !== enrichmentService.id) return

  const enriched = []

  for (const contact of request.inputs.contacts) {
    const enrichedContact = { ...contact }

    // Email verification
    enrichedContact.email = await verifyEmail(contact.email)

    if (request.inputs.level !== 'basic') {
      // Company information
      enrichedContact.company = await ai.research({
        model: 'gpt-5',
        query: contact.companyName,
        sources: ['linkedin', 'crunchbase', 'company-website'],
      })
    }

    if (request.inputs.level === 'premium') {
      // Social profiles
      enrichedContact.socialProfiles = await findSocialProfiles(contact)

      // Job details
      enrichedContact.jobDetails = await ai.extract({
        model: 'gpt-5',
        source: enrichedContact.socialProfiles.linkedin,
        schema: {
          title: 'string',
          seniority: 'string',
          department: 'string',
          startDate: 'date',
        },
      })
    }

    enriched.push(enrichedContact)
  }

  // Deliver enriched data
  await send($.ServiceResult.deliver, {
    requestId: request.id,
    outputs: { contacts: enriched },
  })
})

// Data format converter
const converterService = await $.Service.create({
  name: 'Universal Data Converter',
  type: $.ServiceType.DataTransformation,

  supportedFormats: {
    input: ['json', 'xml', 'csv', 'yaml', 'parquet', 'avro'],
    output: ['json', 'xml', 'csv', 'yaml', 'parquet', 'avro'],
  },

  pricing: {
    model: 'per-mb',
    rate: 0.1,
  },
})

on($.ServiceRequest.created, async (request) => {
  if (request.serviceId !== converterService.id) return

  // Parse input data
  const parsed = await parseData(request.inputs.data, request.inputs.sourceFormat)

  // Apply transformations
  if (request.inputs.transformations) {
    for (const transform of request.inputs.transformations) {
      parsed = await applyTransformation(parsed, transform)
    }
  }

  // Convert to target format
  const converted = await convertData(parsed, request.inputs.targetFormat, request.inputs.options)

  // Deliver converted data
  await send($.ServiceResult.deliver, {
    requestId: request.id,
    outputs: {
      data: converted,
      format: request.inputs.targetFormat,
      size: converted.length,
    },
  })
})

// CRM sync service
const crmSyncService = await $.Service.create({
  name: 'CRM Synchronizer',
  type: $.ServiceType.Integration,
  subtype: 'crm-sync',

  supportedPlatforms: ['salesforce', 'hubspot', 'pipedrive', 'zoho'],

  pricing: {
    model: 'subscription',
    tiers: [
      { name: 'basic', price: 50, records: 1000 },
      { name: 'professional', price: 150, records: 10000 },
      { name: 'enterprise', price: 500, records: 100000 },
    ],
  },
})

// Bidirectional sync
on($.Contact.created, async (contact) => {
  // Get CRM integration
  const integration = await db.findOne($.Integration, {
    businessId: contact.businessId,
    type: 'crm',
  })

  if (!integration) return

  // Create in external CRM
  const externalContact = await createInCRM(integration.platform, integration.credentials, contact)

  // Store mapping
  await db.create($.IntegrationMapping, {
    internalId: contact.id,
    externalId: externalContact.id,
    platform: integration.platform,
    type: 'contact',
  })
})

// Sync from CRM
on($.Integration.sync, async (integration) => {
  // Fetch updates from CRM
  const updates = await fetchCRMUpdates(integration.platform, integration.credentials, integration.lastSync)

  // Apply updates locally
  for (const update of updates) {
    const mapping = await db.findOne($.IntegrationMapping, {
      externalId: update.id,
      platform: integration.platform,
    })

    if (mapping) {
      await db.update($.Contact, {
        where: { id: mapping.internalId },
        data: mapCRMFieldsToInternal(update),
      })
    } else {
      // Create new contact
      const contact = await $.Contact.create(mapCRMFieldsToInternal(update))

      await db.create($.IntegrationMapping, {
        internalId: contact.id,
        externalId: update.id,
        platform: integration.platform,
      })
    }
  }

  // Update last sync time
  await db.update(integration, {
    lastSync: new Date(),
  })
})

// Customer support bot service
const supportService = await $.Service.create({
  name: 'AI Support Agent',
  type: $.ServiceType.CustomerService,

  capabilities: ['answer-questions', 'troubleshoot-issues', 'process-returns', 'schedule-callbacks', 'escalate-to-human'],

  pricing: {
    model: 'per-interaction',
    rate: 1.0,
    escalationFee: 5.0,
  },
})

on($.SupportTicket.created, async (ticket) => {
  // Classify ticket
  const classification = await ai.classify({
    model: 'gpt-5',
    text: ticket.description,
    categories: ['product-question', 'technical-issue', 'billing-inquiry', 'return-request', 'complaint'],
  })

  // Determine if AI can handle
  const complexity = await ai.assess({
    ticket,
    classification,
    customerHistory: await getCustomerHistory(ticket.customerId),
  })

  if (complexity.score > 0.7) {
    // Escalate to human
    await send($.SupportTicket.escalate, {
      ticketId: ticket.id,
      reason: complexity.reason,
      priority: 'high',
    })
    return
  }

  // Handle with AI
  const response = await ai.generate({
    model: 'gpt-5',
    type: 'support-response',
    context: {
      ticket,
      classification,
      knowledge: await getRelevantKnowledge(classification.category),
      customerHistory: complexity.customerHistory,
    },
  })

  // Take action if needed
  if (classification.category === 'return-request') {
    await send($.Return.create, {
      customerId: ticket.customerId,
      orderId: extractOrderId(ticket.description),
      reason: extractReturnReason(ticket.description),
    })
  }

  // Respond to customer
  await send($.SupportTicket.respond, {
    ticketId: ticket.id,
    response: response.message,
    actions: response.actions,
  })

  // Mark ticket as resolved
  if (response.resolved) {
    await db.update(ticket, {
      status: 'resolved',
      resolvedBy: 'ai-agent',
      resolvedAt: new Date(),
    })
  }
})